org.mmtk.policy
Class MarkSweepSpace

java.lang.Object
  org.mmtk.policy.Space
      org.mmtk.policy.SegregatedFreeListSpace
          org.mmtk.policy.MarkSweepSpace

All Implemented Interfaces:

Constants

public final class MarkSweepSpace
extends SegregatedFreeListSpace
implements Constants

Each instance of this class corresponds to one mark-sweep *space*. Each of the instance methods of this class may be called by any thread (i.e. synchronization must be explicit in any instance or class method). This contrasts with the MarkSweepLocal, where instances correspond to *plan* instances and therefore to kernel threads. Thus unlike this class, synchronization is not necessary in the instance methods of MarkSweepLocal.

HEADER_MARK_BITS

public static final boolean HEADER_MARK_BITS

Select between using mark bits in a side bitmap, or mark bits in the headers of object (or other sub-class scheme), and a single mark bit per block.

AVAILABLE_LOCAL_BITS

private static final int AVAILABLE_LOCAL_BITS

highest bit bits we may use

COUNT_BASE

private static final int COUNT_BASE

See Also:

Constant Field Values

DEFAULT_MARKCOUNT_BITS

public static final int DEFAULT_MARKCOUNT_BITS

See Also:

Constant Field Values

MAX_MARKCOUNT_BITS

public static final int MAX_MARKCOUNT_BITS

MARK_COUNT_INCREMENT

private static final byte MARK_COUNT_INCREMENT

See Also:

Constant Field Values

MARK_COUNT_MASK

private static final byte MARK_COUNT_MASK

EAGER_MARK_CLEAR

private static final boolean EAGER_MARK_CLEAR

LOCAL_GC_BITS_REQUIRED

public static final int LOCAL_GC_BITS_REQUIRED

GLOBAL_GC_BITS_REQUIRED

public static final int GLOBAL_GC_BITS_REQUIRED

See Also:

Constant Field Values

GC_HEADER_WORDS_REQUIRED

public static final int GC_HEADER_WORDS_REQUIRED

See Also:

Constant Field Values

markState

private byte markState

allocState

private byte allocState

inMSCollection

private boolean inMSCollection

usingStickyMarkBits

private static final boolean usingStickyMarkBits

isAgeSegregated

private boolean isAgeSegregated

isAllocAsMarked

private boolean isAllocAsMarked

MarkSweepSpace

public MarkSweepSpace(String name,
                      VMRequest vmRequest)

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.

Parameters:

name - The name of this space (used when printing error messages etc)

vmRequest - An object describing the virtual memory requested.

makeAgeSegregatedSpace

public void makeAgeSegregatedSpace()

This instance will be age-segregated using the sticky mark bits algorithm. Perform appropriate initialization

maintainSideBitmap

protected boolean maintainSideBitmap()

Should SegregatedFreeListSpace manage a side bitmap to keep track of live objects?

Specified by:

maintainSideBitmap in class SegregatedFreeListSpace

preserveFreeList

protected boolean preserveFreeList()

Description copied from class: SegregatedFreeListSpace

Do we need to preserve free lists as we move blocks around.

Specified by:

preserveFreeList in class SegregatedFreeListSpace

advanceToBlock

protected Address advanceToBlock(Address block,
                                 int sizeClass)

Prepare the next block in the free block list for use by the free list allocator. In the case of lazy sweeping this involves sweeping the available cells. The sweeping operation must ensure that cells are pre-zeroed, as this method must return pre-zeroed cells.

Specified by:

advanceToBlock in class SegregatedFreeListSpace

Parameters:

block - The block to be prepared for use

sizeClass - The size class of the block

Returns:

The address of the first pre-zeroed cell in the free list for this block, or zero if there are no available cells.

notifyNewBlock

protected void notifyNewBlock(Address block,
                              int sizeClass)

Notify that a new block has been installed. This is to ensure that appropriate collection state can be initialized for the block

This is to ensure that appropriate collection state can be initialized for the block.

Overrides:

notifyNewBlock in class SegregatedFreeListSpace

Parameters:

block - The new block

sizeClass - The block's sizeclass.

prepare

public void prepare(boolean gcWholeMS)

Prepare for a new collection increment. For the mark-sweep collector we must flip the state of the mark bit between collections.

Parameters:

gcWholeMS - True if we are going to collect the whole marksweep space

release

public void release()

A new collection increment has completed. For the mark-sweep collector this means we can perform the sweep phase.

release

public void release(Address start)

Release an allocated page or pages

Specified by:

release in class Space

Parameters:

start - The address of the start of the page or pages

isCellLive

protected boolean isCellLive(ObjectReference object)

Should the sweep reclaim the cell containing this object. Is this object live. This is only used when maintainSideBitmap is false.

Overrides:

isCellLive in class SegregatedFreeListSpace

Parameters:

object - The object to query

Returns:

True if the cell should be reclaimed

traceObject

public ObjectReference traceObject(TransitiveClosure trace,
                                   ObjectReference object)

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.

Specified by:

traceObject in class Space

Parameters:

object - The object to be traced.

trace - The trace being conducted.

Returns:

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).

isLive

public boolean isLive(ObjectReference object)

Description copied from class: Space

Is the object in this space alive?

Specified by:

isLive in class Space

Parameters:

object - The object reference.

Returns:

true if this object is known to be live (i.e. it is marked)

getPreviousMarkState

public byte getPreviousMarkState()

Get the previous mark state.

Returns:

The previous mark state.

deltaMarkState

private byte deltaMarkState(boolean increment)

Return the mark state incremented or decremented by one.

Parameters:

increment - If true, then return the incremented value else return the decremented value

Returns:

the mark state incremented or decremented by one.

postAlloc

public void postAlloc(ObjectReference object)

Perform any required post allocation initialization

Parameters:

object - the object ref to the storage to be initialized

postCopy

public void postCopy(ObjectReference object,
                     boolean majorGC)

Perform any required post copy (i.e. in-GC allocation) initialization. This is relevant (for example) when MS is used as the mature space in a copying GC.

Parameters:

object - the object ref to the storage to be initialized

majorGC - Is this copy happening during a major gc?

initializeHeader

public void initializeHeader(ObjectReference object,
                             boolean alloc)

Perform any required initialization of the GC portion of the header.

Parameters:

object - the object ref to the storage to be initialized

alloc - is this initialization occuring due to (initial) allocation (true) or due to copying (false)?

testAndMark

private boolean testAndMark(ObjectReference object)

Atomically attempt to set the mark bit of an object. Return true if successful, false if the mark bit was already set.

Parameters:

object - The object whose mark bit is to be set

testMarkState

private boolean testMarkState(ObjectReference object)

Return true if the mark count for an object has the given value.

Parameters:

object - The object whose mark bit is to be tested

Returns:

true if the mark bit for the object is set.

makeAllocAsMarked

public void makeAllocAsMarked()