Menu
▾
▴
[Jikesrvm-commits] MMTk/src/org/mmtk/plan/semispace SSCollector.java, NONE, 1.1 SSMutator.java, NONE, 1.1 SSTraceLocal.java, 1.3, 1.4 SSConstraints.java, 1.1, 1.2 SS.java, 1.3, 1.4 SSLocal.java, 1.1, NONE
|
From: Steve B. <ste...@us...> - 2006-06-19 06:08:46
|
Update of /cvsroot/jikesrvm/MMTk/src/org/mmtk/plan/semispace In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv27375/src/org/mmtk/plan/semispace Modified Files: SSTraceLocal.java SSConstraints.java SS.java Added Files: SSCollector.java SSMutator.java Removed Files: SSLocal.java Log Message: Refactored "locals" into MutatorContexts and CollectorContexts. This means MMTk no longer assumes the Jikes RVM threading model. Aside from making matters clearer, a nice side-effect was the removel of the whole concept of "non-participating". A consequence of this refactoring is that MutatorContexts remain embedded in the VM_Processor, but CollectorContexts are now an indirection away. I checked the performance implication of this pretty thoroughly and found no measurable change in performance. I made a bunch of other minor cleanups. Index: SSTraceLocal.java =================================================================== RCS file: /cvsroot/jikesrvm/MMTk/src/org/mmtk/plan/semispace/SSTraceLocal.java,v retrieving revision 1.3 retrieving revision 1.4 diff -C2 -d -r1.3 -r1.4 *** SSTraceLocal.java 7 Jun 2006 03:46:45 -0000 1.3 --- SSTraceLocal.java 19 Jun 2006 06:08:13 -0000 1.4 *************** *** 18,22 **** * $Id$ * ! * @author <a href="http://cs.anu.edu.au/~Steve.Blackburn">Steve Blackburn</a> * @author Perry Cheng * @author Robin Garner --- 18,22 ---- * $Id$ * ! * @author Steve Blackburn * @author Perry Cheng * @author Robin Garner Index: SSConstraints.java =================================================================== RCS file: /cvsroot/jikesrvm/MMTk/src/org/mmtk/plan/semispace/SSConstraints.java,v retrieving revision 1.1 retrieving revision 1.2 diff -C2 -d -r1.1 -r1.2 *** SSConstraints.java 20 Jul 2005 14:32:10 -0000 1.1 --- SSConstraints.java 19 Jun 2006 06:08:13 -0000 1.2 *************** *** 14,18 **** * $Id$ * ! * @author <a href="http://cs.anu.edu.au/~Steve.Blackburn">Steve Blackburn</a> * @author Perry Cheng * @author Robin Garner --- 14,18 ---- * $Id$ * ! * @author Steve Blackburn * @author Perry Cheng * @author Robin Garner Index: SS.java =================================================================== RCS file: /cvsroot/jikesrvm/MMTk/src/org/mmtk/plan/semispace/SS.java,v retrieving revision 1.3 retrieving revision 1.4 diff -C2 -d -r1.3 -r1.4 *** SS.java 24 Apr 2006 13:48:22 -0000 1.3 --- SS.java 19 Jun 2006 06:08:13 -0000 1.4 *************** *** 32,36 **** * $Id$ * ! * @author <a href="http://cs.anu.edu.au/~Steve.Blackburn">Steve Blackburn</a> * @author Perry Cheng * @author Robin Garner --- 32,36 ---- * $Id$ * ! * @author Steve Blackburn * @author Perry Cheng * @author Robin Garner --- NEW FILE: SSCollector.java --- /* * (C) Copyright Department of Computer Science, * Australian National University. 2002 */ package org.mmtk.plan.semispace; import org.mmtk.plan.*; import org.mmtk.policy.CopySpace; import org.mmtk.policy.CopyLocal; import org.mmtk.policy.Space; import org.mmtk.vm.ActivePlan; import org.mmtk.vm.Assert; import org.vmmagic.unboxed.*; import org.vmmagic.pragma.*; /** * This class implements <i>per-collector thread</i> behavior * and state for the <i>SS</i> plan, which implements a full-heap * semi-space collector.<p> * * Specifically, this class defines <i>SS</i> collection behavior * (through <code>trace</code> and the <code>collectionPhase</code> * method), and collection-time allocation (copying of objects).<p> * * @see SS for an overview of the semi-space algorithm.<p> * * @see SS * @see SSMutator * @see StopTheWorldCollector * @see CollectorContext * @see SimplePhase#delegatePhase * * $Id: SSCollector.java,v 1.1 2006/06/19 06:08:13 steveb-oss Exp $ * * @author Steve Blackburn * @author Perry Cheng * @author Robin Garner * @author Daniel Frampton * * @version $Revision: 1.1 $ * @date $Date: 2006/06/19 06:08:13 $ */ public class SSCollector extends StopTheWorldCollector implements Uninterruptible { /**************************************************************************** * Instance fields */ protected final SSTraceLocal trace; protected final CopyLocal ss; /**************************************************************************** * * Initialization */ /** * Constructor */ public SSCollector() { ss = new CopyLocal(SS.copySpace0); trace = new SSTraceLocal(global().ssTrace); } /**************************************************************************** * * Collection-time allocation */ /** * Allocate space for copying an object (this method <i>does not</i> * copy the object, it only allocates space) * * @param original A reference to the original object * @param bytes The size of the space to be allocated (in bytes) * @param align The requested alignment. * @param offset The alignment offset. * @return The address of the first byte of the allocated region */ public Address allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator) throws InlinePragma { if (Assert.VERIFY_ASSERTIONS) { Assert._assert(bytes <= Plan.LOS_SIZE_THRESHOLD); Assert._assert(allocator == SS.ALLOC_SS); } return ss.alloc(bytes, align, offset); } /** * Perform any post-copy actions. * * @param object The newly allocated object * @param typeRef the type reference for the instance being created * @param bytes The size of the space to be allocated (in bytes) */ public void postCopy(ObjectReference object, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma { CopySpace.clearGCBits(object); } /**************************************************************************** * * Collection */ /** * Perform a per-collector collection phase. * * @param phaseId The collection phase to perform * @param participating Is this thread participating in collection * (as opposed to blocked in a JNI call) * @param primary Perform any single-threaded activities using this thread. */ public void collectionPhase(int phaseId, boolean participating, boolean primary) throws InlinePragma { if (phaseId == SS.PREPARE) { // rebind the copy bump pointer to the appropriate semispace. ss.rebind(SS.toSpace()); super.collectionPhase(phaseId, participating,primary); return; } if (phaseId == SS.START_CLOSURE) { trace.startTrace(); return; } if (phaseId == SS.COMPLETE_CLOSURE) { trace.completeTrace(); return; } if (phaseId == SS.RELEASE) { trace.release(); super.collectionPhase(phaseId, participating, primary); return; } super.collectionPhase(phaseId, participating, primary); } /**************************************************************************** * * Object processing and tracing */ /** * Return true if the given reference is to an object that is within * one of the semi-spaces. * * @param object The object in question * @return True if the given reference is to an object that is within * one of the semi-spaces. */ public static final boolean isSemiSpaceObject(ObjectReference object) { return Space.isInSpace(SS.SS0, object) || Space.isInSpace(SS.SS1, object); } /**************************************************************************** * * Miscellaneous */ /** @return The active global plan as an <code>SS</code> instance. */ private static final SS global() throws InlinePragma { return (SS)ActivePlan.global(); } /** @return the current trace object. */ public TraceLocal getCurrentTrace() { return trace; } } --- NEW FILE: SSMutator.java --- /* * (C) Copyright Department of Computer Science, * Australian National University. 2006 */ package org.mmtk.plan.semispace; import org.mmtk.plan.*; import org.mmtk.policy.CopyLocal; import org.mmtk.policy.Space; import org.mmtk.utility.alloc.AllocAdvice; import org.mmtk.utility.alloc.Allocator; import org.mmtk.utility.CallSite; import org.mmtk.utility.scan.*; import org.vmmagic.unboxed.*; import org.vmmagic.pragma.*; /** * This class implements <i>per-mutator thread</i> behavior * and state for the <i>SS</i> plan, which implements a full-heap * semi-space collector.<p> * * Specifically, this class defines <i>SS</i> mutator-time allocation * and per-mutator thread collection semantics (flushing and restoring * per-mutator allocator state).<p> * * @see SS for an overview of the semi-space algorithm.<p> * * @see SS * @see SSCollector * @see StopTheWorldMutator * @see MutatorContext * @see SimplePhase#delegatePhase * * $Id: SSMutator.java,v 1.1 2006/06/19 06:08:13 steveb-oss Exp $ * * @author Steve Blackburn * @author Perry Cheng * @author Robin Garner * @author Daniel Frampton * * @version $Revision: 1.1 $ * @date $Date: 2006/06/19 06:08:13 $ */ public class SSMutator extends StopTheWorldMutator implements Uninterruptible { /**************************************************************************** * Instance fields */ protected final CopyLocal ss; /**************************************************************************** * * Initialization */ /** * Constructor */ public SSMutator() { ss = new CopyLocal(SS.copySpace0); } /**************************************************************************** * * Mutator-time allocation */ /** * Allocate space (for an object) * * @param bytes The size of the space to be allocated (in bytes) * @param align The requested alignment. * @param offset The alignment offset. * @param allocator The allocator number to be used for this allocation * @return The address of the first byte of the allocated region */ public Address alloc(int bytes, int align, int offset, int allocator) throws InlinePragma { if (allocator == SS.ALLOC_SS) return ss.alloc(bytes, align, offset); else return super.alloc(bytes, align, offset, allocator); } /** * Perform post-allocation actions. For many allocators none are * required. * * @param object The newly allocated object * @param typeRef The type reference for the instance being created * @param bytes The size of the space to be allocated (in bytes) * @param allocator The allocator number to be used for this allocation */ public void postAlloc(ObjectReference object, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma { if (allocator == SS.ALLOC_SS) return; super.postAlloc(object,typeRef,bytes,allocator); } /** * Return the space into which an allocator is allocating. This * 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 CollectorContext#getOwnAllocator(Allocator)}. * * @see CollectorContext#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 * <code>a</code>. */ public final Space getSpaceFromAllocator(Allocator a) { if (a == ss) return SS.toSpace(); return super.getSpaceFromAllocator(a); } /** * Return the allocator instance associated with a space * <code>space</code>, for this plan instance. This exists * to support {@link CollectorContext#getOwnAllocator(Allocator)}. * * @see CollectorContext#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> * if no appropriate allocator can be established. */ public final Allocator getAllocatorFromSpace(Space space) { if (space == SS.copySpace0 || space == SS.copySpace1) return ss; return super.getAllocatorFromSpace(space); } /** * Give the compiler/runtime statically generated alloction advice * which will be passed to the allocation routine at runtime. * * @param type The type id of the type being allocated * @param bytes The size (in bytes) required for this object * @param callsite Information identifying the point in the code * where this allocation is taking place. * @param hint A hint from the compiler as to which allocator this * site should use. * @return Allocation advice to be passed to the allocation routine * at runtime */ public final AllocAdvice getAllocAdvice(MMType type, int bytes, CallSite callsite, AllocAdvice hint) { return null; } /**************************************************************************** * * Collection */ /** * Perform a per-mutator collection phase. * * @param phaseId The collection phase to perform * @param participating Is this thread participating in collection * (as opposed to blocked in a JNI call) * @param primary Perform any single-threaded activities using this thread. */ public void collectionPhase(int phaseId, boolean participating, boolean primary) throws InlinePragma { if (phaseId == SS.PREPARE_MUTATOR) { // rebind the allocation bump pointer to the appropriate semispace. ss.rebind(SS.toSpace()); super.collectionPhase(phaseId, participating, primary); return; } if (phaseId == SS.RELEASE_MUTATOR) { super.collectionPhase(phaseId, participating, primary); return; } super.collectionPhase(phaseId, participating, primary); } /**************************************************************************** * * Miscellaneous */ /** * Show the status of each of the allocators. */ public final void show() { ss.show(); los.show(); immortal.show(); } } --- SSLocal.java DELETED --- |