/*
* 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.stickyimmix;
import org.mmtk.plan.TransitiveClosure;
import org.mmtk.plan.immix.Immix;
import org.mmtk.utility.Log;
import org.mmtk.utility.deque.SharedDeque;
import org.mmtk.utility.options.Options;
import org.mmtk.utility.statistics.BooleanCounter;
import org.mmtk.utility.statistics.Stats;
import org.mmtk.vm.Collection;
import org.vmmagic.pragma.*;
/**
* This class implements the global state of a simple sticky mark bits collector,
* based on an immix collector. The sticky mark bits algorithm is
* due to Demmers et al. (http://doi.acm.org/10.1145/96709.96735), and allows
* generational collection to be performed in a non-moving heap by overloading
* the role of mark bits to also indicate whether an object is new (nursery) or
* not. Thus nursery objects are identified by a bit in their header, not by
* where they lie within the address space. While Demmers et al. did their work
* in a conservative collector, here we have an exact collector, so we can use
* a regular write barrier, and don't need to use page protection etc.
*
* See the PLDI'08 paper by Blackburn and McKinley for a description
* of the algorithm: http://doi.acm.org/10.1145/1375581.1375586
*
* All plans make a clear distinction between <i>global</i> and
* <i>thread-local</i> activities, and divides global and local state
* into separate class hierarchies. Global activities must be
* synchronized, whereas no synchronization is required for
* thread-local activities. There is a single instance of Plan (or the
* appropriate sub-class), and a 1:1 mapping of PlanLocal to "kernel
* threads" (aka CPUs or in Jikes RVM, Processors). Thus instance
* methods of PlanLocal allow fast, unsychronized access to functions such as
* allocation and collection.
*
* The global instance defines and manages static resources
* (such as memory and virtual memory resources). This mapping of threads to
* instances is crucial to understanding the correctness and
* performance properties of MMTk plans.
*/
@Uninterruptible
public class StickyImmix extends Immix {
/****************************************************************************
* Constants
*/
/** If true, then new PLOS objects are collected at each nursery GC */
static final boolean NURSERY_COLLECT_PLOS = true;
/** If true then we only do full heap GCs---so we're like MarkSweep (+ write barrier) */
static final boolean MAJOR_GC_ONLY = false;
/** estimated collection yield */
protected static final float SURVIVAL_ESTIMATE = (float) 0.8;
public static int SCAN_NURSERY = 2;
/****************************************************************************
* Class variables
*/
private static int lastCommittedImmixPages = 0;
/* statistics */
public static BooleanCounter fullHeap = new BooleanCounter("majorGC", true, true);
/****************************************************************************
* Instance variables
*/
/* Remset pool */
public final SharedDeque modPool = new SharedDeque("msgen mod objects", metaDataSpace, 1);
/**
* Constructor.
*
*/
public StickyImmix() {
collectWholeHeap = nextGCWholeHeap = false;
}
/*****************************************************************************
*
* Collection
*/
/**
* A user-triggered GC has been initiated.
*/
public void userTriggeredGC() {
nextGCWholeHeap |= Options.fullHeapSystemGC.getValue();
}
/**
* Force the next collection to be full heap.
*/
@Override
public void forceFullHeapCollection() {
nextGCWholeHeap = true;
}
/**
* Perform a (global) collection phase.
*
* @param phaseId Collection phase to execute.
*/
@Inline
@Override
public final void collectionPhase(short phaseId) {
if (phaseId == SET_COLLECTION_KIND) {
collectWholeHeap = requiresFullHeapCollection();
if (Stats.gatheringStats() && collectWholeHeap) fullHeap.set();
super.collectionPhase(phaseId);
return;
}
if (!collectWholeHeap && phaseId == PREPARE) {
immixTrace.prepare();
immixSpace.prepare(false);
return;
}
if (phaseId == RELEASE) {
if (collectWholeHeap) {
super.collectionPhase(RELEASE);
} else {
immixTrace.release();
lastGCWasDefrag = immixSpace.release(false);
}
modPool.reset();
lastCommittedImmixPages = immixSpace.committedPages();
nextGCWholeHeap = (getPagesAvail() < Options.nurserySize.getMinNursery());
return;
}
super.collectionPhase(phaseId);
}
/*****************************************************************************
*
* Accounting
*/
/**
* This method controls the triggering of a GC. It is called periodically
* during allocation. Returns true to trigger a collection.
*
* @param spaceFull Space request failed, must recover pages within 'space'.
* @return True if a collection is requested by the plan.
*/
public final boolean collectionRequired(boolean spaceFull) {
boolean nurseryFull = immixSpace.getPagesAllocated() > Options.nurserySize.getMaxNursery();
return super.collectionRequired(spaceFull) || nurseryFull;
}
/**
* Determine whether this GC should be a full heap collection.
*
* @return True if this GC should be a full heap collection.
*/
protected boolean requiresFullHeapCollection() {
if (collectionTrigger == Collection.EXTERNAL_GC_TRIGGER && Options.fullHeapSystemGC.getValue()) {
return true;
}
if (nextGCWholeHeap || collectionAttempt > 1) {
// Forces full heap collection
return true;
}
if (loSpace.allocationFailed()) {
// We need space from the nursery
return true;
}
// Estimate the yield from small nursery pages
int smallNurseryPages = immixSpace.committedPages() - lastCommittedImmixPages;
int smallNurseryYield = (int)(smallNurseryPages * SURVIVAL_ESTIMATE);
if (smallNurseryYield < getPagesRequired()) {
// Our total yield is insufficient.
return true;
}
if (immixSpace.allocationFailed()) {
if (smallNurseryYield < immixSpace.requiredPages()) {
// We have run out of VM pages in the nursery
return true;
}
}
return false;
}
/**
* Print pre-collection statistics. In this class we prefix the output
* indicating whether the collection was full heap or not.
*/
@Override
public void printPreStats() {
if ((Options.verbose.getValue() >= 1) && (collectWholeHeap))
Log.write("[Full heap]");
super.printPreStats();
}
/**
* @return Is current GC only collecting objects allocated since last GC.
*/
public final boolean isCurrentGCNursery() {
return !collectWholeHeap;
}
/**
* @return Is last GC a full collection?
*/
public final boolean isLastGCFull() {
return collectWholeHeap;
}
/**
* Register specialized methods.
*/
@Interruptible
protected void registerSpecializedMethods() {
TransitiveClosure.registerSpecializedScan(SCAN_NURSERY, StickyImmixNurseryTraceLocal.class);
super.registerSpecializedMethods();
}
}