/*
* 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.refcount;
import org.mmtk.plan.Phase;
import org.mmtk.plan.StopTheWorld;
import org.mmtk.plan.Trace;
import org.mmtk.plan.refcount.backuptrace.BTFreeLargeObjectSweeper;
import org.mmtk.plan.refcount.backuptrace.BTScanLargeObjectSweeper;
import org.mmtk.plan.refcount.backuptrace.BTSweeper;
import org.mmtk.policy.ExplicitFreeListSpace;
import org.mmtk.policy.ExplicitLargeObjectSpace;
import org.mmtk.policy.Space;
import org.mmtk.utility.Log;
import org.mmtk.utility.alloc.LinearScan;
import org.mmtk.utility.deque.SharedDeque;
import org.mmtk.utility.heap.VMRequest;
import org.mmtk.utility.options.Options;
import org.mmtk.utility.sanitychecker.SanityChecker;
import org.mmtk.vm.VM;
import org.vmmagic.pragma.*;
import org.vmmagic.unboxed.ObjectReference;
/**
* This class implements the global state of a a simple reference counting collector.
*/
@Uninterruptible
public class RCBase extends StopTheWorld {
public static final short PROCESS_OLDROOTBUFFER = Phase.createSimple("old-root");
public static final short PROCESS_NEWROOTBUFFER = Phase.createSimple("new-root");
public static final short PROCESS_MODBUFFER = Phase.createSimple("mods");
public static final short PROCESS_DECBUFFER = Phase.createSimple("decs");
/** Is cycle collection enabled? */
public static final boolean CC_ENABLED = true;
/** Force full cycle collection at each GC? */
public static final boolean CC_FORCE_FULL = false;
/** Use backup tracing for cycle collection (currently the only option) */
public static final boolean CC_BACKUP_TRACE = true;
public static boolean performCycleCollection;
public static final short BT_CLOSURE = Phase.createSimple("closure-bt");
// CHECKSTYLE:OFF
/**
* Reference counting specific collection steps.
*/
protected static final short refCountCollectionPhase = Phase.createComplex("release", null,
Phase.scheduleGlobal (PROCESS_OLDROOTBUFFER),
Phase.scheduleCollector (PROCESS_OLDROOTBUFFER),
Phase.scheduleGlobal (PROCESS_NEWROOTBUFFER),
Phase.scheduleCollector (PROCESS_NEWROOTBUFFER),
Phase.scheduleMutator (PROCESS_DECBUFFER),
Phase.scheduleGlobal (PROCESS_DECBUFFER),
Phase.scheduleCollector (PROCESS_DECBUFFER),
Phase.scheduleGlobal (BT_CLOSURE),
Phase.scheduleCollector (BT_CLOSURE));
/**
* 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 (STACK_ROOTS),
Phase.scheduleCollector (ROOTS),
Phase.scheduleGlobal (ROOTS),
Phase.scheduleMutator (PROCESS_MODBUFFER),
Phase.scheduleGlobal (PROCESS_MODBUFFER),
Phase.scheduleCollector (PROCESS_MODBUFFER),
Phase.scheduleGlobal (CLOSURE),
Phase.scheduleCollector (CLOSURE));
/**
* 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(refCountCollectionPhase),
Phase.scheduleComplex(completeClosurePhase),
Phase.scheduleComplex(finishPhase));
// CHECKSTYLE:ON
/*****************************************************************************
*
* Class fields
*/
public static final ExplicitFreeListSpace rcSpace = new ExplicitFreeListSpace("rc", DEFAULT_POLL_FREQUENCY, VMRequest.create());
public static final ExplicitLargeObjectSpace rcloSpace = new ExplicitLargeObjectSpace("rclos", DEFAULT_POLL_FREQUENCY, VMRequest.create());
public static final int REF_COUNT = rcSpace.getDescriptor();
public static final int REF_COUNT_LOS = rcloSpace.getDescriptor();
public final SharedDeque modPool = new SharedDeque("mod", metaDataSpace, 1);
public final SharedDeque decPool = new SharedDeque("dec", metaDataSpace, 1);
public final SharedDeque newRootPool = new SharedDeque("newRoot", metaDataSpace, 1);
public final SharedDeque oldRootPool = new SharedDeque("oldRoot", metaDataSpace, 1);
/*****************************************************************************
*
* Instance fields
*/
public final Trace rootTrace;
public final Trace backupTrace;
private final BTSweeper rcSweeper;
private final BTScanLargeObjectSweeper loScanSweeper;
private final BTFreeLargeObjectSweeper loFreeSweeper;
/**
* Constructor
*/
public RCBase() {
Options.noReferenceTypes.setDefaultValue(true);
Options.noFinalizer.setDefaultValue(true);
rootTrace = new Trace(metaDataSpace);
backupTrace = new Trace(metaDataSpace);
rcSweeper = new BTSweeper();
loScanSweeper = new BTScanLargeObjectSweeper();
loFreeSweeper = new BTFreeLargeObjectSweeper();
}
/**
* The boot method is called early in the boot process before any
* allocation.
*/
@Interruptible
public void postBoot() {
super.postBoot();
if (!Options.noReferenceTypes.getValue()) {
VM.assertions.fail("Reference Types are not supported by RC");
}
if (!Options.noFinalizer.getValue()) {
VM.assertions.fail("Finalizers are not supported by RC");
}
}
/*****************************************************************************
*
* Collection
*/
public static final boolean isRCObject(ObjectReference object) {
return !object.isNull() && !Space.isInSpace(VM_SPACE, object);
}
/**
* @return Whether last GC is a full GC.
*/
public boolean lastCollectionFullHeap() {
return performCycleCollection;
}
/**
* Perform a (global) collection phase.
*
* @param phaseId Collection phase
*/
public void collectionPhase(short phaseId) {
if (phaseId == SET_COLLECTION_KIND) {
super.collectionPhase(phaseId);
if (CC_ENABLED) {
performCycleCollection = (collectionAttempt > 1) || emergencyCollection || CC_FORCE_FULL;
if (performCycleCollection && Options.verbose.getValue() > 0) Log.write(" [CC] ");
}
return;
}
if (phaseId == PREPARE) {
VM.finalizableProcessor.clear();
VM.weakReferences.clear();
VM.softReferences.clear();
VM.phantomReferences.clear();
rootTrace.prepare();
rcSpace.prepare();
if (CC_BACKUP_TRACE && performCycleCollection) {
backupTrace.prepare();
}
return;
}
if (phaseId == CLOSURE) {
rootTrace.prepare();
return;
}
if (phaseId == BT_CLOSURE) {
if (CC_BACKUP_TRACE && performCycleCollection) {
backupTrace.prepare();
}
return;
}
if (phaseId == PROCESS_OLDROOTBUFFER) {
oldRootPool.prepare();
return;
}
if (phaseId == PROCESS_NEWROOTBUFFER) {
newRootPool.prepare();
return;
}
if (phaseId == PROCESS_MODBUFFER) {
modPool.prepare();
return;
}
if (phaseId == PROCESS_DECBUFFER) {
decPool.prepare();
return;
}
if (phaseId == RELEASE) {
rootTrace.release();
if (CC_BACKUP_TRACE && performCycleCollection) {
backupTrace.release();
rcSpace.sweepCells(rcSweeper);
rcloSpace.sweep(loScanSweeper);
rcloSpace.sweep(loFreeSweeper);
} else {
rcSpace.release();
}
return;
}
super.collectionPhase(phaseId);
}
/*****************************************************************************
*
* Accounting
*/
/**
* Return the number of pages used given the pending
* allocation.
*
* @return The number of pages reserved given the pending
* allocation, excluding space reserved for copying.
*/
public int getPagesUsed() {
return (rcSpace.reservedPages() + rcloSpace.reservedPages() + super.getPagesUsed());
}
/**
* Perform a linear scan across all objects in the heap to check for leaks.
*/
public void sanityLinearScan(LinearScan scan) {
//rcSpace.linearScan(scan);
}
/**
* Return the expected reference count. For non-reference counting
* collectors this becomes a true/false relationship.
*
* @param object The object to check.
* @param sanityRootRC The number of root references to the object.
* @return The expected (root excluded) reference count.
*/
public int sanityExpectedRC(ObjectReference object, int sanityRootRC) {
if (RCBase.isRCObject(object)) {
int fullRC = RCHeader.getRC(object);
if (fullRC == 0) {
return SanityChecker.DEAD;
}
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(fullRC >= sanityRootRC);
return fullRC - sanityRootRC;
}
return SanityChecker.ALIVE;
}
/**
* Register specialized methods.
*/
@Interruptible
protected void registerSpecializedMethods() {
super.registerSpecializedMethods();
}
}