/*
* 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.semispace.gcspy;
import org.mmtk.plan.GCspyPlan;
import org.mmtk.plan.Phase;
import org.mmtk.plan.TransitiveClosure;
import org.mmtk.plan.semispace.SS;
import org.mmtk.policy.CopySpace;
import org.mmtk.policy.LargeObjectSpace;
import org.mmtk.utility.gcspy.drivers.AbstractDriver;
import org.mmtk.utility.gcspy.drivers.LinearSpaceDriver;
import org.mmtk.utility.gcspy.drivers.ImmortalSpaceDriver;
import org.mmtk.utility.gcspy.drivers.TreadmillDriver;
import org.mmtk.utility.gcspy.GCspy;
import org.mmtk.utility.Log;
import org.mmtk.utility.options.Options;
import org.vmmagic.pragma.*;
/**
* This class extends a simple semi-space collector to instrument it for
* GCspy. <p>
*
* See the Jones & Lins GC book, section 2.2 for an overview of the basic
* algorithm. This implementation also includes a large object space
* (LOS), and an uncollected "immortal" space.<p>
*
* All plans make a clear distinction between <i>global</i> and
* <i>thread-local</i> activities. Global activities must be
* synchronized, whereas no synchronization is required for
* thread-local activities. Instances of Plan map 1:1 to "kernel
* threads" (aka CPUs). Thus instance
* methods allow fast, unsychronized access to Plan utilities such as
* allocation and collection. Each instance rests on static resources
* (such as memory and virtual memory resources) which are "global"
* and therefore "static" members of Plan. This mapping of threads to
* instances is crucial to understanding the correctness and
* performance proprties of this plan.
*
* FIXME This seems to have changed
* The order of phases and GCspy actions is important here. It is:
* PREPARE phase
* SSGCspyMutator.gcspyGatherData(SSGCspy.BEFORE_COLLECTION); // safepoint
* SSMutator.PREPARE // FIXME DOES NOT ss.rebind(SS.toSpace());
*
* PREPARE phase
* SS.PREPARE // flip semispaces
* gcspySpace.prepare();
* SSGCspyCollector.gcspyGatherData(SSGCspy.BEFORE_COLLECTION);
* SSCollector.PREPARE // ss.rebind(SS.toSpace());
*
*
* FORWARD_FINALIZABLE phase
* SSCollector.FORWARD_FINALIZABLE
* SSGCspyCollector.gcspyGatherData(SSGCspy.SEMISPACE_COPIED);
*
* RELEASE phase
* SSGCspyMutator.gcspyGatherData(SSGCspy.SEMISPACE_COPIED); // safepoint
* SSMutator.RELEASE // FIXME ss.rebind(SS.toSpace());
* SSGCspyMutator.gcspyGatherData(SSGCspy.AFTER_COLLECTION);
*
* RELEASE phase
* SSCollector.RELEASE
* SSGCspyCollector.gcspyGatherData(SSGCspy.AFTER_COLLECTION);
* SS.RELEASE
* gcspySpace.release();
* SSGCspy.gcspyGatherData(); // safepoint
*
* Note that SSMutator has changed the point at which it rebinds toSpace
* from PREPARE (2.4.6) to after RELEASE (3.x.x).
*
--Phase Collector.initiate
--Phase Mutator.initiate-mutator
--Phase Mutator.prepare-mutator
SSGCspyMutator.gcspyGatherData, event=0
--Phase Plan.prepare
--Phase Collector.prepare
SSGCspyCollector.gcspyGatherData, event=0
--Phase Collector.precopy
--Phase Collector.bootimage-root
--Phase Collector.root
--Phase Plan.root
--Phase Collector.start-closure
--Phase Collector.soft-ref
--Phase Collector.complete-closure
--Phase Collector.weak-ref
--Phase Collector.finalize
--Phase Collector.complete-closure
--Phase Collector.phantom-ref
--Phase Collector.forward-ref
--Phase Collector.forward-finalize
SSGCspyCollector.gcspyGatherData, event=1
--Phase Mutator.release-mutator
SSGCspyMutator.gcspyGatherData, event=1
SSGCspyMutator.gcspyGatherData, event=2
--Phase Collector.release
SSGCspyCollector.gcspyGatherData, event=2
--Phase Plan.release
SSGCspy.gcspyGatherData, event=2
--Phase Collector.complete
--Phase Plan.complete
*/
@Uninterruptible public class SSGCspy extends SS implements GCspyPlan {
/****************************************************************************
*
* Class variables
*/
// The events, BEFORE_COLLECTION, SEMISPACE_COPIED or AFTER_COLLECTION
/**
* Before a collection has started,
* i.e. before SS.collectionPhase(SS.PREPARE,..).
*/
static final int BEFORE_COLLECTION = 0;
/**
* After the semispace has been copied and the large object space has been traced
* At this time the Large Object Space has not been swept.
*/
static final int SEMISPACE_COPIED = BEFORE_COLLECTION + 1;
/**
* The collection is complete,
* i.e. immediately after SS.collectionPhase(SS.RELEASE,..).
* The Large Object Space has been swept.
*/
static final int AFTER_COLLECTION = SEMISPACE_COPIED + 1;
static int gcspyEvent_ = BEFORE_COLLECTION;
// The specific drivers for this collector
static LinearSpaceDriver ss0Driver;
static LinearSpaceDriver ss1Driver;
static ImmortalSpaceDriver immortalDriver;
static TreadmillDriver losNurseryDriver;
static TreadmillDriver losDriver;
static TreadmillDriver plosNurseryDriver;
static TreadmillDriver plosDriver;
private static final boolean DEBUG = false;
static {
GCspy.createOptions();
}
/**
* Start the server and wait if necessary.
* This method has the following responsibilities.
* <ol>
* <li> Create and initialise the GCspy server by calling.
* <pre>server = ServerInterpreter.init(name, portNumber, verbose);</pre>
* <li> Add each event to the ServerInterpreter
* <pre>server.addEvent(eventID, eventName);</pre>
* <li> Set some general information about the server (e.g. name of the collector, build, etc).
* <pre>server.setGeneralInfo(info); </pre>
* <li> Create new drivers for each component to be visualised.
* <pre>myDriver = new MyDriver(server, args...);</pre>
* Drivers extend AbstractDriver and register their spce with the
* ServerInterpreter. In addition to the server, drivers will take as
* arguments the name of the space, the MMTk space, the tilesize, and
* whether this space is to be the main space in the visualiser.
* </ol>
*
* WARNING: allocates memory.
* @param wait Whether to wait
* @param port The port to talk to the GCspy client (e.g. visualiser)
*/
@Interruptible
public final void startGCspyServer(int port, boolean wait) {
GCspy.server.init("SemiSpaceServerInterpreter", port, true/*verbose*/);
if (DEBUG) Log.writeln("SSGCspy: ServerInterpreter initialised");
GCspy.server.addEvent(BEFORE_COLLECTION, "Before collection");
GCspy.server.addEvent(SEMISPACE_COPIED, "Semispace copied; LOS traced");
GCspy.server.addEvent(AFTER_COLLECTION, "After collection; LOS swept");
GCspy.server.setGeneralInfo(
"SSGCspy\n\nRichard Jones, October 2006\\http://www.cs.kent.ac.uk/~rej/");
if (DEBUG) Log.writeln("SSGCspy: events added to ServerInterpreter");
// Initialise each driver
ss0Driver = newLinearSpaceDriver("Semispace 0 Space", copySpace0, true);
ss1Driver = newLinearSpaceDriver("Semispace 1 Space", copySpace1, false);
immortalDriver = new ImmortalSpaceDriver(
GCspy.server, "Immortal Space", immortalSpace,
Options.gcspyTileSize.getValue(), false);
losNurseryDriver = newTreadmillDriver("LOS Nursery", loSpace);
losDriver = newTreadmillDriver("LOS", loSpace);
if (DEBUG) Log.write("SemiServerInterpreter initialised\n");
// Register drivers to allow immortal space to notify direct references
immortalDriver.registerDriversForReferenceNotification(
new AbstractDriver[] {ss0Driver, ss1Driver, immortalDriver,
losNurseryDriver, losDriver,
plosNurseryDriver, plosDriver});
if (DEBUG) Log.writeln("SSGCspy: registered drivers");
gcspyEvent_ = BEFORE_COLLECTION;
// Start the server
GCspy.server.startServer(wait);
}
/**
* Create a new LinearSpaceDriver
* TODO is this the best name or should we call it LargeObjectSpaceDriver?
* @param name Name of the space
* @param space The space
* @return A new GCspy driver for this space
*/
@Interruptible
private LinearSpaceDriver newLinearSpaceDriver(String name, CopySpace space, boolean mainSpace) {
// TODO What if tileSize is too small (i.e. too many tiles for GCspy buffer)
// TODO stop the GCspy spaces in the visualiser from fluctuating in size
// so much as we resize them.
return new LinearSpaceDriver(GCspy.server, name, space,
Options.gcspyTileSize.getValue(), mainSpace);
}
/**
* Create a new TreadmillDriver
* TODO is this the best name or should we call it LargeObjectSpaceDriver?
* @param name Name of the space
* @param space The space
* @return A new GCspy driver for this space
*/
@Interruptible
private TreadmillDriver newTreadmillDriver(String name, LargeObjectSpace space) {
return new TreadmillDriver(GCspy.server, name, space,
Options.gcspyTileSize.getValue(), MAX_NON_LOS_COPY_BYTES, false);
}
/****************************************************************************
*
* Collection
*/
/**
* Perform a (global) collection phase.
*
* @param phaseId Collection phase
*/
@Inline
public void collectionPhase(short phaseId) {
if (DEBUG) { Log.write("--Phase Plan."); Log.writeln(Phase.getName(phaseId)); }
if (phaseId == SSGCspy.PREPARE) {
super.collectionPhase(phaseId);
gcspySpace.prepare();
return;
}
if (phaseId == SSGCspy.RELEASE) {
super.collectionPhase(phaseId);
gcspySpace.release();
//if (primary)
gcspyGatherData(SSGCspy.AFTER_COLLECTION);
return;
}
super.collectionPhase(phaseId);
}
/**
* Gather data for GCspy for the semispaces, the immortal space and the large
* object space.
* <p>
* This method sweeps the semispace under consideration to gather data.
* Alternatively and more efficiently, 'used space' can obviously be
* discovered in constant time simply by comparing the start and the end
* addresses of the semispace. However, per-object information can only be
* gathered by sweeping through the space and we do this here for tutorial
* purposes.
*
* @param event
* The event, either BEFORE_COLLECTION, SEMISPACE_COPIED or
* AFTER_COLLECTION
*/
private void gcspyGatherData(int event) {
if(DEBUG) {
Log.writeln("SSGCspy.gcspyGatherData, event=", event);
Log.writeln("SSGCspy.gcspyGatherData, port=", GCspy.getGCspyPort());
}
// If port = 0 there can be no GCspy client connected
if (GCspy.getGCspyPort() == 0)
return;
// This is a safepoint for the server, i.e. it is a point at which
// the server can pause.
// The Mutator is called after the Collector so the Mutator must set the safepoint
if(DEBUG) Log.writeln("SSGCspy safepoint");
GCspy.server.serverSafepoint(event);
}
/****************************************************************************
*
* Accounting
*/
/**
* Return the number of pages reserved for use given the pending
* allocation. This is <i>exclusive of</i> space reserved for
* copying.
*
* @return The number of pages reserved given the pending
* allocation, excluding space reserved for copying.
*/
public final int getPagesUsed() {
return super.getPagesUsed() + gcspySpace.reservedPages();
}
/**
* Report information on the semispaces
*/
static void reportSpaces() {
Log.write("\n Low semispace: ");
Log.write(SSGCspy.copySpace0.getStart());
Log.write(" - ");
Log.write(SSGCspy.copySpace0.getStart()
.plus(SSGCspy.copySpace0.getExtent()));
Log.write("\n High semispace: ");
Log.write(SSGCspy.copySpace1.getStart());
Log.write(" - ");
Log.write(SSGCspy.copySpace1.getStart()
.plus(SSGCspy.copySpace1.getExtent()));
Log.flush();
}
/**
* Register specialized methods.
*/
@Interruptible
protected void registerSpecializedMethods() {
super.registerSpecializedMethods();
TransitiveClosure.registerSpecializedScan(SCAN_SS, SSGCspyTraceLocal.class);
}
}