org.mmtk.policy

Class MarkSweepSpace

java.lang.Object

org.mmtk.policy.Space

org.mmtk.policy.SegregatedFreeListSpace

org.mmtk.policy.MarkSweepSpace

public final class MarkSweepSpace
extends SegregatedFreeListSpace

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.

Nested Class Summary

Nested classes/interfaces inherited from class org.mmtk.policy.SegregatedFreeListSpace

SegregatedFreeListSpace.Sweeper

Nested classes/interfaces inherited from class org.mmtk.policy.Space

Space.SpaceVisitor

Field Summary

Fields

Modifier and Type	Field and Description
private byte	allocState
private static int	AVAILABLE_LOCAL_BITS highest bit bits we may use
private static int	COUNT_BASE
static int	DEFAULT_MARKCOUNT_BITS
private static boolean	EAGER_MARK_CLEAR
static int	GC_HEADER_WORDS_REQUIRED
static int	GLOBAL_GC_BITS_REQUIRED
static 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.
private boolean	inMSCollection
private boolean	isAgeSegregated
private boolean	isAllocAsMarked
static int	LOCAL_GC_BITS_REQUIRED
private static byte	MARK_COUNT_INCREMENT
private static byte	MARK_COUNT_MASK
private byte	markState
static int	MAX_MARKCOUNT_BITS
private static boolean	usingStickyMarkBits

Fields inherited from class org.mmtk.policy.SegregatedFreeListSpace

availableBlockHead, consumedBlockHead, flushedBlockHead, LAZY_SWEEP, lock, MAX_CELL_SIZE, MAX_CELLS, MAX_FREELIST_OBJECT_BYTES, META_DATA_PAGES_PER_REGION_NO_BITMAP, META_DATA_PAGES_PER_REGION_WITH_BITMAP, MIN_CELLS, WORST_CASE_FRAGMENTATION

Fields inherited from class org.mmtk.policy.Space

AVAILABLE_BYTES, AVAILABLE_END, AVAILABLE_PAGES, AVAILABLE_START, BYTES_IN_CHUNK, contiguous, descriptor, extent, headDiscontiguousRegion, HEAP_END, HEAP_START, immortal, LOG_ADDRESS_SPACE, LOG_BYTES_IN_CHUNK, MAX_CHUNKS, MAX_SPACES, movable, PAGES_IN_CHUNK, pr, start, zeroed

Constructor Summary

Constructors

Constructor and Description
MarkSweepSpace(String name, VMRequest vmRequest) The caller specifies the region of virtual memory to be used for this space.

Method Summary

Modifier and Type	Method and Description
protected Address	advanceToBlock(Address block, int sizeClass) Prepare the next block in the free block list for use by the free list allocator.
private byte	deltaMarkState(boolean increment) Return the mark state incremented or decremented by one.
byte	getPreviousMarkState() Get the previous mark state.
void	initializeHeader(ObjectReference object, boolean alloc) Perform any required initialization of the GC portion of the header.
protected boolean	isCellLive(ObjectReference object) Should the sweep reclaim the cell containing this object.
boolean	isLive(ObjectReference object) Is the object in this space alive?
protected boolean	maintainSideBitmap() Should SegregatedFreeListSpace manage a side bitmap to keep track of live objects?
void	makeAgeSegregatedSpace() This instance will be age-segregated using the sticky mark bits algorithm.
void	makeAllocAsMarked()
protected void	notifyNewBlock(Address block, int sizeClass) Notify that a new block has been installed.
void	postAlloc(ObjectReference object) Perform any required post allocation initialization
void	postCopy(ObjectReference object, boolean majorGC) Perform any required post copy (i.e. in-GC allocation) initialization.
void	prepare(boolean gcWholeMS) Prepare for a new collection increment.
protected boolean	preserveFreeList()
void	release() A new collection increment has completed.
void	release(Address start) Release an allocated page or pages
private boolean	testAndMark(ObjectReference object) Atomically attempt to set the mark bit of an object.
private boolean	testMarkState(ObjectReference object) Return true if the mark count for an object has the given value.
ObjectReference	traceObject(TransitiveClosure trace, ObjectReference object) Trace a reference to an object under a mark sweep collection policy.

Methods inherited from class org.mmtk.policy.SegregatedFreeListSpace

clearAllBlockMarks, clearBlockMark, clearLiveBit, clearLiveBit, clearLiveBits, consumeBlocks, containsLiveCell, flushAvailableBlocks, getAllocationBlock, getBaseCellSize, getFreeList, getSizeClass, liveBitSet, liveBitSet, makeFreeList, markBlock, markBlock, parallelSweepCells, reclaimCellForObject, returnBlock, returnConsumedBlock, setFreeList, sizeClassCount, sweepBlock, sweepCells, sweepCells, sweepConsumedBlocks, testAndSetLiveBit, unsyncClearLiveBit, unsyncClearLiveBit, unsyncSetLiveBit, zeroLiveBits

Methods inherited from class org.mmtk.policy.Space

acquire, availablePhysicalPages, chunkAlign, chunkAlign, committedPages, cumulativeCommittedPages, eagerlyMmapMMTkContiguousSpaces, eagerlyMmapMMTkDiscontiguousSpaces, eagerlyMmapMMTkSpaces, getDescriptor, getDiscontigEnd, getDiscontigStart, getExtent, getFracAvailable, getHeadDiscontiguousRegion, getIndex, getName, getSpaceCount, getSpaceForAddress, getSpaceForObject, getSpaces, getStart, growDiscontiguousSpace, growSpace, isImmortal, isImmortal, isInSpace, isInSpace, isMappedAddress, isMappedObject, isMovable, isMovable, isReachable, printUsageMB, printUsagePages, printVMMap, releaseAllChunks, releaseDiscontiguousChunks, requiredChunks, reservedPages, setZeroingApproach, skipConcurrentZeroing, triggerConcurrentZeroing, visitSpaces

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

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

Constructor Detail

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.

Method Detail

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

Returns:

whether SegregatedFreeListSpace should manage a side bitmap to keep track of live objects

preserveFreeList

protected boolean preserveFreeList()

Specified by:

preserveFreeList in class SegregatedFreeListSpace

Returns:

whether free lists need to be preserved when blocks are moved around

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.

Parameters:

object - The object whose mark bit is to be set

Returns:

true if successful, false if the mark bit was already 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()