/*
* This file is part of the Jikes RVM project (http://jikesrvm.org).
*
* This file is licensed to You under the Eclipse Public License (EPL);
* You may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* See the COPYRIGHT.txt file distributed with this work for information
* regarding copyright ownership.
*/
package org.mmtk.policy;
import org.mmtk.plan.TransitiveClosure;
import org.mmtk.utility.heap.FreeListPageResource;
import org.mmtk.utility.heap.VMRequest;
import org.mmtk.utility.HeaderByte;
import org.mmtk.utility.Treadmill;
import org.mmtk.vm.VM;
import org.vmmagic.pragma.*;
import org.vmmagic.unboxed.*;
/**
* Each instance of this class corresponds to one explicitly managed
* large object space.
*/
@Uninterruptible
public final class LargeObjectSpace extends BaseLargeObjectSpace {
/****************************************************************************
*
* Class variables
*/
public static final int LOCAL_GC_BITS_REQUIRED = 2;
public static final int GLOBAL_GC_BITS_REQUIRED = 0;
private static final byte MARK_BIT = 1; // ...01
private static final byte NURSERY_BIT = 2; // ...10
private static final byte LOS_BIT_MASK = 3; // ...11
/****************************************************************************
*
* Instance variables
*/
private byte markState;
private boolean inNurseryGC;
private final Treadmill treadmill;
/****************************************************************************
*
* Initialization
*/
/**
* The caller specifies the region of virtual memory to be used for
* this space. If this region conflicts with an existing space,
* then the constructor will fail.
*
* @param name The name of this space (used when printing error messages etc)
* @param pageBudget The number of pages this space may consume
* before consulting the plan
* @param vmRequest An object describing the virtual memory requested.
*/
public LargeObjectSpace(String name, int pageBudget, VMRequest vmRequest) {
super(name, pageBudget, vmRequest);
treadmill = new Treadmill(LOG_BYTES_IN_PAGE, true);
markState = 0;
}
/****************************************************************************
*
* Collection
*/
/**
* Prepare for a new collection increment. For the mark-sweep
* collector we must flip the state of the mark bit between
* collections.
*/
public void prepare(boolean fullHeap) {
if (fullHeap) {
if (VM.VERIFY_ASSERTIONS) {
VM.assertions._assert(treadmill.fromSpaceEmpty());
}
markState = (byte) (MARK_BIT - markState);
}
treadmill.flip(fullHeap);
inNurseryGC = !fullHeap;
}
/**
* A new collection increment has completed. For the mark-sweep
* collector this means we can perform the sweep phase.
*/
public void release(boolean fullHeap) {
// sweep the large objects
sweepLargePages(true); // sweep the nursery
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(treadmill.nurseryEmpty());
if (fullHeap) sweepLargePages(false); // sweep the mature space
}
/**
* Sweep through the large pages, releasing all superpages on the
* "from space" treadmill.
*/
private void sweepLargePages(boolean sweepNursery) {
while (true) {
Address cell = sweepNursery ? treadmill.popNursery() : treadmill.pop();
if (cell.isZero()) break;
release(getSuperPage(cell));
}
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(sweepNursery ? treadmill.nurseryEmpty() : treadmill.fromSpaceEmpty());
}
/**
* Release a group of pages that were allocated together.
*
* @param first The first page in the group of pages that were
* allocated together.
*/
@Inline
public void release(Address first) {
((FreeListPageResource) pr).releasePages(first);
}
/****************************************************************************
*
* Object processing and tracing
*/
/**
* Trace a reference to an object under a mark sweep collection
* policy. If the object header is not already marked, mark the
* object in either the bitmap or by moving it off the treadmill,
* and enqueue the object for subsequent processing. The object is
* marked as (an atomic) side-effect of checking whether already
* marked.
*
* @param trace The trace being conducted.
* @param object The object to be traced.
* @return The object (there is no object forwarding in this
* collector, so we always return the same object: this could be a
* void method but for compliance to a more general interface).
*/
@Inline
public ObjectReference traceObject(TransitiveClosure trace, ObjectReference object) {
boolean nurseryObject = isInNursery(object);
if (!inNurseryGC || nurseryObject) {
if (testAndMark(object, markState)) {
internalMarkObject(object, nurseryObject);
trace.processNode(object);
}
}
return object;
}
/**
* @param object The object in question
* @return True if this object is known to be live (i.e. it is marked)
*/
@Inline
public boolean isLive(ObjectReference object) {
return testMarkBit(object, markState);
}
/**
* An object has been marked (identifiged as live). Large objects
* are added to the to-space treadmill, while all other objects will
* have a mark bit set in the superpage header.
*
* @param object The object which has been marked.
*/
@Inline
private void internalMarkObject(ObjectReference object, boolean nurseryObject) {
Address cell = VM.objectModel.objectStartRef(object);
Address node = Treadmill.midPayloadToNode(cell);
treadmill.copy(node, nurseryObject);
}
/****************************************************************************
*
* Header manipulation
*/
/**
* Perform any required initialization of the GC portion of the header.
*
* @param object the object ref to the storage to be initialized
* @param alloc is this initialization occuring due to (initial) allocation
* (true) or due to copying (false)?
*/
@Inline
public void initializeHeader(ObjectReference object, boolean alloc) {
byte oldValue = VM.objectModel.readAvailableByte(object);
byte newValue = (byte) ((oldValue & ~LOS_BIT_MASK) | markState);
if (alloc) newValue |= NURSERY_BIT;
if (HeaderByte.NEEDS_UNLOGGED_BIT) newValue |= HeaderByte.UNLOGGED_BIT;
VM.objectModel.writeAvailableByte(object, newValue);
Address cell = VM.objectModel.objectStartRef(object);
treadmill.addToTreadmill(Treadmill.midPayloadToNode(cell), alloc);
}
/**
* Atomically attempt to set the mark bit of an object. Return true
* if successful, false if the mark bit was already set.
*
* @param object The object whose mark bit is to be written
* @param value The value to which the mark bit will be set
*/
@Inline
private boolean testAndMark(ObjectReference object, byte value) {
Word oldValue;
do {
oldValue = VM.objectModel.prepareAvailableBits(object);
byte markBit = (byte) (oldValue.toInt() & (inNurseryGC ? LOS_BIT_MASK : MARK_BIT));
if (markBit == value) return false;
} while (!VM.objectModel.attemptAvailableBits(object, oldValue,
oldValue.and(Word.fromIntZeroExtend(LOS_BIT_MASK).not()).or(Word.fromIntZeroExtend(value))));
return true;
}
/**
* Return true if the mark bit for an object has the given value.
*
* @param object The object whose mark bit is to be tested
* @param value The value against which the mark bit will be tested
* @return True if the mark bit for the object has the given value.
*/
@Inline
private boolean testMarkBit(ObjectReference object, byte value) {
return (byte) (VM.objectModel.readAvailableByte(object) & MARK_BIT) == value;
}
/**
* Return true if the object is in the logical nursery
*
* @param object The object whose status is to be tested
* @return True if the object is in the logical nursery
*/
@Inline
private boolean isInNursery(ObjectReference object) {
return (byte)(VM.objectModel.readAvailableByte(object) & NURSERY_BIT) == NURSERY_BIT;
}
/**
* Return the size of the per-superpage header required by this
* system. In this case it is just the underlying superpage header
* size.
*
* @return The size of the per-superpage header required by this
* system.
*/
@Inline
protected int superPageHeaderSize() {
return Treadmill.headerSize();
}
/**
* Return the size of the per-cell header for cells of a given class
* size.
*
* @return The size of the per-cell header for cells of a given class
* size.
*/
@Inline
protected int cellHeaderSize() {
return 0;
}
/**
* This is the treadmill used by the large object space.
*
* Note that it depends on the specific local in use whether this
* is being used.
*
* @return The treadmill associated with this large object space.
*/
public Treadmill getTreadmill() {
return this.treadmill;
}
}