|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||
| Uses of Interruptible in com.ibm.tuningfork.tracegen.chunk |
|---|
| Methods in com.ibm.tuningfork.tracegen.chunk with annotations of type Interruptible | |
|---|---|
boolean |
EventTypeChunk.add(EventType et)
|
boolean |
FeedletChunk.add(int feedletIndex,
String name,
String description)
|
boolean |
FeedletChunk.addProperty(int feedletIndex,
String key,
String val)
|
protected char[] |
Chunk.getChars(String s)
|
void |
RawChunk.write(OutputStream outputStream)
|
| Uses of Interruptible in com.ibm.tuningfork.tracegen.types |
|---|
| Methods in com.ibm.tuningfork.tracegen.types with annotations of type Interruptible | |
|---|---|
private void |
EventType.checkOrder(int others)
Check that attributes are declared in the proper order |
private static int |
EventType.getNextIndex()
|
| Uses of Interruptible in org.jikesrvm |
|---|
| Methods in org.jikesrvm with annotations of type Interruptible | |
|---|---|
static String |
VM.addressAsHexString(Address addr)
Format a 32/64 bit number as "0x" followed by 8/16 hex digits. |
private static void |
VM.finishBooting()
Complete the task of booting Jikes RVM. |
static String |
Services.getHexString(int i,
boolean blank)
Utility printing function. |
private static void |
VM.init(String bootstrapClasspath,
String[] bootCompilerArgs)
Create class instances needed for boot image or initialize classes needed by tools. |
static void |
VM.initForBootImageWriter(String classPath,
String[] bootCompilerArgs)
Prepare VM classes for use by boot image writer. |
static void |
VM.initForTool()
Prepare VM classes for use by tools. |
static void |
VM.initForTool(String classpath)
Prepare VM classes for use by tools. |
static String |
VM.intAsHexString(int number)
Format a 32 bit number as "0x" followed by 8 hex digits. |
static String |
VM.longAsHexString(long number)
Format a 64 bit number as "0x" followed by 16 hex digits. |
private static void |
VM.pleaseSpecifyAClass()
|
static void |
Options.printHelp()
|
static void |
Options.printOptions()
|
static boolean |
Options.process(String arg)
Take a string (most likely a command-line argument) and try to proccess it as an option command. |
(package private) static void |
VM.runClassInitializer(String className)
Run <clinit> method of specified class, if that class appears
in bootimage and actually has a clinit method (we are flexible to
allow one list of classes to work with different bootimages and
different version of classpath (eg 0.05 vs. cvs head). |
| Uses of Interruptible in org.jikesrvm.adaptive.measurements.listeners |
|---|
| Methods in org.jikesrvm.adaptive.measurements.listeners with annotations of type Interruptible | |
|---|---|
abstract void |
Listener.report()
Entry point to dump what has been collected. |
| Uses of Interruptible in org.jikesrvm.classloader |
|---|
| Methods in org.jikesrvm.classloader with annotations of type Interruptible | |
|---|---|
static boolean |
TypeDescriptorParsing.isJavaClassName(String s)
Is the string s a legal name for a Java class or interface? |
static void |
TypeDescriptorParsing.validateAsTypeDescriptor(Atom a)
|
static void |
TypeDescriptorParsing.validateAsTypeDescriptor(String s)
Validate that the String @param s is a valid type descriptor. |
| Uses of Interruptible in org.jikesrvm.compilers.baseline |
|---|
| Methods in org.jikesrvm.compilers.baseline with annotations of type Interruptible | |
|---|---|
private int |
ReferenceMaps.addUnusualMap(UnusualMaps jsrSiteMap)
Add an UnusualMap to the array of unusual maps, expand the array and referencemap array if necessary |
private int |
ReferenceMaps.getNextMapElement()
get Next free word in referencemaps for GC call sites |
void |
ReferenceMaps.recordJSRSubroutineMap(int byteindex,
byte[] currReferenceMap,
int BBLastPtr,
int returnAddrIndex,
boolean replacemap)
Record a map for a point within a JSR Subroutine. |
void |
ReferenceMaps.recordStkMap(int byteindex,
byte[] byteMap,
int BBLastPtr,
boolean replacemap)
Given the information about a GC point, record the information in the proper tables. |
(package private) int |
ReferenceMaps.scanByteArray(byte[] byteMap,
int BBLastPtr,
byte refType,
int mapslot,
boolean skipOneBit)
Scans the byte array to look for the type of information that was requested. |
int |
ReferenceMaps.showReferenceMapStatistics(RVMMethod method)
|
int |
ReferenceMaps.size()
|
void |
ReferenceMaps.startNewMaps(int gcPointCount,
int jsrCount,
int parameterWords)
start setting up the reference maps for this method. |
| Uses of Interruptible in org.jikesrvm.compilers.common |
|---|
| Methods in org.jikesrvm.compilers.common with annotations of type Interruptible | |
|---|---|
abstract boolean |
CompiledMethod.isWithinUninterruptibleCode(Offset instructionOffset)
Return whether or not the given address (which is purported to be inside of the compiled method's code array) corresponds to an uninterruptible context. |
| Uses of Interruptible in org.jikesrvm.compilers.opt.bc2ir |
|---|
| Methods in org.jikesrvm.compilers.opt.bc2ir with annotations of type Interruptible | |
|---|---|
private static boolean |
GenerateMagic.isPrefix(Atom prefix,
byte[] b)
Is string a a prefix of string
b. |
| Uses of Interruptible in org.jikesrvm.compilers.opt.runtimesupport |
|---|
| Methods in org.jikesrvm.compilers.opt.runtimesupport with annotations of type Interruptible | |
|---|---|
private void |
OptGCMap.addAllSpills(int[] spillArray)
If we will be looking for missed references we need to sort the list of spills and then add them to the map, otherwise, nothing to do |
private void |
OptGCMap.addSpillLocation(int spill)
Adds the passed spill value to the current map |
void |
OptCompiledMethod.applyCodePatches(CompiledMethod cm)
Apply the code patches to the INSTRUCTION array of cm |
void |
OptCompiledMethod.createCodePatchMaps(IR ir)
Create the code patching maps from the IR for the method |
void |
OptCompiledMethod.createFinalExceptionTable(IR ir)
Create the final exception table from the IR for the method. |
void |
OptCompiledMethod.createFinalMCMap(IR ir,
int machineCodeLength)
Create the final machine code map for the compiled method. |
void |
OptCompiledMethod.createFinalOSRMap(IR ir)
|
static void |
OptGCMap.dumpMap(int entry,
int[] gcMap)
Dumps the GCmap that starts at entry. |
private int |
OptGCMap.endCurrentMap(int firstIndex)
Ends the current map |
int[] |
OptGCMap.finish()
Called to complete the encoding and return the final int[] |
int |
OptGCMap.generateGCMapEntry(GCIRMapElement irMapElem)
Construct the GCMap for the argument GCIRMapElement |
static int[] |
OptEncodedCallSiteTree.getEncoding(CallSiteTree tree)
|
(package private) static int |
OptEncodedCallSiteTree.getEncoding(CallSiteTreeNode current,
int offset,
int parent,
int[] encoding)
|
private int |
OptGCMap.getNextMapEntry()
Returns the next GC map entry for use |
boolean |
OptCompiledMethod.isWithinUninterruptibleCode(Offset instructionOffset)
|
void |
OptCompiledMethod.printExceptionTable()
Print the eTable |
void |
OptCompiledMethod.printStackTrace(Offset instructionOffset,
PrintLN out)
|
private void |
OptGCMap.resizeMapInformation(int newSize)
Resize the map array |
static void |
OptSaveVolatile.resolve()
Wrapper to save/restore volatile registers when a class needs to be dynamically loaded/resolved/etc. |
void |
OptCompiledMethod.set(StackBrowser browser,
Offset instr)
|
private int |
OptGCMap.setRegisterBitMap(int bitMap)
Sets the register map information at the next available entry |
int |
OptCompiledMethod.size()
|
boolean |
OptCompiledMethod.up(StackBrowser browser)
|
| Uses of Interruptible in org.jikesrvm.ia32 |
|---|
| Methods in org.jikesrvm.ia32 with annotations of type Interruptible | |
|---|---|
void |
MachineSpecificIA.baselineEmitLoadTIB(ArchitectureSpecific.Assembler asm,
int dest,
int object,
Offset tibOffset)
|
| Uses of Interruptible in org.jikesrvm.mm.mminterface |
|---|
| Methods in org.jikesrvm.mm.mminterface with annotations of type Interruptible | |
|---|---|
static void |
MemoryManager.addFinalizer(Object object)
Adds an object to the list of objects to have their finalize method called when they are reclaimed. |
static void |
MemoryManager.addPhantomReference(PhantomReference<?> obj,
Object referent)
Add a phantom reference to the list of phantom references. |
static void |
MemoryManager.addSoftReference(SoftReference<?> obj,
Object referent)
Add a soft reference to the list of soft references. |
static void |
MemoryManager.addWeakReference(WeakReference<?> obj,
Object referent)
Add a weak reference to the list of weak references. |
static ArchitectureSpecific.CodeArray |
MemoryManager.allocateCode(int numInstrs,
boolean isHot)
Allocate a CodeArray into a code space. |
(package private) static void |
DebugUtil.boot(BootRecord theBootRecord)
|
static void |
MemoryManager.boot(BootRecord theBootRecord)
Initialization that occurs at boot time (runtime initialization). |
static Word |
MemoryManager.bootTimeWriteBarrier(Word value)
Install a reference into the boot image. |
static SpecializedMethod |
MemoryManager.createSpecializedMethod(int id)
Initialize a specified specialized method. |
static void |
MemoryManager.enableCollection()
Allow collection (assumes threads can be created). |
static void |
MemoryManager.fullyBootedVM()
Notify the MM that the host VM is now fully booted. |
static void |
MemoryManager.gc()
External call to force a garbage collection. |
private static int |
SpecializedScanMethod.getPattern(RVMType type)
Get the pattern index for a given type |
static void |
MemoryManager.initializeHeader(BootImageInterface bootImage,
Address ref,
TIB tib,
int size,
boolean isScalar)
Override the boot-time initialization method here, so that the core JMTk code doesn't need to know about the BootImageInterface type. |
private static boolean |
MemoryManager.isPrefix(String a,
byte[] b)
Is string a a prefix of string
b. |
static int[] |
MemoryManager.newContiguousIntArray(int n)
Allocate a contiguous int array |
static IMT |
MemoryManager.newIMT()
Allocate a new interface method table (IMT). |
static ITable |
MemoryManager.newITable(int size)
Allocate a new ITable |
static ITableArray |
MemoryManager.newITableArray(int size)
Allocate a new ITableArray |
static double[] |
MemoryManager.newNonMovingDoubleArray(int size)
Allocate a non moving double array |
static int[] |
MemoryManager.newNonMovingIntArray(int size)
Allocate a non moving int array |
static short[] |
MemoryManager.newNonMovingShortArray(int size)
Allocate a non moving int array |
static WordArray |
MemoryManager.newNonMovingWordArray(int size)
Allocate a non moving word array |
static Object |
MemoryManager.newRuntimeTable(int size,
RVMType type)
Allocate a new runtime table (at runtime) |
static TIB |
MemoryManager.newTIB(int numVirtualMethods,
int alignCode)
Allocate a new type information block (TIB). |
static void |
MemoryManager.notifyClassResolved(RVMType vmType)
A new type has been resolved by the VM. |
static int |
MemoryManager.pickAllocator(RVMType type)
Returns the appropriate allocation scheme/area for the given type. |
static int |
MemoryManager.pickAllocator(RVMType type,
RVMMethod method)
Returns the appropriate allocation scheme/area for the given type and given method requesting the allocation. |
private static int |
MemoryManager.pickAllocatorForType(RVMType type)
Determine the default allocator to be used for a given type. |
static void |
MemoryManager.postBoot()
Perform postBoot operations such as dealing with command line options (this is called as soon as options have been parsed, which is necessarily after the basic allocator boot). |
static void |
MemoryManager.processCommandLineArg(String arg)
Process GC parameters. |
ArchitectureSpecific.CodeArray |
SpecializedScanMethod.specializeMethod(RVMType type)
TODO: Lazily compile specialized methods? |
static void |
MemoryManager.startGCspyServer()
Start the GCspy server |
| Uses of Interruptible in org.jikesrvm.mm.mmtk |
|---|
| Methods in org.jikesrvm.mm.mmtk with annotations of type Interruptible | |
|---|---|
static void |
ReferenceProcessor.addPhantomCandidate(PhantomReference<?> ref,
ObjectReference referent)
Add a reference to the list of phantom references. |
static void |
ReferenceProcessor.addSoftCandidate(SoftReference<?> ref,
ObjectReference referent)
Add a reference to the list of soft references. |
static void |
ReferenceProcessor.addWeakCandidate(WeakReference<?> ref,
ObjectReference referent)
Add a reference to the list of weak references. |
static ReferenceProcessor |
ReferenceProcessor.get(ReferenceProcessor.Semantics semantics)
Factory method. |
ImmortalSpace |
Memory.getVMSpace()
Return the space associated with/reserved for the VM. |
void |
Statistics.perfEventInit(String events)
|
Address |
TraceInterface.skipOwnFramesAndDump(ObjectReference typeRef)
|
void |
Collection.spawnCollectorContext(CollectorContext context)
Spawn a thread to execute the supplied collector context. |
| Uses of Interruptible in org.jikesrvm.mm.mmtk.gcspy |
|---|
| Methods in org.jikesrvm.mm.mmtk.gcspy with annotations of type Interruptible | |
|---|---|
Object |
Util.createDataArray(Object templ,
int numElements)
|
void |
ServerInterpreter.init(String name,
int port,
boolean verbose)
|
| Uses of Interruptible in org.jikesrvm.objectmodel |
|---|
| Methods in org.jikesrvm.objectmodel with annotations of type Interruptible | |
|---|---|
static TIB |
TIB.allocate(int size,
int alignData)
Create a new TIB of the specified size. |
static Address |
ObjectModel.allocateArray(BootImageInterface bootImage,
RVMArray array,
int numElements,
boolean needsIdentityHash,
int identityHashValue,
int alignCode)
Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. |
static Address |
ObjectModel.allocateArray(BootImageInterface bootImage,
RVMArray array,
int numElements,
boolean needsIdentityHash,
int identityHashValue,
int align,
int alignCode)
Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. |
static Address |
ObjectModel.allocateCode(BootImageInterface bootImage,
RVMArray array,
int numElements)
Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. |
static Address |
ObjectModel.allocateScalar(BootImageInterface bootImage,
RVMClass klass,
boolean needsIdentityHash,
int identityHashValue)
Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (scalar) type specified by klass. |
static void |
ObjectModel.baselineEmitLoadTIB(ArchitectureSpecific.Assembler asm,
int dest,
int object)
The following method will emit code that moves a reference to an object's TIB into a destination register. |
static void |
JavaHeader.baselineEmitLoadTIB(ArchitectureSpecific.Assembler asm,
int dest,
int object)
The following method will emit code that moves a reference to an object's TIB into a destination register. |
static int |
ObjectModel.computeHeaderSize(Object ref)
Compute the header size of an object |
static void |
ObjectModel.fillAlignmentGap(BootImageInterface bootImage,
Address address,
Extent size)
Fill an alignment gap with the alignment value |
ArchitectureSpecific.CodeArray |
ITable.getCode(int index)
Gets the code array at the given index. |
IMT |
TIB.getImt()
Get the IMT from the TIB |
RVMClass |
ITable.getInterfaceClass()
|
ITableArray |
TIB.getITableArray()
Get the ITable array for this type. |
static int |
ObjectModel.getObjectHashCode(Object o)
Get the hash code of an object. |
static int |
JavaHeader.getObjectHashCode(Object o)
Get the hash code of an object. |
ArchitectureSpecific.CodeArray |
TIB.getVirtualMethod(int virtualMethodIndex)
Get a virtual method from this TIB. |
ArchitectureSpecific.CodeArray |
TIB.getVirtualMethod(Offset virtualMethodOffset)
Get a virtual method from this TIB by offset. |
static Address |
JavaHeader.initializeArrayHeader(BootImageInterface bootImage,
Address ptr,
TIB tib,
int size,
int numElements,
boolean needsIdentityHash,
int identityHashValue)
Perform any required initialization of the JAVA portion of the header. |
static void |
ObjectModel.initializeAvailableByte(Object o)
Freeze the other bits in the byte containing the available bits so that it is safe to update them using setAvailableBits. |
static void |
JavaHeader.initializeAvailableByte(Object o)
Freeze the other bits in the byte containing the available bits so that it is safe to update them using setAvailableBits. |
static void |
MiscHeader.initializeHeader(BootImageInterface bootImage,
Address ref,
TIB tib,
int size,
boolean isScalar)
Perform any required initialization of the MISC portion of the header. |
static Address |
JavaHeader.initializeScalarHeader(BootImageInterface bootImage,
Address ptr,
TIB tib,
int size,
boolean needsIdentityHash,
int identityHashValue)
Perform any required initialization of the JAVA portion of the header. |
protected static int |
JavaHeader.installHashCode(Object o)
Install a new hashcode (only used if ! |
static void |
ObjectModel.layoutInstanceFields(RVMClass klass)
Layout the instance fields declared in this class. |
static void |
ObjectModel.setTIB(BootImageInterface bootImage,
Address refAddress,
Address tibAddr,
RVMType type)
Set the TIB for an object. |
static void |
JavaHeader.setTIB(BootImageInterface bootImage,
Address refOffset,
Address tibAddr,
RVMType type)
Set the TIB for an object. |
static void |
JavaHeader.writeAvailableByte(BootImageInterface bootImage,
Address ref,
byte val)
Non-atomic write of word containing available bits |
| Uses of Interruptible in org.jikesrvm.osr |
|---|
| Methods in org.jikesrvm.osr with annotations of type Interruptible | |
|---|---|
static void |
ObjectHolder.boot()
|
static int |
ObjectHolder.handinRefs(Object[] objs)
The VM scope descriptor extractor can hand in an object here |
| Uses of Interruptible in org.jikesrvm.scheduler |
|---|
| Methods in org.jikesrvm.scheduler with annotations of type Interruptible | |
|---|---|
(package private) void |
RVMThread.assignThreadSlot()
Find a thread slot not in use by any other live thread and bind the given thread to it. |
static void |
RVMThread.boot()
Boot the threading subsystem. |
static void |
Lock.boot()
Set up callbacks to report statistics. |
private void |
RVMThread.callSystemExit(int exitStatus)
Call System.exit() with the correct security status. |
int |
RVMThread.countStackFrames()
Count the stack frames of this thread |
Thread.State |
RVMThread.getState()
Get the state of the thread in a manner compatible with the Java API |
static String |
Lock.getThreadState(RVMThread t)
scan lock queues for thread and report its state |
void |
RVMThread.handleUncaughtException(Throwable exceptionObject)
|
static void |
RVMThread.init()
Initialize the threading subsystem for the boot image. |
static void |
Lock.init()
Sets up the data structures for holding heavy-weight locks. |
void |
RVMThread.initializeJNIEnv()
Initialize JNI environment for system threads. |
void |
RVMThread.interrupt()
Interrupt this thread |
void |
RVMThread.join(long ms,
int ns)
Wait for the thread to die or for the timeout to occur |
static void |
RVMThread.notify(Object o)
Support for Java Object.notify() synchronization
primitive. |
static void |
RVMThread.notifyAll(Object o)
Support for Java synchronization primitive. |
void |
RVMThread.park(boolean isAbsolute,
long time)
|
void |
RVMThread.resume()
Resume execution of a thread that has been suspended. |
void |
RVMThread.run()
Method to be executed when this thread starts running. |
abstract void |
SystemThread.run()
|
void |
RVMThread.setupBootJavaThread()
Called during booting to give the boot thread a java.lang.Thread |
static RVMThread |
RVMThread.setupBootThread()
Set up the initial thread and processors as part of boot image writing |
static void |
RVMThread.sleep(long ns)
Suspend execution of current thread for specified number of seconds (or fraction). |
static void |
RVMThread.sleep(long millis,
int ns)
Suspend execution of current thread for specified number of seconds (or fraction). |
void |
RVMThread.start()
Start execution of 'this' by putting it on the appropriate queue of an unspecified virtual processor. |
void |
SystemThread.start()
|
private static void |
RVMThread.startoff()
Begin execution of current thread by calling its "run" method. |
void |
RVMThread.terminate()
Terminate execution of current thread by abandoning all references to it and resuming execution in some other (ready) thread. |
void |
LightMonitor.timedWaitAbsoluteInterruptibly(long whenAwakeNanos)
|
void |
LightMonitor.timedWaitRelativeInterruptibly(long delayNanos)
|
void |
RVMThread.unpark()
|
static void |
RVMThread.wait(Object o)
Support for Java Object.wait() synchronization primitive. |
static void |
RVMThread.wait(Object o,
long millis)
Support for Java Object.wait() synchronization primitive. |
static void |
RVMThread.waitAbsoluteNanos(Object o,
long whenNanos)
Support for RTSJ- and pthread-style absolute wait. |
private void |
LightMonitor.waitImpl(long whenAwake)
|
(package private) void |
RVMThread.waitImpl(Object o,
boolean hasTimeout,
long whenWakeupNanos)
|
void |
LightMonitor.waitInterruptibly()
|
| Uses of Interruptible in org.mmtk.plan |
|---|
| Methods in org.mmtk.plan with annotations of type Interruptible | |
|---|---|
static short |
Phase.createComplex(String name,
int... scheduledPhases)
Construct a complex phase. |
static short |
Phase.createComplex(String name,
Timer timer,
int... scheduledPhases)
Construct a complex phase, re-using a specified timer. |
static short |
Phase.createConcurrent(String name,
int atomicScheduledPhase)
Construct a phase. |
static short |
Phase.createConcurrent(String name,
Timer timer,
int atomicScheduledPhase)
Construct a phase, re-using a specified timer. |
static short |
Phase.createSimple(String name)
Construct a phase. |
static short |
Phase.createSimple(String name,
Timer timer)
Construct a phase, re-using a specified timer. |
void |
Plan.enableAllocation()
The enableAllocation method is called early in the boot process to allow allocation. |
void |
Plan.enableCollection()
The enableCollection method is called by the runtime after it is safe to spawn collector contexts and allow garbage collection. |
void |
Plan.fullyBooted()
|
static void |
Plan.harnessBegin()
Generic hook to allow benchmarks to be harnessed. |
static void |
Plan.harnessEnd()
Generic hook to allow benchmarks to be harnessed. |
void |
ControllerCollectorContext.initCollector(int id)
|
void |
CollectorContext.initCollector(int id)
Notify that the collector context is registered and ready to execute. |
void |
ParallelCollectorGroup.initGroup(int size,
Class<? extends ParallelCollector> klass)
Initialize the collector context group. |
void |
Plan.insertPhaseAfter(int markerScheduledPhase,
int scheduledPhase)
Insert a phase. |
void |
Plan.notifyExit(int value)
The VM is about to exit. |
void |
StopTheWorld.processOptions()
The processOptions method is called by the runtime immediately after command-line arguments are available. |
void |
Plan.processOptions()
The processOptions method is called by the runtime immediately after command-line arguments are available. |
protected void |
Plan.registerSpecializedMethods()
Register specialized methods. |
static void |
TransitiveClosure.registerSpecializedScan(int id,
Class<?> specializedScanClass)
A transitive closure has been created that is designed to work with a specialized scan method. |
void |
Plan.replacePhase(int oldScheduledPhase,
int scheduledPhase)
Replace a phase. |
void |
Plan.startGCspyServer(int port,
boolean wait)
Start GCspy server. |
| Uses of Interruptible in org.mmtk.plan.concurrent |
|---|
| Methods in org.mmtk.plan.concurrent with annotations of type Interruptible | |
|---|---|
void |
Concurrent.processOptions()
The processOptions method is called by the runtime immediately after command-line arguments are available. |
| Uses of Interruptible in org.mmtk.plan.copyms |
|---|
| Methods in org.mmtk.plan.copyms with annotations of type Interruptible | |
|---|---|
void |
CopyMS.fullyBooted()
|
protected void |
CopyMS.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.generational |
|---|
| Methods in org.mmtk.plan.generational with annotations of type Interruptible | |
|---|---|
void |
Gen.fullyBooted()
|
protected void |
Gen.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.generational.copying |
|---|
| Methods in org.mmtk.plan.generational.copying with annotations of type Interruptible | |
|---|---|
protected void |
GenCopy.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.generational.immix |
|---|
| Methods in org.mmtk.plan.generational.immix with annotations of type Interruptible | |
|---|---|
protected void |
GenImmix.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.generational.marksweep |
|---|
| Methods in org.mmtk.plan.generational.marksweep with annotations of type Interruptible | |
|---|---|
protected void |
GenMS.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.immix |
|---|
| Methods in org.mmtk.plan.immix with annotations of type Interruptible | |
|---|---|
protected void |
Immix.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.markcompact |
|---|
| Methods in org.mmtk.plan.markcompact with annotations of type Interruptible | |
|---|---|
protected void |
MC.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.marksweep |
|---|
| Methods in org.mmtk.plan.marksweep with annotations of type Interruptible | |
|---|---|
protected void |
MS.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.nogc |
|---|
| Methods in org.mmtk.plan.nogc with annotations of type Interruptible | |
|---|---|
protected void |
NoGC.registerSpecializedMethods()
Register specialized methods. |
| Uses of Interruptible in org.mmtk.plan.refcount |
|---|
| Methods in org.mmtk.plan.refcount with annotations of type Interruptible | |
|---|---|
void |
RCBase.processOptions()
|
protected void |
RCBase.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.refcount.generational |
|---|
| Methods in org.mmtk.plan.refcount.generational with annotations of type Interruptible | |
|---|---|
void |
GenRC.fullyBooted()
|
| Uses of Interruptible in org.mmtk.plan.semispace |
|---|
| Methods in org.mmtk.plan.semispace with annotations of type Interruptible | |
|---|---|
protected void |
SS.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.semispace.gcspy |
|---|
| Methods in org.mmtk.plan.semispace.gcspy with annotations of type Interruptible | |
|---|---|
private LinearSpaceDriver |
SSGCspy.newLinearSpaceDriver(String name,
CopySpace space,
boolean mainSpace)
Create a new LinearSpaceDriver TODO is this the best name or should we call it LargeObjectSpaceDriver? |
private TreadmillDriver |
SSGCspy.newTreadmillDriver(String name,
LargeObjectSpace space)
Create a new TreadmillDriver TODO is this the best name or should we call it LargeObjectSpaceDriver? |
protected void |
SSGCspy.registerSpecializedMethods()
|
void |
SSGCspy.startGCspyServer(int port,
boolean wait)
Start the server and wait if necessary. |
| Uses of Interruptible in org.mmtk.plan.semispace.gctrace |
|---|
| Methods in org.mmtk.plan.semispace.gctrace with annotations of type Interruptible | |
|---|---|
void |
GCTrace.notifyExit(int value)
The planExit method is called at RVM termination to allow the trace process to finish. |
void |
GCTrace.processOptions()
|
| Uses of Interruptible in org.mmtk.plan.stickyimmix |
|---|
| Methods in org.mmtk.plan.stickyimmix with annotations of type Interruptible | |
|---|---|
protected void |
StickyImmix.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.plan.stickyms |
|---|
| Methods in org.mmtk.plan.stickyms with annotations of type Interruptible | |
|---|---|
protected void |
StickyMS.registerSpecializedMethods()
|
| Uses of Interruptible in org.mmtk.policy |
|---|
| Methods in org.mmtk.policy with annotations of type Interruptible | |
|---|---|
static void |
Space.eagerlyMmapMMTkContiguousSpaces()
Ensure that all contiguous MMTk spaces are mapped. |
static void |
Space.eagerlyMmapMMTkDiscontiguousSpaces()
Ensure that all discontiguous MMTk spaces are mapped. |
static void |
Space.eagerlyMmapMMTkSpaces()
Ensure that all MMTk spaces (all spaces aside from the VM space) are mapped. |
void |
Space.setZeroingApproach(boolean useNT,
boolean concurrent)
Update the zeroing approach for this space. |
static void |
Space.visitSpaces(Space.SpaceVisitor v)
Implement the Visitor Pattern for Spaces. |
| Uses of Interruptible in org.mmtk.utility |
|---|
| Methods in org.mmtk.utility with annotations of type Interruptible | |
|---|---|
static void |
TraceGenerator.init(SortTODSharedDeque worklist_,
SortTODSharedDeque trace_)
This is called at "build-time" and passes the necessary build image objects to the trace processor. |
void |
GenericFreeList.resizeFreeList()
Resize the free list for a child free list. |
void |
GenericFreeList.resizeFreeList(int units,
int grain)
Resize the free list for a parent free list. |
| Uses of Interruptible in org.mmtk.utility.gcspy |
|---|
| Methods in org.mmtk.utility.gcspy with annotations of type Interruptible | |
|---|---|
static void |
GCspy.createOptions()
|
static void |
GCspy.startGCspyServer()
Start the GCspy server. |
| Uses of Interruptible in org.mmtk.utility.gcspy.drivers |
|---|
| Methods in org.mmtk.utility.gcspy.drivers with annotations of type Interruptible | |
|---|---|
void |
AbstractDriver.addStream(Stream stream)
Add a stream to the driver. |
private ShortStream |
LinearSpaceDriver.createArrayObjectsStream()
|
private ShortStream |
LinearSpaceDriver.createArrayPrimitiveStream()
|
private IntStream |
LinearSpaceDriver.createArrayUsedSpaceStream()
|
private ShortStream |
TreadmillDriver.createObjectsStream()
|
private ShortStream |
TreadmillDriver.createRefFromImmortalStream()
|
private ShortStream |
LinearSpaceDriver.createRefFromImmortalStream()
|
private ShortStream |
GenImmortalSpaceDriver.createRemsetStream()
Helper methods to create the additional streams |
private ShortStream |
GenLOSDriver.createRemsetStream()
|
private ShortStream |
TreadmillDriver.createRootsStream()
|
private ShortStream |
LinearSpaceDriver.createRootsStream()
|
private ShortStream |
LinearSpaceDriver.createScalarObjectsStream()
|
private IntStream |
LinearSpaceDriver.createScalarUsedSpaceStream()
Private creator methods to create the Streams. |
protected ServerSpace |
AbstractDriver.createServerSpace(ServerInterpreter server,
String spaceName,
int maxTileNum,
boolean mainSpace)
Create a new GCspy ServerSpace and add it to the ServerInterpreter. |
protected Subspace |
AbstractDriver.createSubspace(Space mmtkSpace)
Create a subspace for this space. |
private IntStream |
TreadmillDriver.createUsedSpaceStream()
|
| Uses of Interruptible in org.mmtk.utility.heap |
|---|
| Methods in org.mmtk.utility.heap with annotations of type Interruptible | |
|---|---|
static void |
Map.finalizeStaticSpaceMap()
Finalize the space map, establishing which virtual memory is nailed down, and then placing the rest into a map to be used by discontiguous spaces. |
static int |
Map.getDiscontigFreeListPROrdinal(FreeListPageResource pr)
Return the ordinal number for some free list space wishing to share a discontiguous region. |
void |
FreeListPageResource.resizeFreeList(Address startAddress)
Resize the free list associated with this resource and nail down its start address. |
void |
PageResource.updateZeroingApproach(boolean nontemporal,
boolean concurrent)
Update the zeroing approach for this page resource. |
| Uses of Interruptible in org.mmtk.utility.statistics |
|---|
| Methods in org.mmtk.utility.statistics with annotations of type Interruptible | |
|---|---|
(package private) static void |
Stats.newCounter(Counter ctr)
Add a new counter to the set of managed counters. |
private static void |
Stats.printColumnNames()
Print out statistics column names |
static void |
Stats.printPhases()
Print out statistics for each mutator/gc phase |
private static void |
Stats.printPhaseStatXml(Counter c,
int p,
Stats.Phase phase)
Print a single phase counter in an xml tag |
static void |
Stats.printPhasesXml()
Print out statistics for each mutator/gc phase in Xml format |
static void |
Stats.printStats()
|
static void |
Stats.printStatsPlain()
Print out statistics |
static void |
Stats.printStatsXml()
Print command-line options and statistics in XML format |
static void |
Stats.printTotals()
Print out statistics totals |
static void |
Stats.printTotalsXml()
Print out statistics totals in Xml format |
private static void |
Stats.printTotalXml(Counter c,
Stats.Phase phase)
Print a single total in an xml tag |
static void |
Stats.stopAll()
Stop all counters |
| Uses of Interruptible in org.mmtk.vm |
|---|
| Methods in org.mmtk.vm with annotations of type Interruptible | |
|---|---|
abstract ImmortalSpace |
Memory.getVMSpace()
Return the space associated with/reserved for the VM. |
abstract void |
Statistics.perfEventInit(String events)
Initialize performance events |
abstract Address |
TraceInterface.skipOwnFramesAndDump(ObjectReference typeRef)
This skips over the frames added by the tracing algorithm, outputs information identifying the method the containts the "new" call triggering the allocation, and returns the address of the first non-trace, non-alloc stack frame. |
abstract void |
Collection.spawnCollectorContext(CollectorContext context)
Spawn a thread to execute the supplied collector context. |
| Uses of Interruptible in org.mmtk.vm.gcspy |
|---|
| Methods in org.mmtk.vm.gcspy with annotations of type Interruptible | |
|---|---|
int |
ServerInterpreter.addSpace(ServerSpace space)
Add a GCspy ServerSpace to the ServerInterpreter. |
abstract Object |
Util.createDataArray(Object templ,
int numElements)
Create an array of a particular type. |
abstract void |
ServerInterpreter.init(String name,
int port,
boolean verbose)
Create a new ServerInterpreter singleton. |
private void |
Stream.setupSummary(int presentation)
Setup the summary array. |
| Uses of Interruptible in org.vmmagic.unboxed |
|---|
| Methods in org.vmmagic.unboxed with annotations of type Interruptible | |
|---|---|
String |
ArchitecturalWord.toString()
|
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||