/*
* 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.vm;
import org.mmtk.utility.options.Options;
import org.mmtk.utility.gcspy.Color;
import org.mmtk.utility.gcspy.drivers.AbstractDriver;
import org.mmtk.vm.gcspy.ByteStream;
import org.mmtk.vm.gcspy.IntStream;
import org.mmtk.vm.gcspy.ServerInterpreter;
import org.mmtk.vm.gcspy.ServerSpace;
import org.mmtk.vm.gcspy.ShortStream;
import org.mmtk.vm.gcspy.Util;
import org.vmmagic.pragma.Untraced;
import org.vmmagic.unboxed.Address;
import org.vmmagic.unboxed.Offset;
/**
* This class is responsible for all VM-specific functionality required
* by MMTk.<p>
*
* The class has three major elements. First it defines VM-specific
* constants which are used throughout MMTk, second, it declares
* singleton instances of each of the abstract classes in this
* package, and third, it provides factory methods for VM-specific
* instances which are needed by MMTk (such as <code>Lock</code>).<p>
*
* Both the constants and the singleton instances are initialized to
* VM-specific values at build time using reflection and a VM-specific
* factory class. The system property <code>mmtk.hostjvm</code> is
* interrogated at build time to establish concrete instantations of
* the abstract classes in this package. By <b>convention</b>,
* <code>mmtk.hostjvm</code> will identify a VM-provided package which
* includes concrete instances of each of the abstract classes, with
* each concrete class having the same base class name (but different
* package name) as the abstract classes defined here. The class
* initializer for this class then uses the system property
* <code>mmtk.hostjvm</code> to load the VM-specific concrete classes
* and initialize the constants and singletons defined here.
*/
public final class VM {
/*
* VM-specific constant values
*/
/** <code>true</code> if assertions should be verified */
public static final boolean VERIFY_ASSERTIONS;
/** The lowest address in virtual memory known to MMTk */
public static final Address HEAP_START;
/** The highest address in virtual memory known to MMTk */
public static final Address HEAP_END;
/** The lowest address in the contiguously available memory available to MMTk */
public static final Address AVAILABLE_START;
/** The highest address in the contiguously available memory available to MMTk */
public static final Address AVAILABLE_END;
/** The log base two of the size of an address */
public static final byte LOG_BYTES_IN_ADDRESS;
/** The log base two of the size of a word */
public static final byte LOG_BYTES_IN_WORD;
/** The log base two of the size of an OS page */
public static final byte LOG_BYTES_IN_PAGE;
/** The log base two of the minimum allocation alignment */
public static final byte LOG_MIN_ALIGNMENT;
/** The log base two of (MAX_ALIGNMENT/MIN_ALIGNMENT) */
public static final byte MAX_ALIGNMENT_SHIFT;
/** The maximum number of bytes of padding to prepend to an object */
public static final int MAX_BYTES_PADDING;
/** The value to store in alignment holes */
public static final int ALIGNMENT_VALUE;
/** The offset from an array reference to element zero */
public static final Offset ARRAY_BASE_OFFSET;
/** Global debugging switch */
public static final boolean DEBUG;
/*
* VM-specific functionality captured in a series of singleton classs
*/
@Untraced
public static final ActivePlan activePlan;
@Untraced
public static final Assert assertions;
@Untraced
public static final Barriers barriers;
@Untraced
public static final Collection collection;
@Untraced
public static final Config config;
@Untraced
public static final Memory memory;
@Untraced
public static final ObjectModel objectModel;
@Untraced
public static final ReferenceProcessor weakReferences;
@Untraced
public static final ReferenceProcessor softReferences;
@Untraced
public static final ReferenceProcessor phantomReferences;
@Untraced
public static final FinalizableProcessor finalizableProcessor;
@Untraced
public static final Scanning scanning;
@Untraced
public static final Statistics statistics;
@Untraced
public static final Strings strings;
@Untraced
public static final TraceInterface traceInterface;
@Untraced
public static final MMTk_Events events;
@Untraced
public static final Debug debugging;
@Untraced
public static final GPU gpu;
/*
* The remainder is does the static initialization of the
* above, reflectively binding to the appropriate host jvm
* classes.
*/
private static final Factory factory;
private static final String vmFactory;
/**
* This class initializer establishes a VM-specific factory class
* using reflection, and then uses that to create VM-specific concrete
* instances of all of the vm classes, initializing the singltons in
* this class. Finally the constants declared in this class are
* initialized using the VM-specific singletons.
*/
static {
/* Identify the VM-specific factory using reflection */
vmFactory = System.getProperty("mmtk.hostjvm");
Factory xfa = null;
try {
xfa = (Factory) Class.forName(vmFactory).newInstance();
} catch (Exception e) {
e.printStackTrace();
System.exit(-1); // we must *not* go on if the above has failed
}
factory = xfa;
/* Now instantiate the singletons using the factory */
activePlan = factory.newActivePlan();
assertions = factory.newAssert();
barriers = factory.newBarriers();
collection = factory.newCollection();
memory = factory.newMemory();
objectModel = factory.newObjectModel();
Options.set = factory.getOptionSet();
weakReferences = factory.newReferenceProcessor(ReferenceProcessor.Semantics.WEAK);
softReferences = factory.newReferenceProcessor(ReferenceProcessor.Semantics.SOFT);
phantomReferences = factory.newReferenceProcessor(ReferenceProcessor.Semantics.PHANTOM);
finalizableProcessor = factory.newFinalizableProcessor();
scanning = factory.newScanning();
statistics = factory.newStatistics();
strings = factory.newStrings();
traceInterface = factory.newTraceInterface();
events = factory.newEvents();
debugging = factory.newDebug();
config = new Config(factory.newBuildTimeConfig());
gpu = factory.newGPU();
/* Now initialize the constants using the vm-specific singletons */
VERIFY_ASSERTIONS = Assert.verifyAssertionsTrapdoor(assertions);
HEAP_START = Memory.heapStartTrapdoor(memory);
HEAP_END = Memory.heapEndTrapdoor(memory);
AVAILABLE_START = Memory.availableStartTrapdoor(memory);
AVAILABLE_END = Memory.availableEndTrapdoor(memory);
LOG_BYTES_IN_ADDRESS = Memory.logBytesInAddressTrapdoor(memory);
LOG_BYTES_IN_WORD = Memory.logBytesInWordTrapdoor(memory);
LOG_BYTES_IN_PAGE = Memory.logBytesInPageTrapdoor(memory);
LOG_MIN_ALIGNMENT = Memory.logMinAlignmentTrapdoor(memory);
MAX_ALIGNMENT_SHIFT = Memory.maxAlignmentShiftTrapdoor(memory);
MAX_BYTES_PADDING = Memory.maxBytesPaddingTrapdoor(memory);
ALIGNMENT_VALUE = Memory.alignmentValueTrapdoor(memory);
ARRAY_BASE_OFFSET = ObjectModel.arrayBaseOffsetTrapdoor(objectModel);
DEBUG = Debug.isEnabledTrapdoor(debugging);
}
/**
* Create a new Lock instance using the appropriate VM-specific
* concrete Lock sub-class.
*
* @see Lock
*
* @param name The string to be associated with this lock instance
* @return A concrete VM-specific Lock instance.
*/
public static Lock newLock(String name) {
return factory.newLock(name);
}
/**
* Create a new SynchronizedCounter instance using the appropriate
* VM-specific concrete SynchronizedCounter sub-class.
*
* @see SynchronizedCounter
*
* @return A concrete VM-specific SynchronizedCounter instance.
*/
public static SynchronizedCounter newSynchronizedCounter() {
return factory.newSynchronizedCounter();
}
/**********************************************************************
* GCspy methods
*/
/**
* Create a new Util instance using the appropriate
* VM-specific concrete Util sub-class.
*
* @see Util
*
* @return A concrete VM-specific Util instance.
*/
public static Util newGCspyUtil() {
return factory.newGCspyUtil();
}
/**
* Create a new ServerInterpreter instance using the appropriate
* VM-specific concrete ServerInterpreter sub-class.
*
* @see ServerInterpreter
*
* @return A concrete VM-specific ServerInterpreter instance.
*/
public static ServerInterpreter newGCspyServerInterpreter() {
return factory.newGCspyServerInterpreter();
}
/**
* Create a new ServerInterpreter instance using the appropriate
* VM-specific concrete ServerInterpreter sub-class.
*
* @see ServerInterpreter
*
* @return A concrete VM-specific ServerInterpreter instance.
*/
public static ServerSpace newGCspyServerSpace(
ServerInterpreter serverInterpreter,
String serverName,
String driverName,
String title,
String blockInfo,
int tileNum,
String unused,
boolean mainSpace) {
return factory.newGCspyServerSpace(serverInterpreter, serverName, driverName,
title, blockInfo, tileNum, unused,
mainSpace);
}
/**
* Create a new ByteStream instance using the appropriate
* VM-specific concrete ByteStream sub-class.
*
* @param driver The driver that owns this Stream
* @param name The name of the stream (e.g. "Used space")
* @param minValue The minimum value for any item in this stream.
* Values less than this will be represented as "minValue-"
* @param maxValue The maximum value for any item in this stream.
* Values greater than this will be represented as "maxValue+"
* @param zeroValue The zero value for this stream
* @param defaultValue The default value for this stream
* @param stringPre A string to prefix values (e.g. "Used: ")
* @param stringPost A string to suffix values (e.g. " bytes.")
* @param presentation How a stream value is to be presented.
* @param paintStyle How the value is to be painted.
* @param indexMaxStream The index of the maximum stream if the presentation is *_VAR.
* @param colour The default colour for tiles of this stream
* @see IntStream
*
* @return A concrete VM-specific ByteStream instance.
*/
public static ByteStream newGCspyByteStream(
AbstractDriver driver,
String name,
byte minValue,
byte maxValue,
byte zeroValue,
byte defaultValue,
String stringPre,
String stringPost,
int presentation,
int paintStyle,
int indexMaxStream,
Color colour,
boolean summary) {
return factory.newGCspyByteStream(driver, name, minValue, maxValue,
zeroValue, defaultValue, stringPre, stringPost,
presentation, paintStyle, indexMaxStream,
colour, summary);
}
/**
* Create a new IntStream instance using the appropriate
* VM-specific concrete IntStream sub-class.
*
* @param driver The driver that owns this Stream
* @param name The name of the stream (e.g. "Used space")
* @param minValue The minimum value for any item in this stream.
* Values less than this will be represented as "minValue-"
* @param maxValue The maximum value for any item in this stream.
* Values greater than this will be represented as "maxValue+"
* @param zeroValue The zero value for this stream
* @param defaultValue The default value for this stream
* @param stringPre A string to prefix values (e.g. "Used: ")
* @param stringPost A string to suffix values (e.g. " bytes.")
* @param presentation How a stream value is to be presented.
* @param paintStyle How the value is to be painted.
* @param indexMaxStream The index of the maximum stream if the presentation is *_VAR.
* @param colour The default colour for tiles of this stream
* @see IntStream
*
* @return A concrete VM-specific IntStream instance.
*/
public static IntStream newGCspyIntStream(
AbstractDriver driver,
String name,
int minValue,
int maxValue,
int zeroValue,
int defaultValue,
String stringPre,
String stringPost,
int presentation,
int paintStyle,
int indexMaxStream,
Color colour,
boolean summary) {
return factory.newGCspyIntStream(driver, name, minValue, maxValue,
zeroValue, defaultValue, stringPre, stringPost,
presentation, paintStyle, indexMaxStream,
colour, summary);
}
/**
* Create a new ShortStream instance using the appropriate
* VM-specific concrete ShortStream sub-class.
*
* @param driver The driver that owns this Stream
* @param name The name of the stream (e.g. "Used space")
* @param minValue The minimum value for any item in this stream.
* Values less than this will be represented as "minValue-"
* @param maxValue The maximum value for any item in this stream.
* Values greater than this will be represented as "maxValue+"
* @param zeroValue The zero value for this stream
* @param defaultValue The default value for this stream
* @param stringPre A string to prefix values (e.g. "Used: ")
* @param stringPost A string to suffix values (e.g. " bytes.")
* @param presentation How a stream value is to be presented.
* @param paintStyle How the value is to be painted.
* @param indexMaxStream The index of the maximum stream if the presentation is *_VAR.
* @param colour The default colour for tiles of this stream
* @see IntStream
*
* @return A concrete VM-specific IntStream instance.
*/
public static ShortStream newGCspyShortStream(
AbstractDriver driver,
String name,
short minValue,
short maxValue,
short zeroValue,
short defaultValue,
String stringPre,
String stringPost,
int presentation,
int paintStyle,
int indexMaxStream,
Color colour,
boolean summary) {
return factory.newGCspyShortStream(driver, name, minValue, maxValue,
zeroValue, defaultValue, stringPre, stringPost,
presentation, paintStyle, indexMaxStream,
colour, summary);
}
}