/* * This file is part of the Jikes RVM project (http://jikesrvm.org). * * This file is licensed to You under the Eclipse Public License (EPL); * You may not use this file except in compliance with the License. You * may obtain a copy of the License at * * http://www.opensource.org/licenses/eclipse-1.0.php * * See the COPYRIGHT.txt file distributed with this work for information * regarding copyright ownership. */ package org.mmtk.plan.generational.copying; import org.mmtk.plan.generational.Gen; import org.mmtk.plan.generational.GenCollector; import org.mmtk.plan.Plan; import org.mmtk.plan.TraceLocal; import org.mmtk.policy.CopyLocal; import org.mmtk.utility.ForwardingWord; import org.mmtk.utility.HeaderByte; import org.mmtk.utility.alloc.Allocator; import org.mmtk.vm.VM; import org.vmmagic.unboxed.*; import org.vmmagic.pragma.*; /** * This class implements <i>per-collector thread</i> behavior and state for * the <code>GenCopy</code> two-generational copying collector.<p> * * Specifically, this class defines semantics specific to the collection of * the mature generation (<code>GenCollector</code> defines nursery semantics). * In particular the mature space allocator is defined (for collection-time * allocation into the mature space), and the mature space per-collector thread * collection time semantics are defined.<p> * * @see GenCopy for a description of the <code>GenCopy</code> algorithm. * * @see GenCopy * @see GenCopyMutator * @see GenCollector * @see org.mmtk.plan.StopTheWorldCollector * @see org.mmtk.plan.CollectorContext */ @Uninterruptible public class GenCopyCollector extends GenCollector { /****************************************************************** * Instance fields */ /** The allocator for the mature space */ private final CopyLocal mature; /** The trace object for full-heap collections */ private final GenCopyMatureTraceLocal matureTrace; /**************************************************************************** * * Initialization */ /** * Constructor */ public GenCopyCollector() { mature = new CopyLocal(GenCopy.toSpace()); matureTrace = new GenCopyMatureTraceLocal(global().matureTrace, this); } /**************************************************************************** * * Collection-time allocation */ /** * {@inheritDoc} */ @Override @Inline public Address allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator) { if (allocator == Plan.ALLOC_LOS) { if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(Allocator.getMaximumAlignedSize(bytes, align) > Plan.MAX_NON_LOS_COPY_BYTES); return los.alloc(bytes, align, offset); } else { if (VM.VERIFY_ASSERTIONS) { VM.assertions._assert(bytes <= Plan.MAX_NON_LOS_COPY_BYTES); VM.assertions._assert(allocator == GenCopy.ALLOC_MATURE_MINORGC || allocator == GenCopy.ALLOC_MATURE_MAJORGC); } return mature.alloc(bytes, align, offset); } } /** * {@inheritDoc}<p> * * In this case we clear any bits used for this object's GC metadata. */ @Override @Inline public final void postCopy(ObjectReference object, ObjectReference typeRef, int bytes, int allocator) { ForwardingWord.clearForwardingBits(object); if (allocator == Plan.ALLOC_LOS) Plan.loSpace.initializeHeader(object, false); else if (GenCopy.IGNORE_REMSETS) GenCopy.immortalSpace.traceObject(getCurrentTrace(), object); // FIXME this does not look right if (Gen.USE_OBJECT_BARRIER) HeaderByte.markAsUnlogged(object); } /***************************************************************************** * * Collection */ /** * {@inheritDoc} */ @Override public void collectionPhase(short phaseId, boolean primary) { if (global().traceFullHeap()) { if (phaseId == GenCopy.PREPARE) { super.collectionPhase(phaseId, primary); if (global().gcFullHeap) mature.rebind(GenCopy.toSpace()); } if (phaseId == GenCopy.CLOSURE) { matureTrace.completeTrace(); return; } if (phaseId == GenCopy.RELEASE) { matureTrace.release(); super.collectionPhase(phaseId, primary); return; } } super.collectionPhase(phaseId, primary); } /***************************************************************************** * * Miscellaneous */ /** @return The active global plan as a <code>GenCopy</code> instance. */ private static GenCopy global() { return (GenCopy) VM.activePlan.global(); } /** Show the status of the mature allocator. */ protected final void showMature() { mature.show(); } @Override public final TraceLocal getFullHeapTrace() { return matureTrace; } }