From: <ste...@us...> - 2006-09-06 02:00:34
|
Revision: 10753 http://svn.sourceforge.net/jikesrvm/?rev=10753&view=rev Author: steveb-oss Date: 2006-09-05 19:00:25 -0700 (Tue, 05 Sep 2006) Log Message: ----------- Fixed a bug in SegregatedFreeList. The marking operation was using the address of the object referecnce, not the first byte in the object. This showed up when the code was used on another VM with a different object model. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2006-09-06 00:35:37 UTC (rev 10752) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2006-09-06 02:00:25 UTC (rev 10753) @@ -37,13 +37,14 @@ * @see SegregatedFreeList * @see MarkSweepSpace * + * $Id$ + * * @author Steve Blackburn * @version $Revision$ * @date $Date$ */ public final class MarkSweepLocal extends SegregatedFreeList implements Constants, Uninterruptible { - public final static String Id = "$Id$"; /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-09-06 00:35:37 UTC (rev 10752) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-09-06 02:00:25 UTC (rev 10753) @@ -37,13 +37,14 @@ * size class becomes the current block and its free list is used. If * there are no more blocks the a new block is allocated.<p> * + * $Id$ + * * @author Steve Blackburn * @version $Revision$ * @date $Date$ */ public abstract class SegregatedFreeList extends Allocator implements Constants, Uninterruptible { - public final static String Id = "$Id$"; /**************************************************************************** * @@ -747,7 +748,7 @@ */ public static final boolean liveObject(ObjectReference object) throws InlinePragma { - return liveAddress(VM.objectModel.refToAddress(object), true); + return liveAddress(VM.objectModel.objectStartRef(object), true); } /** This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-09-15 04:16:19
|
Revision: 10785 http://svn.sourceforge.net/jikesrvm/?rev=10785&view=rev Author: steveb-oss Date: 2006-09-14 21:16:12 -0700 (Thu, 14 Sep 2006) Log Message: ----------- Modified the bump pointer to introduce an internal (unsynchronized) slow path which may operate at a higher frequency than the external (synchronized) slow path. By default the frequency is set at 1MB, which means the existing external slow path dominates. The performance of this change was carefully measured and showed a very marginal improvement over the previous code. This change generalizes the bump pointer slightly and should make it easier for people to experiment with designs which require sampling or modification ot the bump pointer. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactLocal.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactLocal.java 2006-09-14 23:32:16 UTC (rev 10784) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactLocal.java 2006-09-15 04:16:12 UTC (rev 10785) @@ -109,7 +109,7 @@ allocStart.store(Address.zero(), DATA_END_OFFSET); region = allocStart; cursor = allocCursor; - limit = allocEnd; + updateLimit(allocEnd, region, 0); if (oldPages > newPages) { ((MarkCompactSpace) space).unusePages((oldPages - newPages)); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java 2006-09-14 23:32:16 UTC (rev 10784) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java 2006-09-15 04:16:12 UTC (rev 10785) @@ -32,6 +32,8 @@ * where the allocation that caused a GC or allocations immediately following * GC are run incorrectly. * + * $Id$ + * * @author Perry Cheng * @modified Daniel Frampton * @version $Revision$ @@ -39,8 +41,6 @@ */ public abstract class Allocator implements Constants, Uninterruptible { - public final static String Id = "$Id$"; - /** * Maximum number of retries on consecutive allocation failure. * @@ -213,9 +213,24 @@ int offset, boolean inGC); /** - * Slow path allocation. This method attempts allocSlowOnce several times, - * and allows collection to occur, and ensures that execution safely - * resumes by taking care of potential thread/mutator context affinity + * <b>Out-of-line</b> slow path allocation. This method forces slow path + * allocation to be out of line (typically desirable, but not when the + * calling context is already explicitly out-of-line). + * + * @param bytes The size of the allocation request + * @param alignment The required alignment + * @param offset The alignment offset + * @param inGC Is this request occuring during GC + * @return The start address of the region, or zero if allocation fails + */ + final public Address allocSlow(int bytes, int alignment, int offset, boolean inGC) throws NoInlinePragma { + return allocSlowInline(bytes, alignment, offset, inGC); + } + + /** + * <b>Inline</b> slow path allocation. This method attempts allocSlowOnce + * several times, and allows collection to occur, and ensures that execution + * safely resumes by taking care of potential thread/mutator context affinity * changes. All allocators should use this as the trampoline for slow * path allocation. * @@ -225,13 +240,12 @@ * @param inGC Is this request occuring during GC * @return The start address of the region, or zero if allocation fails */ - final public Address allocSlow(int bytes, int alignment, int offset, - boolean inGC) throws NoInlinePragma { + final public Address allocSlowInline(int bytes, int alignment, int offset, + boolean inGC) throws InlinePragma { int gcCountStart = Stats.gcCount(); Allocator current = this; for (int i = 0; i < MAX_RETRY; i++) { - Address result = - current.allocSlowOnce(bytes, alignment, offset, inGC); + Address result = current.allocSlowOnce(bytes, alignment, offset, inGC); if (!result.isZero()) return result; if (!inGC) { @@ -245,14 +259,16 @@ } Log.write("GC Warning: Possible VM range imbalance - Allocator.allocSlow failed on request of "); Log.write(bytes); - Log.write(" on space "); Log.writeln(Plan.getSpaceNameFromAllocatorAnyLocal(this)); - Log.write("gcCountStart = "); Log.writeln(gcCountStart); - Log.write("gcCount (now) = "); Log.writeln(Stats.gcCount()); + Log.write(" on space "); + Log.writeln(Plan.getSpaceNameFromAllocatorAnyLocal(this)); + Log.write("gcCountStart = "); + Log.writeln(gcCountStart); + Log.write("gcCount (now) = "); + Log.writeln(Stats.gcCount()); Space.printUsageMB(); VM.assertions.dumpStack(); VM.assertions.failWithOutOfMemoryError(); /* NOTREACHED */ return Address.zero(); } - } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2006-09-14 23:32:16 UTC (rev 10784) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2006-09-15 04:16:12 UTC (rev 10785) @@ -60,6 +60,8 @@ */ // Chunk size defines slow path periodicity. + private static final int LOG_DEFAULT_STEP_SIZE = 20; + private static final int DEFAULT_STEP_SIZE = 1<<LOG_DEFAULT_STEP_SIZE; protected static final int LOG_CHUNK_SIZE = LOG_BYTES_IN_PAGE + 3; protected static final Word CHUNK_MASK = Word.one().lsh(LOG_CHUNK_SIZE).minus(Word.one()); @@ -78,7 +80,8 @@ * Instance variables */ protected Address cursor; // insertion point - protected Address limit; // current sentinal for bump pointer + private Address internalLimit; // current internal slow-path sentinal for bump pointer + private Address limit; // current external slow-path sentinal for bump pointer protected Space space; // space this bump pointer is associated with protected Address initialRegion; // first contigious region protected final boolean allowScanning; // linear scanning is permitted if true @@ -101,9 +104,10 @@ * Reset the allocator. Note that this does not reset the space. * This is must be done by the caller. */ - public void reset() { + public final void reset() { cursor = Address.zero(); limit = Address.zero(); + internalLimit = Address.zero(); initialRegion = Address.zero(); region = Address.zero(); } @@ -115,7 +119,7 @@ * * @param space The space to associate the bump pointer with. */ - public void rebind(Space space) { + public final void rebind(Space space) { reset(); this.space = space; } @@ -131,19 +135,49 @@ * @param inGC Is the allocation request occuring during GC. * @return The address of the first byte of the allocated region */ - final public Address alloc(int bytes, int align, int offset, boolean inGC) + public final Address alloc(int bytes, int align, int offset, boolean inGC) throws InlinePragma { Address start = alignAllocationNoFill(cursor, align, offset); Address end = start.plus(bytes); - if (end.GT(limit)) - return allocSlow(bytes, align, offset, inGC); + if (end.GT(internalLimit)) + return allocSlow(start, end, align, offset, inGC); fillAlignmentGap(cursor, start); cursor = end; return start; } + /** + * Internal allocation slow path. This is called whenever the bump + * pointer reaches the internal limit. The code is forced out of + * line. If required we perform an external slow path take, which + * we inline into this method since this is already out of line. + * + * @param start The start address for the pending allocation + * @param end The end address for the pending allocation + * @param align The requested alignment + * @param offset The offset from the alignment + * @param inGC Is the allocation request occuring during GC. + * @return The address of the first byte of the allocated region + * @throws NoInlinePragma + */ + private final Address allocSlow(Address start, Address end, int align, + int offset, boolean inGC) throws NoInlinePragma { + if (end.GT(limit)) { + return allocSlowInline(end.diff(start).toInt(), align, offset, + inGC); + } else { + while (internalLimit.LE(end)) + internalLimit = internalLimit.plus(DEFAULT_STEP_SIZE); + if (internalLimit.GT(limit)) + internalLimit = limit; + fillAlignmentGap(cursor, start); + cursor = end; + return start; + } + } + /** - * Allocation slow path (called by superclass when slow path is + * External allocation slow path (called by superclass when slow path is * actually taken. This is necessary (rather than a direct call * from the fast path) because of the possibility of a thread switch * and corresponding re-association of bump pointers to kernel @@ -156,22 +190,13 @@ * @return The address of the first byte of the allocated region or * zero on failure */ - final protected Address allocSlowOnce(int bytes, int align, int offset, + protected final Address allocSlowOnce(int bytes, int align, int offset, boolean inGC) { /* Check if we already have a chunk to use */ if (allowScanning && !region.isZero()) { Address nextRegion = region.loadAddress(NEXT_REGION_OFFSET); if (!nextRegion.isZero()) { - region.plus(DATA_END_OFFSET).store(cursor); - region = nextRegion; - cursor = nextRegion.plus(DATA_START_OFFSET); - limit = nextRegion.loadAddress(REGION_LIMIT_OFFSET); - nextRegion.store(Address.zero(), DATA_END_OFFSET); - VM.memory.zero(cursor, limit.diff(cursor).toWord().toExtent().plus(BYTES_IN_ADDRESS)); - - reusePages(Conversions.bytesToPages(limit.diff(region).plus(BYTES_IN_ADDRESS))); - - return alloc(bytes, align, offset, inGC); + return consumeNextRegion(nextRegion, bytes, align, offset, inGC); } } @@ -183,21 +208,70 @@ if (start.isZero()) return start; // failed allocation if (!allowScanning) { // simple allocator - if (start.NE(limit)) cursor = start; - limit = start.plus(chunkSize); + if (start.NE(limit)) cursor = start; // discontigious + updateLimit(start.plus(chunkSize), start, bytes); } else // scannable allocator - updateMetaData(start, chunkSize); + updateMetaData(start, chunkSize, bytes); return alloc(bytes, align, offset, inGC); } /** + * Update the limit pointer. As a side effect update the internal limit + * pointer appropriately. + * + * @param newLimit The new value for the limit pointer + * @param start The start of the region to be allocated into + * @param bytes The size of the pending allocation (if any). + */ + protected final void updateLimit(Address newLimit, Address start, int bytes) + throws InlinePragma { + limit = newLimit; + internalLimit = start.plus(DEFAULT_STEP_SIZE); + if (internalLimit.GT(limit)) + internalLimit = limit; + else { + while (internalLimit.LT(cursor.plus(bytes))) + internalLimit = internalLimit.plus(DEFAULT_STEP_SIZE); + if (VM.VERIFY_ASSERTIONS) + VM.assertions._assert(internalLimit.LE(limit)); + } + } + + /** + * A bump pointer chuck/region has been consumed but the contigious region + * is available, so consume it and then return the address of the start + * of a memory region satisfying the outstanding allocation request. This + * is relevant when re-using memory, as in a mark-compact collector. + * + * @param nextRegion The region to be consumed + * @param bytes The number of bytes allocated + * @param align The requested alignment + * @param offset The offset from the alignment + * @param inGC Was the request made from within GC? + * @return The address of the first byte of the allocated region or + * zero on failure + */ + private final Address consumeNextRegion(Address nextRegion, int bytes, int align, + int offset, boolean inGC) { + region.plus(DATA_END_OFFSET).store(cursor); + region = nextRegion; + cursor = nextRegion.plus(DATA_START_OFFSET); + updateLimit(nextRegion.loadAddress(REGION_LIMIT_OFFSET), nextRegion, bytes); + nextRegion.store(Address.zero(), DATA_END_OFFSET); + VM.memory.zero(cursor, limit.diff(cursor).toWord().toExtent().plus(BYTES_IN_ADDRESS)); + reusePages(Conversions.bytesToPages(limit.diff(region).plus(BYTES_IN_ADDRESS))); + + return alloc(bytes, align, offset, inGC); + } + + /** * Update the metadata to reflect the addition of a new region. * * @param start The start of the new region * @param size The size of the new region (rounded up to chunk-alignment) */ - private void updateMetaData(Address start, Extent size) + private final void updateMetaData(Address start, Extent size, int bytes) throws InlinePragma { if (initialRegion.isZero()) { /* this is the first allocation */ @@ -213,7 +287,7 @@ region = start; cursor = start.plus(DATA_START_OFFSET); } - limit = start.plus(size.minus(BYTES_IN_ADDRESS)); // skip over region limit + updateLimit(start.plus(size.minus(BYTES_IN_ADDRESS)), start, bytes); // skip over region limit region.plus(REGION_LIMIT_OFFSET).store(limit); } @@ -222,7 +296,7 @@ * * @param scanner The scan object to delegate scanning to. */ - public void linearScan(LinearScan scanner) throws InlinePragma { + public final void linearScan(LinearScan scanner) throws InlinePragma { if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(allowScanning); /* Has this allocator ever allocated anything? */ if (initialRegion.isZero()) return; @@ -241,7 +315,7 @@ * @param scanner The scan object to delegate to. * @param start The start of this region */ - private void scanRegion(LinearScan scanner, Address start) + private final void scanRegion(LinearScan scanner, Address start) throws InlinePragma { /* Get the end of this region */ Address dataEnd = start.plus(DATA_END_OFFSET).loadAddress(); @@ -274,14 +348,14 @@ protected Extent maximumRegionSize() { return Extent.max(); } /** @return the current cursor value */ - public Address getCursor() { return cursor; } + public final Address getCursor() { return cursor; } /** @return the space associated with this bump pointer */ - public Space getSpace() { return space; } + public final Space getSpace() { return space; } /** * Print out the status of the allocator (for debugging) */ - public void show() { + public final void show() { Log.write("cursor = "); Log.write(cursor); if (allowScanning) { Log.write(" region = "); Log.write(region); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dgr...@us...> - 2006-09-22 17:28:16
|
Revision: 10814 http://svn.sourceforge.net/jikesrvm/?rev=10814&view=rev Author: dgrove-oss Date: 2006-09-22 10:27:58 -0700 (Fri, 22 Sep 2006) Log Message: ----------- add missing header elements Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyMatureTraceLocal.java rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java rvmroot/trunk/MMTk/src/org/mmtk/vm/ActivePlan.java rvmroot/trunk/MMTk/src/org/mmtk/vm/Options.java rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -5,7 +5,7 @@ * available at http://www.opensource.org/licenses/cpl1.0.php * * (C) Copyright Department of Computer Science, - * Australian National University. 2005 + * Australian National University. 2005 */ package org.mmtk.plan.generational; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyCollector.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyCollector.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -1,3 +1,12 @@ +/* + * This file is part of MMTk (http://jikesrvm.sourceforge.net). + * MMTk is distributed under the Common Public License (CPL). + * A copy of the license is included in the distribution, and is also + * available at http://www.opensource.org/licenses/cpl1.0.php + * + * (C) Copyright Department of Computer Science, + * Australian National University. 2005 + */ package org.mmtk.plan.generational.copying; import org.mmtk.plan.generational.GenCollector; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyConstraints.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyConstraints.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyConstraints.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -6,6 +6,8 @@ * * (C) Copyright Department of Computer Science, * Australian National University. 2005 + * + * $Id$ */ package org.mmtk.plan.generational.copying; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyMatureTraceLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyMatureTraceLocal.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/copying/GenCopyMatureTraceLocal.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -1,3 +1,12 @@ +/* + * This file is part of MMTk (http://jikesrvm.sourceforge.net). + * MMTk is distributed under the Common Public License (CPL). + * A copy of the license is included in the distribution, and is also + * available at http://www.opensource.org/licenses/cpl1.0.php + * + * (C) Copyright Department of Computer Science, + * Australian National University. 2005 + */ package org.mmtk.plan.generational.copying; import org.mmtk.plan.generational.GenCollector; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -9,6 +9,8 @@ * * (C) Copyright Department of Computer Science, * University of Massachusetts, Amherst. 2003 + * + * $Id$ */ package org.mmtk.plan.semispace.gctrace; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -5,6 +5,8 @@ * available at http://www.opensource.org/licenses/cpl1.0.php * * (C) Copyright IBM Corp 2001,2002 + * + * $Id$ */ package org.mmtk.utility; Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/ActivePlan.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/ActivePlan.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/ActivePlan.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -1,3 +1,14 @@ +/* + * This file is part of MMTk (http://jikesrvm.sourceforge.net). + * MMTk is distributed under the Common Public License (CPL). + * A copy of the license is included in the distribution, and is also + * available at http://www.opensource.org/licenses/cpl1.0.php + * + * (C) Copyright Department of Computer Science, + * Australian National University. 2004 + * + * (C) Copyright IBM Corp. 2001, 2003 + */ package org.mmtk.vm; import org.mmtk.plan.Plan; Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/Options.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/Options.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/Options.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -5,6 +5,8 @@ * available at http://www.opensource.org/licenses/cpl1.0.php * * (C) Copyright ANU. 2004 + * + * $Id$ */ package org.mmtk.vm; Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java 2006-09-22 15:57:47 UTC (rev 10813) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java 2006-09-22 17:27:58 UTC (rev 10814) @@ -6,6 +6,8 @@ * * (C) Copyright Department of Computer Science, * University of Massachusetts, Amherst. 2003. + * + * $Id$ */ package org.mmtk.vm; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-09-25 00:09:50
|
Revision: 10823 http://svn.sourceforge.net/jikesrvm/?rev=10823&view=rev Author: steveb-oss Date: 2006-09-24 17:09:34 -0700 (Sun, 24 Sep 2006) Log Message: ----------- Added generic support for card scanning. By default this does nothing, but it provides hooks which can be used to trivially implement a card-marking write barrier and a variety of sanity checks, such as the capacity to perform a reverse mapping (check whether a given address corresponds to a real object). Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/MonotonePageResource.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/PageResource.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -38,7 +38,7 @@ public boolean needsStaticReadBarrier() { return false; } /** @return True if this Plan requires linear scanning. */ - public boolean needsLinearScan() { return false;} + public boolean needsLinearScan() { return org.mmtk.utility.Constants.SUPPORT_CARD_SCANNING;} /** @return True if this Plan does not support parallel collection. */ public boolean noParallelGC() { return false;} Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -45,6 +45,8 @@ public static final int GLOBAL_GC_BITS_REQUIRED = 0; public static final int GC_HEADER_WORDS_REQUIRED = 0; + private static final int META_DATA_PAGES_PER_REGION = CARD_META_PAGES_PER_REGION; + /* * The forwarding process uses three states to deal with a GC race: * 1. !GC_FORWARDED: Unforwarded @@ -89,7 +91,7 @@ boolean fromSpace) { super(name, true, false, start, bytes); this.fromSpace = fromSpace; - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -109,7 +111,7 @@ public CopySpace(String name, int pageBudget, int mb, boolean fromSpace) { super(name, true, false, mb); this.fromSpace = fromSpace; - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -132,7 +134,7 @@ boolean fromSpace) { super(name, true, false, frac); this.fromSpace = fromSpace; - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -159,7 +161,7 @@ boolean fromSpace) { super(name, true, false, mb, top); this.fromSpace = fromSpace; - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -187,7 +189,7 @@ boolean fromSpace) { super(name, true, false, frac, top); this.fromSpace = fromSpace; - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -41,6 +41,7 @@ * Class variables */ static final Word GC_MARK_BIT_MASK = Word.one(); + private static final int META_DATA_PAGES_PER_REGION = CARD_META_PAGES_PER_REGION; /**************************************************************************** * @@ -67,7 +68,7 @@ public ImmortalSpace(String name, int pageBudget, Address start, Extent bytes) { super(name, false, true, start, bytes); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -84,7 +85,7 @@ */ public ImmortalSpace(String name, int pageBudget, int mb) { super(name, false, true, mb); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -103,7 +104,7 @@ */ public ImmortalSpace(String name, int pageBudget, float frac) { super(name, false, true, frac); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -126,7 +127,7 @@ */ public ImmortalSpace(String name, int pageBudget, int mb, boolean top) { super(name, false, true, mb, top); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @@ -150,7 +151,7 @@ */ public ImmortalSpace(String name, int pageBudget, float frac, boolean top) { super(name, false, true, frac, top); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION); } /** @return the current mark state */ Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -68,7 +68,7 @@ */ public MarkCompactSpace(String name, int pageBudget, float frac) { super(name, true, false, frac); - pr = new MonotonePageResource(pageBudget, this, start, extent); + pr = new MonotonePageResource(pageBudget, this, start, extent, 0); } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -12,6 +12,7 @@ package org.mmtk.utility; +import org.mmtk.utility.alloc.EmbeddedMetaData; import org.mmtk.vm.VM; /** @@ -61,6 +62,21 @@ /**************************************************************************** * + * Card scanning + */ + public static final boolean SUPPORT_CARD_SCANNING = false; + public static final int LOG_CARD_META_SIZE = 2;// each card consumes four bytes of metadata + static final int LOG_CARD_UNITS = 10; // number of units tracked per card + static final int LOG_CARD_GRAIN = 0; // track at byte grain, save shifting + public static final int LOG_CARD_BYTES = LOG_CARD_UNITS + LOG_CARD_GRAIN; + static final int LOG_CARD_META_BYTES = EmbeddedMetaData.LOG_BYTES_IN_REGION - LOG_CARD_BYTES + LOG_CARD_META_SIZE; + static final int LOG_CARD_META_PAGES = LOG_CARD_META_BYTES - VM.LOG_BYTES_IN_PAGE; + public static final int CARD_META_PAGES_PER_REGION = SUPPORT_CARD_SCANNING ? (1<<LOG_CARD_META_PAGES) : 0; + public static final int CARD_MASK = (1<<LOG_CARD_BYTES) - 1; + + + /**************************************************************************** + * * Java-specific sizes currently required by MMTk * * TODO MMTk should really become independant of these Java types Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -46,6 +46,7 @@ public static final int LOG_BLOCKS_IN_REGION = EmbeddedMetaData.LOG_BYTES_IN_REGION - LOG_MIN_BLOCK; private static final int SUB_PAGE_SIZE_CLASS = LOG_BYTES_IN_PAGE - LOG_MIN_BLOCK - 1; public static final int LOG_MAX_BLOCK = 15; // 32K bytes + private static final int BLOCK_SIZES = 1 + LOG_MAX_BLOCK - LOG_MIN_BLOCK; public static final int MAX_BLOCK_SIZE = 1 << LOG_MAX_BLOCK; private static final int MAX_BLOCK_PAGES = 1 << (LOG_MAX_BLOCK - LOG_BYTES_IN_PAGE); private static final byte MAX_BLOCK_SIZE_CLASS = LOG_MAX_BLOCK - LOG_MIN_BLOCK; @@ -57,9 +58,13 @@ // metadata private static final Offset PREV_OFFSET = Offset.zero(); private static final Offset NEXT_OFFSET = PREV_OFFSET.plus(BYTES_IN_ADDRESS); - private static final Offset SC_OFFSET = NEXT_OFFSET.plus(BYTES_IN_ADDRESS); - private static final Offset IU_OFFSET = SC_OFFSET.plus(BYTES_IN_SHORT); + private static final Offset BMD_OFFSET = NEXT_OFFSET.plus(BYTES_IN_ADDRESS); + private static final Offset CSC_OFFSET = BMD_OFFSET.plus(1); + private static final Offset IU_OFFSET = CSC_OFFSET.plus(1); private static final Offset FL_META_OFFSET = IU_OFFSET.plus(BYTES_IN_SHORT); + private static final byte BLOCK_SC_MASK = 0xf; // lower 4 bits + private static final int BLOCK_PAGE_OFFSET_SHIFT = 4; // higher 4 bits + private static final int MAX_BLOCK_PAGE_OFFSET = (1<<4)-1; // 4 bits private static final int LOG_BYTES_IN_BLOCK_META = LOG_BYTES_IN_ADDRESS + 2; private static final int BLOCK_META_SIZE = 1 << LOG_BYTES_IN_BLOCK_META; private static final int LOG_BYTE_COVERAGE = LOG_MIN_BLOCK - LOG_BYTES_IN_BLOCK_META; @@ -189,7 +194,7 @@ Address rtn; int pages = pagesForSizeClass(blockSizeClass); if (!(rtn = space.acquire(pages)).isZero()) { - setBlkSizeClass(rtn, (short) blockSizeClass); + setBlkSizeMetaData(rtn, (byte) blockSizeClass); if (blockSizeClass <= SUB_PAGE_SIZE_CLASS) populatePage(rtn, blockSizeClass); if (PARANOID) { @@ -330,10 +335,22 @@ * @param address The address of interest * @param sc The value to which this field is to be set */ - private static final void setBlkSizeClass(Address address, short sc) + private static final void setBlkSizeMetaData(Address block, byte sc) throws InlinePragma { - address = Conversions.pageAlign(address); - getMetaAddress(address).store(sc, SC_OFFSET); + if (VM.VERIFY_ASSERTIONS) { + VM.assertions._assert(block == Conversions.pageAlign(block)); + VM.assertions._assert(pagesForSizeClass(sc) - 1 <= MAX_BLOCK_PAGE_OFFSET); + } + Address address = block; + for (int i = 0; i < pagesForSizeClass(sc); i++) { + byte value = (byte) ((i << BLOCK_PAGE_OFFSET_SHIFT) | sc); + getMetaAddress(address).store(value, BMD_OFFSET); + if (VM.VERIFY_ASSERTIONS) { + VM.assertions._assert(getBlkStart(address).EQ(block)); + VM.assertions._assert(getBlkSizeClass(address) == sc); + } + address = address.plus(1<<VM.LOG_BYTES_IN_PAGE); + } } /** @@ -344,15 +361,61 @@ * @param address The address of interest * @return The size class field for the block containing the given address */ - private static final short getBlkSizeClass(Address address) + private static final byte getBlkSizeClass(Address address) throws InlinePragma { address = Conversions.pageAlign(address); - short rtn = getMetaAddress(address).loadShort(SC_OFFSET); - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(rtn >= 0 && rtn <= (short) MAX_BLOCK_SIZE_CLASS); + byte rtn = (byte) (getMetaAddress(address).loadByte(BMD_OFFSET) & BLOCK_SC_MASK); + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(rtn >= 0 && rtn <= (byte) MAX_BLOCK_SIZE_CLASS); return rtn; } /** + * Get the <i>address of the start of a block size class</i> a given page + * within the block. + * + * @param address The address of interest + * @return The address of the block containing the address + */ + public static final Address getBlkStart(Address address) throws InlinePragma { + address = Conversions.pageAlign(address); + byte offset = (byte) (getMetaAddress(address).loadByte(BMD_OFFSET) >>> BLOCK_PAGE_OFFSET_SHIFT); + return address.minus(offset<<LOG_BYTES_IN_PAGE); + } + + /** + * Set the <i>client size class</i> meta data field for a given + * address (all blocks on a given page are homogeneous with respect + * to block size class). + * + * @param address The address of interest + * @param sc The value to which this field is to be set + */ + public static final void setAllClientSizeClass(Address block, int blocksc, byte sc) + throws InlinePragma { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(block == Conversions.pageAlign(block)); + Address address = block; + for (int i = 0; i < pagesForSizeClass(blocksc); i++) { + getMetaAddress(address).store(sc, CSC_OFFSET); + address = address.plus(1<<VM.LOG_BYTES_IN_PAGE); + } + } + + /** + * Get the <i>client size class</i> meta data field for a given page + * (all blocks on a given page are homogeneous with respect to block + * size class). + * + * @param address The address of interest + * @return The size class field for the block containing the given address + */ + public static final byte getClientSizeClass(Address address) + throws InlinePragma { + address = Conversions.pageAlign(address); + byte rtn = getMetaAddress(address).loadByte(CSC_OFFSET); + return rtn; + } + + /** * Set the free list meta data field for a given address (this is * per-block meta data that is stored along with the block metadata * but not used by the block allocator). Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -65,8 +65,8 @@ */ // Chunk size defines slow path periodicity. - private static final int LOG_DEFAULT_STEP_SIZE = 20; - private static final int DEFAULT_STEP_SIZE = 1<<LOG_DEFAULT_STEP_SIZE; + private static final int LOG_DEFAULT_STEP_SIZE = 20; // 1M: let the external slow path dominate + private static final int STEP_SIZE = 1<<(SUPPORT_CARD_SCANNING ? LOG_CARD_BYTES : LOG_DEFAULT_STEP_SIZE); protected static final int LOG_CHUNK_SIZE = LOG_BYTES_IN_PAGE + 3; protected static final Word CHUNK_MASK = Word.one().lsh(LOG_CHUNK_SIZE).minus(Word.one()); @@ -79,6 +79,9 @@ protected static final Offset DATA_START_OFFSET = alignAllocationNoFill( Address.zero().plus(DATA_END_OFFSET.plus(BYTES_IN_ADDRESS)), MIN_ALIGNMENT, 0).toWord().toOffset(); + protected static final Offset MAX_DATA_START_OFFSET = alignAllocationNoFill( + Address.zero().plus(DATA_END_OFFSET.plus(BYTES_IN_ADDRESS)), + MAX_ALIGNMENT, 0).toWord().toOffset(); /**************************************************************************** * @@ -167,21 +170,74 @@ */ private final Address allocSlow(Address start, Address end, int align, int offset, boolean inGC) throws NoInlinePragma { - if (end.GT(limit)) { - return allocSlowInline(end.diff(start).toInt(), align, offset, + Address rtn = null; + Address card = null; + if (SUPPORT_CARD_SCANNING) + getCard(start.plus(CARD_MASK)); // round up + if (end.GT(limit)) { /* external slow path */ + rtn = allocSlowInline(end.diff(start).toInt(), align, offset, inGC); - } else { + if (SUPPORT_CARD_SCANNING && card.NE(getCard(rtn.plus(CARD_MASK)))) + card = getCard(rtn); // round down + } else { /* internal slow path */ while (internalLimit.LE(end)) - internalLimit = internalLimit.plus(DEFAULT_STEP_SIZE); + internalLimit = internalLimit.plus(STEP_SIZE); if (internalLimit.GT(limit)) internalLimit = limit; fillAlignmentGap(cursor, start); cursor = end; - return start; + rtn = start; } + if (SUPPORT_CARD_SCANNING && !rtn.isZero()) + createCardAnchor(card, rtn, end.diff(start).toInt()); + return rtn; } + + /** + * Given an allocation which starts a new card, create a record of + * where the start of the object is relative to the start of the + * card. + * + * @param card An address that lies within the card to be marked + * @param start The address of an object which creates a new card. + * @param bytes The size of the pending allocation in bytes (used for debugging) + */ + private final void createCardAnchor(Address card, Address start, int bytes) { + if (VM.VERIFY_ASSERTIONS) { + VM.assertions._assert(allowScanning); + VM.assertions._assert(card.EQ(getCard(card))); + VM.assertions._assert(start.diff(card).sLE(MAX_DATA_START_OFFSET)); + VM.assertions._assert(start.diff(card).toInt() >= -CARD_MASK); + } + while (bytes > 0) { + int offset = start.diff(card).toInt(); + getCardMetaData(card).store(offset); + card = card.plus(1 << LOG_CARD_BYTES); + bytes -= (1 << LOG_CARD_BYTES); + } + } /** + * Return the start of the card corresponding to a given address. + * + * @param address The address for which the card start is required + * @return The start of the card containing the address + */ + private static final Address getCard(Address address) { + return address.toWord().and(Word.fromInt(CARD_MASK).not()).toAddress(); + } + + /** + * Return the address of the metadata for a card, given the address of the card. + * @param card The address of some card + * @return The address of the metadata associated with that card + */ + private static final Address getCardMetaData(Address card) { + Address metadata = EmbeddedMetaData.getMetaDataBase(card); + return metadata.plus(EmbeddedMetaData.getMetaDataOffset(card, LOG_CARD_BYTES-LOG_CARD_META_SIZE, LOG_CARD_META_SIZE)); + } + + /** * External allocation slow path (called by superclass when slow path is * actually taken. This is necessary (rather than a direct call * from the fast path) because of the possibility of a thread switch @@ -217,7 +273,6 @@ updateLimit(start.plus(chunkSize), start, bytes); } else // scannable allocator updateMetaData(start, chunkSize, bytes); - return alloc(bytes, align, offset, inGC); } @@ -232,12 +287,12 @@ protected final void updateLimit(Address newLimit, Address start, int bytes) throws InlinePragma { limit = newLimit; - internalLimit = start.plus(DEFAULT_STEP_SIZE); + internalLimit = start.plus(STEP_SIZE); if (internalLimit.GT(limit)) internalLimit = limit; else { while (internalLimit.LT(cursor.plus(bytes))) - internalLimit = internalLimit.plus(DEFAULT_STEP_SIZE); + internalLimit = internalLimit.plus(STEP_SIZE); if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(internalLimit.LE(limit)); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -372,6 +372,7 @@ */ private final void installNewBlock(Address block, int sizeClass) throws InlinePragma { + BlockAllocator.setAllClientSizeClass(block, blockSizeClass[sizeClass], (byte) sizeClass); BlockAllocator.linkedListInsert(block, lastBlock.get(sizeClass)); currentBlock.set(sizeClass, block); lastBlock.set(sizeClass, block); Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -164,7 +164,6 @@ unlock(); } - /** * Reserve virtual address space for meta-data. * @@ -185,6 +184,28 @@ } } + /** + * Adjust a page request to include metadata requirements, if any. In the + * case of a free-list allocator, meta-data is pre-allocated, so simply + * return the un-adjusted request size. + * + * @param pages The size of the pending allocation in pages + * @return The (unadjusted) request size, since metadata is pre-allocated + */ + public final int adjustForMetaData(int pages) { return pages; } + + /** + * Adjust a page request to include metadata requirements, if any. In the + * case of a free-list allocator, meta-data is pre-allocated, so simply + * return the un-adjusted request size. + * + * @param pages The size of the pending allocation in pages + * @param begin The start of the region of memory assigned to this pending + * allocation + * @return The (unadjusted) request size, since metadata is pre-allocated + */ + public final int adjustForMetaData(int pages, Address begin) { return pages; } + final int pages(Address first) throws InlinePragma { return freeList.size(Conversions.bytesToPages(first.diff(start))); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/MonotonePageResource.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/MonotonePageResource.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/MonotonePageResource.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -9,6 +9,7 @@ */ package org.mmtk.utility.heap; +import org.mmtk.utility.alloc.EmbeddedMetaData; import org.mmtk.utility.options.Options; import org.mmtk.policy.Space; import org.mmtk.utility.Conversions; @@ -40,6 +41,7 @@ */ private Address cursor; private Address sentinel; + private int metaDataPagesPerRegion; /** * Constructor @@ -52,12 +54,15 @@ * @param space The space to which this resource is attached * @param start The start of the address range allocated to this resource * @param bytes The size of the address rage allocated to this resource + * @param metaDataPagesPerRegion The number of pages of meta data + * that are embedded in each region. */ public MonotonePageResource(int pageBudget, Space space, Address start, - Extent bytes) { + Extent bytes, int metaDataPagesPerRegion) { super(pageBudget, space, start); this.cursor = start; this.sentinel = start.plus(bytes); + this.metaDataPagesPerRegion = metaDataPagesPerRegion; } /** @@ -72,8 +77,10 @@ * @param pageBudget The budget of pages available to this memory * manager before it must poll the collector. * @param space The space to which this resource is attached + * @param metaDataPagesPerRegion The number of pages of meta data + * that are embedded in each region. */ - public MonotonePageResource(int pageBudget, Space space) { + public MonotonePageResource(int pageBudget, Space space, int metaDataPagesPerRegion) { super(pageBudget, space); /* unimplemented */ if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false); @@ -81,6 +88,7 @@ this.start = Address.zero(); this.cursor = Address.zero(); this.sentinel = Address.zero(); + this.metaDataPagesPerRegion = metaDataPagesPerRegion; } /** @@ -95,11 +103,27 @@ * @return The start of the first page if successful, zero on * failure. */ - protected final Address allocPages(int pages) throws InlinePragma { - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(contiguous); + protected final Address allocPages(int requestPages) throws InlinePragma { + if (VM.VERIFY_ASSERTIONS) + VM.assertions._assert(contiguous); + int pages = requestPages; lock(); + Address rtn = cursor; + if (metaDataPagesPerRegion != 0) { + /* adjust allocation for metadata */ + Address regionStart = getRegionStart(cursor.plus(Conversions + .pagesToBytes(pages))); + Offset regionDelta = regionStart.diff(cursor); + if (regionDelta.sGE(Offset.zero())) { + /* start new region, so adjust pages and return address accordingly */ + pages += Conversions.bytesToPages(regionDelta) + metaDataPagesPerRegion; + rtn = regionStart.plus(Conversions.pagesToBytes(metaDataPagesPerRegion)); + } + } Extent bytes = Conversions.pagesToBytes(pages); Address tmp = cursor.plus(bytes); + if (VM.VERIFY_ASSERTIONS) + VM.assertions._assert(rtn.GE(cursor) && rtn.LT(cursor.plus(bytes))); if (tmp.GT(sentinel)) { unlock(); return Address.zero(); @@ -109,8 +133,55 @@ unlock(); LazyMmapper.ensureMapped(old, pages); VM.memory.zero(old, bytes); - return old; + return rtn; } + } + + /** + * Adjust a page request to include metadata requirements, if any.<p> + * + * Note that there could be a race here, with multiple threads each + * adjusting their request on account of the same single metadata + * region. This should not be harmful, as the failing requests will + * just retry, and if multiple requests succeed, only one of them + * will actually have the metadata accounted against it, the others + * will simply have more space than they originally requested. + * + * @param pages The size of the pending allocation in pages + * @return The number of required pages, inclusive of any metadata + */ + public final int adjustForMetaData(int pages) { + Extent bytes = Conversions.pagesToBytes(pages); + if (metaDataPagesPerRegion != 0) { + if (cursor.LE(getRegionStart(cursor.plus(bytes)))) + pages += metaDataPagesPerRegion; + } + return pages; + } + + /** + * Adjust a page request to include metadata requirements, if any.<p> + * + * Note that there could be a race here, with multiple threads each + * adjusting their request on account of the same single metadata + * region. This should not be harmful, as the failing requests will + * just retry, and if multiple requests succeed, only one of them + * will actually have the metadata accounted against it, the others + * will simply have more space than they originally requested. + * + * @param pages The size of the pending allocation in pages + * @param begin The start address of the region assigned to this pending + * request + * @return The number of required pages, inclusive of any metadata + */ + public final int adjustForMetaData(int pages, Address begin) { + if (getRegionStart(begin).plus(metaDataPagesPerRegion<<LOG_BYTES_IN_PAGE).EQ(begin)) + pages += metaDataPagesPerRegion; + return pages; + } + + private static final Address getRegionStart(Address addr) { + return addr.toWord().and(Word.fromInt(EmbeddedMetaData.BYTES_IN_REGION - 1).not()).toAddress(); } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/PageResource.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/PageResource.java 2006-09-24 18:17:07 UTC (rev 10822) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/PageResource.java 2006-09-25 00:09:34 UTC (rev 10823) @@ -116,7 +116,7 @@ */ public final boolean reservePages(int pages) throws InlinePragma { lock(); - reserved = committed + pages; + reserved = committed + adjustForMetaData(pages); boolean satisfied = reserved <= pageBudget; unlock(); return satisfied; @@ -125,6 +125,24 @@ abstract Address allocPages(int pages); /** + * Adjust a page request to include metadata requirements, if any. + * + * @param pages The size of the pending allocation in pages + * @return The number of required pages, inclusive of any metadata + */ + abstract public int adjustForMetaData(int pages); + + /** + * Adjust a page request to include metadata requirements, if any. + * + * @param pages The size of the pending allocation in pages + * @param begin The address of the virtual memory region assigned to this + * pending request + * @return The number of required pages, inclusive of any metadata + */ + abstract public int adjustForMetaData(int pages, Address begin); + + /** * Allocate pages in virtual memory, returning zero on failure.<p> * * If the request cannot be satisified, zero is returned and it @@ -140,7 +158,7 @@ */ public final Address getNewPages(int pages) throws InlinePragma { Address rtn = allocPages(pages); - if (!rtn.isZero()) commitPages(pages); + if (!rtn.isZero()) commitPages(pages, rtn); return rtn; } @@ -152,10 +170,11 @@ * <code>reserved</code> while the request was pending. * * @param pages The number of pages to be committed + * @param begin The start address of the allocated region */ - private final void commitPages(int pages) { + private final void commitPages(int pages, Address begin) { lock(); - committed += pages; + committed += adjustForMetaData(pages, begin); if (!Plan.gcInProgress()) addToCommitted(pages); // only count mutator pages unlock(); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2006-10-08 22:47:15
|
Revision: 10875 http://svn.sourceforge.net/jikesrvm/?rev=10875&view=rev Author: dframpton-oss Date: 2006-10-08 15:47:00 -0700 (Sun, 08 Oct 2006) Log Message: ----------- Removed SANITY_FORWARD phase. This is related to future functionality that is not yet implemented, but was interfering with some basic functionality. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2006-10-08 04:22:37 UTC (rev 10874) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2006-10-08 22:47:00 UTC (rev 10875) @@ -85,14 +85,7 @@ public static final int SANITY_ROOTS = new SimplePhase("sanity-roots", null, Phase.GLOBAL_LAST ).getId(); public static final int SANITY_CHECK = new SimplePhase("sanity", null, Phase.COLLECTOR_ONLY ).getId(); public static final int SANITY_RELEASE = new SimplePhase("sanity-release", null, Phase.GLOBAL_LAST ).getId(); - public static final int SANITY_FORWARD = new SimplePhase("sanity-forward", null, Phase.COLLECTOR_ONLY ).getId(); - /* Sanity forwarding piggy-back */ - private static final int sanityForwardPhase = new ComplexPhase("sanity-forward-cf", null, new int[] { - FORWARD, - SANITY_FORWARD, - }).getId(); - /* Sanity check phase sequence */ private static final int sanityPhase = new ComplexPhase("sanity-check", null, new int[] { SANITY_PREPARE, @@ -188,7 +181,6 @@ } else { Log.writeln("Collection sanity checking enabled."); collection.replacePhase(SANITY_PLACEHOLDER, sanityPhase); - collection.replacePhase(FORWARD, sanityForwardPhase); } } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2006-10-08 04:22:37 UTC (rev 10874) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2006-10-08 22:47:00 UTC (rev 10875) @@ -112,14 +112,6 @@ return true; } - if (phaseId == StopTheWorld.SANITY_FORWARD) { - if (primary) { - TraceLocal trace = VM.activePlan.collector().getCurrentTrace(); - global().getSanityTable().forwardTable(trace); - } - return true; - } - return false; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-10-09 01:21:23
|
Revision: 10876 http://svn.sourceforge.net/jikesrvm/?rev=10876&view=rev Author: steveb-oss Date: 2006-10-08 18:21:00 -0700 (Sun, 08 Oct 2006) Log Message: ----------- A number of minor code cleanups, mostly centered on marksweep mark bits. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java rvmroot/trunk/MMTk/src/org/mmtk/plan/TraceLocal.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCCollector.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/RefCountLocal.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SharedDeque.java rvmroot/trunk/MMTk/src/org/mmtk/utility/options/MarkSweepMarkBits.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -182,9 +182,9 @@ public void postAlloc(ObjectReference ref, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma { switch (allocator) { - case Plan.ALLOC_LOS: Plan.loSpace.initializeHeader(ref); return; - case Plan.ALLOC_PRIMITIVE_LOS: Plan.ploSpace.initializeHeader(ref); return; - case Plan.ALLOC_IMMORTAL: Plan.immortalSpace.postAlloc(ref); return; + case Plan.ALLOC_LOS: Plan.loSpace.initializeHeader(ref, false); return; + case Plan.ALLOC_PRIMITIVE_LOS: Plan.ploSpace.initializeHeader(ref, true); return; + case Plan.ALLOC_IMMORTAL: Plan.immortalSpace.initializeHeader(ref); return; default: VM.assertions.fail("No such allocator"); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/TraceLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/TraceLocal.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/TraceLocal.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -472,6 +472,7 @@ } processRememberedSets(); } while (!values.isEmpty()); + assertMutatorRemsetsFlushed(); } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -18,8 +18,6 @@ import org.mmtk.utility.options.Options; import org.mmtk.utility.statistics.*; -import org.mmtk.vm.ActivePlan; -import org.mmtk.vm.Assert; import org.mmtk.vm.Collection; import org.mmtk.vm.VM; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCCollector.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCCollector.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -109,7 +109,7 @@ public void postCopy(ObjectReference object, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma { - MC.immortalSpace.postAlloc(object); + MC.immortalSpace.initializeHeader(object); } /**************************************************************************** Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -163,33 +163,18 @@ */ /** - * test to see if the mark bit has the given value + * Initialize the object header post-allocation. We need to set the mark state + * correctly and set the logged bit if necessary. + * + * @param object The newly allocated object instance whose header we are initializing */ - private static boolean testMarkBit(ObjectReference object, Word value) { - return !(VM.objectModel.readAvailableBitsWord(object).and(value).isZero()); - } - - /** - * write the given value in the mark bit. - */ - private static void writeMarkBit(ObjectReference object, Word value) { + public final void initializeHeader(ObjectReference object) { Word oldValue = VM.objectModel.readAvailableBitsWord(object); - Word newValue = oldValue.and(GC_MARK_BIT_MASK.not()).or(value); + Word newValue = oldValue.and(GC_MARK_BIT_MASK.not()).or(markState); VM.objectModel.writeAvailableBitsWord(object, newValue); } /** - * atomically write the given value in the mark bit. - */ - private static void atomicWriteMarkBit(ObjectReference object, Word value) { - while (true) { - Word oldValue = VM.objectModel.prepareAvailableBits(object); - Word newValue = oldValue.and(GC_MARK_BIT_MASK.not()).or(value); - if (VM.objectModel.attemptAvailableBits(object, oldValue, newValue)) break; - } - } - - /** * Used to mark boot image objects during a parallel scan of objects during GC * Returns true if marking was done. */ @@ -222,10 +207,6 @@ return object; } - public void postAlloc(ObjectReference object) throws InlinePragma { - writeMarkBit(object, markState); - } - /** * Prepare for a new collection increment. For the immortal * collector we must flip the state of the mark bit between Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -260,21 +260,12 @@ */ /** - * Perform any required post-allocation initialization * - * - * @param object the object ref to the storage to be initialized - */ - public final void postAlloc(ObjectReference object) - throws InlinePragma { - initializeHeader(object); - } - - /** * Perform any required initialization of the GC portion of the header. * * @param object the object ref to the storage to be initialized + * @param isPLOSObject the object is allocated in the PLOS */ - public final void initializeHeader(ObjectReference object) + public final void initializeHeader(ObjectReference object, boolean isPLOSObject) throws InlinePragma { Word oldValue = VM.objectModel.readAvailableBitsWord(object); Word newValue = oldValue.and(LOS_BIT_MASK.not()).or(markState).or(NURSERY_BIT); Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -189,7 +189,7 @@ * */ public final void releaseCollector() { - sweepBlocks(); // sweep the blocks + sweepBlocks(true); // sweep the blocks } /** * Finish up after a collection. @@ -212,7 +212,7 @@ protected final boolean reclaimCellForObject(ObjectReference object, Word markState) throws InlinePragma { - return !MarkSweepSpace.testMarkBit(object, markState); + return !MarkSweepSpace.testMarkState(object, markState); } /**************************************************************************** Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -43,10 +43,22 @@ * * Class variables */ - public static final int LOCAL_GC_BITS_REQUIRED = 4; + /** highest bit bits we may use */ + private static final int MAX_BITS = 4; + + /* mark bits */ + private static final int COUNT_BASE = 0; + public static final int DEFAULT_MARKCOUNT_BITS = 2; + public static final int MAX_MARKCOUNT_BITS = MAX_BITS; + private static final Word MARK_COUNT_INCREMENT = Word.one().lsh(COUNT_BASE); + private static final Word MARK_COUNT_MASK = Word.one().lsh(MAX_MARKCOUNT_BITS).minus(Word.one()).lsh(COUNT_BASE); + private static final Word MARK_BITS_MASK = Word.one().lsh(MAX_BITS).minus(Word.one()); + + /* header requirements */ + public static final int LOCAL_GC_BITS_REQUIRED = MAX_BITS; public static final int GLOBAL_GC_BITS_REQUIRED = 0; public static final int GC_HEADER_WORDS_REQUIRED = 0; - public static final Word MARK_BIT_MASK = Word.one().lsh(4).minus(Word.one()); // ...01111 + /**************************************************************************** * @@ -174,12 +186,10 @@ * 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() { if (MarkSweepLocal.HEADER_MARK_BITS) { - Word mask = Word.fromInt((1 << Options.markSweepMarkBits.getValue()) - 1); - markState = markState.plus(Word.one()).and(mask); + markState = deltaMarkState(true); } else { MarkSweepLocal.zeroLiveBits(start, ((FreeListPageResource) pr).getHighWater()); } @@ -255,7 +265,7 @@ public boolean isLive(ObjectReference object) throws InlinePragma { if (MarkSweepLocal.HEADER_MARK_BITS) { - return testMarkBit(object, markState); + return testMarkState(object, markState); } else { return MarkSweepLocal.isLiveObject(object); } @@ -267,6 +277,7 @@ * @return The current mark state. */ public final Word getMarkState() throws InlinePragma { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(markState.and(MARK_COUNT_MASK.not()).isZero()); return markState; } @@ -277,10 +288,23 @@ */ public final Word getPreviousMarkState() throws InlinePragma { - Word mask = Word.fromInt((1 << Options.markSweepMarkBits.getValue()) - 1); - return markState.minus(Word.one()).and(mask); + return deltaMarkState(false); } + /** + * Return the mark state incremented or decremented by one. + * + * @param increment If true, then return the incremented value else return the decremented value + * @return the mark state incremented or decremented by one. + */ + private final Word deltaMarkState(boolean increment) { + Word mask = Word.fromInt((1 << Options.markSweepMarkBits.getValue()) - 1).lsh(COUNT_BASE); + Word rtn = increment ? markState.plus(MARK_COUNT_INCREMENT) : markState.minus(MARK_COUNT_INCREMENT); + rtn = rtn.and(mask); + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(markState.and(MARK_COUNT_MASK.not()).isZero()); + return rtn; + } + /**************************************************************************** * * Header manipulation @@ -297,7 +321,9 @@ } /** - * Perform any required post copy (i.e. in-GC allocation) initialization + * 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. * * @param object the object ref to the storage to be initialized * @param majorGC Is this copy happening during a major gc? @@ -320,7 +346,7 @@ public final void initializeHeader(ObjectReference object) throws InlinePragma { if (MarkSweepLocal.HEADER_MARK_BITS) - writeMarkBit(object); + writeMarkState(object); } /** @@ -328,28 +354,29 @@ * 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 + * @param value The value to which the mark bits will be set */ private static boolean testAndMark(ObjectReference object, Word value) throws InlinePragma { - Word oldValue, markBit; + Word oldValue, markBits; oldValue = VM.objectModel.readAvailableBitsWord(object); - markBit = oldValue.and(MARK_BIT_MASK); - if (markBit.EQ(value)) return false; - VM.objectModel.writeAvailableBitsWord(object, oldValue.and(MARK_BIT_MASK.not()).or(value)); + markBits = oldValue.and(MARK_BITS_MASK); + if (markBits.EQ(value)) return false; + VM.objectModel.writeAvailableBitsWord(object, oldValue.and(MARK_BITS_MASK.not()).or(value)); return true; } /** - * Return true if the mark bit for an object has the given value. + * Return true if the mark count 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. */ - public static boolean testMarkBit(ObjectReference object, Word value) + public static boolean testMarkState(ObjectReference object, Word value) throws InlinePragma { - return VM.objectModel.readAvailableBitsWord(object).and(MARK_BIT_MASK).EQ(value); + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(value.and(MARK_COUNT_MASK.not()).isZero()); + return VM.objectModel.readAvailableBitsWord(object).and(MARK_COUNT_MASK).EQ(value); } /** @@ -357,10 +384,9 @@ * * @param object The object whose mark bit is to be written */ - public void writeMarkBit(ObjectReference object) throws InlinePragma { + private final void writeMarkState(ObjectReference object) throws InlinePragma { Word oldValue = VM.objectModel.readAvailableBitsWord(object); - Word newValue = oldValue.and(MARK_BIT_MASK.not()).or(markState); + Word newValue = oldValue.and(MARK_BITS_MASK.not()).or(markState); VM.objectModel.writeAvailableBitsWord(object, newValue); } - } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/RefCountLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/RefCountLocal.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/RefCountLocal.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -258,7 +258,7 @@ if (timekeeper) decTime.stop(); VM.collection.rendezvous(4410); // RC_SWEEP - sweepBlocks(); + sweepBlocks(true); // RC_CYCLE_DETECTION if (RCBase.REF_COUNT_CYCLE_DETECTION) { if (timekeeper) cdTime.start(); Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -601,16 +601,24 @@ } /** - * Clear the metadata for this block. + * Return true if the metadata for this block was set. * * @param block The block address - * @return the previous value of the meta data. + * @return value of the meta data. */ - public static final boolean clearBlockMeta(Address block) + public static final boolean checkBlockMeta(Address block) throws InlinePragma { - boolean result = getMetaAddress(block).plus(FL_META_OFFSET).loadWord().EQ(Word.one()); + return getMetaAddress(block).plus(FL_META_OFFSET).loadWord().EQ(Word.one()); + } + + /** + * Clear the metadata for this block + * + * @param block The block address + */ + public static final void clearBlockMeta(Address block) + throws InlinePragma { getMetaAddress(block).plus(FL_META_OFFSET).store(Word.zero()); - return result; } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -619,8 +619,9 @@ * Sweep all blocks for free objects. * * FIXME This is currently implemented by searching each *mutator* free list. It needs to be per-collector, not per-mutator. + * @param clearBlockMarks should we clear block mark bits after reading? Otherwise they must be done on masse when appropriate. */ - protected final void sweepBlocks() { + protected final void sweepBlocks(boolean clearBlockMarks) { for (int sizeClass = 0; sizeClass < SIZE_CLASSES; sizeClass++) { Address block = firstBlock.get(sizeClass); clearBucketList(); @@ -641,7 +642,8 @@ boolean live = false; Address cursor = block; while(cursor.LT(block.plus(blockSize))) { - live |= BlockAllocator.clearBlockMeta(cursor); + live |= BlockAllocator.checkBlockMeta(cursor); + if (clearBlockMarks) BlockAllocator.clearBlockMeta(cursor); cursor = cursor.plus(1 << BlockAllocator.LOG_MIN_BLOCK); } if (!live) { @@ -654,6 +656,25 @@ } } + /** + * Clear the per-block mark state en masse + */ + public final void clearBlockMarks() { + for (int sizeClass = 0; sizeClass < SIZE_CLASSES; sizeClass++) { + Address block = firstBlock.get(sizeClass); + Extent blockSize = Extent.fromIntSignExtend(BlockAllocator.blockSize(blockSizeClass[sizeClass])); + while (!block.isZero()) { + Address next = BlockAllocator.getNextBlock(block); + Address cursor = block; + while(cursor.LT(block.plus(blockSize))) { + BlockAllocator.clearBlockMeta(cursor); + cursor = cursor.plus(1 << BlockAllocator.LOG_MIN_BLOCK); + } + block = next; + } + } + } + protected final void consumeBlockLists(Word markState) { for (int sizeClass = 0; sizeClass < SIZE_CLASSES; sizeClass++) { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SharedDeque.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SharedDeque.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SharedDeque.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -119,6 +119,10 @@ public final void reset() { setNumConsumersWaiting(0); setCompletionFlag(0); + assertExhausted(); + } + + public final void assertExhausted() { if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(head.isZero() && tail.isZero()); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/options/MarkSweepMarkBits.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/options/MarkSweepMarkBits.java 2006-10-08 22:47:00 UTC (rev 10875) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/options/MarkSweepMarkBits.java 2006-10-09 01:21:00 UTC (rev 10876) @@ -9,6 +9,8 @@ */ package org.mmtk.utility.options; +import org.mmtk.policy.MarkSweepSpace; + /** * Number of bits to use for the header cycle of mark sweep spaces. * @@ -25,14 +27,14 @@ public MarkSweepMarkBits() { super("Mark Sweep Mark Bits", "Number of bits to use for the header cycle of mark sweep spaces", - 2); + MarkSweepSpace.DEFAULT_MARKCOUNT_BITS); } /** - * Ensure the port is valid. + * Ensure the value is valid. */ protected void validate() { failIf(this.value <= 0, "Must provide at least one bit"); - failIf(this.value > 4 , "Only 4 bits are reserved in MarkSweepSpace"); + failIf(this.value > MarkSweepSpace.MAX_MARKCOUNT_BITS , "Only "+MarkSweepSpace.MAX_MARKCOUNT_BITS+" bits are reserved in MarkSweepSpace"); } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-10-10 12:25:08
|
Revision: 10882 http://svn.sourceforge.net/jikesrvm/?rev=10882&view=rev Author: steveb-oss Date: 2006-10-10 05:24:58 -0700 (Tue, 10 Oct 2006) Log Message: ----------- Fix for regression failures. Previous change to the way mark state is managed did not accommodate those collectors who alloc into ms space at *collection* time (rather than mutation time) Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMSMutator.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/marksweep/GenMSMutator.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMSMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMSMutator.java 2006-10-10 04:39:02 UTC (rev 10881) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMSMutator.java 2006-10-10 12:24:58 UTC (rev 10882) @@ -105,7 +105,7 @@ if (allocator == CopyMS.ALLOC_DEFAULT) return; else if (allocator == CopyMS.ALLOC_MS) - CopyMS.msSpace.initializeHeader(ref); + CopyMS.msSpace.initializeHeader(ref, true); else super.postAlloc(ref, typeRef, bytes, allocator); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/marksweep/GenMSMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/marksweep/GenMSMutator.java 2006-10-10 04:39:02 UTC (rev 10881) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/marksweep/GenMSMutator.java 2006-10-10 12:24:58 UTC (rev 10882) @@ -107,7 +107,7 @@ public final void postAlloc(ObjectReference ref, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma { if (allocator == GenMS.ALLOC_MATURE) { - GenMS.msSpace.initializeHeader(ref); + GenMS.msSpace.initializeHeader(ref, true); } else { super.postAlloc(ref, typeRef, bytes, allocator); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2006-10-10 04:39:02 UTC (rev 10881) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2006-10-10 12:24:58 UTC (rev 10882) @@ -319,7 +319,7 @@ */ public final void postAlloc(ObjectReference object) throws InlinePragma { - initializeHeader(object); + initializeHeader(object, true); } /** @@ -332,7 +332,7 @@ */ public final void postCopy(ObjectReference object, boolean majorGC) throws InlinePragma { - initializeHeader(object); + initializeHeader(object, false); if (MarkSweepLocal.HEADER_MARK_BITS) { if (majorGC) MarkSweepLocal.liveBlock(object); } else { @@ -344,12 +344,17 @@ * 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)? */ - public final void initializeHeader(ObjectReference object) + public final void initializeHeader(ObjectReference object, boolean alloc) throws InlinePragma { if (MarkSweepLocal.HEADER_MARK_BITS) - writeAllocState(object); - } + if (alloc) + writeAllocState(object); + else + writeMarkState(object); + } /** * Atomically attempt to set the mark bit of an object. Return true @@ -382,7 +387,8 @@ } /** - * Write the allocState into the mark state fields of an object non-atomically + * Write the allocState into the mark state fields of an object non-atomically. + * This is appropriate for allocation time initialization. * * @param object The object whose mark state is to be written */ @@ -391,4 +397,16 @@ Word newValue = oldValue.and(MARK_BITS_MASK.not()).or(allocState); VM.objectModel.writeAvailableBitsWord(object, newValue); } + + /** + * Write the markState into the mark state fields of an object non-atomically. + * This is appropriate for collection time initialization. + * + * @param object The object whose mark state is to be written + */ + private final void writeMarkState(ObjectReference object) throws InlinePragma { + Word oldValue = VM.objectModel.readAvailableBitsWord(object); + Word newValue = oldValue.and(MARK_BITS_MASK.not()).or(markState); + VM.objectModel.writeAvailableBitsWord(object, newValue); + } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2006-10-26 04:40:05
|
Revision: 10923 http://svn.sourceforge.net/jikesrvm/?rev=10923&view=rev Author: dframpton-oss Date: 2006-10-25 21:39:51 -0700 (Wed, 25 Oct 2006) Log Message: ----------- Patch 1514837 GC Tracing patch (Matthew Hertz) Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java 2006-10-24 04:24:12 UTC (rev 10922) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java 2006-10-26 04:39:51 UTC (rev 10923) @@ -96,11 +96,11 @@ */ /* Spaces */ - public static final RawPageSpace traceSpace = new RawPageSpace("trace", DEFAULT_POLL_FREQUENCY, META_DATA_MB); - + public static final RawPageSpace traceSpace = new RawPageSpace("trace", DEFAULT_POLL_FREQUENCY, META_DATA_MB<<2); public static final int TRACE = traceSpace.getDescriptor(); /* GC state */ + public static boolean lastGCWasTracing = false; // True when previous GC was for tracing public static boolean traceInducedGC = false; // True if trace triggered GC public static boolean deathScan = false; public static boolean finalDead = false; @@ -190,6 +190,9 @@ */ public void collectionPhase(int phaseId) { + if (phaseId == PREPARE) { + lastGCWasTracing = traceInducedGC; + } if (phaseId == RELEASE) { if (traceInducedGC) { /* Clean up following a trace-induced scan */ @@ -223,7 +226,7 @@ * their failure to return memory isn't cause for concern. */ public boolean isLastGCFull() { - return !traceInducedGC; + return !lastGCWasTracing; } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceCollector.java 2006-10-24 04:24:12 UTC (rev 10922) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceCollector.java 2006-10-26 04:39:51 UTC (rev 10923) @@ -78,11 +78,6 @@ * @param primary perform any single-threaded local activities. */ public void collectionPhase(int phaseId, boolean primary) { - if (phaseId == SS.PREPARE) { - super.collectionPhase(phaseId, primary); - return; - } - if (phaseId == GCTrace.START_CLOSURE) { inducedTrace.startTrace(); return; @@ -106,12 +101,10 @@ ((phaseId != StopTheWorld.SOFT_REFS) && (phaseId != StopTheWorld.WEAK_REFS) && (phaseId != StopTheWorld.PHANTOM_REFS) && - (phaseId != StopTheWorld.FORWARD_REFS) && - (phaseId != StopTheWorld.FORWARD_FINALIZABLE) && - (phaseId != StopTheWorld.FINALIZABLE))) { + (phaseId != StopTheWorld.FINALIZABLE) && + (phaseId != SS.PREPARE))) { // Delegate up. super.collectionPhase(phaseId, primary); - return; } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2006-10-24 04:24:12 UTC (rev 10922) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2006-10-26 04:39:51 UTC (rev 10923) @@ -14,6 +14,7 @@ import org.mmtk.plan.semispace.SSMutator; import org.mmtk.plan.semispace.*; +import org.mmtk.plan.*; import org.mmtk.utility.TraceGenerator; import org.mmtk.vm.VM; @@ -153,15 +154,11 @@ * @param primary perform any single-threaded local activities. */ public void collectionPhase(int phaseId, boolean primary) { - if (phaseId == SS.PREPARE_MUTATOR) { - if (!GCTrace.traceInducedGC) { - // rebind the semispace bump pointer to the appropriate semispace. - ss.rebind(SS.toSpace()); - } + if (!GCTrace.traceInducedGC || + (phaseId != StopTheWorld.PREPARE_MUTATOR) && + (phaseId != StopTheWorld.RELEASE_MUTATOR)) { + // Delegate up. super.collectionPhase(phaseId, primary); - return; } - - super.collectionPhase(phaseId, primary); } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java 2006-10-24 04:24:12 UTC (rev 10922) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java 2006-10-26 04:39:51 UTC (rev 10923) @@ -226,9 +226,6 @@ public static final void traceAlloc(boolean isImmortal, ObjectReference ref, ObjectReference typeRef, int bytes) throws LogicallyUninterruptiblePragma, NoInlinePragma { - /* Assert that this isn't the result of tracing */ - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!traceBusy); - boolean gcAllowed = VM.traceInterface.gcEnabled() && Plan.isInitialized() && !Plan.gcInProgress(); /* Test if it is time/possible for an exact allocation. */ @@ -242,6 +239,24 @@ } /* Add the allocation into the trace. */ traceBusy = true; + /* When legally permissible, add the record to the trace buffer */ + if (MERLIN_ANALYSIS) { + Address fp = (TraceBuffer.OMIT_ALLOCS) ? Address.zero() : VM.traceInterface.skipOwnFramesAndDump(typeRef); + + if (isImmortal && allocType.EQ(TRACE_EXACT_ALLOC)) + trace.push(TRACE_EXACT_IMMORTAL_ALLOC); + else if (isImmortal) + trace.push(TRACE_IMMORTAL_ALLOC); + else + trace.push(allocType); + trace.push(VM.traceInterface.getOID(ref)); + trace.push(Word.fromInt(bytes - VM.traceInterface.getHeaderSize())); + trace.push(fp.toWord()); + trace.push(Word.fromInt(0 /* VM_Magic.getThreadId() */)); + trace.push(TRACE_TIB_SET); + trace.push(VM.traceInterface.getOID(ref)); + trace.push(VM.traceInterface.getOID(typeRef)); + } /* Perform the necessary work for death times. */ if (allocType.EQ(TRACE_EXACT_ALLOC)) { if (MERLIN_ANALYSIS) { @@ -253,25 +268,27 @@ lastGC = VM.traceInterface.getOID(ref); } } - Address fp = VM.traceInterface.skipOwnFramesAndDump(typeRef); - if (isImmortal && allocType.EQ(TRACE_EXACT_ALLOC)) - trace.push(TRACE_EXACT_IMMORTAL_ALLOC); - else if (isImmortal) - trace.push(TRACE_IMMORTAL_ALLOC); - else - trace.push(allocType); - trace.push(VM.traceInterface.getOID(ref)); - trace.push(Word.fromInt(bytes - VM.traceInterface.getHeaderSize())); - trace.push(fp.toWord()); - trace.push(Word.fromInt(0 /* VM_Magic.getThreadId() */)); - trace.push(TRACE_TIB_SET); - trace.push(VM.traceInterface.getOID(ref)); - trace.push(VM.traceInterface.getOID(typeRef)); + /* Add the allocation record to the buffer if we have not yet done so. */ + if (!MERLIN_ANALYSIS) { + Address fp = (TraceBuffer.OMIT_ALLOCS) ? Address.zero() : VM.traceInterface.skipOwnFramesAndDump(typeRef); + if (isImmortal && allocType.EQ(TRACE_EXACT_ALLOC)) + trace.push(TRACE_EXACT_IMMORTAL_ALLOC); + else if (isImmortal) + trace.push(TRACE_IMMORTAL_ALLOC); + else + trace.push(allocType); + trace.push(VM.traceInterface.getOID(ref)); + trace.push(Word.fromInt(bytes - VM.traceInterface.getHeaderSize())); + trace.push(fp.toWord()); + trace.push(Word.fromInt(0 /* VM_Magic.getThreadId() */)); + trace.push(TRACE_TIB_SET); + trace.push(VM.traceInterface.getOID(ref)); + trace.push(VM.traceInterface.getOID(typeRef)); + } trace.process(); traceBusy = false; } - /*********************************************************************** * * Merlin lifetime analysis methods @@ -300,7 +317,8 @@ } } /* Sort the objects on the worklist by their timestamp */ - worklist.sort(); + if (!worklist.isEmpty()) + worklist.sort(); /* Now compute the death times. */ computeTransitiveClosure(); } @@ -372,23 +390,24 @@ * as the latest reaching death time to an object. */ private static final void computeTransitiveClosure() { - /* The latest time an object can die. */ - agePropagate = Word.max(); - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!worklist.isEmpty()); - /* Process through the entire buffer. */ - ObjectReference ref = worklist.pop(); - while (!ref.isNull()) { - Word currentAge = VM.traceInterface.getDeathTime(ref); - /* This is a cheap and simple test to process objects only once. */ - if (currentAge.LE(agePropagate)) { - /* Set the "new" dead age. */ - agePropagate = currentAge; - /* Scan the object, pushing the survivors */ - Scan.scanObject(getTraceLocal(), ref); - } - /* Get the next object to process */ - ref = worklist.pop(); - } + if (!worklist.isEmpty()) { + /* The latest time an object can die. */ + agePropagate = Word.max(); + /* Process through the entire buffer. */ + ObjectReference ref = worklist.pop(); + while (!ref.isNull()) { + Word currentAge = VM.traceInterface.getDeathTime(ref); + /* This is a cheap and simple test to process objects only once. */ + if (currentAge.LE(agePropagate)) { + /* Set the "new" dead age. */ + agePropagate = currentAge; + /* Scan the object, pushing the survivors */ + Scan.scanObject(getTraceLocal(), ref); + } + /* Get the next object to process */ + ref = worklist.pop(); + } + } } private static final TraceLocal getTraceLocal() { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java 2006-10-24 04:24:12 UTC (rev 10922) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java 2006-10-26 04:39:51 UTC (rev 10923) @@ -48,6 +48,18 @@ private static final Word TRACE_STATIC_TARGET = Word.fromInt(17); private static final Word TRACE_BOOT_ALLOC_SIZE = Word.fromInt(18); + /* + * Debugging and trace reducing constants + */ + public static final boolean OMIT_ALLOCS=false; + public static final boolean OMIT_UPDATES=false; + public static final boolean OMIT_BOOTALLOCS=false; + public static final boolean OMIT_UNREACHABLES=false; + public static final boolean OMIT_OTHERS=false; + public static final boolean OMIT_OUTPUT=OMIT_ALLOCS && OMIT_UPDATES && + OMIT_OTHERS; + + /*********************************************************************** * * Instance fields @@ -86,9 +98,10 @@ public final void process() { Word traceState = TRACE_NEW_RECORD; int entriesNotFlushed = 0; + boolean loggedRecord = false; /* First we must flush any remaining data */ - Log.writeln(); - + if (!OMIT_OUTPUT) Log.writeln(); + /* Process through the entire buffer. */ while (checkDequeue(1)) { /* For speed and efficiency, we will actually process the data buffer by @@ -97,92 +110,130 @@ head = head.minus(BYTES_IN_ADDRESS); Word val = head.loadWord(); if (traceState.EQ(TRACE_NEW_RECORD)) { + loggedRecord = false; if (val.EQ(TRACE_GCSTART)) { - Log.write('G'); - Log.write('C'); - Log.writeln('B', true); + if (!OMIT_OTHERS) { + Log.write('G'); + Log.write('C'); + Log.writeln('B', true); + } } else if (val.EQ(TRACE_GCEND)) { - Log.write('G'); - Log.write('C'); - Log.writeln('E', true); + if (!OMIT_OTHERS) { + Log.write('G'); + Log.write('C'); + Log.writeln('E', true); + } } else { traceState = val; } } else { if (traceState.EQ(TRACE_EXACT_ALLOC) || traceState.EQ(TRACE_ALLOC)) { - Log.write((traceState.EQ(TRACE_EXACT_ALLOC)) ? 'A' : 'a'); - Log.write(' '); - Log.write(val); + if (!OMIT_ALLOCS) { + Log.write( (traceState.EQ(TRACE_EXACT_ALLOC)) ? 'A' : 'a'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_ALLOC_SIZE; } else if (traceState.EQ(TRACE_EXACT_IMMORTAL_ALLOC) || traceState.EQ(TRACE_IMMORTAL_ALLOC)) { - Log.write((traceState.EQ(TRACE_EXACT_IMMORTAL_ALLOC)) ? 'I' : 'i'); - Log.write(' '); - Log.write(val); + if (!OMIT_ALLOCS) { + Log.write( (traceState.EQ(TRACE_EXACT_IMMORTAL_ALLOC)) ? 'I' : 'i'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_ALLOC_SIZE; } else if (traceState.EQ(TRACE_BOOT_ALLOC)) { - Log.write('B'); - Log.write(' '); - Log.write(val); + if (!OMIT_BOOTALLOCS) { + Log.write('B'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_BOOT_ALLOC_SIZE; } else if (traceState.EQ(TRACE_DEATH)) { - Log.write('D'); - Log.write(' '); - Log.write(val); + if (!OMIT_UNREACHABLES) { + Log.write('D'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_DEATH_TIME; } else if (traceState.EQ(TRACE_BOOT_ALLOC_SIZE)) { - Log.write(val); + if (!OMIT_BOOTALLOCS) + Log.write(val); traceState = TRACE_NEW_RECORD; } else if (traceState.EQ(TRACE_ALLOC_SIZE)) { - Log.write(val); + if (!OMIT_ALLOCS) + Log.write(val); traceState = TRACE_ALLOC_FP; } else if (traceState.EQ(TRACE_ALLOC_FP)) { - Log.write(val); + if (!OMIT_ALLOCS) + Log.write(val); traceState = TRACE_ALLOC_THREAD; } else if (traceState.EQ(TRACE_ALLOC_THREAD)) { - Log.write(val); + if (!OMIT_ALLOCS) + Log.write(val); traceState = TRACE_NEW_RECORD; } else if (traceState.EQ(TRACE_TIB_SET)) { - Log.write('T'); - Log.write(' '); - Log.write(val); + if (!OMIT_UPDATES) { + Log.write('T'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_TIB_VALUE; } else if (traceState.EQ(TRACE_STATIC_SET)) { - Log.write('S'); - Log.write(' '); - Log.write(val); + if (!OMIT_UPDATES) { + Log.write('S'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_STATIC_TARGET; } else if (traceState.EQ(TRACE_TIB_VALUE) || - traceState.EQ(TRACE_DEATH_TIME) || traceState.EQ(TRACE_STATIC_TARGET)) { - Log.write(val); + if (!OMIT_UPDATES) + Log.write(val); traceState = TRACE_NEW_RECORD; + } else if (traceState.EQ(TRACE_DEATH_TIME)) { + if (!OMIT_UNREACHABLES) + Log.write(val); + traceState = TRACE_NEW_RECORD; } else if (traceState.EQ(TRACE_FIELD_SET) || traceState.EQ(TRACE_ARRAY_SET)) { - Log.write('U'); - Log.write(' '); - Log.write(val); + if (!OMIT_UPDATES) { + Log.write('U'); + Log.write(' '); + Log.write(val); + loggedRecord = true; + } traceState = TRACE_FIELD_SLOT; } else if (traceState.EQ(TRACE_FIELD_TARGET) || traceState.EQ(TRACE_ARRAY_TARGET)) { - Log.write(val); + if (!OMIT_UPDATES) + Log.write(val); traceState = TRACE_NEW_RECORD; } else if (traceState.EQ(TRACE_FIELD_SLOT) || traceState.EQ(TRACE_ARRAY_ELEMENT)) { - Log.write(val); + if (!OMIT_UPDATES) + Log.write(val); traceState = TRACE_FIELD_TARGET; - } else + } else { VM.assertions.fail("Cannot understand directive!\n"); - if (traceState.EQ(TRACE_NEW_RECORD)) { + } + if (traceState.EQ(TRACE_NEW_RECORD) && loggedRecord) { entriesNotFlushed++; Log.writeln(); - } else { - Log.write(' '); + } else if (loggedRecord) { + Log.write(' '); } } if (entriesNotFlushed == 10) { - Log.flush(); + if (!OMIT_OUTPUT) + Log.flush(); entriesNotFlushed = 0; } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dgr...@us...> - 2006-11-03 15:57:41
|
Revision: 10946 http://svn.sourceforge.net/jikesrvm/?rev=10946&view=rev Author: dgrove-oss Date: 2006-11-03 07:57:30 -0800 (Fri, 03 Nov 2006) Log Message: ----------- fix various javadoc errors introduced in RC refactor Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/DecBuffer.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/fullheap/RCMutator.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCMutator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/ObjectReferenceBuffer.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/DecBuffer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/DecBuffer.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/DecBuffer.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -36,7 +36,7 @@ /** * Constructor * - * @param trace The shared deque that is used. + * @param queue The shared deque that is used. */ public DecBuffer(SharedDeque queue) { super("dec", queue); @@ -53,4 +53,4 @@ push(object); } } -} \ No newline at end of file +} Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -39,9 +39,9 @@ * * @see RCBase * @see RCBaseCollector - * @see StopTheWorldMutator - * @see MutatorContext - * @see SimplePhase#delegatePhase + * @see org.mmtk.plan.StopTheWorldMutator + * @see org.mmtk.plan.MutatorContext + * @see org.mmtk.plan.SimplePhase#delegatePhase * * $Id$ * Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -215,9 +215,6 @@ * grey. This means "pretending" that the initial object is dead, * and thus applying temporary decrements to each of the object's * decendents. - * - * @param timeCap The time by which we must stop marking - * grey. */ private final void doMarkGreyPhase() { ObjectReference object = ObjectReference.nullReference(); @@ -377,4 +374,4 @@ private static final TrialDeletion global() throws InlinePragma { return (TrialDeletion)((RCBase)VM.activePlan.global()).cycleDetector(); } -} \ No newline at end of file +} Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/fullheap/RCMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/fullheap/RCMutator.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/fullheap/RCMutator.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -29,7 +29,7 @@ * and per-mutator thread collection semantics (flushing and restoring * per-mutator allocator state).<p> * - * @see MC for an overview of the mark-compact algorithm.<p> + * @see org.mmtk.plan.markcompact.MC for an overview of the mark-compact algorithm.<p> * * FIXME The SegregatedFreeList class (and its decendents such as * MarkSweepLocal) does not properly separate mutator and collector @@ -39,9 +39,9 @@ * * @see RC * @see RCCollector - * @see StopTheWorldMutator - * @see MutatorContext - * @see SimplePhase#delegatePhase + * @see org.mmtk.plan.StopTheWorldMutator + * @see org.mmtk.plan.MutatorContext + * @see org.mmtk.plan.SimplePhase#delegatePhase * * $Id$ * Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCCollector.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCCollector.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -40,9 +40,9 @@ * * @see GenRC * @see GenRCMutator - * @see StopTheWorldCollector - * @see CollectorContext - * @see SimplePhase#delegatePhase + * @see org.mmtk.plan.StopTheWorldCollector + * @see org.mmtk.plan.CollectorContext + * @see org.mmtk.plan.SimplePhase#delegatePhase * * $Id$ * Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCMutator.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/generational/GenRCMutator.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -38,12 +38,12 @@ * behaviors, so most of the collection logic in GenRCMutator should really * be per-collector thread, not per-mutator thread. * - * @see RCBaseMutator + * @see org.mmtk.plan.refcount.RCBaseMutator * @see GenRC * @see GenRCCollector - * @see StopTheWorldMutator - * @see MutatorContext - * @see SimplePhase#delegatePhase + * @see org.mmtk.plan.StopTheWorldMutator + * @see org.mmtk.plan.MutatorContext + * @see org.mmtk.plan.SimplePhase#delegatePhase * * $Id$ * @@ -105,9 +105,9 @@ * particular method will match against those spaces defined at this * level of the class hierarchy. Subclasses must deal with spaces * they define and refer to superclasses appropriately. This exists - * to support {@link org.mmtk.plan.CollectorContext#getOwnAllocator(Allocator)}. + * to support {@link org.mmtk.plan.MutatorContext#getOwnAllocator(Allocator)}. * - * @see org.mmtk.plan.CollectorContext#getOwnAllocator(Allocator) + * @see org.mmtk.plan.MutatorContext#getOwnAllocator(Allocator) * @param a An allocator * @return The space into which <code>a</code> is allocating, or * <code>null</code> if there is no space associated with @@ -121,9 +121,9 @@ /** * Return the allocator instance associated with a space * <code>space</code>, for this plan instance. This exists - * to support {@link org.mmtk.plan.CollectorContext#getOwnAllocator(Allocator)}. + * to support {@link org.mmtk.plan.MutatorContext#getOwnAllocator(Allocator)}. * - * @see org.mmtk.plan.CollectorContext#getOwnAllocator(Allocator) + * @see org.mmtk.plan.MutatorContext#getOwnAllocator(Allocator) * @param space The space for which the allocator instance is desired. * @return The allocator instance associated with this plan instance * which is allocating into <code>space</code>, or <code>null</code> Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/ObjectReferenceBuffer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/ObjectReferenceBuffer.java 2006-11-03 10:57:49 UTC (rev 10945) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/ObjectReferenceBuffer.java 2006-11-03 15:57:30 UTC (rev 10946) @@ -44,7 +44,7 @@ * Constructor * * @param name The name of the underlying deque. - * @param trace The shared deque that is used. + * @param queue The shared deque that is used. */ public ObjectReferenceBuffer(String name, SharedDeque queue) { values = new ObjectReferenceDeque(name, queue); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-11-29 05:37:22
|
Revision: 11080 http://svn.sourceforge.net/jikesrvm/?rev=11080&view=rev Author: steveb-oss Date: 2006-11-28 21:37:21 -0800 (Tue, 28 Nov 2006) Log Message: ----------- Got rid of warnings... Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCMarkTraceLocal.java rvmroot/trunk/MMTk/src/org/mmtk/plan/nogc/NoGCCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/SimpleHashtable.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SortSharedDeque.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -10,7 +10,6 @@ package org.mmtk.plan; import org.mmtk.utility.Log; -import org.mmtk.vm.Assert; import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCMarkTraceLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCMarkTraceLocal.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MCMarkTraceLocal.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -13,7 +13,6 @@ import org.mmtk.plan.Trace; import org.mmtk.policy.MarkCompactSpace; import org.mmtk.policy.Space; -import org.mmtk.vm.Assert; import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/nogc/NoGCCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/nogc/NoGCCollector.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/nogc/NoGCCollector.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -10,7 +10,6 @@ package org.mmtk.plan.nogc; import org.mmtk.plan.*; -import org.mmtk.vm.Assert; import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/cd/TrialDeletionCollector.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -13,7 +13,6 @@ import org.mmtk.plan.refcount.RCBaseCollector; import org.mmtk.plan.refcount.RCHeader; import org.mmtk.utility.Constants; -import org.mmtk.utility.Log; import org.mmtk.utility.deque.ObjectReferenceDeque; import org.mmtk.utility.scan.Scan; Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -13,7 +13,6 @@ package org.mmtk.plan.semispace.gctrace; import org.mmtk.plan.semispace.SSMutator; -import org.mmtk.plan.semispace.*; import org.mmtk.plan.*; import org.mmtk.utility.TraceGenerator; import org.mmtk.vm.VM; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/SimpleHashtable.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/SimpleHashtable.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/SimpleHashtable.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -10,9 +10,6 @@ package org.mmtk.utility; import org.mmtk.policy.RawPageSpace; - -import org.mmtk.vm.Assert; - import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SortSharedDeque.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SortSharedDeque.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/SortSharedDeque.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -296,7 +296,6 @@ stackLoc = 0; Address endOfBlock = tail; - Address trailer = tail; Address startPtr = bufferStart(endOfBlock); Word min = Word.max(); Word max = Word.zero(); @@ -355,7 +354,7 @@ */ private final void checkIfSorted() { if (VM.VERIFY_ASSERTIONS) { - Address next, buf, end; + Address buf, end; Word prevKey = Word.max(); end = tail; buf = bufferStart(end); Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/TraceBuffer.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -11,7 +11,6 @@ import org.mmtk.utility.Log; import org.mmtk.utility.TracingConstants; -import org.mmtk.vm.Assert; import org.mmtk.vm.VM; import org.mmtk.utility.Constants; Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java 2006-11-29 03:06:47 UTC (rev 11079) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/TraceInterface.java 2006-11-29 05:37:21 UTC (rev 11080) @@ -12,7 +12,6 @@ package org.mmtk.vm; import org.vmmagic.unboxed.*; -import org.vmmagic.pragma.*; /** * Class that supports scanning Objects or Arrays for references This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2006-12-15 09:51:53
|
Revision: 11198 http://svn.sourceforge.net/jikesrvm/?rev=11198&view=rev Author: steveb-oss Date: 2006-12-15 01:51:52 -0800 (Fri, 15 Dec 2006) Log Message: ----------- Fixed some missed MMTk problems --- thanks Peter Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspyMutator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenImmortalSpaceDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenLOSDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspyMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspyMutator.java 2006-12-15 09:21:13 UTC (rev 11197) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspyMutator.java 2006-12-15 09:51:52 UTC (rev 11198) @@ -21,12 +21,9 @@ import org.mmtk.utility.gcspy.GCspy; import org.mmtk.utility.gcspy.drivers.LinearSpaceDriver; -import org.vmmagic.pragma.InlinePragma; -import org.vmmagic.pragma.Uninterruptible; +import org.vmmagic.pragma.*; +import org.vmmagic.unboxed.*; -import org.vmmagic.unboxed.Address; -import org.vmmagic.unboxed.ObjectReference; - /** * This class implements <i>per-mutator thread</i> behavior and state for the * <i>SSGCspy</i> plan. Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenImmortalSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenImmortalSpaceDriver.java 2006-12-15 09:21:13 UTC (rev 11197) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenImmortalSpaceDriver.java 2006-12-15 09:51:52 UTC (rev 11198) @@ -54,7 +54,6 @@ * @param blockSize The tile size * @param mainSpace Is this the main space? */ - @Interruptible public GenImmortalSpaceDriver( ServerInterpreter server, String spaceName, Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenLOSDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenLOSDriver.java 2006-12-15 09:21:13 UTC (rev 11197) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/GenLOSDriver.java 2006-12-15 09:51:52 UTC (rev 11198) @@ -52,7 +52,6 @@ * @param threshold the size threshold of the LOS * @param mainSpace Is this the main space? */ - @Interruptible public GenLOSDriver(ServerInterpreter server, String spaceName, LargeObjectSpace lospace, Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2006-12-15 09:21:13 UTC (rev 11197) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2006-12-15 09:51:52 UTC (rev 11198) @@ -49,7 +49,6 @@ * @param blockSize The tile size * @param mainSpace Is this the main space? */ - @Interruptible public ImmortalSpaceDriver( ServerInterpreter server, String spaceName, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-02-26 06:49:43
|
Revision: 11531 http://svn.sourceforge.net/jikesrvm/?rev=11531&view=rev Author: peter_donald Date: 2007-02-25 22:49:41 -0800 (Sun, 25 Feb 2007) Log Message: ----------- Remove imports for classes in the same package Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectLocal.java rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Conversions.java rvmroot/trunk/MMTk/src/org/mmtk/utility/DoublyLinkedList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Log.java rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectLocal.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectLocal.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -9,7 +9,6 @@ */ package org.mmtk.policy; -import org.mmtk.policy.LargeObjectSpace; import org.mmtk.utility.alloc.LargeObjectAllocator; import org.mmtk.utility.Treadmill; import org.mmtk.utility.gcspy.drivers.TreadmillDriver; @@ -81,7 +80,7 @@ @Inline protected final void postAlloc (Address cell) { space.getTreadmill().addToTreadmill(Treadmill.payloadToNode(cell)); - }; + } /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -13,8 +13,6 @@ */ package org.mmtk.utility; -import org.mmtk.utility.Constants; - import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Conversions.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Conversions.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Conversions.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -10,7 +10,6 @@ package org.mmtk.utility; -import org.mmtk.utility.Constants; import org.mmtk.utility.heap.*; import org.mmtk.vm.VM; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/DoublyLinkedList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/DoublyLinkedList.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/DoublyLinkedList.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -8,7 +8,6 @@ */ package org.mmtk.utility; -import org.mmtk.utility.Constants; import org.mmtk.utility.gcspy.drivers.AbstractDriver; import org.mmtk.vm.Lock; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -13,8 +13,6 @@ */ package org.mmtk.utility; -import org.mmtk.utility.Constants; - import org.mmtk.vm.VM; import org.vmmagic.pragma.*; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Log.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Log.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Log.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -12,8 +12,6 @@ //$Id$ package org.mmtk.utility; -import org.mmtk.utility.Constants; - import org.mmtk.vm.VM; import org.vmmagic.unboxed.*; @@ -426,7 +424,7 @@ /** * writes the start of an array of characters and a new-line, then * flushes the buffer. - * @see #write(char [], int) + * @see #write(char[], int) * * @param ca the array of characters * @param len the number of characters to be logged, starting with @@ -437,7 +435,7 @@ /** * writes an array of bytes and a new-line, then * flushes the buffer. - * @see #write(byte []) + * @see #write(byte[]) * * @param b the array of bytes to be logged */ @@ -580,7 +578,7 @@ /** * writes the start of an array of characters and a new-line, then * optionally flushes the buffer. - * @see #write(char [], int) + * @see #write(char[], int) * * @param ca the array of characters * @param len the number of characters to be logged, starting with @@ -595,7 +593,7 @@ /** * writes an array of bytes and a new-line, then optionally flushes the * buffer. - * @see #write(byte []) + * @see #write(byte[]) * * @param b the array of bytes to be logged * @param flush if <code>true</code> then flushes the buffer Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -13,8 +13,6 @@ */ package org.mmtk.utility; -import org.mmtk.utility.Constants; - import org.mmtk.vm.VM; import org.vmmagic.pragma.Uninterruptible; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/TraceGenerator.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -13,7 +13,6 @@ import org.mmtk.plan.semispace.gctrace.GCTrace; import org.mmtk.plan.TraceLocal; import org.mmtk.policy.Space; -import org.mmtk.utility.Constants; import org.mmtk.utility.deque.*; import org.mmtk.utility.options.Options; import org.mmtk.utility.options.TraceRate; Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2007-02-26 06:35:46 UTC (rev 11530) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2007-02-26 06:49:41 UTC (rev 11531) @@ -11,7 +11,6 @@ package org.mmtk.utility; import org.mmtk.utility.gcspy.drivers.TreadmillDriver; -import org.mmtk.utility.Constants; import org.vmmagic.unboxed.*; import org.vmmagic.pragma.*; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-03-02 11:55:54
|
Revision: 11642 http://svn.sourceforge.net/jikesrvm/?rev=11642&view=rev Author: peter_donald Date: 2007-03-02 03:55:53 -0800 (Fri, 02 Mar 2007) Log Message: ----------- Remove some unused fields Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMS.java rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java rvmroot/trunk/MMTk/src/org/mmtk/utility/statistics/LongCounter.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMS.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMS.java 2007-03-02 11:54:55 UTC (rev 11641) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/copyms/CopyMS.java 2007-03-02 11:55:53 UTC (rev 11642) @@ -66,7 +66,6 @@ public static final int ALLOC_NURSERY = ALLOC_DEFAULT; public static final int ALLOC_MS = StopTheWorld.ALLOCATORS + 1; - public static int ALLOCATORS = ALLOC_MS; /**************************************************************************** Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2007-03-02 11:54:55 UTC (rev 11641) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2007-03-02 11:55:53 UTC (rev 11642) @@ -60,7 +60,6 @@ public static final int ALLOC_MATURE = StopTheWorld.ALLOCATORS + 1; public static final int ALLOC_MATURE_MINORGC = StopTheWorld.ALLOCATORS + 2; public static final int ALLOC_MATURE_MAJORGC = StopTheWorld.ALLOCATORS + 3; - public static int ALLOCATORS = ALLOC_MATURE_MAJORGC; /***************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/statistics/LongCounter.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/statistics/LongCounter.java 2007-03-02 11:54:55 UTC (rev 11641) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/statistics/LongCounter.java 2007-03-02 11:55:53 UTC (rev 11642) @@ -33,8 +33,6 @@ private long startValue = 0; protected long totalCount = 0; - protected long min = 0; - protected long max = 0; private boolean running = false; /**************************************************************************** This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-04-29 02:39:25
|
Revision: 12103 http://svn.sourceforge.net/jikesrvm/?rev=12103&view=rev Author: peter_donald Date: 2007-04-28 19:39:23 -0700 (Sat, 28 Apr 2007) Log Message: ----------- Remove methods that just invoke the overidden method Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MC.java rvmroot/trunk/MMTk/src/org/mmtk/policy/CopyLocal.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalLocal.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MC.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MC.java 2007-04-29 02:36:27 UTC (rev 12102) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/markcompact/MC.java 2007-04-29 02:39:23 UTC (rev 12103) @@ -99,14 +99,6 @@ collection = mcCollection; } - /** - * Boot-time initialization - */ - @Interruptible - public void boot() { - super.boot(); - } - /***************************************************************************** * * Collection Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/CopyLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopyLocal.java 2007-04-29 02:36:27 UTC (rev 12102) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/CopyLocal.java 2007-04-29 02:39:23 UTC (rev 12103) @@ -34,15 +34,4 @@ public CopyLocal(CopySpace space) { super(space, true); } - - /** - * Re-associate this bump pointer with a different space. Also - * reset the bump pointer so that it will use the new space - * on the next call to <code>alloc</code>. - * - * @param space The space to associate the bump pointer with. - */ - public void rebind(CopySpace space) { - super.rebind(space); - } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalLocal.java 2007-04-29 02:36:27 UTC (rev 12102) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalLocal.java 2007-04-29 02:39:23 UTC (rev 12103) @@ -34,15 +34,4 @@ public ImmortalLocal(ImmortalSpace space) { super(space, true); } - - /** - * Re-associate this bump pointer with a different space. Also - * reset the bump pointer so that it will use the new space - * on the next call to <code>alloc</code>. - * - * @param space The space to associate the bump pointer with. - */ - public void rebind(ImmortalSpace space) { - super.rebind(space); - } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-06-30 14:10:40
|
Revision: 12852 http://svn.sourceforge.net/jikesrvm/?rev=12852&view=rev Author: dframpton-oss Date: 2007-06-30 07:10:38 -0700 (Sat, 30 Jun 2007) Log Message: ----------- Subtle mistake during the conversion of poll caused regressions in RC. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/Plan.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalDeque.java rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalSSB.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/Plan.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/Plan.java 2007-06-30 13:43:56 UTC (rev 12851) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/Plan.java 2007-06-30 14:10:38 UTC (rev 12852) @@ -349,6 +349,7 @@ protected static int requiredAtStart; protected static boolean userTriggeredGC; protected static boolean emergencyCollection; + protected static boolean awaitingAsyncCollection; private static boolean initialized = false; private static boolean collectionTriggered; @@ -728,7 +729,7 @@ * an asynchronous GC, which will occur at the next safe point. */ logPoll(space, "Asynchronous collection requested"); - VM.collection.triggerAsyncCollection(Collection.RESOURCE_GC_TRIGGER); + setAwaitingAsyncCollection(); return false; } logPoll(space, "Triggering collection"); @@ -740,6 +741,31 @@ } /** + * Check whether an asynchronous collection is pending.<p> + * + * This is decoupled from the poll() mechanism because the + * triggering of asynchronous collections can trigger write + * barriers, which can trigger an asynchronous collection. Thus, if + * the triggering were tightly coupled with the request to alloc() + * within the write buffer code, then inifinite regress could + * result. There is no race condition in the following code since + * there is no harm in triggering the collection more than once, + * thus it is unsynchronized. + */ + @Inline + public static void checkForAsyncCollection() { + if (awaitingAsyncCollection && VM.collection.noThreadsInGC()) { + awaitingAsyncCollection = false; + VM.collection.triggerAsyncCollection(Collection.RESOURCE_GC_TRIGGER); + } + } + + /** Request an async GC */ + protected static void setAwaitingAsyncCollection() { + awaitingAsyncCollection = true; + } + + /** * Log a message from within 'poll' * @param space * @param message Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-06-30 13:43:56 UTC (rev 12851) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-06-30 14:10:38 UTC (rev 12852) @@ -255,6 +255,7 @@ } Space.clearAllAllocationFailed(); userTriggeredGC = false; + awaitingAsyncCollection = false; return; } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalDeque.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalDeque.java 2007-06-30 13:43:56 UTC (rev 12851) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalDeque.java 2007-06-30 14:10:38 UTC (rev 12852) @@ -113,6 +113,7 @@ closeAndInsertHead(arity); head = queue.alloc(); + Plan.checkForAsyncCollection(); // possible side-effect of alloc() } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalSSB.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalSSB.java 2007-06-30 13:43:56 UTC (rev 12851) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/deque/LocalSSB.java 2007-06-30 14:10:38 UTC (rev 12852) @@ -180,6 +180,7 @@ } tail = queue.alloc().plus(bufferSentinel(arity)); tailBufferEnd = tail; + Plan.checkForAsyncCollection(); // possible side-effect of alloc() } /** This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-07-18 06:01:01
|
Revision: 13085 http://svn.sourceforge.net/jikesrvm/?rev=13085&view=rev Author: dframpton-oss Date: 2007-07-17 23:00:57 -0700 (Tue, 17 Jul 2007) Log Message: ----------- Improve flexibility of sanity checker by dividing the building and validation of the sanity tables. Also separate pre and post sanity placeholders to allow them to be treated differently by individual collectors Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-07-18 05:08:37 UTC (rev 13084) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-07-18 06:00:57 UTC (rev 13085) @@ -72,22 +72,35 @@ public static final int COMPLETE = new SimplePhase("complete", null, Phase.GLOBAL_LAST ).getId(); /* Sanity placeholder */ - public static final int SANITY_PLACEHOLDER = new SimplePhase("sanity-placeholder", null, Phase.PLACEHOLDER ).getId(); + public static final int PRE_SANITY_PLACEHOLDER = new SimplePhase("pre-sanity-placeholder", null, Phase.PLACEHOLDER).getId(); + public static final int POST_SANITY_PLACEHOLDER = new SimplePhase("post-sanity-placeholder", null, Phase.PLACEHOLDER).getId(); /* Sanity phases */ - public static final int SANITY_PREPARE = new SimplePhase("sanity-prepare", null, Phase.GLOBAL_FIRST ).getId(); - public static final int SANITY_ROOTS = new SimplePhase("sanity-roots", null, Phase.GLOBAL_LAST ).getId(); - public static final int SANITY_CHECK = new SimplePhase("sanity", null, Phase.COLLECTOR_ONLY ).getId(); - public static final int SANITY_RELEASE = new SimplePhase("sanity-release", null, Phase.GLOBAL_LAST ).getId(); + public static final int SANITY_PREPARE = new SimplePhase("sanity-prepare", null, Phase.GLOBAL_FIRST ).getId(); + public static final int SANITY_ROOTS = new SimplePhase("sanity-roots", null, Phase.GLOBAL_LAST ).getId(); + public static final int SANITY_BUILD_TABLE = new SimplePhase("sanity-build-table", null, Phase.COLLECTOR_ONLY).getId(); + public static final int SANITY_CHECK_TABLE = new SimplePhase("sanity-check-table", null, Phase.COLLECTOR_ONLY).getId(); + public static final int SANITY_RELEASE = new SimplePhase("sanity-release", null, Phase.GLOBAL_LAST ).getId(); - /* Sanity check phase sequence */ - private static final int sanityPhase = new ComplexPhase("sanity-check", null, new int[] { + /* Trace and set up a sanity table */ + private static final int sanityBuildPhase = new ComplexPhase("sanity-build", null, new int[] { SANITY_PREPARE, SANITY_ROOTS, - SANITY_CHECK, + SANITY_BUILD_TABLE, + }).getId(); + + /* Validate a sanity table */ + private static final int sanityCheckPhase = new ComplexPhase("sanity-check", null, new int[] { + SANITY_CHECK_TABLE, SANITY_RELEASE }).getId(); + /* Build and validate a sanity table */ + private static final int sanityPhase = new ComplexPhase("sanity", null, new int[] { + sanityBuildPhase, + sanityCheckPhase + }).getId(); + /** * Start the collection, including preparation for any collected spaces. */ @@ -95,7 +108,7 @@ SET_COLLECTION_KIND, INITIATE, INITIATE_MUTATOR, - SANITY_PLACEHOLDER, + PRE_SANITY_PLACEHOLDER, }).getId(); /** @@ -141,7 +154,7 @@ * The collection scheme - this is a small tree of complex phases. */ protected static final int finishPhase = new ComplexPhase("finish", new int[] { - SANITY_PLACEHOLDER, + POST_SANITY_PLACEHOLDER, COMPLETE}).getId(); /** @@ -181,7 +194,8 @@ Log.writeln("Collector does not support sanity checking!"); } else { Log.writeln("Collection sanity checking enabled."); - replacePhase(SANITY_PLACEHOLDER, sanityPhase); + replacePhase(PRE_SANITY_PLACEHOLDER, sanityPhase); + replacePhase(POST_SANITY_PLACEHOLDER, sanityPhase); } } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2007-07-18 05:08:37 UTC (rev 13084) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2007-07-18 06:00:57 UTC (rev 13085) @@ -65,11 +65,16 @@ return true; } - if (phaseId == StopTheWorld.SANITY_CHECK) { + if (phaseId == StopTheWorld.SANITY_BUILD_TABLE) { if (primary) { // Trace, checking for dangling pointers sanityTrace.startTrace(); + } + return true; + } + if (phaseId == StopTheWorld.SANITY_CHECK_TABLE) { + if (primary) { // Iterate over the reachable objects. Address curr = global().getSanityTable().getFirst(); while (!curr.isZero()) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-07-21 07:11:21
|
Revision: 13125 http://svn.sourceforge.net/jikesrvm/?rev=13125&view=rev Author: peter_donald Date: 2007-07-21 00:11:19 -0700 (Sat, 21 Jul 2007) Log Message: ----------- Refactor Map so that it deals with Addresses rather than than with a combination of Addresses and ObjectReferences Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-21 06:51:18 UTC (rev 13124) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-21 07:11:19 UTC (rev 13125) @@ -87,7 +87,7 @@ protected Extent extent; protected boolean immortal; protected boolean movable; - + private boolean allocationFailed; protected PageResource pr; @@ -305,10 +305,10 @@ /** Allocationfailed getter @return true if an allocation has failed since GC */ public final boolean allocationFailed() { return allocationFailed; } - + /** Clear Allocationfailed flag */ public final void clearAllocationFailed() { allocationFailed = false; } - + /** ReservedPages getter @return The number of reserved pages */ public final int reservedPages() { return pr.reservedPages(); } @@ -317,7 +317,7 @@ /** RequiredPages getter @return The number of required pages */ public final int requiredPages() { return pr.requiredPages(); } - + /** Cumulative committed pages getter @return Cumulative committed pages. */ public static long cumulativeCommittedPages() { return PageResource.cumulativeCommittedPages(); @@ -390,18 +390,33 @@ */ @Inline public static boolean isInSpace(int descriptor, ObjectReference object) { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isNull()); + return isInSpace(descriptor, VM.objectModel.refToAddress(object)); + } + + /** + * Return true if the given address is the space associated with the + * given descriptor. + * + * @param descriptor The descriptor for a space + * @param address The address in question. + * @return True if the given address is in the space associated with + * the descriptor. + */ + @Inline + public static boolean isInSpace(int descriptor, Address address) { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!address.isZero()); if (!SpaceDescriptor.isContiguous(descriptor)) { - return getDescriptorForObject(object) == descriptor; + return getDescriptorForAddress(address) == descriptor; } else { - Address addr = VM.objectModel.refToAddress(object); Address start = SpaceDescriptor.getStart(descriptor); if (!VM.VERIFY_ASSERTIONS && SpaceDescriptor.isContiguousHi(descriptor)) - return addr.GE(start); + return address.GE(start); else { Extent size = Word.fromIntSignExtend(SpaceDescriptor.getChunks(descriptor)).lsh(LOG_BYTES_IN_CHUNK).toExtent(); Address end = start.plus(size); - return addr.GE(start) && addr.LT(end); + return address.GE(start) && address.LT(end); } } } @@ -414,19 +429,20 @@ */ @Inline public static Space getSpaceForObject(ObjectReference object) { - return Map.getSpaceForObject(object); + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isNull()); + return Map.getSpaceForAddress(VM.objectModel.refToAddress(object)); } /** - * Return the descriptor for a given object + * Return the descriptor for a given address. * - * @param object The object in question - * @return The descriptor for the space containing the object + * @param address The address in question. + * @return The descriptor for the space containing the address. */ @Inline - public static int getDescriptorForObject(ObjectReference object) { - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isNull()); - return Map.getDescriptorForObject(object); + public static int getDescriptorForAddress(Address address) { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!address.isZero()); + return Map.getDescriptorForAddress(address); } @@ -457,7 +473,7 @@ */ public final Address acquire(int pages) { boolean allowPoll = !Plan.gcInProgress() && Plan.isInitialized() && !Plan.isEmergencyAllocation(); - + /* First check page budget and poll if necessary */ if (!pr.reservePages(pages)) { /* Need to poll, either fixing budget or requiring GC */ @@ -482,7 +498,7 @@ pr.clearRequest(pages); return Address.zero(); } - + if (allowPoll) VM.collection.reportAllocationSuccess(); return rtn; } @@ -495,7 +511,7 @@ public abstract void release(Address start); /** - * Clear the allocation failed flag for all spaces. + * Clear the allocation failed flag for all spaces. * */ public static void clearAllAllocationFailed() { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2007-07-21 06:51:18 UTC (rev 13124) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2007-07-21 07:11:19 UTC (rev 13125) @@ -83,18 +83,6 @@ } /** - * Return the space in which this object resides. - * - * @param object The object in question - * @return The space in which the object resides - */ - @Inline - public static Space getSpaceForObject(ObjectReference object) { - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isNull()); - return getSpaceForAddress(VM.objectModel.refToAddress(object)); - } - - /** * Return the space in which this address resides. * * @param address The address in question @@ -115,9 +103,9 @@ * resides */ @Inline - public static int getDescriptorForObject(ObjectReference object) { - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isNull()); - int index = hashAddress(VM.objectModel.refToAddress(object)); + public static int getDescriptorForAddress(Address object) { + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!object.isZero()); + int index = hashAddress(object); return VM.barriers.getArrayNoBarrier(descriptorMap, index); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-07-21 09:04:24
|
Revision: 13128 http://svn.sourceforge.net/jikesrvm/?rev=13128&view=rev Author: peter_donald Date: 2007-07-21 02:04:20 -0700 (Sat, 21 Jul 2007) Log Message: ----------- Extract a ContiguousSpace space from Space so that in the future it is possible to define non-contiguous spaces. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java Added Paths: ----------- rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java Added: rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -0,0 +1,296 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.policy; + +import org.mmtk.utility.Log; +import org.mmtk.utility.heap.Map; +import org.mmtk.utility.heap.Mmapper; +import org.mmtk.utility.heap.SpaceDescriptor; +import org.mmtk.vm.VM; +import org.vmmagic.pragma.Uninterruptible; +import org.vmmagic.unboxed.Address; +import org.vmmagic.unboxed.Extent; +import org.vmmagic.unboxed.Word; + +/** + * The continuous space requires that the managed virtual memory is contiguous. + */ +@Uninterruptible +public abstract class ContiguousSpace extends Space { + + /**************************************************************************** + * + * Class variables + */ + private static boolean DEBUG = false; + + /**************************************************************************** + * + * Instance variables + */ + protected Address start; + protected Extent extent; + + /**************************************************************************** + * + * Initialization + */ + + /** + * This is the base constructor for <i>contigious</i> spaces + * (i.e. those that occupy a single contigious range of virtual + * memory which is identified at construction time).<p> + * + * 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 movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param start The start address of the space in virtual memory + * @param extent The size of the space in virtual memory, in bytes + */ + ContiguousSpace(String name, boolean movable, boolean immortal, Address start, + Extent extent) { + super(name, movable, immortal, createDescriptor(false, start, extent)); + this.start = start; + this.extent = extent; + /* ensure requests are chunk aligned */ + if (extent.NE(chunkAlign(extent, false))) { + Log.write("Warning: "); + Log.write(name); + Log.write(" space request for "); + Log.write(extent.toLong()); Log.write(" bytes rounded up to "); + extent = chunkAlign(extent, false); + Log.write(extent.toLong()); Log.writeln(" extent"); + Log.writeln("(requests should be Space.BYTES_IN_CHUNK aligned)"); + } + this.extent = extent; + + VM.memory.setHeapRange(getIndex(), start, start.plus(extent)); + Map.insert(start, this.extent, getDescriptor(), this); + + if (DEBUG) { + Log.write(name); Log.write(" "); + Log.write(start); Log.write(" "); + Log.write(start.plus(this.extent)); Log.write(" "); + Log.writeln(extent.toWord()); + } + } + + /** + * Construct a space of a given number of megabytes in size.<p> + * + * The caller specifies the amount virtual memory to be used for + * this space <i>in megabytes</i>. If there is insufficient address + * space, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param mb The size of the space in virtual memory, in megabytes (MB) + */ + ContiguousSpace(String name, boolean movable, boolean immortal, int mb) { + this(name, movable, immortal, heapCursor, + Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent()); + heapCursor = heapCursor.plus(extent); + if (heapCursor.GT(heapLimit)) { + Log.write("Out of virtual address space allocating \""); + Log.write(name); Log.write("\" at "); + Log.write(heapCursor.minus(extent)); Log.write(" ("); + Log.write(heapCursor); Log.write(" > "); + Log.write(heapLimit); Log.writeln(")"); + VM.assertions.fail("exiting"); + } + } + + /** + * Construct a space that consumes a given fraction of the available + * virtual memory.<p> + * + * The caller specifies the amount virtual memory to be used for + * this space <i>as a fraction of the total available</i>. If there + * is insufficient address space, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param frac The size of the space in virtual memory, as a + * fraction of all available virtual memory + */ + ContiguousSpace(String name, boolean movable, boolean immortal, float frac) { + this(name, movable, immortal, heapCursor, getFracAvailable(frac)); + heapCursor = heapCursor.plus(extent); + } + + /** + * Construct a space that consumes a given number of megabytes of + * virtual memory, at either the top or bottom of the available + * virtual memory. + * + * The caller specifies the amount virtual memory to be used for + * this space <i>in megabytes</i>, and whether it should be at the + * top or bottom of the available virtual memory. If the request + * clashes with existing virtual memory allocations, then the + * constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param mb The size of the space in virtual memory, in megabytes (MB) + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + ContiguousSpace(String name, boolean movable, boolean immortal, int mb, boolean top) { + this(name, movable, immortal, + Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent(), top); + } + + /** + * Construct a space that consumes a given fraction of the available + * virtual memory, at either the top or bottom of the available + * virtual memory. + * + * The caller specifies the amount virtual memory to be used for + * this space <i>as a fraction of the total available</i>, and + * whether it should be at the top or bottom of the available + * virtual memory. If the request clashes with existing virtual + * memory allocations, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param frac The size of the space in virtual memory, as a + * fraction of all available virtual memory + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + ContiguousSpace(String name, boolean movable, boolean immortal, float frac, + boolean top) { + this(name, movable, immortal, getFracAvailable(frac), top); + } + + /** + * This is a private constructor that creates a contigious space at + * the top or bottom of the available virtual memory, if + * possible.<p> + * + * The caller specifies the size of the region of virtual memory and + * whether it should be at the top or bottom of the available + * address 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 movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param bytes The size of the space in virtual memory, in bytes + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + private ContiguousSpace(String name, boolean movable, boolean immortal, Extent bytes, + boolean top) { + this(name, movable, immortal, (top) ? heapLimit.minus(bytes) : HEAP_START, + bytes); + if (top) { // request for the top of available memory + /* if (heapLimit.NE(HEAP_END)) { + Log.write("Unable to satisfy virtual address space request \""); + Log.write(name); Log.write("\" at "); + Log.writeln(heapLimit); + VM.assertions.fail("exiting"); + } */ + heapLimit = heapLimit.minus(extent); + } else { // request for the bottom of available memory + if (heapCursor.GT(HEAP_START)) { + Log.write("Unable to satisfy virtual address space request \""); + Log.write(name); Log.write("\" at "); + Log.writeln(heapCursor); + VM.assertions.fail("exiting"); + } + heapCursor = heapCursor.plus(extent); + } + } + + + /**************************************************************************** + * + * Accessor methods + */ + + /** Start getter @return The start address of this space */ + public final Address getStart() { return start; } + + /** Extent getter @return The size (extent) of this space */ + public final Extent getExtent() { return extent; } + + /**************************************************************************** + * + * Debugging / printing + */ + + protected void printVMRange() { + Log.write(start); + Log.write("->"); + Log.writeln(start.plus(extent.minus(1))); + } + + /** + * {@inheritDoc} + */ + protected void ensureMapped() { + Mmapper.ensureMapped(start, extent.toInt()>>LOG_BYTES_IN_PAGE); + } + + /**************************************************************************** + * + * Miscellaneous + */ + + /** + * Align an extent to a space chunk + * + * @param bytes The extent to be aligned + * @param down If true the address will be rounded down, otherwise + * it will rounded up. + */ + private static Extent chunkAlign(Extent bytes, boolean down) { + if (!down) bytes = bytes.plus(BYTES_IN_CHUNK - 1); + return bytes.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toExtent(); + } + + /** + * Initialize/create the descriptor for this space + * + * @param shared True if this is a shared (discontigious) space + */ + private static int createDescriptor(boolean shared, Address start, Extent extent) { + if (shared) + return SpaceDescriptor.createDescriptor(); + else + return SpaceDescriptor.createDescriptor(start, start.plus(extent)); + } + + /** + * Convert a fraction into a number of bytes according to the + * fraction of available bytes. + * + * @param frac The fraction of avialable virtual memory desired + * @return The corresponding number of bytes, chunk-aligned. + */ + private static Extent getFracAvailable(float frac) { + long bytes = (long) (frac * AVAILABLE_BYTES.toLong()); + Word mb = Word.fromIntSignExtend((int) (bytes >> LOG_BYTES_IN_MBYTE)); + Extent rtn = mb.lsh(LOG_BYTES_IN_MBYTE).toExtent(); + return chunkAlign(rtn, false); + } +} Property changes on: rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -26,8 +26,8 @@ * space. Since no state needs to be held globally or locally, all * methods are static. */ -@Uninterruptible public final class CopySpace extends Space - implements Constants { +@Uninterruptible public final class CopySpace extends ContiguousSpace + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -28,8 +28,7 @@ * threads. Thus unlike this class, synchronization is not necessary * in the instance methods of MarkSweepLocal. */ -@Uninterruptible public final class ExplicitFreeListSpace extends Space - implements Constants { +@Uninterruptible public final class ExplicitFreeListSpace extends ContiguousSpace implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -29,8 +29,9 @@ * actually collect. This class does not hold any state, all methods * are static. */ -@Uninterruptible public final class ImmortalSpace extends Space - implements Constants { +@Uninterruptible public final class ImmortalSpace + extends ContiguousSpace + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -35,8 +35,7 @@ * and called on a per-thread basis, where each instance of * TreadmillLocal corresponds to one thread operating over one space. */ -@Uninterruptible public final class LargeObjectSpace extends Space - implements Constants { +@Uninterruptible public final class LargeObjectSpace extends ContiguousSpace implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -25,8 +25,7 @@ * This class implements functionality for a simple sliding mark-compact * space. */ -@Uninterruptible public final class MarkCompactSpace extends Space - implements Constants { +@Uninterruptible public final class MarkCompactSpace extends ContiguousSpace implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -33,8 +33,7 @@ * threads. Thus unlike this class, synchronization is not necessary * in the instance methods of MarkSweepLocal. */ -@Uninterruptible public final class MarkSweepSpace extends Space - implements Constants { +@Uninterruptible public final class MarkSweepSpace extends ContiguousSpace implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -27,8 +27,7 @@ * This class provides access to raw memory for managing internal meta * data. */ -@Uninterruptible public final class RawPageSpace extends Space - implements Constants { +@Uninterruptible public final class RawPageSpace extends ContiguousSpace implements Constants { /** * The caller specifies the region of virtual memory to be used for Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -45,19 +45,12 @@ */ @Uninterruptible public abstract class Space implements Constants { - /**************************************************************************** - * - * Class variables - */ - - private static boolean DEBUG = false; - // the following is somewhat arbitrary for the 64 bit system at this stage private static final int LOG_ADDRESS_SPACE = (BYTES_IN_ADDRESS == 4) ? 32 : 40; - private static Address HEAP_START = chunkAlign(VM.HEAP_START, true); + protected static Address HEAP_START = chunkAlign(VM.HEAP_START, true); private static Address AVAILABLE_START = chunkAlign(VM.AVAILABLE_START, false); private static Address AVAILABLE_END = chunkAlign(VM.AVAILABLE_END, true); - private static Extent AVAILABLE_BYTES = AVAILABLE_END.toWord().minus(AVAILABLE_START.toWord()).toExtent(); + protected static Extent AVAILABLE_BYTES = AVAILABLE_END.toWord().minus(AVAILABLE_START.toWord()).toExtent(); public static final Address HEAP_END = chunkAlign(VM.HEAP_END, false); public static final int LOG_BYTES_IN_CHUNK = 22; @@ -73,20 +66,18 @@ private static int spaceCount = 0; private static Space[] spaces = new Space[MAX_SPACES]; - private static Address heapCursor = HEAP_START; - private static Address heapLimit = HEAP_END; + protected static Address heapCursor = HEAP_START; + protected static Address heapLimit = HEAP_END; /**************************************************************************** * * Instance variables */ - private int descriptor; - private int index; - private String name; - protected Address start; - protected Extent extent; - protected boolean immortal; - protected boolean movable; + private final int descriptor; + private final int index; + private final String name; + private final boolean immortal; + private final boolean movable; private boolean allocationFailed; protected PageResource pr; @@ -108,175 +99,16 @@ * @param name The name of this space (used when printing error messages etc) * @param movable Are objects in this space movable? * @param immortal Are objects in this space immortal (uncollected)? - * @param start The start address of the space in virtual memory - * @param bytes The size of the space in virtual memory, in bytes */ - Space(String name, boolean movable, boolean immortal, Address start, - Extent bytes) { + Space(String name, boolean movable, boolean immortal, int descriptor) { this.name = name; this.movable = movable; this.immortal = immortal; - this.start = start; + this.descriptor = descriptor; index = spaceCount++; spaces[index] = this; - - /* ensure requests are chunk aligned */ - if (bytes.NE(chunkAlign(bytes, false))) { - Log.write("Warning: "); - Log.write(name); - Log.write(" space request for "); - Log.write(bytes.toLong()); Log.write(" bytes rounded up to "); - bytes = chunkAlign(bytes, false); - Log.write(bytes.toLong()); Log.writeln(" bytes"); - Log.writeln("(requests should be Space.BYTES_IN_CHUNK aligned)"); - } - this.extent = bytes; - - VM.memory.setHeapRange(index, start, start.plus(bytes)); - createDescriptor(false); - Map.insert(start, extent, descriptor, this); - - if (DEBUG) { - Log.write(name); Log.write(" "); - Log.write(start); Log.write(" "); - Log.write(start.plus(extent)); Log.write(" "); - Log.writeln(bytes.toWord()); - } } - /** - * Construct a space of a given number of megabytes in size.<p> - * - * The caller specifies the amount virtual memory to be used for - * this space <i>in megabytes</i>. If there is insufficient address - * space, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param mb The size of the space in virtual memory, in megabytes (MB) - */ - Space(String name, boolean movable, boolean immortal, int mb) { - this(name, movable, immortal, heapCursor, - Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent()); - heapCursor = heapCursor.plus(extent); - if (heapCursor.GT(heapLimit)) { - Log.write("Out of virtual address space allocating \""); - Log.write(name); Log.write("\" at "); - Log.write(heapCursor.minus(extent)); Log.write(" ("); - Log.write(heapCursor); Log.write(" > "); - Log.write(heapLimit); Log.writeln(")"); - VM.assertions.fail("exiting"); - } - } - - /** - * Construct a space that consumes a given fraction of the available - * virtual memory.<p> - * - * The caller specifies the amount virtual memory to be used for - * this space <i>as a fraction of the total available</i>. If there - * is insufficient address space, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param frac The size of the space in virtual memory, as a - * fraction of all available virtual memory - */ - Space(String name, boolean movable, boolean immortal, float frac) { - this(name, movable, immortal, heapCursor, getFracAvailable(frac)); - heapCursor = heapCursor.plus(extent); - } - - /** - * Construct a space that consumes a given number of megabytes of - * virtual memory, at either the top or bottom of the available - * virtual memory. - * - * The caller specifies the amount virtual memory to be used for - * this space <i>in megabytes</i>, and whether it should be at the - * top or bottom of the available virtual memory. If the request - * clashes with existing virtual memory allocations, then the - * constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param mb The size of the space in virtual memory, in megabytes (MB) - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - Space(String name, boolean movable, boolean immortal, int mb, boolean top) { - this(name, movable, immortal, - Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent(), top); - } - - /** - * Construct a space that consumes a given fraction of the available - * virtual memory, at either the top or bottom of the available - * virtual memory. - * - * The caller specifies the amount virtual memory to be used for - * this space <i>as a fraction of the total available</i>, and - * whether it should be at the top or bottom of the available - * virtual memory. If the request clashes with existing virtual - * memory allocations, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param frac The size of the space in virtual memory, as a - * fraction of all available virtual memory - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - Space(String name, boolean movable, boolean immortal, float frac, - boolean top) { - this(name, movable, immortal, getFracAvailable(frac), top); - } - - /** - * This is a private constructor that creates a contigious space at - * the top or bottom of the available virtual memory, if - * possible.<p> - * - * The caller specifies the size of the region of virtual memory and - * whether it should be at the top or bottom of the available - * address 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 movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param bytes The size of the space in virtual memory, in bytes - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - private Space(String name, boolean movable, boolean immortal, Extent bytes, - boolean top) { - this(name, movable, immortal, (top) ? heapLimit.minus(bytes) : HEAP_START, - bytes); - if (top) { // request for the top of available memory - /* if (heapLimit.NE(HEAP_END)) { - Log.write("Unable to satisfy virtual address space request \""); - Log.write(name); Log.write("\" at "); - Log.writeln(heapLimit); - VM.assertions.fail("exiting"); - } */ - heapLimit = heapLimit.minus(extent); - } else { // request for the bottom of available memory - if (heapCursor.GT(HEAP_START)) { - Log.write("Unable to satisfy virtual address space request \""); - Log.write(name); Log.write("\" at "); - Log.writeln(heapCursor); - VM.assertions.fail("exiting"); - } - heapCursor = heapCursor.plus(extent); - } - } - - /**************************************************************************** * * Accessor methods @@ -285,12 +117,6 @@ /** Name getter @return The name of this space */ public final String getName() { return name; } - /** Start getter @return The start address of this space */ - public final Address getStart() { return start; } - - /** Extent getter @return The size (extent) of this space */ - public final Extent getExtent() { return extent; } - /** Descriptor method @return The integer descriptor for this space */ public final int getDescriptor() { return descriptor; } @@ -555,11 +381,12 @@ for (int i = 0; i < spaceCount; i++) { Space space = spaces[i]; Log.write(space.name); Log.write(" "); - Log.write(space.start); Log.write("->"); - Log.writeln(space.start.plus(space.extent.minus(1))); + space.printVMRange(); } } + protected abstract void printVMRange(); + /** * Ensure that all MMTk spaces (all spaces aside from the VM space) * are mapped. Demand zero map all of them if they are not already @@ -572,18 +399,22 @@ if (space != VM.memory.getVMSpace()) { if (Options.verbose.getValue() > 2) { Log.write("Mapping "); - Log.write(space.name); + Log.write(space.getName()); Log.write(" "); - Log.write(space.start); - Log.write("->"); - Log.writeln(space.start.plus(space.extent.minus(1))); + space.printVMRange(); } - Mmapper.ensureMapped(space.start, space.extent.toInt()>>LOG_BYTES_IN_PAGE); + space.ensureMapped(); } } } /** + * Ensure that this space is mapped. + * Demand zero map all of them if they are not already mapped. + */ + protected abstract void ensureMapped(); + + /** * Print out the memory used by all spaces in either megabytes or * pages. * @@ -670,42 +501,4 @@ if (!down) addr = addr.plus(BYTES_IN_CHUNK - 1); return addr.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toAddress(); } - - /** - * Align an extent to a space chunk - * - * @param bytes The extent to be aligned - * @param down If true the address will be rounded down, otherwise - * it will rounded up. - */ - private static Extent chunkAlign(Extent bytes, boolean down) { - if (!down) bytes = bytes.plus(BYTES_IN_CHUNK - 1); - return bytes.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toExtent(); - } - - /** - * Initialize/create the descriptor for this space - * - * @param shared True if this is a shared (discontigious) space - */ - private void createDescriptor(boolean shared) { - if (shared) - descriptor = SpaceDescriptor.createDescriptor(); - else - descriptor = SpaceDescriptor.createDescriptor(start, start.plus(extent)); - } - - /** - * Convert a fraction into a number of bytes according to the - * fraction of available bytes. - * - * @param frac The fraction of avialable virtual memory desired - * @return The corresponding number of bytes, chunk-aligned. - */ - private static Extent getFracAvailable(float frac) { - long bytes = (long) (frac * AVAILABLE_BYTES.toLong()); - Word mb = Word.fromIntSignExtend((int) (bytes >> LOG_BYTES_IN_MBYTE)); - Extent rtn = mb.lsh(LOG_BYTES_IN_MBYTE).toExtent(); - return chunkAlign(rtn, false); - } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -13,6 +13,7 @@ package org.mmtk.utility.alloc; import org.mmtk.policy.Space; +import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.*; import org.mmtk.utility.gcspy.drivers.LinearSpaceDriver; import org.mmtk.vm.VM; @@ -86,7 +87,7 @@ protected Address cursor; // insertion point private Address internalLimit; // current internal slow-path sentinal for bump pointer private Address limit; // current external slow-path sentinal for bump pointer - protected Space space; // space this bump pointer is associated with + protected ContiguousSpace space; // space this bump pointer is associated with protected Address initialRegion; // first contiguous region protected final boolean allowScanning; // linear scanning is permitted if true protected Address region; // current contigious region @@ -98,7 +99,7 @@ * @param space The space to bump point into. * @param allowScanning Allow linear scanning of this region of memory. */ - protected BumpPointer(Space space, boolean allowScanning) { + protected BumpPointer(ContiguousSpace space, boolean allowScanning) { this.space = space; this.allowScanning = allowScanning; reset(); @@ -123,7 +124,7 @@ * * @param space The space to associate the bump pointer with. */ - public final void rebind(Space space) { + public final void rebind(ContiguousSpace space) { reset(); this.space = space; } @@ -368,7 +369,7 @@ * @param driver The GCspy driver for this space. * @param scanSpace The space to scan */ - public void gcspyGatherData(LinearSpaceDriver driver, Space scanSpace) { + public void gcspyGatherData(LinearSpaceDriver driver, ContiguousSpace scanSpace) { //TODO can scanSpace ever be different to this.space? if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(scanSpace == space, "scanSpace != space"); @@ -447,7 +448,7 @@ /** @return the current cursor value */ public final Address getCursor() { return cursor; } /** @return the space associated with this bump pointer */ - public final Space getSpace() { return space; } + public final ContiguousSpace getSpace() { return space; } /** * Print out the status of the allocator (for debugging) Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -13,6 +13,7 @@ package org.mmtk.utility.gcspy.drivers; import org.mmtk.policy.Space; +import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.Log; import org.mmtk.utility.gcspy.GCspy; import org.mmtk.utility.gcspy.Subspace; @@ -93,7 +94,7 @@ */ public AbstractDriver(ServerInterpreter server, String name, - Space mmtkSpace, + ContiguousSpace mmtkSpace, int blockSize, boolean mainSpace) { this.server = server; @@ -115,7 +116,7 @@ * @param mmtkSpace The MMTk space */ @Interruptible - protected Subspace createSubspace (Space mmtkSpace) { + protected Subspace createSubspace (ContiguousSpace mmtkSpace) { Address start = mmtkSpace.getStart(); return new Subspace(start, start, 0, blockSize, 0); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -12,7 +12,7 @@ */ package org.mmtk.utility.gcspy.drivers; -import org.mmtk.policy.Space; +import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.scan.MMType; import org.mmtk.utility.Log; import org.mmtk.vm.gcspy.ServerInterpreter; @@ -48,7 +48,7 @@ public ImmortalSpaceDriver( ServerInterpreter server, String spaceName, - Space mmtkSpace, + ContiguousSpace mmtkSpace, int blockSize, boolean mainSpace) { @@ -109,5 +109,4 @@ public void registerDriversForReferenceNotification(AbstractDriver[] drivers) { this.registeredDrivers = drivers; } - } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -12,7 +12,7 @@ */ package org.mmtk.utility.gcspy.drivers; -import org.mmtk.policy.Space; +import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.scan.MMType; import org.mmtk.utility.gcspy.Color; import org.mmtk.utility.gcspy.LinearScan; @@ -77,7 +77,7 @@ public LinearSpaceDriver( ServerInterpreter server, String spaceName, - Space mmtkSpace, + ContiguousSpace mmtkSpace, int blockSize, boolean mainSpace) { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2007-07-21 08:01:32 UTC (rev 13127) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2007-07-21 09:04:20 UTC (rev 13128) @@ -13,6 +13,7 @@ package org.mmtk.utility.heap; import org.mmtk.policy.Space; +import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.alloc.EmbeddedMetaData; import org.mmtk.utility.Conversions; import org.mmtk.utility.GenericFreeList; @@ -67,7 +68,7 @@ * @param metaDataPagesPerRegion The number of pages of meta data * that are embedded in each region. */ - public FreeListPageResource(int pageBudget, Space space, Address start, + public FreeListPageResource(int pageBudget, ContiguousSpace space, Address start, Extent bytes, int metaDataPagesPerRegion) { super(pageBudget, space, start); this.metaDataPagesPerRegion = metaDataPagesPerRegion; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pet...@us...> - 2007-07-22 00:19:37
|
Revision: 13130 http://svn.sourceforge.net/jikesrvm/?rev=13130&view=rev Author: peter_donald Date: 2007-07-21 17:19:33 -0700 (Sat, 21 Jul 2007) Log Message: ----------- Back out r13128 Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java Removed Paths: ------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java Deleted: rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ContiguousSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -1,296 +0,0 @@ -/* - * This file is part of the Jikes RVM project (http://jikesrvm.org). - * - * This file is licensed to You under the Common Public License (CPL); - * 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/cpl1.0.php - * - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. - */ -package org.mmtk.policy; - -import org.mmtk.utility.Log; -import org.mmtk.utility.heap.Map; -import org.mmtk.utility.heap.Mmapper; -import org.mmtk.utility.heap.SpaceDescriptor; -import org.mmtk.vm.VM; -import org.vmmagic.pragma.Uninterruptible; -import org.vmmagic.unboxed.Address; -import org.vmmagic.unboxed.Extent; -import org.vmmagic.unboxed.Word; - -/** - * The continuous space requires that the managed virtual memory is contiguous. - */ -@Uninterruptible -public abstract class ContiguousSpace extends Space { - - /**************************************************************************** - * - * Class variables - */ - private static boolean DEBUG = false; - - /**************************************************************************** - * - * Instance variables - */ - protected Address start; - protected Extent extent; - - /**************************************************************************** - * - * Initialization - */ - - /** - * This is the base constructor for <i>contigious</i> spaces - * (i.e. those that occupy a single contigious range of virtual - * memory which is identified at construction time).<p> - * - * 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 movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param start The start address of the space in virtual memory - * @param extent The size of the space in virtual memory, in bytes - */ - ContiguousSpace(String name, boolean movable, boolean immortal, Address start, - Extent extent) { - super(name, movable, immortal, createDescriptor(false, start, extent)); - this.start = start; - this.extent = extent; - /* ensure requests are chunk aligned */ - if (extent.NE(chunkAlign(extent, false))) { - Log.write("Warning: "); - Log.write(name); - Log.write(" space request for "); - Log.write(extent.toLong()); Log.write(" bytes rounded up to "); - extent = chunkAlign(extent, false); - Log.write(extent.toLong()); Log.writeln(" extent"); - Log.writeln("(requests should be Space.BYTES_IN_CHUNK aligned)"); - } - this.extent = extent; - - VM.memory.setHeapRange(getIndex(), start, start.plus(extent)); - Map.insert(start, this.extent, getDescriptor(), this); - - if (DEBUG) { - Log.write(name); Log.write(" "); - Log.write(start); Log.write(" "); - Log.write(start.plus(this.extent)); Log.write(" "); - Log.writeln(extent.toWord()); - } - } - - /** - * Construct a space of a given number of megabytes in size.<p> - * - * The caller specifies the amount virtual memory to be used for - * this space <i>in megabytes</i>. If there is insufficient address - * space, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param mb The size of the space in virtual memory, in megabytes (MB) - */ - ContiguousSpace(String name, boolean movable, boolean immortal, int mb) { - this(name, movable, immortal, heapCursor, - Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent()); - heapCursor = heapCursor.plus(extent); - if (heapCursor.GT(heapLimit)) { - Log.write("Out of virtual address space allocating \""); - Log.write(name); Log.write("\" at "); - Log.write(heapCursor.minus(extent)); Log.write(" ("); - Log.write(heapCursor); Log.write(" > "); - Log.write(heapLimit); Log.writeln(")"); - VM.assertions.fail("exiting"); - } - } - - /** - * Construct a space that consumes a given fraction of the available - * virtual memory.<p> - * - * The caller specifies the amount virtual memory to be used for - * this space <i>as a fraction of the total available</i>. If there - * is insufficient address space, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param frac The size of the space in virtual memory, as a - * fraction of all available virtual memory - */ - ContiguousSpace(String name, boolean movable, boolean immortal, float frac) { - this(name, movable, immortal, heapCursor, getFracAvailable(frac)); - heapCursor = heapCursor.plus(extent); - } - - /** - * Construct a space that consumes a given number of megabytes of - * virtual memory, at either the top or bottom of the available - * virtual memory. - * - * The caller specifies the amount virtual memory to be used for - * this space <i>in megabytes</i>, and whether it should be at the - * top or bottom of the available virtual memory. If the request - * clashes with existing virtual memory allocations, then the - * constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param mb The size of the space in virtual memory, in megabytes (MB) - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - ContiguousSpace(String name, boolean movable, boolean immortal, int mb, boolean top) { - this(name, movable, immortal, - Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent(), top); - } - - /** - * Construct a space that consumes a given fraction of the available - * virtual memory, at either the top or bottom of the available - * virtual memory. - * - * The caller specifies the amount virtual memory to be used for - * this space <i>as a fraction of the total available</i>, and - * whether it should be at the top or bottom of the available - * virtual memory. If the request clashes with existing virtual - * memory allocations, then the constructor will fail. - * - * @param name The name of this space (used when printing error messages etc) - * @param movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param frac The size of the space in virtual memory, as a - * fraction of all available virtual memory - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - ContiguousSpace(String name, boolean movable, boolean immortal, float frac, - boolean top) { - this(name, movable, immortal, getFracAvailable(frac), top); - } - - /** - * This is a private constructor that creates a contigious space at - * the top or bottom of the available virtual memory, if - * possible.<p> - * - * The caller specifies the size of the region of virtual memory and - * whether it should be at the top or bottom of the available - * address 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 movable Are objects in this space movable? - * @param immortal Are objects in this space immortal (uncollected)? - * @param bytes The size of the space in virtual memory, in bytes - * @param top Should this space be at the top (or bottom) of the - * available virtual memory. - */ - private ContiguousSpace(String name, boolean movable, boolean immortal, Extent bytes, - boolean top) { - this(name, movable, immortal, (top) ? heapLimit.minus(bytes) : HEAP_START, - bytes); - if (top) { // request for the top of available memory - /* if (heapLimit.NE(HEAP_END)) { - Log.write("Unable to satisfy virtual address space request \""); - Log.write(name); Log.write("\" at "); - Log.writeln(heapLimit); - VM.assertions.fail("exiting"); - } */ - heapLimit = heapLimit.minus(extent); - } else { // request for the bottom of available memory - if (heapCursor.GT(HEAP_START)) { - Log.write("Unable to satisfy virtual address space request \""); - Log.write(name); Log.write("\" at "); - Log.writeln(heapCursor); - VM.assertions.fail("exiting"); - } - heapCursor = heapCursor.plus(extent); - } - } - - - /**************************************************************************** - * - * Accessor methods - */ - - /** Start getter @return The start address of this space */ - public final Address getStart() { return start; } - - /** Extent getter @return The size (extent) of this space */ - public final Extent getExtent() { return extent; } - - /**************************************************************************** - * - * Debugging / printing - */ - - protected void printVMRange() { - Log.write(start); - Log.write("->"); - Log.writeln(start.plus(extent.minus(1))); - } - - /** - * {@inheritDoc} - */ - protected void ensureMapped() { - Mmapper.ensureMapped(start, extent.toInt()>>LOG_BYTES_IN_PAGE); - } - - /**************************************************************************** - * - * Miscellaneous - */ - - /** - * Align an extent to a space chunk - * - * @param bytes The extent to be aligned - * @param down If true the address will be rounded down, otherwise - * it will rounded up. - */ - private static Extent chunkAlign(Extent bytes, boolean down) { - if (!down) bytes = bytes.plus(BYTES_IN_CHUNK - 1); - return bytes.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toExtent(); - } - - /** - * Initialize/create the descriptor for this space - * - * @param shared True if this is a shared (discontigious) space - */ - private static int createDescriptor(boolean shared, Address start, Extent extent) { - if (shared) - return SpaceDescriptor.createDescriptor(); - else - return SpaceDescriptor.createDescriptor(start, start.plus(extent)); - } - - /** - * Convert a fraction into a number of bytes according to the - * fraction of available bytes. - * - * @param frac The fraction of avialable virtual memory desired - * @return The corresponding number of bytes, chunk-aligned. - */ - private static Extent getFracAvailable(float frac) { - long bytes = (long) (frac * AVAILABLE_BYTES.toLong()); - Word mb = Word.fromIntSignExtend((int) (bytes >> LOG_BYTES_IN_MBYTE)); - Extent rtn = mb.lsh(LOG_BYTES_IN_MBYTE).toExtent(); - return chunkAlign(rtn, false); - } -} Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/CopySpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -26,8 +26,8 @@ * space. Since no state needs to be held globally or locally, all * methods are static. */ -@Uninterruptible public final class CopySpace extends ContiguousSpace - implements Constants { +@Uninterruptible public final class CopySpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -28,7 +28,8 @@ * threads. Thus unlike this class, synchronization is not necessary * in the instance methods of MarkSweepLocal. */ -@Uninterruptible public final class ExplicitFreeListSpace extends ContiguousSpace implements Constants { +@Uninterruptible public final class ExplicitFreeListSpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ImmortalSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -29,9 +29,8 @@ * actually collect. This class does not hold any state, all methods * are static. */ -@Uninterruptible public final class ImmortalSpace - extends ContiguousSpace - implements Constants { +@Uninterruptible public final class ImmortalSpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -35,7 +35,8 @@ * and called on a per-thread basis, where each instance of * TreadmillLocal corresponds to one thread operating over one space. */ -@Uninterruptible public final class LargeObjectSpace extends ContiguousSpace implements Constants { +@Uninterruptible public final class LargeObjectSpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkCompactSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -25,7 +25,8 @@ * This class implements functionality for a simple sliding mark-compact * space. */ -@Uninterruptible public final class MarkCompactSpace extends ContiguousSpace implements Constants { +@Uninterruptible public final class MarkCompactSpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -33,7 +33,8 @@ * threads. Thus unlike this class, synchronization is not necessary * in the instance methods of MarkSweepLocal. */ -@Uninterruptible public final class MarkSweepSpace extends ContiguousSpace implements Constants { +@Uninterruptible public final class MarkSweepSpace extends Space + implements Constants { /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/RawPageSpace.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -27,7 +27,8 @@ * This class provides access to raw memory for managing internal meta * data. */ -@Uninterruptible public final class RawPageSpace extends ContiguousSpace implements Constants { +@Uninterruptible public final class RawPageSpace extends Space + implements Constants { /** * The caller specifies the region of virtual memory to be used for Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -45,12 +45,19 @@ */ @Uninterruptible public abstract class Space implements Constants { + /**************************************************************************** + * + * Class variables + */ + + private static boolean DEBUG = false; + // the following is somewhat arbitrary for the 64 bit system at this stage private static final int LOG_ADDRESS_SPACE = (BYTES_IN_ADDRESS == 4) ? 32 : 40; - protected static Address HEAP_START = chunkAlign(VM.HEAP_START, true); + private static Address HEAP_START = chunkAlign(VM.HEAP_START, true); private static Address AVAILABLE_START = chunkAlign(VM.AVAILABLE_START, false); private static Address AVAILABLE_END = chunkAlign(VM.AVAILABLE_END, true); - protected static Extent AVAILABLE_BYTES = AVAILABLE_END.toWord().minus(AVAILABLE_START.toWord()).toExtent(); + private static Extent AVAILABLE_BYTES = AVAILABLE_END.toWord().minus(AVAILABLE_START.toWord()).toExtent(); public static final Address HEAP_END = chunkAlign(VM.HEAP_END, false); public static final int LOG_BYTES_IN_CHUNK = 22; @@ -66,18 +73,20 @@ private static int spaceCount = 0; private static Space[] spaces = new Space[MAX_SPACES]; - protected static Address heapCursor = HEAP_START; - protected static Address heapLimit = HEAP_END; + private static Address heapCursor = HEAP_START; + private static Address heapLimit = HEAP_END; /**************************************************************************** * * Instance variables */ - private final int descriptor; - private final int index; - private final String name; - private final boolean immortal; - private final boolean movable; + private int descriptor; + private int index; + private String name; + protected Address start; + protected Extent extent; + protected boolean immortal; + protected boolean movable; private boolean allocationFailed; protected PageResource pr; @@ -99,16 +108,175 @@ * @param name The name of this space (used when printing error messages etc) * @param movable Are objects in this space movable? * @param immortal Are objects in this space immortal (uncollected)? + * @param start The start address of the space in virtual memory + * @param bytes The size of the space in virtual memory, in bytes */ - Space(String name, boolean movable, boolean immortal, int descriptor) { + Space(String name, boolean movable, boolean immortal, Address start, + Extent bytes) { this.name = name; this.movable = movable; this.immortal = immortal; - this.descriptor = descriptor; + this.start = start; index = spaceCount++; spaces[index] = this; + + /* ensure requests are chunk aligned */ + if (bytes.NE(chunkAlign(bytes, false))) { + Log.write("Warning: "); + Log.write(name); + Log.write(" space request for "); + Log.write(bytes.toLong()); Log.write(" bytes rounded up to "); + bytes = chunkAlign(bytes, false); + Log.write(bytes.toLong()); Log.writeln(" bytes"); + Log.writeln("(requests should be Space.BYTES_IN_CHUNK aligned)"); + } + this.extent = bytes; + + VM.memory.setHeapRange(index, start, start.plus(bytes)); + createDescriptor(false); + Map.insert(start, extent, descriptor, this); + + if (DEBUG) { + Log.write(name); Log.write(" "); + Log.write(start); Log.write(" "); + Log.write(start.plus(extent)); Log.write(" "); + Log.writeln(bytes.toWord()); + } } + /** + * Construct a space of a given number of megabytes in size.<p> + * + * The caller specifies the amount virtual memory to be used for + * this space <i>in megabytes</i>. If there is insufficient address + * space, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param mb The size of the space in virtual memory, in megabytes (MB) + */ + Space(String name, boolean movable, boolean immortal, int mb) { + this(name, movable, immortal, heapCursor, + Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent()); + heapCursor = heapCursor.plus(extent); + if (heapCursor.GT(heapLimit)) { + Log.write("Out of virtual address space allocating \""); + Log.write(name); Log.write("\" at "); + Log.write(heapCursor.minus(extent)); Log.write(" ("); + Log.write(heapCursor); Log.write(" > "); + Log.write(heapLimit); Log.writeln(")"); + VM.assertions.fail("exiting"); + } + } + + /** + * Construct a space that consumes a given fraction of the available + * virtual memory.<p> + * + * The caller specifies the amount virtual memory to be used for + * this space <i>as a fraction of the total available</i>. If there + * is insufficient address space, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param frac The size of the space in virtual memory, as a + * fraction of all available virtual memory + */ + Space(String name, boolean movable, boolean immortal, float frac) { + this(name, movable, immortal, heapCursor, getFracAvailable(frac)); + heapCursor = heapCursor.plus(extent); + } + + /** + * Construct a space that consumes a given number of megabytes of + * virtual memory, at either the top or bottom of the available + * virtual memory. + * + * The caller specifies the amount virtual memory to be used for + * this space <i>in megabytes</i>, and whether it should be at the + * top or bottom of the available virtual memory. If the request + * clashes with existing virtual memory allocations, then the + * constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param mb The size of the space in virtual memory, in megabytes (MB) + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + Space(String name, boolean movable, boolean immortal, int mb, boolean top) { + this(name, movable, immortal, + Word.fromIntSignExtend(mb).lsh(LOG_BYTES_IN_MBYTE).toExtent(), top); + } + + /** + * Construct a space that consumes a given fraction of the available + * virtual memory, at either the top or bottom of the available + * virtual memory. + * + * The caller specifies the amount virtual memory to be used for + * this space <i>as a fraction of the total available</i>, and + * whether it should be at the top or bottom of the available + * virtual memory. If the request clashes with existing virtual + * memory allocations, then the constructor will fail. + * + * @param name The name of this space (used when printing error messages etc) + * @param movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param frac The size of the space in virtual memory, as a + * fraction of all available virtual memory + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + Space(String name, boolean movable, boolean immortal, float frac, + boolean top) { + this(name, movable, immortal, getFracAvailable(frac), top); + } + + /** + * This is a private constructor that creates a contigious space at + * the top or bottom of the available virtual memory, if + * possible.<p> + * + * The caller specifies the size of the region of virtual memory and + * whether it should be at the top or bottom of the available + * address 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 movable Are objects in this space movable? + * @param immortal Are objects in this space immortal (uncollected)? + * @param bytes The size of the space in virtual memory, in bytes + * @param top Should this space be at the top (or bottom) of the + * available virtual memory. + */ + private Space(String name, boolean movable, boolean immortal, Extent bytes, + boolean top) { + this(name, movable, immortal, (top) ? heapLimit.minus(bytes) : HEAP_START, + bytes); + if (top) { // request for the top of available memory + /* if (heapLimit.NE(HEAP_END)) { + Log.write("Unable to satisfy virtual address space request \""); + Log.write(name); Log.write("\" at "); + Log.writeln(heapLimit); + VM.assertions.fail("exiting"); + } */ + heapLimit = heapLimit.minus(extent); + } else { // request for the bottom of available memory + if (heapCursor.GT(HEAP_START)) { + Log.write("Unable to satisfy virtual address space request \""); + Log.write(name); Log.write("\" at "); + Log.writeln(heapCursor); + VM.assertions.fail("exiting"); + } + heapCursor = heapCursor.plus(extent); + } + } + + /**************************************************************************** * * Accessor methods @@ -117,6 +285,12 @@ /** Name getter @return The name of this space */ public final String getName() { return name; } + /** Start getter @return The start address of this space */ + public final Address getStart() { return start; } + + /** Extent getter @return The size (extent) of this space */ + public final Extent getExtent() { return extent; } + /** Descriptor method @return The integer descriptor for this space */ public final int getDescriptor() { return descriptor; } @@ -381,12 +555,11 @@ for (int i = 0; i < spaceCount; i++) { Space space = spaces[i]; Log.write(space.name); Log.write(" "); - space.printVMRange(); + Log.write(space.start); Log.write("->"); + Log.writeln(space.start.plus(space.extent.minus(1))); } } - protected abstract void printVMRange(); - /** * Ensure that all MMTk spaces (all spaces aside from the VM space) * are mapped. Demand zero map all of them if they are not already @@ -399,22 +572,18 @@ if (space != VM.memory.getVMSpace()) { if (Options.verbose.getValue() > 2) { Log.write("Mapping "); - Log.write(space.getName()); + Log.write(space.name); Log.write(" "); - space.printVMRange(); + Log.write(space.start); + Log.write("->"); + Log.writeln(space.start.plus(space.extent.minus(1))); } - space.ensureMapped(); + Mmapper.ensureMapped(space.start, space.extent.toInt()>>LOG_BYTES_IN_PAGE); } } } /** - * Ensure that this space is mapped. - * Demand zero map all of them if they are not already mapped. - */ - protected abstract void ensureMapped(); - - /** * Print out the memory used by all spaces in either megabytes or * pages. * @@ -501,4 +670,42 @@ if (!down) addr = addr.plus(BYTES_IN_CHUNK - 1); return addr.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toAddress(); } + + /** + * Align an extent to a space chunk + * + * @param bytes The extent to be aligned + * @param down If true the address will be rounded down, otherwise + * it will rounded up. + */ + private static Extent chunkAlign(Extent bytes, boolean down) { + if (!down) bytes = bytes.plus(BYTES_IN_CHUNK - 1); + return bytes.toWord().rshl(LOG_BYTES_IN_CHUNK).lsh(LOG_BYTES_IN_CHUNK).toExtent(); + } + + /** + * Initialize/create the descriptor for this space + * + * @param shared True if this is a shared (discontigious) space + */ + private void createDescriptor(boolean shared) { + if (shared) + descriptor = SpaceDescriptor.createDescriptor(); + else + descriptor = SpaceDescriptor.createDescriptor(start, start.plus(extent)); + } + + /** + * Convert a fraction into a number of bytes according to the + * fraction of available bytes. + * + * @param frac The fraction of avialable virtual memory desired + * @return The corresponding number of bytes, chunk-aligned. + */ + private static Extent getFracAvailable(float frac) { + long bytes = (long) (frac * AVAILABLE_BYTES.toLong()); + Word mb = Word.fromIntSignExtend((int) (bytes >> LOG_BYTES_IN_MBYTE)); + Extent rtn = mb.lsh(LOG_BYTES_IN_MBYTE).toExtent(); + return chunkAlign(rtn, false); + } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -13,7 +13,6 @@ package org.mmtk.utility.alloc; import org.mmtk.policy.Space; -import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.*; import org.mmtk.utility.gcspy.drivers.LinearSpaceDriver; import org.mmtk.vm.VM; @@ -87,7 +86,7 @@ protected Address cursor; // insertion point private Address internalLimit; // current internal slow-path sentinal for bump pointer private Address limit; // current external slow-path sentinal for bump pointer - protected ContiguousSpace space; // space this bump pointer is associated with + protected Space space; // space this bump pointer is associated with protected Address initialRegion; // first contiguous region protected final boolean allowScanning; // linear scanning is permitted if true protected Address region; // current contigious region @@ -99,7 +98,7 @@ * @param space The space to bump point into. * @param allowScanning Allow linear scanning of this region of memory. */ - protected BumpPointer(ContiguousSpace space, boolean allowScanning) { + protected BumpPointer(Space space, boolean allowScanning) { this.space = space; this.allowScanning = allowScanning; reset(); @@ -124,7 +123,7 @@ * * @param space The space to associate the bump pointer with. */ - public final void rebind(ContiguousSpace space) { + public final void rebind(Space space) { reset(); this.space = space; } @@ -369,7 +368,7 @@ * @param driver The GCspy driver for this space. * @param scanSpace The space to scan */ - public void gcspyGatherData(LinearSpaceDriver driver, ContiguousSpace scanSpace) { + public void gcspyGatherData(LinearSpaceDriver driver, Space scanSpace) { //TODO can scanSpace ever be different to this.space? if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(scanSpace == space, "scanSpace != space"); @@ -448,7 +447,7 @@ /** @return the current cursor value */ public final Address getCursor() { return cursor; } /** @return the space associated with this bump pointer */ - public final ContiguousSpace getSpace() { return space; } + public final Space getSpace() { return space; } /** * Print out the status of the allocator (for debugging) Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -13,7 +13,6 @@ package org.mmtk.utility.gcspy.drivers; import org.mmtk.policy.Space; -import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.Log; import org.mmtk.utility.gcspy.GCspy; import org.mmtk.utility.gcspy.Subspace; @@ -94,7 +93,7 @@ */ public AbstractDriver(ServerInterpreter server, String name, - ContiguousSpace mmtkSpace, + Space mmtkSpace, int blockSize, boolean mainSpace) { this.server = server; @@ -116,7 +115,7 @@ * @param mmtkSpace The MMTk space */ @Interruptible - protected Subspace createSubspace (ContiguousSpace mmtkSpace) { + protected Subspace createSubspace (Space mmtkSpace) { Address start = mmtkSpace.getStart(); return new Subspace(start, start, 0, blockSize, 0); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/ImmortalSpaceDriver.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -12,7 +12,7 @@ */ package org.mmtk.utility.gcspy.drivers; -import org.mmtk.policy.ContiguousSpace; +import org.mmtk.policy.Space; import org.mmtk.utility.scan.MMType; import org.mmtk.utility.Log; import org.mmtk.vm.gcspy.ServerInterpreter; @@ -48,7 +48,7 @@ public ImmortalSpaceDriver( ServerInterpreter server, String spaceName, - ContiguousSpace mmtkSpace, + Space mmtkSpace, int blockSize, boolean mainSpace) { @@ -109,4 +109,5 @@ public void registerDriversForReferenceNotification(AbstractDriver[] drivers) { this.registeredDrivers = drivers; } + } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/gcspy/drivers/LinearSpaceDriver.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -12,7 +12,7 @@ */ package org.mmtk.utility.gcspy.drivers; -import org.mmtk.policy.ContiguousSpace; +import org.mmtk.policy.Space; import org.mmtk.utility.scan.MMType; import org.mmtk.utility.gcspy.Color; import org.mmtk.utility.gcspy.LinearScan; @@ -77,7 +77,7 @@ public LinearSpaceDriver( ServerInterpreter server, String spaceName, - ContiguousSpace mmtkSpace, + Space mmtkSpace, int blockSize, boolean mainSpace) { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2007-07-21 09:34:59 UTC (rev 13129) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/FreeListPageResource.java 2007-07-22 00:19:33 UTC (rev 13130) @@ -13,7 +13,6 @@ package org.mmtk.utility.heap; import org.mmtk.policy.Space; -import org.mmtk.policy.ContiguousSpace; import org.mmtk.utility.alloc.EmbeddedMetaData; import org.mmtk.utility.Conversions; import org.mmtk.utility.GenericFreeList; @@ -68,7 +67,7 @@ * @param metaDataPagesPerRegion The number of pages of meta data * that are embedded in each region. */ - public FreeListPageResource(int pageBudget, ContiguousSpace space, Address start, + public FreeListPageResource(int pageBudget, Space space, Address start, Extent bytes, int metaDataPagesPerRegion) { super(pageBudget, space, start); this.metaDataPagesPerRegion = metaDataPagesPerRegion; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ste...@us...> - 2007-08-16 00:50:57
|
Revision: 13329 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13329&view=rev Author: steveb-oss Date: 2007-08-15 17:50:54 -0700 (Wed, 15 Aug 2007) Log Message: ----------- Spell contiguous correctly. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/EmbeddedMetaData.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/SpaceDescriptor.java rvmroot/trunk/MMTk/src/org/mmtk/vm/Memory.java rvmroot/trunk/MMTk/src/org/mmtk/vm/VM.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -29,7 +29,7 @@ * each header's object word, and a mark bitmap. Sweeping is * performed lazily.<p> * - * A free list block is a contigious region of memory containing cells + * A free list block is a contiguous region of memory containing cells * of a single size class, and is a construct of the * SegregatedFreeList. This class extends the block to include a mark * bitmap. During the mark phase, if an object is encountered with Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/Space.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -29,7 +29,7 @@ /** * This class defines and manages spaces. Each policy is an instance - * of a space. A space is a region of virtual memory (contigious or + * of a space. A space is a region of virtual memory (contiguous or * discontigous) which is subject to the same memory management * regime. Multiple spaces (instances of this class or its * descendants) may have the same policy (eg there could be numerous @@ -41,7 +41,7 @@ * policy, spaces also manage memory consumption (<i>used</i> virtual * memory).<p> * - * Discontigious spaces are currently unsupported. + * Discontiguous spaces are currently unsupported. */ @Uninterruptible public abstract class Space implements Constants { @@ -97,8 +97,8 @@ */ /** - * This is the base constructor for <i>contigious</i> spaces - * (i.e. those that occupy a single contigious range of virtual + * This is the base constructor for <i>contiguous</i> spaces + * (i.e. those that occupy a single contiguous range of virtual * memory which is identified at construction time).<p> * * The caller specifies the region of virtual memory to be used for @@ -237,7 +237,7 @@ } /** - * This is a private constructor that creates a contigious space at + * This is a private constructor that creates a contiguous space at * the top or bottom of the available virtual memory, if * possible.<p> * @@ -686,7 +686,7 @@ /** * Initialize/create the descriptor for this space * - * @param shared True if this is a shared (discontigious) space + * @param shared True if this is a shared (discontiguous) space */ private void createDescriptor(boolean shared) { if (shared) Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/BaseGenericFreeList.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -21,7 +21,7 @@ * abstractly, in "units", which the user may associate with some * other allocatable resource (e.g. heap blocks). The user issues * requests for N units and the allocator returns the index of the - * first of a contigious set of N units or fails, returning -1. The + * first of a contiguous set of N units or fails, returning -1. The * user frees the block of N units by calling <code>free()</code> with * the index of the first unit as the argument.<p> * @@ -44,11 +44,11 @@ * * - single free unit: "free", "single", "prev", "next" * - single used unit: "used", "single" - * - contigious free units + * - contiguous free units * . first unit: "free", "multi", "prev", "next" * . second unit: "free", "multi", "size" * . last unit: "free", "multi", "size" - * - contigious used units + * - contiguous used units * . first unit: "used", "multi", "prev", "next" * . second unit: "used", "multi", "size" * . last unit: "used", "multi", "size" @@ -101,7 +101,7 @@ * * @param size The number of units to be allocated * @return The index of the first of the <code>size</code> - * contigious units, or -1 if the request can't be satisfied + * contiguous units, or -1 if the request can't be satisfied */ public final int alloc(int size) { // Note: -1 is both the default return value *and* the start sentinel index @@ -131,7 +131,7 @@ * * @param size The number of units to be allocated * @return The index of the first of the <code>size</code> - * contigious units, or -1 if the request can't be satisfied + * contiguous units, or -1 if the request can't be satisfied */ public final int alloc(int size, int unit) { int s = 0; @@ -147,7 +147,7 @@ * * @param size The number of units to be allocated * @return The index of the first of the <code>size</code> - * contigious units, or -1 if the request can't be satisfied + * contiguous units, or -1 if the request can't be satisfied */ private int alloc(int size, int unit, int unitSize) { if (unitSize >= size) { @@ -162,7 +162,7 @@ } /** - * Free a previously allocated contigious lump of units. + * Free a previously allocated contiguous lump of units. * * @param unit The index of the first unit. * @return The number of units freed. @@ -246,7 +246,7 @@ } /** - * Coalesce two or three contigious lumps of units, removing start + * Coalesce two or three contiguous lumps of units, removing start * and end lumps from the free list as necessary. * @param start The index of the start of the first lump * @param end The index of the start of the last lump Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/GenericFreeList.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -21,7 +21,7 @@ * abstractly, in "units", which the user may associate with some * other allocatable resource (e.g. heap blocks). The user issues * requests for N units and the allocator returns the index of the - * first of a contigious set of N units or fails, returning -1. The + * first of a contiguous set of N units or fails, returning -1. The * user frees the block of N units by calling <code>free()</code> with * the index of the first unit as the argument.<p> * Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/SmallGenericFreeList.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -21,7 +21,7 @@ * abstractly, in "units", which the user may associate with some * other allocatable resource (e.g. heap blocks). The user issues * requests for N units and the allocator returns the index of the - * first of a contigious set of N units or fails, returning -1. The + * first of a contiguous set of N units or fails, returning -1. The * user frees the block of N units by calling <code>free()</code> with * the index of the first unit as the argument.<p> * @@ -44,11 +44,11 @@ * * - single free unit: "free", "single", "prev", "next" * - single used unit: "used", "single" - * - contigious free units + * - contiguous free units * . first unit: "free", "multi", "prev", "next" * . second unit: "free", "multi", "size" * . last unit: "free", "multi", "size" - * - contigious used units + * - contiguous used units * . first unit: "used", "multi", "prev", "next" * . second unit: "used", "multi", "size" * . last unit: "used", "multi", "size" Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BumpPointer.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -89,7 +89,7 @@ protected Space space; // space this bump pointer is associated with protected Address initialRegion; // first contiguous region protected final boolean allowScanning; // linear scanning is permitted if true - protected Address region; // current contigious region + protected Address region; // current contiguous region /** @@ -265,7 +265,7 @@ if (start.isZero()) return start; // failed allocation if (!allowScanning) { // simple allocator - if (start.NE(limit)) cursor = start; // discontigious + if (start.NE(limit)) cursor = start; // discontiguous updateLimit(start.plus(chunkSize), start, bytes); } else // scannable allocator updateMetaData(start, chunkSize, bytes); @@ -295,7 +295,7 @@ } /** - * A bump pointer chuck/region has been consumed but the contigious region + * A bump pointer chuck/region has been consumed but the contiguous region * is available, so consume it and then return the address of the start * of a memory region satisfying the outstanding allocation request. This * is relevant when re-using memory, as in a mark-compact collector. @@ -405,7 +405,7 @@ } /** - * Perform a linear scan through a single contigious region + * Perform a linear scan through a single contiguous region * * @param scanner The scan object to delegate to. * @param start The start of this region Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/EmbeddedMetaData.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/EmbeddedMetaData.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/EmbeddedMetaData.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -22,7 +22,7 @@ * that is embeded in allocation spaces (rather than kept on the * side). The basic idea is that meta data be embeded at a very * coarse power of two granularity for fast access, minimal wastage - * and by making the regions coarse, the contigious meta-data will be + * and by making the regions coarse, the contiguous meta-data will be * relatively large and thus the probability of L1 conflict misses * will be reduced (as compared with embedding meta-data at the start * of each page which will cause those few cache lines corresponding Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -136,7 +136,7 @@ */ /** - * Allocate <code>bytes</code> contigious bytes of zeroed memory.<p> + * Allocate <code>bytes</code> contiguous bytes of zeroed memory.<p> * * This code first tries the fast version and, if needed, the slow path. * @@ -146,7 +146,7 @@ * @param inGC If true, this allocation is occuring with respect to * a space that is currently being collected. * @return The address of the first word of <code>bytes</code> - * contigious bytes of zeroed memory. + * contiguous bytes of zeroed memory. */ @Inline public final Address alloc(int bytes, int align, int offset, boolean inGC) { @@ -160,7 +160,7 @@ } /** - * Allocate <code>bytes</code> contigious bytes of zeroed memory.<p> + * Allocate <code>bytes</code> contiguous bytes of zeroed memory.<p> * * This code must be efficient and must compile easily. Here we * minimize the number of calls to inlined functions, and force the @@ -174,7 +174,7 @@ * @param inGC If true, this allocation is occuring with respect to * a space that is currently being collected. * @return The address of the first word of <code>bytes</code> - * contigious bytes of zeroed memory. + * contiguous bytes of zeroed memory. */ @Inline public final Address allocFast(int bytes, int align, int offset, @@ -196,7 +196,7 @@ } /** - * Allocate <code>bytes</code> contigious bytes of non-zeroed + * Allocate <code>bytes</code> contiguous bytes of non-zeroed * memory. First check if the fast path works. This is needed * since this method may be called in the context when the fast * version was NOT just called. If this fails, it will try finding @@ -220,7 +220,7 @@ * @param inGC If true, this allocation is occuring with respect to * a space that is currently being collected. * @return The address of the first word of the <code>bytes</code> - * contigious bytes of zerod memory. + * contiguous bytes of zerod memory. */ @NoInline public final Address allocSlowOnce(int bytes, int align, int offset, Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -24,7 +24,7 @@ /** * This class manages the mapping of spaces to virtual memory ranges.<p> * - * Discontigious spaces are currently unsupported. + * Discontiguous spaces are currently unsupported. */ @Uninterruptible public class Map { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/SpaceDescriptor.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/SpaceDescriptor.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/SpaceDescriptor.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -24,9 +24,9 @@ * This class manages the encoding and decoding of space descriptors.<p> * * Space descriptors are integers that encode a space's mapping into - * virtual memory. For discontigious spaces, they indicate + * virtual memory. For discontiguous spaces, they indicate * discontiguity and mapping must be done by consulting the space map. - * For contigious spaces, the space's address range is encoded into + * For contiguous spaces, the space's address range is encoded into * the integer (using a fixed point notation).<p> * * The purpose of this class is to allow <code>static final int</code> @@ -63,7 +63,7 @@ */ /** - * Create a descriptor for a <i>contigious</i> space + * Create a descriptor for a <i>contiguous</i> space * * @param start The start address of the space * @param end The end address of the space @@ -92,10 +92,10 @@ } /** - * Create a descriptor for a <i>dis-contigious</i> (shared) space + * Create a descriptor for a <i>dis-contiguous</i> (shared) space * * @return An integer descriptor reflecting the fact that this space - * is shared (and thus discontigious and so must be established via + * is shared (and thus discontiguous and so must be established via * maps). */ public static int createDescriptor() { @@ -108,10 +108,10 @@ */ /** - * Return true if this descriptor describes a contigious space + * Return true if this descriptor describes a contiguous space * * @param descriptor - * @return True if this descriptor describes a contigious space + * @return True if this descriptor describes a contiguous space */ @Inline public static boolean isContiguous(int descriptor) { @@ -119,11 +119,11 @@ } /** - * Return true if this descriptor describes a contigious space that + * Return true if this descriptor describes a contiguous space that * is at the top of the virtual address space * * @param descriptor - * @return True if this descriptor describes a contigious space that + * @return True if this descriptor describes a contiguous space that * is at the top of the virtual address space */ @Inline Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/Memory.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/Memory.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/Memory.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -150,9 +150,9 @@ protected abstract Address getHeapStartConstant(); /** @return The highest address in the virtual address space known to MMTk */ protected abstract Address getHeapEndConstant(); - /** @return The lowest address in the contigious address space available to MMTk */ + /** @return The lowest address in the contiguous address space available to MMTk */ protected abstract Address getAvailableStartConstant(); - /** @return The highest address in the contigious address space available to MMTk */ + /** @return The highest address in the contiguous address space available to MMTk */ protected abstract Address getAvailableEndConstant(); /** @return The log base two of the size of an address */ protected abstract byte getLogBytesInAddressConstant(); Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/VM.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/vm/VM.java 2007-08-15 23:18:50 UTC (rev 13328) +++ rvmroot/trunk/MMTk/src/org/mmtk/vm/VM.java 2007-08-16 00:50:54 UTC (rev 13329) @@ -57,9 +57,9 @@ public static final Address HEAP_START; /** The highest address in virtual memory known to MMTk */ public static final Address HEAP_END; - /** The lowest address in the contigiously available memory available to MMTk */ + /** The lowest address in the contiguously available memory available to MMTk */ public static final Address AVAILABLE_START; - /** The highest address in the contigiously available memory available to MMTk */ + /** The highest address in the contiguously available memory available to MMTk */ public static final Address AVAILABLE_END; /** The log base two of the size of an address */ public static final byte LOG_BYTES_IN_ADDRESS; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-08-17 01:48:39
|
Revision: 13332 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13332&view=rev Author: dframpton-oss Date: 2007-08-16 18:48:35 -0700 (Thu, 16 Aug 2007) Log Message: ----------- Separate out a collection and an allocation nursery for the large object space in preparation for concurrent/incremental collection. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-08-16 21:23:01 UTC (rev 13331) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/LargeObjectSpace.java 2007-08-17 01:48:35 UTC (rev 13332) @@ -186,8 +186,8 @@ VM.assertions._assert(treadmill.fromSpaceEmpty()); } markState = MARK_BIT.minus(markState); - treadmill.flip(); } + treadmill.flip(fullHeap); inNurseryGC = !fullHeap; } @@ -208,16 +208,11 @@ */ private void sweepLargePages(boolean sweepNursery) { while (true) { - Address cell = treadmill.pop(sweepNursery); + Address cell = sweepNursery ? treadmill.popNursery() : treadmill.pop(); if (cell.isZero()) break; release(LargeObjectAllocator.getSuperPage(cell)); } - if (VM.VERIFY_ASSERTIONS) { - if (sweepNursery) - VM.assertions._assert(treadmill.nurseryEmpty()); - else - VM.assertions._assert(treadmill.fromSpaceEmpty()); - } + if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(sweepNursery ? treadmill.nurseryEmpty() : treadmill.fromSpaceEmpty()); } /** Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2007-08-16 21:23:01 UTC (rev 13331) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Treadmill.java 2007-08-17 01:48:35 UTC (rev 13332) @@ -33,8 +33,8 @@ * * Access to the instances may be synchronized depending on the constructor argument. */ -@Uninterruptible public final class Treadmill - implements Constants { +@Uninterruptible +public final class Treadmill implements Constants { /**************************************************************************** * @@ -42,7 +42,8 @@ */ private DoublyLinkedList fromSpace; private DoublyLinkedList toSpace; - private DoublyLinkedList nursery; + private DoublyLinkedList collectNursery; + private DoublyLinkedList allocNursery; /**************************************************************************** * @@ -55,47 +56,83 @@ public Treadmill(int granularity, boolean shared) { fromSpace = new DoublyLinkedList(granularity, shared); toSpace = new DoublyLinkedList(granularity, shared); - nursery = new DoublyLinkedList(granularity, shared); + allocNursery = new DoublyLinkedList(granularity, shared); + collectNursery = new DoublyLinkedList(granularity, shared); } + /** + * Add a node to the treadmill. This is usually performed on allocation. + */ @Inline public void addToTreadmill(Address node) { - nursery.add(node); + allocNursery.add(node); } + /** + * Remove a node from the nursery list. + */ @Inline - public Address pop(boolean fromNursery) { - return (fromNursery) ? nursery.pop() : fromSpace.pop(); + public Address popNursery() { + return collectNursery.pop(); } + /** + * Remove a node from the mature list. + */ @Inline + public Address pop() { + return fromSpace.pop(); + } + + /** + * Copy a node (during gc tracing). + */ + @Inline public void copy(Address node, boolean isInNursery) { - if (isInNursery) - nursery.remove(node); - else + if (isInNursery) { + collectNursery.remove(node); + } else { fromSpace.remove(node); + } toSpace.add(node); } + /** + * Is the to-space empty? + */ @Inline public boolean toSpaceEmpty() { return toSpace.isEmpty(); } + /** + * Is the from-space empty? + */ @Inline public boolean fromSpaceEmpty() { return fromSpace.isEmpty(); } + /** + * Is the nursery empty? + */ @Inline public boolean nurseryEmpty() { - return nursery.isEmpty(); + return collectNursery.isEmpty(); } - public void flip() { - DoublyLinkedList tmp = fromSpace; - fromSpace = toSpace; - toSpace = tmp; + /** + * Flip the roles of the spaces in preparation for a collection. + */ + public void flip(boolean fullHeap) { + DoublyLinkedList tmp = allocNursery; + allocNursery = collectNursery; + collectNursery = tmp; + if (fullHeap) { + tmp = fromSpace; + fromSpace = toSpace; + toSpace = tmp; + } } /**************************************************************************** @@ -134,7 +171,7 @@ * @param tmDriver the GCSpy space driver */ public void gcspyGatherData(int event, TreadmillDriver tmDriver) { - this.nursery.gcspyGatherData(tmDriver); + this.allocNursery.gcspyGatherData(tmDriver); } /** This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-08-17 05:58:57
|
Revision: 13336 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13336&view=rev Author: dframpton-oss Date: 2007-08-16 22:58:56 -0700 (Thu, 16 Aug 2007) Log Message: ----------- Move notification of block liveness to be set when we advance to or install a block. This supports both allocation during gc and concurrent collection. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-17 04:59:10 UTC (rev 13335) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-17 05:58:56 UTC (rev 13336) @@ -196,9 +196,9 @@ Log.writeln("Collector does not support sanity checking!"); } else { Log.writeln("Collection sanity checking enabled."); - replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), + replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), Phase.scheduleComplex(sanityPhase)); - replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), + replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), Phase.scheduleComplex(sanityPhase)); } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-17 04:59:10 UTC (rev 13335) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-17 05:58:56 UTC (rev 13336) @@ -158,12 +158,28 @@ * for this block, or zero if there are no available cells. */ protected Address advanceToBlock(Address block, int sizeClass) { + if (HEADER_MARK_BITS) { + MarkSweepLocal.liveBlock(block); + } + if (LAZY_SWEEP) return makeFreeListFromLiveBits(block, sizeClass, msSpace.getMarkState()); else return getFreeList(block); } + /** + * Notify that a new block has been installed. This is to ensure that + * appropriate collection state can be initialized for the block + * + * @param block The new block + * @param sizeClass The block's sizeclass. + */ + protected void notifyNewBlock(Address block, int sizeClass) { + if (HEADER_MARK_BITS) { + MarkSweepLocal.liveBlock(block); + } + } /**************************************************************************** * Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-08-17 04:59:10 UTC (rev 13335) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepSpace.java 2007-08-17 05:58:56 UTC (rev 13336) @@ -332,9 +332,7 @@ @Inline public void postCopy(ObjectReference object, boolean majorGC) { initializeHeader(object, false); - if (MarkSweepLocal.HEADER_MARK_BITS) { - if (majorGC) MarkSweepLocal.liveBlock(object); - } else { + if (!MarkSweepLocal.HEADER_MARK_BITS) { MarkSweepLocal.liveObject(object); } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2007-08-17 04:59:10 UTC (rev 13335) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/BlockAllocator.java 2007-08-17 05:58:56 UTC (rev 13336) @@ -603,6 +603,16 @@ } /** + * Mark the metadata for this block. + * + * @param block The block address + */ + @Inline + public static void markBlockMeta(Address block) { + getMetaAddress(block).plus(FL_META_OFFSET).store(Word.one()); + } + + /** * Return true if the metadata for this block was set. * * @param block The block address Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-17 04:59:10 UTC (rev 13335) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-17 05:58:56 UTC (rev 13336) @@ -281,6 +281,7 @@ if (block.isZero()) return Address.zero(); + notifyNewBlock(block, sizeClass); installNewBlock(block, sizeClass); int cellExtent = cellSize[sizeClass]; @@ -519,6 +520,14 @@ protected abstract Address advanceToBlock(Address block, int sizeClass); /** + * Notify that a new block has been installed. + * + * @param block The new block + * @param sizeClass The block's sizeclass. + */ + protected void notifyNewBlock(Address block, int sizeClass) {} + + /** * Should the sweep reclaim the cell containing this object. Is this object * live. This is only used when maintainSideBitmap is false. * @@ -780,6 +789,16 @@ } /** + * Set the live bit for the given block. + * + * @param block The block whose liveness is to be set. + */ + @Inline + public static void liveBlock(Address block) { + BlockAllocator.markBlockMeta(block); + } + + /** * Set the live bit for a given object, without using * synchronization primitives---must only be used when contention * for live bit is strictly not possible This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-08-28 09:12:54
|
Revision: 13387 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13387&view=rev Author: dframpton-oss Date: 2007-08-28 02:12:51 -0700 (Tue, 28 Aug 2007) Log Message: ----------- Correct issue affecting whole heap mark sweep that meant blocks were erroneously marked. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListLocal.java rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListLocal.java 2007-08-27 15:08:18 UTC (rev 13386) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/ExplicitFreeListLocal.java 2007-08-28 09:12:51 UTC (rev 13387) @@ -108,7 +108,7 @@ * @return The address of the first pre-zeroed cell in the free list * for this block, or zero if there are no available cells. */ - protected Address advanceToBlock(Address block, int sizeClass) { + protected Address advanceToBlock(Address block, int sizeClass, boolean duringGC) { return makeFreeListFromLiveBits(block, sizeClass); } Modified: rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-27 15:08:18 UTC (rev 13386) +++ rvmroot/trunk/MMTk/src/org/mmtk/policy/MarkSweepLocal.java 2007-08-28 09:12:51 UTC (rev 13387) @@ -44,8 +44,8 @@ * @see SegregatedFreeList * @see MarkSweepSpace */ -@Uninterruptible public final class MarkSweepLocal extends SegregatedFreeList - implements Constants { +@Uninterruptible +public final class MarkSweepLocal extends SegregatedFreeList implements Constants { /**************************************************************************** * @@ -154,12 +154,13 @@ * * @param block The block to be prepared for use * @param sizeClass The size class of the block + * @param inGC Is this space currently being collected * @return The address of the first pre-zeroed cell in the free list * for this block, or zero if there are no available cells. */ - protected Address advanceToBlock(Address block, int sizeClass) { + protected Address advanceToBlock(Address block, int sizeClass, boolean inGC) { if (HEADER_MARK_BITS) { - MarkSweepLocal.liveBlock(block); + if (inGC) MarkSweepLocal.liveBlock(block); } if (LAZY_SWEEP) @@ -175,9 +176,9 @@ * @param block The new block * @param sizeClass The block's sizeclass. */ - protected void notifyNewBlock(Address block, int sizeClass) { + protected void notifyNewBlock(Address block, int sizeClass, boolean inGC) { if (HEADER_MARK_BITS) { - MarkSweepLocal.liveBlock(block); + if (inGC) MarkSweepLocal.liveBlock(block); } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java 2007-08-27 15:08:18 UTC (rev 13386) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/Allocator.java 2007-08-28 09:12:51 UTC (rev 13387) @@ -231,8 +231,7 @@ * @return The start address of the region, or zero if allocation fails */ @Inline - public final Address allocSlowInline(int bytes, int alignment, int offset, - boolean inGC) { + public final Address allocSlowInline(int bytes, int alignment, int offset, boolean inGC) { int gcCountStart = Stats.gcCount(); Allocator current = this; for (int i = 0; i < Plan.MAX_COLLECTION_ATTEMPTS; i++) { Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-27 15:08:18 UTC (rev 13386) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/alloc/SegregatedFreeList.java 2007-08-28 09:12:51 UTC (rev 13387) @@ -223,8 +223,7 @@ * contiguous bytes of zerod memory. */ @NoInline - public final Address allocSlowOnce(int bytes, int align, int offset, - boolean inGC) { + public final Address allocSlowOnce(int bytes, int align, int offset, boolean inGC) { Address cell = allocFast(bytes, align, offset, inGC); if (!cell.isZero()) return cell; @@ -241,7 +240,7 @@ // find a free list which is not empty current = BlockAllocator.getNextBlock(current); while (!current.isZero()) { - cell = advanceToBlock(current, sizeClass); + cell = advanceToBlock(current, sizeClass, inGC); if (!cell.isZero()) { // this block has at least one free cell, so use it currentBlock.set(sizeClass, current); @@ -253,7 +252,7 @@ } } - cell = expandSizeClass(sizeClass); + cell = expandSizeClass(sizeClass, inGC); if (cell.isZero()) return Address.zero(); @@ -271,17 +270,18 @@ * <b>This is guaranteed to return pre-zeroed cells</b> * * @param sizeClass The size class to be expanded + * @param inGC Is this space currently being collected * @return The address of the first available cell in the newly * allocated block of pre-zeroed cells, or return zero if there were * insufficient resources to allocate a new block. */ @Inline - private Address expandSizeClass(int sizeClass) { + private Address expandSizeClass(int sizeClass, boolean inGC) { Address block = blockAllocator.alloc(blockSizeClass[sizeClass]); if (block.isZero()) return Address.zero(); - notifyNewBlock(block, sizeClass); + notifyNewBlock(block, sizeClass, inGC); installNewBlock(block, sizeClass); int cellExtent = cellSize[sizeClass]; @@ -517,15 +517,16 @@ protected abstract boolean maintainSideBitmap(); protected abstract boolean preserveFreeList(); - protected abstract Address advanceToBlock(Address block, int sizeClass); + protected abstract Address advanceToBlock(Address block, int sizeClass, boolean inGC); /** * Notify that a new block has been installed. * * @param block The new block * @param sizeClass The block's sizeclass. + * @param inGC Is this space currently being collected. */ - protected void notifyNewBlock(Address block, int sizeClass) {} + protected void notifyNewBlock(Address block, int sizeClass, boolean inGC) {} /** * Should the sweep reclaim the cell containing this object. Is this object @@ -573,7 +574,7 @@ } else if (preserveFreeList()) { freeList.set(sizeClass, getFreeList(block)); } else - freeList.set(sizeClass, advanceToBlock(block, sizeClass)); + freeList.set(sizeClass, advanceToBlock(block, sizeClass, true)); } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-08-30 10:55:47
|
Revision: 13412 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13412&view=rev Author: dframpton-oss Date: 2007-08-30 03:55:45 -0700 (Thu, 30 Aug 2007) Log Message: ----------- Change how pre/post gc sanity flag is set to allow more complete sanity checking for concurrent collectors. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-30 07:29:18 UTC (rev 13411) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-30 10:55:45 UTC (rev 13412) @@ -72,6 +72,8 @@ public static final short POST_SANITY_PLACEHOLDER = Phase.createSimple("post-sanity-placeholder", null); /* Sanity phases */ + public static final short SANITY_SET_PREGC = Phase.createSimple("sanity-setpre", null); + public static final short SANITY_SET_POSTGC = Phase.createSimple("sanity-setpost", null); public static final short SANITY_PREPARE = Phase.createSimple("sanity-prepare", null); public static final short SANITY_ROOTS = Phase.createSimple("sanity-roots", null); public static final short SANITY_BUILD_TABLE = Phase.createSimple("sanity-build-table", null); @@ -102,10 +104,17 @@ Phase.scheduleGlobal (SANITY_RELEASE)); /** Build and validate a sanity table */ - protected static final short sanityPhase = Phase.createComplex("sanity", null, + protected static final short preSanityPhase = Phase.createComplex("pre-sanity", null, Phase.scheduleComplex (sanityBuildPhase), + Phase.scheduleGlobal (SANITY_SET_PREGC), Phase.scheduleComplex (sanityCheckPhase)); + /** Build and validate a sanity table */ + protected static final short postSanityPhase = Phase.createComplex("post-sanity", null, + Phase.scheduleComplex (sanityBuildPhase), + Phase.scheduleGlobal (SANITY_SET_POSTGC), + Phase.scheduleComplex (sanityCheckPhase)); + /** Start the collection, including preparation for any collected spaces. */ protected static final short initPhase = Phase.createComplex("init", Phase.scheduleGlobal (SET_COLLECTION_KIND), @@ -203,10 +212,8 @@ Log.writeln("Collector does not support sanity checking!"); } else { Log.writeln("Collection sanity checking enabled."); - replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), - Phase.scheduleComplex(sanityPhase)); - replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), - Phase.scheduleComplex(sanityPhase)); + replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), Phase.scheduleComplex(preSanityPhase)); + replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), Phase.scheduleComplex(postSanityPhase)); } } } Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java 2007-08-30 07:29:18 UTC (rev 13411) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java 2007-08-30 10:55:45 UTC (rev 13412) @@ -56,7 +56,6 @@ public SanityChecker() { sanityTable = new SanityDataTable(sanitySpace, LOG_SANITY_DATA_SIZE); trace = new Trace(sanitySpace); - preGCSanity = true; } /** @@ -81,6 +80,16 @@ */ @NoInline public boolean collectionPhase(int phaseId) { + if (phaseId == StopTheWorld.SANITY_SET_PREGC) { + preGCSanity = true; + return true; + } + + if (phaseId == StopTheWorld.SANITY_SET_POSTGC) { + preGCSanity = false; + return true; + } + if (phaseId == StopTheWorld.SANITY_PREPARE) { Log.writeln(""); Log.write("============================== GC Sanity Checking "); @@ -119,7 +128,6 @@ Log.write("========================================"); Log.writeln("========================================"); - preGCSanity = !preGCSanity; return true; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dfr...@us...> - 2007-08-31 02:43:04
|
Revision: 13421 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=13421&view=rev Author: dframpton-oss Date: 2007-08-30 19:42:53 -0700 (Thu, 30 Aug 2007) Log Message: ----------- Hoist logic that can be shared between simple concurrent and stop-the-world collectors into a base class. Modified Paths: -------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/CollectorContext.java rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java Added Paths: ----------- rvmroot/trunk/MMTk/src/org/mmtk/plan/Simple.java rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleMutator.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java Removed Paths: ------------- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/CollectorContext.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/CollectorContext.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/CollectorContext.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -149,14 +149,7 @@ public abstract void collect(); /** Perform some concurrent garbage collection */ - public final void concurrentCollect() { - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!Plan.gcInProgress()); - if (Phase.startConcurrentPhase()) { - /* Can't change while we are 'in' the concurrent phase */ - short phaseId = Phase.getConcurrentPhaseId(); - concurrentCollectionPhase(phaseId); - } - } + public abstract void concurrentCollect(); /** * Perform a (local) collection phase. Copied: rvmroot/trunk/MMTk/src/org/mmtk/plan/Simple.java (from rev 13420, rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java) =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/Simple.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/Simple.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,286 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.mmtk.policy.Space; +import org.mmtk.utility.Constants; +import org.mmtk.utility.Log; +import org.mmtk.utility.options.*; +import org.mmtk.utility.sanitychecker.SanityChecker; +import org.mmtk.utility.statistics.Timer; +import org.mmtk.vm.VM; + +import org.vmmagic.pragma.*; + +/** + * This abstract class implements the core functionality for + * simple collectors.<p> + * + * This class defines the collection phases, and provides base + * level implementations of them. Subclasses should provide + * implementations for the spaces that they introduce, and + * delegate up the class hierarchy.<p> + * + * For details of the split between global and thread-local operations + * @see org.mmtk.plan.Plan + */ +@Uninterruptible +public abstract class Simple extends Plan implements Constants { + /**************************************************************************** + * Constants + */ + + /* Shared Timers */ + private static final Timer refTypeTime = new Timer("refType", false, true); + private static final Timer scanTime = new Timer("scan", false, true); + private static final Timer finalizeTime = new Timer("finalize", false, true); + + /* Phases */ + public static final short SET_COLLECTION_KIND = Phase.createSimple("set-collection-kind", null); + public static final short INITIATE = Phase.createSimple("initiate", null); + public static final short PREPARE = Phase.createSimple("prepare"); + public static final short PRECOPY = Phase.createSimple("precopy"); + public static final short PREPARE_STACKS = Phase.createSimple("prepare-stacks", null); + public static final short ROOTS = Phase.createSimple("root"); + public static final short BOOTIMAGE_ROOTS = Phase.createSimple("bootimage-root"); + public static final short START_CLOSURE = Phase.createSimple("start-closure", scanTime); + public static final short SOFT_REFS = Phase.createSimple("soft-ref", refTypeTime); + public static final short COMPLETE_CLOSURE = Phase.createSimple("complete-closure", scanTime); + public static final short WEAK_REFS = Phase.createSimple("weak-ref", refTypeTime); + public static final short FINALIZABLE = Phase.createSimple("finalize", finalizeTime); + public static final short WEAK_TRACK_REFS = Phase.createSimple("weak-track-ref", refTypeTime); + public static final short PHANTOM_REFS = Phase.createSimple("phantom-ref", refTypeTime); + public static final short FORWARD = Phase.createSimple("forward"); + public static final short FORWARD_REFS = Phase.createSimple("forward-ref", refTypeTime); + public static final short FORWARD_FINALIZABLE = Phase.createSimple("forward-finalize", finalizeTime); + public static final short RELEASE = Phase.createSimple("release"); + public static final short COMPLETE = Phase.createSimple("complete", null); + + /* Sanity placeholder */ + public static final short PRE_SANITY_PLACEHOLDER = Phase.createSimple("pre-sanity-placeholder", null); + public static final short POST_SANITY_PLACEHOLDER = Phase.createSimple("post-sanity-placeholder", null); + + /* Sanity phases */ + public static final short SANITY_SET_PREGC = Phase.createSimple("sanity-setpre", null); + public static final short SANITY_SET_POSTGC = Phase.createSimple("sanity-setpost", null); + public static final short SANITY_PREPARE = Phase.createSimple("sanity-prepare", null); + public static final short SANITY_ROOTS = Phase.createSimple("sanity-roots", null); + public static final short SANITY_BUILD_TABLE = Phase.createSimple("sanity-build-table", null); + public static final short SANITY_CHECK_TABLE = Phase.createSimple("sanity-check-table", null); + public static final short SANITY_RELEASE = Phase.createSimple("sanity-release", null); + + // CHECKSTYLE:OFF + + /** Ensure stacks are ready to be scanned */ + protected static final short prepareStacks = Phase.createComplex("prepare-stacks", null, + Phase.scheduleCollector (PREPARE_STACKS), + Phase.scheduleMutator (PREPARE_STACKS), + Phase.scheduleGlobal (PREPARE_STACKS)); + + /** Trace and set up a sanity table */ + protected static final short sanityBuildPhase = Phase.createComplex("sanity-build", null, + Phase.scheduleGlobal (SANITY_PREPARE), + Phase.scheduleCollector (SANITY_PREPARE), + Phase.scheduleComplex (prepareStacks), + Phase.scheduleCollector (SANITY_ROOTS), + Phase.scheduleGlobal (SANITY_ROOTS), + Phase.scheduleCollector (SANITY_BUILD_TABLE)); + + /** Validate a sanity table */ + protected static final short sanityCheckPhase = Phase.createComplex("sanity-check", null, + Phase.scheduleCollector (SANITY_CHECK_TABLE), + Phase.scheduleCollector (SANITY_RELEASE), + Phase.scheduleGlobal (SANITY_RELEASE)); + + /** Start the collection, including preparation for any collected spaces. */ + protected static final short initPhase = Phase.createComplex("init", + Phase.scheduleGlobal (SET_COLLECTION_KIND), + Phase.scheduleGlobal (INITIATE), + Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER)); + + /** + * Perform the initial determination of liveness from the roots. + */ + protected static final short rootClosurePhase = Phase.createComplex("initial-closure", null, + Phase.scheduleMutator (PREPARE), + Phase.scheduleGlobal (PREPARE), + Phase.scheduleCollector (PREPARE), + Phase.scheduleComplex (prepareStacks), + Phase.scheduleCollector (PRECOPY), + Phase.scheduleCollector (BOOTIMAGE_ROOTS), + Phase.scheduleCollector (ROOTS), + Phase.scheduleGlobal (ROOTS), + Phase.scheduleCollector (START_CLOSURE)); + + /** + * Complete closure including reference types and finalizable objects. + */ + protected static final short refTypeClosurePhase = Phase.createComplex("refType-closure", null, + Phase.scheduleCollector (SOFT_REFS), + Phase.scheduleCollector (COMPLETE_CLOSURE), + Phase.scheduleCollector (WEAK_REFS), + Phase.scheduleCollector (FINALIZABLE), + Phase.scheduleCollector (COMPLETE_CLOSURE), + Phase.schedulePlaceholder(WEAK_TRACK_REFS), + Phase.scheduleCollector (PHANTOM_REFS)); + + /** + * Ensure that all references in the system are correct. + */ + protected static final short forwardPhase = Phase.createComplex("forward-all", null, + /* Finish up */ + Phase.schedulePlaceholder(FORWARD), + Phase.scheduleCollector (FORWARD_REFS), + Phase.scheduleCollector (FORWARD_FINALIZABLE)); + + /** + * Complete closure including reference types and finalizable objects. + */ + protected static final short completeClosurePhase = Phase.createComplex("release", null, + Phase.scheduleMutator (RELEASE), + Phase.scheduleCollector (RELEASE), + Phase.scheduleGlobal (RELEASE)); + + + /** + * The collection scheme - this is a small tree of complex phases. + */ + protected static final short finishPhase = Phase.createComplex("finish", + Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), + Phase.scheduleCollector (COMPLETE), + Phase.scheduleGlobal (COMPLETE)); + + /** + * This is the phase that is executed to perform a collection. + */ + public short collection = Phase.createComplex("collection", null, + Phase.scheduleComplex(initPhase), + Phase.scheduleComplex(rootClosurePhase), + Phase.scheduleComplex(refTypeClosurePhase), + Phase.scheduleComplex(forwardPhase), + Phase.scheduleComplex(completeClosurePhase), + Phase.scheduleComplex(finishPhase)); + + // CHECKSTYLE:ON + + /* Basic GC sanity checker */ + private SanityChecker sanityChecker = new SanityChecker(); + + /** + * The current collection attempt. + */ + protected int collectionAttempt; + + /**************************************************************************** + * Collection + */ + + /** + * @return Return the current sanity checker. + */ + public SanityChecker getSanityChecker() { + return sanityChecker; + } + + /** + * Perform a (global) collection phase. + * + * @param phaseId The unique of the phase to perform. + */ + @Inline + public void collectionPhase(short phaseId) { + if (phaseId == SET_COLLECTION_KIND) { + requiredAtStart = getPagesRequired(); + collectionAttempt = VM.collection.maximumCollectionAttempt(); + emergencyCollection = lastCollectionFullHeap() && collectionAttempt > 1; + if (collectionAttempt > MAX_COLLECTION_ATTEMPTS) { + VM.assertions.fail("Too many collection attempts. Suspect plan is not setting FullHeap flag"); + } + if (emergencyCollection) { + if (Options.verbose.getValue() >= 1) Log.write("[Emergency]"); + forceFullHeapCollection(); + } + return; + } + + if (phaseId == INITIATE) { + setGCStatus(GC_PREPARE); + return; + } + + if (phaseId == PREPARE_STACKS) { + stacksPrepared = true; + return; + } + + if (phaseId == PREPARE) { + loSpace.prepare(true); + ploSpace.prepare(true); + immortalSpace.prepare(); + VM.memory.globalPrepareVMSpace(); + return; + } + + if (phaseId == ROOTS) { + VM.scanning.resetThreadCounter(); + setGCStatus(GC_PROPER); + return; + } + + if (phaseId == RELEASE) { + loSpace.release(true); + ploSpace.release(true); + immortalSpace.release(); + VM.memory.globalReleaseVMSpace(); + return; + } + + if (phaseId == COMPLETE) { + setGCStatus(NOT_IN_GC); + Space.clearAllAllocationFailed(); + awaitingAsyncCollection = false; + return; + } + + if (Options.sanityCheck.getValue() && + getSanityChecker().collectionPhase(phaseId)) { + return; + } + + Log.write("Global phase "); Log.write(Phase.getName(phaseId)); + Log.writeln(" not handled."); + VM.assertions.fail("Global phase not handled!"); + } + + /** + * Replace a scheduled phase. Used for example to replace a placeholder. + * + * @param oldScheduledPhase The scheduled phase to replace. + * @param newScheduledPhase The new scheduled phase. + */ + public void replacePhase(int oldScheduledPhase, int newScheduledPhase) { + ComplexPhase cp = (ComplexPhase)Phase.getPhase(collection); + cp.replacePhase(oldScheduledPhase, newScheduledPhase); + } + + /** + * Replace a placeholder phase. + * + * @param placeHolderPhase The placeholder phase + * @param newScheduledPhase The new scheduled phase. + */ + public void replacePlaceholderPhase(short placeHolderPhase, int newScheduledPhase) { + ComplexPhase cp = (ComplexPhase)Phase.getPhase(collection); + cp.replacePhase(Phase.schedulePlaceholder(placeHolderPhase), newScheduledPhase); + } +} Copied: rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleCollector.java (from rev 13420, rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java) =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleCollector.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleCollector.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,172 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.mmtk.utility.Finalizer; +import org.mmtk.utility.Log; +import org.mmtk.utility.options.Options; +import org.mmtk.utility.sanitychecker.SanityCheckerLocal; + +import org.mmtk.vm.VM; + +import org.vmmagic.pragma.*; + +/** + * This class (and its sub-classes) implement <i>per-collector thread</i> + * behavior and state. + * + * MMTk assumes that the VM instantiates instances of CollectorContext + * in thread local storage (TLS) for each thread participating in + * collection. Accesses to this state are therefore assumed to be + * low-cost during mutator time.<p> + * + * @see CollectorContext + */ +@Uninterruptible +public abstract class SimpleCollector extends CollectorContext { + + /**************************************************************************** + * Instance fields + */ + + /** Basic sanity checker */ + private SanityCheckerLocal sanityChecker = new SanityCheckerLocal(); + + /**************************************************************************** + * + * Collection + */ + + /** + * Perform a per-collector collection phase. + * + * @param phaseId The unique phase identifier + * @param primary Should this thread be used to execute any single-threaded + * local operations? + */ + @Inline + public void collectionPhase(short phaseId, boolean primary) { + if (phaseId == Simple.PREPARE_STACKS) { + if (!Plan.stacksPrepared()) { + VM.collection.prepareCollector(this); + } + return; + } + + if (phaseId == Simple.PREPARE) { + // Nothing to do + return; + } + + if (phaseId == Simple.PRECOPY) { + if (VM.activePlan.constraints().movesObjects()) { + VM.scanning.preCopyGCInstances(getCurrentTrace()); + } + return; + } + + if (phaseId == Simple.ROOTS) { + VM.scanning.computeStaticRoots(getCurrentTrace()); + VM.scanning.computeThreadRoots(getCurrentTrace()); + return; + } + + if (phaseId == Simple.BOOTIMAGE_ROOTS) { + if (Plan.SCAN_BOOT_IMAGE) + VM.scanning.computeBootImageRoots(getCurrentTrace()); + return; + } + + if (phaseId == Simple.SOFT_REFS) { + if (primary && !Options.noReferenceTypes.getValue()) { + VM.softReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); + } + return; + } + + if (phaseId == Simple.WEAK_REFS) { + if (primary && !Options.noReferenceTypes.getValue()) + VM.weakReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); + return; + } + + if (phaseId == Simple.FINALIZABLE) { + if (primary) { + if (Options.noFinalizer.getValue()) + Finalizer.kill(); + else + Finalizer.moveToFinalizable(getCurrentTrace()); + } + return; + } + + if (phaseId == Simple.PHANTOM_REFS) { + if (primary && !Options.noReferenceTypes.getValue()) + VM.phantomReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); + return; + } + + if (phaseId == Simple.FORWARD_REFS) { + if (primary && !Options.noReferenceTypes.getValue() && + VM.activePlan.constraints().needsForwardAfterLiveness()) { + VM.softReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); + VM.weakReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); + VM.phantomReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); + } + return; + } + + if (phaseId == Simple.FORWARD_FINALIZABLE) { + if (primary && !Options.noFinalizer.getValue() && + VM.activePlan.constraints().needsForwardAfterLiveness()) { + Finalizer.forward(getCurrentTrace()); + } + return; + } + + if (phaseId == Simple.COMPLETE) { + // Nothing to do + return; + } + + if (phaseId == Simple.RELEASE) { + // Nothing to do + return; + } + + if (Options.sanityCheck.getValue() && + getSanityChecker().collectionPhase(phaseId, primary)) { + return; + } + + Log.write("Per-collector phase "); Log.write(Phase.getName(phaseId)); + Log.writeln(" not handled."); + VM.assertions.fail("Per-collector phase not handled!"); + } + + /**************************************************************************** + * + * Miscellaneous. + */ + + /** @return The active global plan as a <code>Simple</code> instance. */ + @Inline + private static Simple global() { + return (Simple) VM.activePlan.global(); + } + + /** @return The current sanity checker. */ + public SanityCheckerLocal getSanityChecker() { + return sanityChecker; + } +} Copied: rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleConstraints.java (from rev 13420, rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java) =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleConstraints.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleConstraints.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,22 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.vmmagic.pragma.*; + +/** + * Constraints specific to simple collectors. + */ +@Uninterruptible +public abstract class SimpleConstraints extends PlanConstraints { +} Copied: rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleMutator.java (from rev 13420, rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java) =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleMutator.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/SimpleMutator.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,74 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.mmtk.utility.Log; +import org.mmtk.vm.VM; + +import org.vmmagic.pragma.*; + +/** + * This class (and its sub-classes) implement <i>per-mutator thread</i> + * behavior and state. + * + * MMTk assumes that the VM instantiates instances of MutatorContext + * in thread local storage (TLS) for each application thread. Accesses + * to this state are therefore assumed to be low-cost during mutator + * time.<p> + * + * @see MutatorContext + */ +@Uninterruptible +public abstract class SimpleMutator extends MutatorContext { + + /**************************************************************************** + * + * Collection. + */ + + /** + * Perform a per-mutator collection phase. This is executed by + * one collector thread on behalf of a mutator thread. + * + * @param phaseId The unique phase identifier + * @param primary Should this thread be used to execute any single-threaded + * local operations? + */ + @Inline + public void collectionPhase(short phaseId, boolean primary) { + if (phaseId == Simple.PREPARE_STACKS) { + if (!Plan.stacksPrepared()) { + VM.collection.prepareMutator(this); + } + return; + } + + if (phaseId == Simple.PREPARE) { + los.prepare(true); + plos.prepare(true); + VM.memory.collectorPrepareVMSpace(); + return; + } + + if (phaseId == Simple.RELEASE) { + los.release(true); + plos.release(true); + VM.memory.collectorReleaseVMSpace(); + return; + } + + Log.write("Per-mutator phase \""); Phase.getPhase(phaseId).logPhase(); + Log.writeln("\" not handled."); + VM.assertions.fail("Per-mutator phase not handled!"); + } +} Deleted: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -1,319 +0,0 @@ -/* - * This file is part of the Jikes RVM project (http://jikesrvm.org). - * - * This file is licensed to You under the Common Public License (CPL); - * 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/cpl1.0.php - * - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. - */ -package org.mmtk.plan; - -import org.mmtk.policy.Space; -import org.mmtk.utility.Constants; -import org.mmtk.utility.Log; -import org.mmtk.utility.options.*; -import org.mmtk.utility.sanitychecker.SanityChecker; -import org.mmtk.utility.statistics.Timer; -import org.mmtk.vm.VM; - -import org.vmmagic.pragma.*; - -/** - * This abstract class implements the core functionality for - * stop-the-world collectors. Stop-the-world collectors should - * inherit from this class.<p> - * - * This class defines the collection phases, and provides base - * level implementations of them. Subclasses should provide - * implementations for the spaces that they introduce, and - * delegate up the class hierarchy.<p> - * - * For details of the split between global and thread-local operations - * @see org.mmtk.plan.Plan - */ -@Uninterruptible public abstract class StopTheWorld extends Plan - implements Constants { - /**************************************************************************** - * Constants - */ - - /* Shared Timers */ - private static final Timer refTypeTime = new Timer("refType", false, true); - private static final Timer scanTime = new Timer("scan", false, true); - private static final Timer finalizeTime = new Timer("finalize", false, true); - - /* Phases */ - public static final short SET_COLLECTION_KIND = Phase.createSimple("set-collection-kind", null); - public static final short INITIATE = Phase.createSimple("initiate", null); - public static final short PREPARE = Phase.createSimple("prepare"); - public static final short PRECOPY = Phase.createSimple("precopy"); - public static final short PREPARE_STACKS = Phase.createSimple("prepare-stacks", null); - public static final short ROOTS = Phase.createSimple("root"); - public static final short BOOTIMAGE_ROOTS = Phase.createSimple("bootimage-root"); - public static final short START_CLOSURE = Phase.createSimple("start-closure", scanTime); - public static final short SOFT_REFS = Phase.createSimple("soft-ref", refTypeTime); - public static final short COMPLETE_CLOSURE = Phase.createSimple("complete-closure", scanTime); - public static final short WEAK_REFS = Phase.createSimple("weak-ref", refTypeTime); - public static final short FINALIZABLE = Phase.createSimple("finalize", finalizeTime); - public static final short WEAK_TRACK_REFS = Phase.createSimple("weak-track-ref", refTypeTime); - public static final short PHANTOM_REFS = Phase.createSimple("phantom-ref", refTypeTime); - public static final short FORWARD = Phase.createSimple("forward"); - public static final short FORWARD_REFS = Phase.createSimple("forward-ref", refTypeTime); - public static final short FORWARD_FINALIZABLE = Phase.createSimple("forward-finalize", finalizeTime); - public static final short RELEASE = Phase.createSimple("release"); - public static final short COMPLETE = Phase.createSimple("complete", null); - - /* Sanity placeholder */ - public static final short PRE_SANITY_PLACEHOLDER = Phase.createSimple("pre-sanity-placeholder", null); - public static final short POST_SANITY_PLACEHOLDER = Phase.createSimple("post-sanity-placeholder", null); - - /* Sanity phases */ - public static final short SANITY_SET_PREGC = Phase.createSimple("sanity-setpre", null); - public static final short SANITY_SET_POSTGC = Phase.createSimple("sanity-setpost", null); - public static final short SANITY_PREPARE = Phase.createSimple("sanity-prepare", null); - public static final short SANITY_ROOTS = Phase.createSimple("sanity-roots", null); - public static final short SANITY_BUILD_TABLE = Phase.createSimple("sanity-build-table", null); - public static final short SANITY_CHECK_TABLE = Phase.createSimple("sanity-check-table", null); - public static final short SANITY_RELEASE = Phase.createSimple("sanity-release", null); - - // CHECKSTYLE:OFF - - /** Ensure stacks are ready to be scanned */ - protected static final short prepareStacks = Phase.createComplex("prepare-stacks", null, - Phase.scheduleCollector (PREPARE_STACKS), - Phase.scheduleMutator (PREPARE_STACKS), - Phase.scheduleGlobal (PREPARE_STACKS)); - - /** Trace and set up a sanity table */ - protected static final short sanityBuildPhase = Phase.createComplex("sanity-build", null, - Phase.scheduleGlobal (SANITY_PREPARE), - Phase.scheduleCollector (SANITY_PREPARE), - Phase.scheduleComplex (prepareStacks), - Phase.scheduleCollector (SANITY_ROOTS), - Phase.scheduleGlobal (SANITY_ROOTS), - Phase.scheduleCollector (SANITY_BUILD_TABLE)); - - /** Validate a sanity table */ - protected static final short sanityCheckPhase = Phase.createComplex("sanity-check", null, - Phase.scheduleCollector (SANITY_CHECK_TABLE), - Phase.scheduleCollector (SANITY_RELEASE), - Phase.scheduleGlobal (SANITY_RELEASE)); - - /** Build and validate a sanity table */ - protected static final short preSanityPhase = Phase.createComplex("pre-sanity", null, - Phase.scheduleComplex (sanityBuildPhase), - Phase.scheduleGlobal (SANITY_SET_PREGC), - Phase.scheduleComplex (sanityCheckPhase)); - - /** Build and validate a sanity table */ - protected static final short postSanityPhase = Phase.createComplex("post-sanity", null, - Phase.scheduleComplex (sanityBuildPhase), - Phase.scheduleGlobal (SANITY_SET_POSTGC), - Phase.scheduleComplex (sanityCheckPhase)); - - /** Start the collection, including preparation for any collected spaces. */ - protected static final short initPhase = Phase.createComplex("init", - Phase.scheduleGlobal (SET_COLLECTION_KIND), - Phase.scheduleGlobal (INITIATE), - Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER)); - - /** - * Perform the initial determination of liveness from the roots. - */ - protected static final short rootClosurePhase = Phase.createComplex("initial-closure", null, - Phase.scheduleMutator (PREPARE), - Phase.scheduleGlobal (PREPARE), - Phase.scheduleCollector (PREPARE), - Phase.scheduleComplex (prepareStacks), - Phase.scheduleCollector (PRECOPY), - Phase.scheduleCollector (BOOTIMAGE_ROOTS), - Phase.scheduleCollector (ROOTS), - Phase.scheduleGlobal (ROOTS), - Phase.scheduleCollector (START_CLOSURE)); - - /** - * Complete closure including reference types and finalizable objects. - */ - protected static final short refTypeClosurePhase = Phase.createComplex("refType-closure", null, - Phase.scheduleCollector (SOFT_REFS), - Phase.scheduleCollector (COMPLETE_CLOSURE), - Phase.scheduleCollector (WEAK_REFS), - Phase.scheduleCollector (FINALIZABLE), - Phase.scheduleCollector (COMPLETE_CLOSURE), - Phase.schedulePlaceholder(WEAK_TRACK_REFS), - Phase.scheduleCollector (PHANTOM_REFS)); - - /** - * Ensure that all references in the system are correct. - */ - protected static final short forwardPhase = Phase.createComplex("forward-all", null, - /* Finish up */ - Phase.schedulePlaceholder(FORWARD), - Phase.scheduleCollector (FORWARD_REFS), - Phase.scheduleCollector (FORWARD_FINALIZABLE)); - - /** - * Complete closure including reference types and finalizable objects. - */ - protected static final short completeClosurePhase = Phase.createComplex("release", null, - Phase.scheduleMutator (RELEASE), - Phase.scheduleCollector (RELEASE), - Phase.scheduleGlobal (RELEASE)); - - - /** - * The collection scheme - this is a small tree of complex phases. - */ - protected static final short finishPhase = Phase.createComplex("finish", - Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), - Phase.scheduleCollector (COMPLETE), - Phase.scheduleGlobal (COMPLETE)); - - /** - * This is the phase that is executed to perform a collection. - */ - public short collection = Phase.createComplex("collection", null, - Phase.scheduleComplex(initPhase), - Phase.scheduleComplex(rootClosurePhase), - Phase.scheduleComplex(refTypeClosurePhase), - Phase.scheduleComplex(forwardPhase), - Phase.scheduleComplex(completeClosurePhase), - Phase.scheduleComplex(finishPhase)); - - // CHECKSTYLE:ON - - /* Basic GC sanity checker */ - private SanityChecker sanityChecker = new SanityChecker(); - - /** - * The current collection attempt. - */ - protected int collectionAttempt; - - /**************************************************************************** - * Collection - */ - - /** - * The boot method is called early in the boot process before any - * allocation. - */ - @Interruptible - public void postBoot() { - super.postBoot(); - - if (Options.sanityCheck.getValue()) { - if (getSanityChecker() == null || - VM.activePlan.collector().getSanityChecker() == null) { - Log.writeln("Collector does not support sanity checking!"); - } else { - Log.writeln("Collection sanity checking enabled."); - replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), Phase.scheduleComplex(preSanityPhase)); - replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), Phase.scheduleComplex(postSanityPhase)); - } - } - } - - /** - * @return Return the current sanity checker. - */ - public SanityChecker getSanityChecker() { - return sanityChecker; - } - - /** - * Perform a (global) collection phase. - * - * @param phaseId The unique of the phase to perform. - */ - @Inline - public void collectionPhase(short phaseId) { - if (phaseId == SET_COLLECTION_KIND) { - requiredAtStart = getPagesRequired(); - collectionAttempt = VM.collection.maximumCollectionAttempt(); - emergencyCollection = lastCollectionFullHeap() && collectionAttempt > 1; - if (collectionAttempt > MAX_COLLECTION_ATTEMPTS) { - VM.assertions.fail("Too many collection attempts. Suspect plan is not setting FullHeap flag"); - } - if (emergencyCollection) { - if (Options.verbose.getValue() >= 1) Log.write("[Emergency]"); - forceFullHeapCollection(); - } - return; - } - - if (phaseId == INITIATE) { - setGCStatus(GC_PREPARE); - return; - } - - if (phaseId == PREPARE_STACKS) { - stacksPrepared = true; - return; - } - - if (phaseId == PREPARE) { - loSpace.prepare(true); - ploSpace.prepare(true); - immortalSpace.prepare(); - VM.memory.globalPrepareVMSpace(); - return; - } - - if (phaseId == ROOTS) { - VM.scanning.resetThreadCounter(); - setGCStatus(GC_PROPER); - return; - } - - if (phaseId == RELEASE) { - loSpace.release(true); - ploSpace.release(true); - immortalSpace.release(); - VM.memory.globalReleaseVMSpace(); - return; - } - - if (phaseId == COMPLETE) { - setGCStatus(NOT_IN_GC); - Space.clearAllAllocationFailed(); - awaitingAsyncCollection = false; - return; - } - - if (Options.sanityCheck.getValue() && - getSanityChecker().collectionPhase(phaseId)) { - return; - } - - Log.write("Global phase "); Log.write(Phase.getName(phaseId)); - Log.writeln(" not handled."); - VM.assertions.fail("Global phase not handled!"); - } - - /** - * Replace a scheduled phase. Used for example to replace a placeholder. - * - * @param oldScheduledPhase The scheduled phase to replace. - * @param newScheduledPhase The new scheduled phase. - */ - public void replacePhase(int oldScheduledPhase, int newScheduledPhase) { - ComplexPhase cp = (ComplexPhase)Phase.getPhase(collection); - cp.replacePhase(oldScheduledPhase, newScheduledPhase); - } - - /** - * Replace a placeholder phase. - * - * @param placeHolderPhase The placeholder phase - * @param newScheduledPhase The new scheduled phase. - */ - public void replacePlaceholderPhase(short placeHolderPhase, int newScheduledPhase) { - ComplexPhase cp = (ComplexPhase)Phase.getPhase(collection); - cp.replacePhase(Phase.schedulePlaceholder(placeHolderPhase), newScheduledPhase); - } -} Added: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorld.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,74 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.mmtk.utility.Log; +import org.mmtk.utility.options.Options; +import org.mmtk.vm.VM; +import org.vmmagic.pragma.*; + +/** + * This abstract class implements the core functionality for + * stop-the-world collectors. Stop-the-world collectors should + * inherit from this class.<p> + * + * This class defines the collection phases, and provides base + * level implementations of them. Subclasses should provide + * implementations for the spaces that they introduce, and + * delegate up the class hierarchy.<p> + * + * For details of the split between global and thread-local operations + * @see org.mmtk.plan.Plan + */ +@Uninterruptible +public abstract class StopTheWorld extends Simple { + + // CHECKSTYLE:OFF + + /** Build and validate a sanity table */ + protected static final short preSanityPhase = Phase.createComplex("pre-sanity", null, + Phase.scheduleComplex (sanityBuildPhase), + Phase.scheduleGlobal (SANITY_SET_PREGC), + Phase.scheduleComplex (sanityCheckPhase)); + + /** Build and validate a sanity table */ + protected static final short postSanityPhase = Phase.createComplex("post-sanity", null, + Phase.scheduleComplex (sanityBuildPhase), + Phase.scheduleGlobal (SANITY_SET_POSTGC), + Phase.scheduleComplex (sanityCheckPhase)); + + // CHECKSTYLE:ON + + /**************************************************************************** + * Collection + */ + + /** + * The boot method is called early in the boot process before any + * allocation. + */ + @Interruptible + public void postBoot() { + super.postBoot(); + + if (Options.sanityCheck.getValue()) { + if (getSanityChecker() == null || VM.activePlan.collector().getSanityChecker() == null) { + Log.writeln("Collector does not support sanity checking!"); + } else { + Log.writeln("Collection sanity checking enabled."); + replacePhase(Phase.schedulePlaceholder(PRE_SANITY_PLACEHOLDER), Phase.scheduleComplex(preSanityPhase)); + replacePhase(Phase.schedulePlaceholder(POST_SANITY_PLACEHOLDER), Phase.scheduleComplex(postSanityPhase)); + } + } + } +} Deleted: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -1,183 +0,0 @@ -/* - * This file is part of the Jikes RVM project (http://jikesrvm.org). - * - * This file is licensed to You under the Common Public License (CPL); - * 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/cpl1.0.php - * - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. - */ -package org.mmtk.plan; - -import org.mmtk.utility.Finalizer; -import org.mmtk.utility.Log; -import org.mmtk.utility.options.Options; -import org.mmtk.utility.sanitychecker.SanityCheckerLocal; - -import org.mmtk.vm.VM; - -import org.vmmagic.pragma.*; - -/** - * This class (and its sub-classes) implement <i>per-collector thread</i> - * behavior and state. - * - * MMTk assumes that the VM instantiates instances of CollectorContext - * in thread local storage (TLS) for each thread participating in - * collection. Accesses to this state are therefore assumed to be - * low-cost during mutator time.<p> - * - * @see CollectorContext - */ -@Uninterruptible public abstract class StopTheWorldCollector extends CollectorContext { - - /**************************************************************************** - * Instance fields - */ - - /** Basic sanity checker */ - private SanityCheckerLocal sanityChecker = new SanityCheckerLocal(); - - /**************************************************************************** - * - * Collection - */ - public void collect() { - Phase.beginNewPhaseStack(Phase.scheduleComplex(global().collection)); - } - - /** - * Perform a per-collector collection phase. - * - * @param phaseId The unique phase identifier - * @param primary Should this thread be used to execute any single-threaded - * local operations? - */ - @Inline - public void collectionPhase(short phaseId, boolean primary) { - if (phaseId == StopTheWorld.PREPARE_STACKS) { - if (!Plan.stacksPrepared()) { - VM.collection.prepareCollector(this); - } - return; - } - - if (phaseId == StopTheWorld.PREPARE) { - // Nothing to do - return; - } - - if (phaseId == StopTheWorld.PRECOPY) { - if (VM.activePlan.constraints().movesObjects()) { - VM.scanning.preCopyGCInstances(getCurrentTrace()); - } - return; - } - - if (phaseId == StopTheWorld.ROOTS) { - VM.scanning.computeStaticRoots(getCurrentTrace()); - VM.scanning.computeThreadRoots(getCurrentTrace()); - return; - } - - if (phaseId == StopTheWorld.BOOTIMAGE_ROOTS) { - if (Plan.SCAN_BOOT_IMAGE) - VM.scanning.computeBootImageRoots(getCurrentTrace()); - return; - } - - if (phaseId == StopTheWorld.SOFT_REFS) { - if (primary && !Options.noReferenceTypes.getValue()) { - VM.softReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); - } - return; - } - - if (phaseId == StopTheWorld.WEAK_REFS) { - if (primary && !Options.noReferenceTypes.getValue()) - VM.weakReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); - return; - } - - if (phaseId == StopTheWorld.FINALIZABLE) { - if (primary) { - if (Options.noFinalizer.getValue()) - Finalizer.kill(); - else - Finalizer.moveToFinalizable(getCurrentTrace()); - } - return; - } - - if (phaseId == StopTheWorld.PHANTOM_REFS) { - if (primary && !Options.noReferenceTypes.getValue()) - VM.phantomReferences.scan(getCurrentTrace(),global().isCurrentGCNursery()); - return; - } - - if (phaseId == StopTheWorld.FORWARD_REFS) { - if (primary && !Options.noReferenceTypes.getValue() && - VM.activePlan.constraints().needsForwardAfterLiveness()) { - VM.softReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); - VM.weakReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); - VM.phantomReferences.forward(getCurrentTrace(),global().isCurrentGCNursery()); - } - return; - } - - if (phaseId == StopTheWorld.FORWARD_FINALIZABLE) { - if (primary && !Options.noFinalizer.getValue() && - VM.activePlan.constraints().needsForwardAfterLiveness()) { - Finalizer.forward(getCurrentTrace()); - } - return; - } - - if (phaseId == StopTheWorld.COMPLETE) { - // Nothing to do - return; - } - - if (phaseId == StopTheWorld.RELEASE) { - // Nothing to do - return; - } - - if (Options.sanityCheck.getValue() && - getSanityChecker().collectionPhase(phaseId, primary)) { - return; - } - - Log.write("Per-collector phase "); Log.write(Phase.getName(phaseId)); - Log.writeln(" not handled."); - VM.assertions.fail("Per-collector phase not handled!"); - } - - /** - * Perform some concurrent collection work. - * - * @param phaseId The unique phase identifier - */ - public void concurrentCollectionPhase(short phaseId) { - VM.assertions.fail("Concurrent phase triggered on StopTheWorld collector"); - } - - /**************************************************************************** - * - * Miscellaneous. - */ - - /** @return The active global plan as a <code>StopTheWorld</code> instance. */ - @Inline - private static StopTheWorld global() { - return (StopTheWorld) VM.activePlan.global(); - } - - /** @return The current sanity checker. */ - public SanityCheckerLocal getSanityChecker() { - return sanityChecker; - } -} Added: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldCollector.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,66 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.mmtk.vm.VM; +import org.vmmagic.pragma.*; + +/** + * This class (and its sub-classes) implement <i>per-collector thread</i> + * behavior and state. + * + * MMTk assumes that the VM instantiates instances of CollectorContext + * in thread local storage (TLS) for each thread participating in + * collection. Accesses to this state are therefore assumed to be + * low-cost during mutator time.<p> + * + * @see CollectorContext + */ +@Uninterruptible +public abstract class StopTheWorldCollector extends SimpleCollector { + + /**************************************************************************** + * + * Collection. + */ + + /** Perform garbage collection */ + public void collect() { + Phase.beginNewPhaseStack(Phase.scheduleComplex(global().collection)); + } + + /** Perform some concurrent garbage collection */ + public final void concurrentCollect() { + VM.assertions.fail("concurrentCollect called on StopTheWorld collector"); + } + + /** + * Perform some concurrent collection work. + * + * @param phaseId The unique phase identifier + */ + public void concurrentCollectionPhase(short phaseId) { + VM.assertions.fail("concurrentCollectionPhase triggered on StopTheWorld collector"); + } + + /**************************************************************************** + * + * Miscellaneous. + */ + + /** @return The active global plan as a <code>StopTheWorld</code> instance. */ + @Inline + private static StopTheWorld global() { + return (StopTheWorld) VM.activePlan.global(); + } +} Deleted: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -1,21 +0,0 @@ -/* - * This file is part of the Jikes RVM project (http://jikesrvm.org). - * - * This file is licensed to You under the Common Public License (CPL); - * 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/cpl1.0.php - * - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. - */ -package org.mmtk.plan; - -import org.vmmagic.pragma.*; - -/** - * Constraints specific to Stop-the-world collectors. - */ -@Uninterruptible public abstract class StopTheWorldConstraints extends PlanConstraints { -} Added: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldConstraints.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,22 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.vmmagic.pragma.*; + +/** + * Constraints specific to Stop-the-world collectors. + */ +@Uninterruptible +public abstract class StopTheWorldConstraints extends SimpleConstraints { +} Deleted: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -1,73 +0,0 @@ -/* - * This file is part of the Jikes RVM project (http://jikesrvm.org). - * - * This file is licensed to You under the Common Public License (CPL); - * 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/cpl1.0.php - * - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. - */ -package org.mmtk.plan; - -import org.mmtk.utility.Log; -import org.mmtk.vm.VM; - -import org.vmmagic.pragma.*; - -/** - * This class (and its sub-classes) implement <i>per-mutator thread</i> - * behavior and state. - * - * MMTk assumes that the VM instantiates instances of MutatorContext - * in thread local storage (TLS) for each application thread. Accesses - * to this state are therefore assumed to be low-cost during mutator - * time.<p> - * - * @see MutatorContext - */ -@Uninterruptible public abstract class StopTheWorldMutator extends MutatorContext { - - /**************************************************************************** - * - * Collection. - */ - - /** - * Perform a per-mutator collection phase. This is executed by - * one collector thread on behalf of a mutator thread. - * - * @param phaseId The unique phase identifier - * @param primary Should this thread be used to execute any single-threaded - * local operations? - */ - @Inline - public void collectionPhase(short phaseId, boolean primary) { - if (phaseId == StopTheWorld.PREPARE_STACKS) { - if (!Plan.stacksPrepared()) { - VM.collection.prepareMutator(this); - } - return; - } - - if (phaseId == StopTheWorld.PREPARE) { - los.prepare(true); - plos.prepare(true); - VM.memory.collectorPrepareVMSpace(); - return; - } - - if (phaseId == StopTheWorld.RELEASE) { - los.release(true); - plos.release(true); - VM.memory.collectorReleaseVMSpace(); - return; - } - - Log.write("Per-mutator phase \""); Phase.getPhase(phaseId).logPhase(); - Log.writeln("\" not handled."); - VM.assertions.fail("Per-mutator phase not handled!"); - } -} Added: rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java (rev 0) +++ rvmroot/trunk/MMTk/src/org/mmtk/plan/StopTheWorldMutator.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -0,0 +1,30 @@ +/* + * This file is part of the Jikes RVM project (http://jikesrvm.org). + * + * This file is licensed to You under the Common Public License (CPL); + * 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/cpl1.0.php + * + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. + */ +package org.mmtk.plan; + +import org.vmmagic.pragma.*; + +/** + * This class (and its sub-classes) implement <i>per-mutator thread</i> + * behavior and state. + * + * MMTk assumes that the VM instantiates instances of MutatorContext + * in thread local storage (TLS) for each application thread. Accesses + * to this state are therefore assumed to be low-cost during mutator + * time.<p> + * + * @see MutatorContext + */ +@Uninterruptible +public abstract class StopTheWorldMutator extends SimpleMutator { +} Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityChecker.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -13,7 +13,7 @@ package org.mmtk.utility.sanitychecker; import org.mmtk.plan.Trace; -import org.mmtk.plan.StopTheWorld; +import org.mmtk.plan.Simple; import org.mmtk.policy.RawPageSpace; import org.mmtk.policy.Space; import org.mmtk.utility.Constants; @@ -25,7 +25,7 @@ import org.vmmagic.unboxed.*; /** - * This class performs sanity checks for StopTheWorld collectors. + * This class performs sanity checks for Simple collectors. */ @Uninterruptible public final class SanityChecker implements Constants { @@ -80,17 +80,17 @@ */ @NoInline public boolean collectionPhase(int phaseId) { - if (phaseId == StopTheWorld.SANITY_SET_PREGC) { + if (phaseId == Simple.SANITY_SET_PREGC) { preGCSanity = true; return true; } - if (phaseId == StopTheWorld.SANITY_SET_POSTGC) { + if (phaseId == Simple.SANITY_SET_POSTGC) { preGCSanity = false; return true; } - if (phaseId == StopTheWorld.SANITY_PREPARE) { + if (phaseId == Simple.SANITY_PREPARE) { Log.writeln(""); Log.write("============================== GC Sanity Checking "); Log.writeln("=============================="); @@ -110,12 +110,12 @@ return true; } - if (phaseId == StopTheWorld.SANITY_ROOTS) { + if (phaseId == Simple.SANITY_ROOTS) { VM.scanning.resetThreadCounter(); return true; } - if (phaseId == StopTheWorld.SANITY_RELEASE) { + if (phaseId == Simple.SANITY_RELEASE) { trace.release(); sanityTable.releaseTable(); Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java =================================================================== --- rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2007-08-31 00:20:31 UTC (rev 13420) +++ rvmroot/trunk/MMTk/src/org/mmtk/utility/sanitychecker/SanityCheckerLocal.java 2007-08-31 02:42:53 UTC (rev 13421) @@ -13,7 +13,7 @@ package org.mmtk.utility.sanitychecker; import org.mmtk.plan.Plan; -import org.mmtk.plan.StopTheWorld; +import org.mmtk.plan.Simple; import org.mmtk.plan.TraceLocal; import org.mmtk.policy.Space; import org.mmtk.utility.Constants; @@ -25,7 +25,7 @@ import org.vmmagic.unboxed.*; /** - * This class performs sanity checks for StopTheWorld collectors. + * This class performs sanity checks for Simple collectors. */ @Uninterruptible public class SanityCheckerLocal implements Constants { @@ -49,14 +49,14 @@ */ @NoInline public final boolean collectionPhase(int phaseId, boolean primary) { - if (phaseId == StopTheWorld.SANITY_PREPARE) { + if (phaseId == Simple.SANITY_PREPARE) { if (primary) { sanityTrace.prepare(); } return true; } - if (phaseId == StopTheWorld.SANITY_ROOTS) { + if (phaseId == Simple.SANITY_ROOTS) { VM.scanning.computeStaticRoots(sanityTrace); VM.scanning.computeThreadRoots(sanityTrace); if (Plan.SCAN_BOOT_IMAGE) { @@ -66,7 +66,7 @@ return true; } - if (phaseId == StopTheWorld.SANITY_BUILD_TABLE) { + if (phaseId == Simple.SANITY_BUILD_TABLE) { if (primary) { // Trace, checking for dangling pointers sanityTrace.startTrace(); @@ -74,7 +74,7 @@ return true; } - if (phaseId == StopTheWorld.SANITY_CHECK_TABLE) { + if (phaseId == Simple.SANITY_CHECK_TABLE) { if (primary) { // Iterate over the reachable objects. Address curr = global().getSanityTable().getFirst(); @@ -113,7 +113,7 @@ return true; } - if (phaseId == StopTheWorld.SANITY_RELEASE) { + if (phaseId == Simple.SANITY_RELEASE) { if (primary) { sanityTrace.release(); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |