Uses of Class org.vmmagic.pragma.Uninterruptible (Jikes RVM API)

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
org.vmmagic.pragma.Uninterruptible

Packages that use Uninterruptible
com.ibm.tuningfork.tracegen.chunk
com.ibm.tuningfork.tracegen.types
org.jikesrvm
org.jikesrvm.adaptive
org.jikesrvm.adaptive.measurements
org.jikesrvm.adaptive.measurements.listeners
org.jikesrvm.adaptive.measurements.organizers
org.jikesrvm.adaptive.recompilation.instrumentation
org.jikesrvm.classloader
org.jikesrvm.compilers.baseline
org.jikesrvm.compilers.baseline.ia32
org.jikesrvm.compilers.common
org.jikesrvm.compilers.opt.runtimesupport
org.jikesrvm.compilers.opt.runtimesupport.ia32
org.jikesrvm.ia32
org.jikesrvm.jni
org.jikesrvm.jni.ia32
org.jikesrvm.mm.mminterface
org.jikesrvm.mm.mmtk
org.jikesrvm.mm.mmtk.gcspy
org.jikesrvm.objectmodel
org.jikesrvm.options
org.jikesrvm.osr
org.jikesrvm.osr.ia32
org.jikesrvm.runtime
org.jikesrvm.scheduler
org.jikesrvm.tuningfork
org.mmtk.plan
org.mmtk.plan.concurrent
org.mmtk.plan.concurrent.marksweep
org.mmtk.plan.copyms
org.mmtk.plan.generational
org.mmtk.plan.generational.copying
org.mmtk.plan.generational.immix
org.mmtk.plan.generational.marksweep
org.mmtk.plan.immix
org.mmtk.plan.markcompact
org.mmtk.plan.marksweep
org.mmtk.plan.nogc
org.mmtk.plan.poisoned
org.mmtk.plan.refcount
org.mmtk.plan.refcount.backuptrace
org.mmtk.plan.refcount.fullheap
org.mmtk.plan.refcount.generational
org.mmtk.plan.semispace
org.mmtk.plan.semispace.gcspy
org.mmtk.plan.semispace.gctrace
org.mmtk.plan.semispace.usePrimitiveWriteBarriers
org.mmtk.plan.stickyimmix
org.mmtk.plan.stickyms
org.mmtk.policy
org.mmtk.policy.immix
org.mmtk.utility
org.mmtk.utility.alloc
org.mmtk.utility.deque
org.mmtk.utility.gcspy
org.mmtk.utility.gcspy.drivers
org.mmtk.utility.heap
org.mmtk.utility.options
org.mmtk.utility.sanitychecker
org.mmtk.utility.statistics
org.mmtk.vm
org.mmtk.vm.gcspy
org.vmmagic.unboxed
org.vmutil.options

Uses of Uninterruptible in com.ibm.tuningfork.tracegen.chunk

Classes in com.ibm.tuningfork.tracegen.chunk with annotations of type Uninterruptible
`class`	`Chunk`
`class`	`EventChunk`
`class`	`EventTypeChunk`
`class`	`EventTypeSpaceChunk`
`class`	`FeedHeaderChunk`
`class`	`FeedletChunk`
`class`	`PropertyTableChunk`
`class`	`RawChunk`
`class`	`StringTableChunk`

Uses of Uninterruptible in com.ibm.tuningfork.tracegen.types

Classes in com.ibm.tuningfork.tracegen.types with annotations of type Uninterruptible
`class`	`EventAttribute` An attribute of an EventType.
`class`	`EventType` An EventType describes the types and attributes of the data values associated with a particular event index.

Uses of Uninterruptible in org.jikesrvm

Classes in org.jikesrvm with annotations of type Uninterruptible
`class`	`Options` Class to handle command-line arguments and options meant for the core runtime system of the VM.
`class`	`Services` Various service utilities.
`class`	`VM` A virtual machine.

Methods in org.jikesrvm with annotations of type Uninterruptible
`void`	`MachineSpecific.adjustESP(ArchitectureSpecific.Registers registers, Offset delta, boolean traceAdjustments)` A thread's stack has been moved or resized.
`static void`	`VM.shutdown(int value)` Shut down the virtual machine.

Uses of Uninterruptible in org.jikesrvm.adaptive

Methods in org.jikesrvm.adaptive with annotations of type Uninterruptible
`void`	`OSROrganizerThread.activate()` Activates organizer thread if it is waiting.

Uses of Uninterruptible in org.jikesrvm.adaptive.measurements

Methods in org.jikesrvm.adaptive.measurements with annotations of type Uninterruptible
`static void`	`RuntimeMeasurements.takeCBSCallSample(int whereFrom, Address yieldpointServiceMethodFP)` Called from Thread.yieldpoint when it is time to take a CBS call sample.
`static void`	`RuntimeMeasurements.takeCBSMethodSample(int whereFrom, Address yieldpointServiceMethodFP)` Called from Thread.yieldpoint when it is time to take a CBS method sample.
`static void`	`RuntimeMeasurements.takeTimerSample(int whereFrom, Address yieldpointServiceMethodFP)` Called from Thread.yieldpoint every time it is invoked due to a timer interrupt.

Uses of Uninterruptible in org.jikesrvm.adaptive.measurements.listeners

Classes in org.jikesrvm.adaptive.measurements.listeners with annotations of type Uninterruptible
`class`	`CallDensityListener` A simple listener to accumulate counts of total events and the fraction of those events that occurred at loop backedges.
`class`	`ContextListener` This object that is invoked when online measurement information must be collected.
`class`	`EdgeListener` A EdgeListener defines a listener that computes a call graph edge from the call stack.
`class`	`Listener` A Listener object is invoked when online measurement information needs to be collected.
`class`	`MethodListener` A MethodListener defines a listener to collect method invocation samples.
`class`	`NullListener` A NullListener is an object that is invoked when online measurement information must be collected.
`class`	`YieldCounterListener` A YieldCounterListener samples yield points, and notifies an Organizer when a threshold is reached.

Uses of Uninterruptible in org.jikesrvm.adaptive.measurements.organizers

Methods in org.jikesrvm.adaptive.measurements.organizers with annotations of type Uninterruptible
`void`	`Organizer.activate()` Called to activate the organizer thread (i.e. schedule it for execution).

Uses of Uninterruptible in org.jikesrvm.adaptive.recompilation.instrumentation

Classes in org.jikesrvm.adaptive.recompilation.instrumentation with annotations of type Uninterruptible
`class`	`CounterBasedSampling` Contains necessary infrastructure to perform counter-based sampling used with the instrumentation sampling code (PLDI'01) (see InstrumentationSamplingFramework)

Uses of Uninterruptible in org.jikesrvm.classloader

Methods in org.jikesrvm.classloader with annotations of type Uninterruptible
`(package private) TypeReference`	`RVMAnnotation.annotationType()` Return the TypeReference of the declared annotation, ie an interface and not the class object of this instance
`RVMArray`	`RVMType.asArray()`
`RVMClass`	`RVMType.asClass()`
`FieldReference`	`MemberReference.asFieldReference()`
`MethodReference`	`MemberReference.asMethodReference()`
`Primitive`	`RVMType.asPrimitive()`
`UnboxedType`	`RVMType.asUnboxedType()`
`int`	`RVMArray.getAlignment()`
`int`	`RVMClass.getAlignment()`
`static Atom`	`Atom.getAtom(int id)`
`byte[]`	`Atom.getBytes()` Return the underlying set of bytes for the Atom.
`RVMMethod`	`RVMClass.getClassInitializerMethod()` Static initializer method for this class (`null` -> no static initializer or initializer already been run).
`ClassLoader`	`TypeReference.getClassLoader()`
`ClassLoader`	`RVMType.getClassLoader()` Get the class loader for this type
`(package private) int`	`RVMField.getConstantValueIndex()` Get index of constant pool entry containing this "static final constant" field's value.
`RVMField[]`	`RVMClass.getDeclaredFields()` Fields defined directly by this class (i.e. not including superclasses).
`RVMClass[]`	`RVMClass.getDeclaredInterfaces()` Interfaces implemented directly by this class (ie. not including superclasses).
`RVMMethod[]`	`RVMClass.getDeclaredMethods()` Methods defined directly by this class (i.e. not including superclasses).
`RVMClass`	`RVMMember.getDeclaringClass()` Class that declared this field or method.
`Atom`	`RVMType.getDescriptor()` Descriptor for this type.
`Atom`	`RVMMember.getDescriptor()` Descriptor for this member.
`Atom`	`MemberReference.getDescriptor()`
`int`	`Primitive.getDimensionality()` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
`abstract int`	`RVMType.getDimensionality()` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
`int`	`UnboxedType.getDimensionality()`
`int`	`RVMArray.getDimensionality()` Number of [ in descriptor for arrays
`int`	`RVMClass.getDimensionality()` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
`int[]`	`RVMType.getDoesImplement()` get doesImplement vector (@see DynamicTypeCheck)
`void`	`NormalMethod.getDynamicLink(DynamicLink dynamicLink, int bcIndex)` Fill in DynamicLink object for the invoke at the given bytecode index
`RVMType`	`RVMArray.getElementType()`
`ExceptionHandlerMap`	`NormalMethod.getExceptionHandlerMap()` Exceptions caught by this method.
`TypeReference`	`FieldReference.getFieldContentsType()`
`FieldReference`	`RVMClass.getFieldRef(int constantPoolIndex)` Get contents of a "fieldRef" constant pool entry.
`(package private) static FieldReference`	`ClassFileReader.getFieldRef(int[] constantPool, int constantPoolIndex)` Get contents of a "methodRef" constant pool entry.
`int`	`TypeReference.getId()`
`int`	`RVMType.getId()` Get the numeric identifier for this type
`int`	`RVMMember.getId()` Get a unique id for this member.
`int`	`MemberReference.getId()`
`RVMType`	`RVMArray.getInnermostElementType()`
`int`	`RVMClass.getInstanceSize()` Total size, in bytes, of an instance of this class (including object header).
`int`	`RVMArray.getInstanceSize(int numelts)` Total size, in bytes, of an instance of this array type (including object header).
`int`	`RVMClass.getInstanceSizeInternal()` Total size, in bytes, of an instance of this class (including object header).
`int`	`NormalMethod.getLineNumberForBCIndex(int bci)` Return the line number information for the argument bytecode index.
`int`	`NormalMethod.getLocalWords()` Space required by this method for its local variables, in words.
`int`	`RVMArray.getLogElementSize()` Size, in bytes, of an array element, log base 2.
`MemberReference`	`RVMMember.getMemberRef()` Canonical member reference for this member.
`static MemberReference`	`MemberReference.getMemberRef(int id)`
`int`	`Primitive.getMemoryBytes()`
`int`	`TypeReference.getMemoryBytes()` How many bytes do values of this type take?
`abstract int`	`RVMType.getMemoryBytes()` Number of bytes in memory required to represent the type
`int`	`UnboxedType.getMemoryBytes()`
`int`	`RVMArray.getMemoryBytes()`
`int`	`RVMClass.getMemoryBytes()`
`MethodReference`	`RVMClass.getMethodRef(int constantPoolIndex)` Get contents of a "methodRef" constant pool entry.
`(package private) static MethodReference`	`ClassFileReader.getMethodRef(int[] constantPool, int constantPoolIndex)` Get contents of a "methodRef" constant pool entry.
`int`	`RVMType.getMMAllocator()` This returns the allocator id as supplied by the memory manager.
`Atom`	`TypeReference.getName()`
`Atom`	`RVMMember.getName()` Name of this member.
`Atom`	`MemberReference.getName()`
`Offset`	`RVMMember.getOffset()` Offset of this field or method, in bytes.
`int`	`NormalMethod.getOperandWords()` Space required by this method for its operand stack, in words.
`TypeReference[]`	`MethodReference.getParameterTypes()`
`TypeReference[]`	`RVMMethod.getParameterTypes()` Type of this method's parameters.
`int`	`MethodReference.getParameterWords()` Space required by method for its parameters, in words.
`int`	`RVMMethod.getParameterWords()` Space required by this method for its parameters, in words.
`int[]`	`RVMType.getReferenceOffsets()` Offsets of reference-containing instance fields of this class type.
`Class<?>`	`RVMType.getResolvedClassForType()` Instance of java.lang.Class corresponding to this type.
`RVMMethod`	`MethodReference.getResolvedMember()` Get the member this reference has been resolved to, if it has already been resolved.
`TypeReference`	`MethodReference.getReturnType()`
`TypeReference`	`RVMMethod.getReturnType()` Type of this method's return value.
`int`	`FieldReference.getSize()` Get size of the field's value, in bytes.
`int`	`Primitive.getStackWords()` Stack space requirement in words.
`int`	`TypeReference.getStackWords()` How many java stack/local words do value of this type take?
`abstract int`	`RVMType.getStackWords()` Space required when this type is stored on the stack (or as a field), in words.
`int`	`UnboxedType.getStackWords()` Stack space requirement in words.
`int`	`RVMArray.getStackWords()`
`int`	`RVMClass.getStackWords()`
`RVMClass[]`	`RVMClass.getSubClasses()` Currently loaded classes that "extend" this class.
`RVMClass`	`RVMClass.getSuperClass()` Superclass of this class (`null` means "no superclass", i.e. class is "java/lang/Object").
`short[]`	`RVMType.getSuperclassIds()` get superclass id vector (@see DynamicTypeCheck)
`Offset`	`Primitive.getThinLockOffset()`
`abstract Offset`	`RVMType.getThinLockOffset()` Get the offset in instances of this type assigned to the thin lock word.
`Offset`	`UnboxedType.getThinLockOffset()`
`Offset`	`RVMArray.getThinLockOffset()` Get the offset in instances of this type assigned to the thin lock word.
`Offset`	`RVMClass.getThinLockOffset()` Get the offset in instances of this type assigned to the thin lock word.
`Offset`	`RVMType.getTibOffset()` Get offset of tib slot from start of jtoc, in bytes.
`TypeReference`	`RVMField.getType()` Get type of this field's value.
`TypeReference`	`MemberReference.getType()`
`static RVMType`	`RVMType.getType(int id)` Get the type for the given id
`int`	`Primitive.getTypeDepth()` get number of superclasses to Object
`abstract int`	`RVMType.getTypeDepth()` get number of superclasses to Object 0 java.lang.Object, Primitive, and Classes that are interfaces 1 for RVMArrays and classes that extend Object directly
`int`	`UnboxedType.getTypeDepth()`
`int`	`RVMArray.getTypeDepth()`
`int`	`RVMClass.getTypeDepth()` Get number of superclasses to Object.
`TIB`	`Primitive.getTypeInformationBlock()` Runtime type information for this class/array type.
`abstract TIB`	`RVMType.getTypeInformationBlock()` Runtime type information for this class/array type.
`TIB`	`UnboxedType.getTypeInformationBlock()` Runtime type information for this class/array type.
`TIB`	`RVMArray.getTypeInformationBlock()` Runtime type information for this array type.
`TIB`	`RVMClass.getTypeInformationBlock()` Runtime type information for this class type.
`TypeReference`	`RVMType.getTypeRef()` Canonical type reference for this type.
`static TypeReference`	`TypeReference.getTypeRef(int id)` Get the canonical type reference given its id.
`TypeReference`	`RVMClass.getTypeRef(int constantPoolIndex)` Get contents of a "typeRef" constant pool entry.
`(package private) static TypeReference`	`ClassFileReader.getTypeRef(int[] constantPool, int constantPoolIndex)` Get contents of a "typeRef" constant pool entry.
`(package private) Atom`	`RVMClass.getUtf(int constantPoolIndex)` Get contents of a "utf" constant pool entry.
`(package private) static Atom`	`ClassFileReader.getUtf(int[] constantPool, int constantPoolIndex)` Get contents of a "utf" from a constant pool entry.
`boolean`	`AnnotatedElement.hasAnnotations()` Does the element have any annotations?
`boolean`	`AnnotatedElement.hasBaselineSaveLSRegistersAnnotation()` Return true if this element has a BaselineSaveLSRegisters annotation.
`boolean`	`RVMClass.hasBridgeFromNativeAnnotation()` The methods of this class are only called from native code, they are compiled with a special prolog to interface with the native stack frame.
`boolean`	`RVMClass.hasDynamicBridgeAnnotation()` Should the methods of this class be compiled with special register save/restore logic?
`boolean`	`Primitive.hasFinalizer()`
`abstract boolean`	`RVMType.hasFinalizer()` Does this type override java.lang.Object.finalize()?
`boolean`	`UnboxedType.hasFinalizer()`
`boolean`	`RVMArray.hasFinalizer()`
`boolean`	`RVMClass.hasFinalizer()` Does this class override java.lang.Object.finalize()?
`boolean`	`AnnotatedElement.hasUntracedAnnotation()` Return true if this element has a Untraced annotation.
`static boolean`	`DynamicTypeCheck.instanceOfClass(RVMClass LHSclass, TIB rhsTIB)` LHSclass is a fully loaded class.
`boolean`	`RVMMethod.isAbstract()` Implemented in subclass?
`boolean`	`RVMClass.isAbstract()` Non-instantiable?
`boolean`	`Primitive.isAcyclicReference()`
`abstract boolean`	`RVMType.isAcyclicReference()` Reference Count GC: Is a reference of this type contained in another object inherently acyclic (without cycles)?
`boolean`	`UnboxedType.isAcyclicReference()`
`boolean`	`RVMArray.isAcyclicReference()`
`boolean`	`RVMClass.isAcyclicReference()`
`boolean`	`TypeReference.isAddressType()` Does 'this' refer to Address
`(package private) boolean`	`AnnotatedElement.isAnnotationDeclared(TypeReference annotationTypeRef)` Return true if annotation present.
`boolean`	`Atom.isArrayDescriptor()` Is "this" atom an array descriptor?
`boolean`	`Primitive.isArrayType()`
`boolean`	`TypeReference.isArrayType()` Does 'this' refer to an array?
`abstract boolean`	`RVMType.isArrayType()` Is this an instance of RVMArray?
`boolean`	`UnboxedType.isArrayType()`
`boolean`	`RVMArray.isArrayType()`
`boolean`	`RVMClass.isArrayType()`
`boolean`	`TypeReference.isBooleanType()` Is this the type reference for the boolean primitive type?
`boolean`	`RVMType.isBooleanType()`
`boolean`	`TypeReference.isByteType()` Is this the type reference for the byte primitive type?
`boolean`	`RVMType.isByteType()`
`boolean`	`TypeReference.isCharType()` Is this the type reference for the char primitive type?
`boolean`	`RVMType.isCharType()`
`boolean`	`Atom.isClassDescriptor()` Is "this" atom a class descriptor?
`boolean`	`RVMMethod.isClassInitializer()` Is this method a class initializer?
`boolean`	`Primitive.isClassType()`
`boolean`	`TypeReference.isClassType()` Does 'this' refer to a class?
`abstract boolean`	`RVMType.isClassType()` Is this is an instance of RVMClass?
`boolean`	`UnboxedType.isClassType()`
`boolean`	`RVMArray.isClassType()`
`boolean`	`RVMClass.isClassType()`
`boolean`	`TypeReference.isCodeArrayType()` Does 'this' refer to CodeArray
`boolean`	`TypeReference.isCodeType()` Does 'this' refer to Code
`boolean`	`TypeReference.isDoubleType()` Is this the type reference for the double primitive type?
`boolean`	`RVMType.isDoubleType()`
`boolean`	`TypeReference.isExtentType()` Does 'this' refer to Extent
`boolean`	`MemberReference.isFieldReference()` Is this member reference to a field?
`boolean`	`RVMField.isFinal()` May only be assigned once?
`boolean`	`RVMMethod.isFinal()` Declared as non-overridable by subclasses?
`boolean`	`RVMClass.isFinal()` Non-subclassable?
`boolean`	`TypeReference.isFloatType()` Is this the type reference for the float primitive type?
`boolean`	`RVMType.isFloatType()`
`boolean`	`Primitive.isInBootImage()`
`abstract boolean`	`RVMType.isInBootImage()` Is this class part of the virtual machine's boot image?
`boolean`	`UnboxedType.isInBootImage()`
`boolean`	`RVMArray.isInBootImage()`
`boolean`	`RVMClass.isInBootImage()`
`boolean`	`Primitive.isInitialized()`
`abstract boolean`	`RVMType.isInitialized()` Initialization status.
`boolean`	`UnboxedType.isInitialized()`
`boolean`	`RVMArray.isInitialized()`
`boolean`	`RVMClass.isInitialized()`
`boolean`	`Primitive.isInstantiated()`
`abstract boolean`	`RVMType.isInstantiated()` Instantiation status.
`boolean`	`UnboxedType.isInstantiated()`
`boolean`	`RVMArray.isInstantiated()`
`boolean`	`RVMClass.isInstantiated()`
`boolean`	`RVMClass.isInterface()` An "interface" description rather than a "class" description?
`boolean`	`TypeReference.isIntLikeType()` Is `this` the type reference for an int-like (1, 8, 16, or 32 bit integral) primitive type?
`boolean`	`RVMType.isIntLikeType()`
`boolean`	`TypeReference.isIntType()` Is this the type reference for the int primitive type?
`boolean`	`RVMType.isIntType()`
`boolean`	`RVMType.isJavaLangObjectType()`
`boolean`	`RVMType.isJavaLangStringType()`
`boolean`	`RVMType.isJavaLangThrowableType()`
`boolean`	`TypeReference.isLoaded()` Return true if the type for type reference has been loaded.
`boolean`	`TypeReference.isLongType()` Is this the type reference for the long primitive type?
`boolean`	`RVMType.isLongType()`
`boolean`	`TypeReference.isMagicType()` Does 'this' refer to Magic?
`boolean`	`Atom.isMethodDescriptor()` Is "this" atom a method descriptor?
`boolean`	`MemberReference.isMethodReference()` Is this member reference to a method?
`boolean`	`RVMMethod.isNative()` Not implemented in java?
`boolean`	`RVMMethod.isObjectInitializer()` Is this method an object initializer?
`boolean`	`RVMMethod.isObjectInitializerHelper()` Is this method a compiler-generated object initializer helper?
`boolean`	`TypeReference.isOffsetType()` Does 'this' refer to Offset
`boolean`	`Primitive.isPrimitiveType()`
`boolean`	`TypeReference.isPrimitiveType()` Does 'this' refer to a primitive type
`abstract boolean`	`RVMType.isPrimitiveType()` Is this a primitive type?
`boolean`	`UnboxedType.isPrimitiveType()`
`boolean`	`RVMArray.isPrimitiveType()`
`boolean`	`RVMClass.isPrimitiveType()`
`boolean`	`RVMClass.isPublic()` Usable from other packages?
`boolean`	`Primitive.isReferenceType()`
`boolean`	`TypeReference.isReferenceType()` Does 'this' refer to a reference type
`abstract boolean`	`RVMType.isReferenceType()` Is this a reference type?
`boolean`	`UnboxedType.isReferenceType()`
`boolean`	`RVMArray.isReferenceType()`
`boolean`	`RVMClass.isReferenceType()`
`boolean`	`Atom.isReservedMemberName()` Is "this" atom a reserved member name?
`boolean`	`Primitive.isResolved()`
`boolean`	`TypeReference.isResolved()` Return true if the type for type reference has been loaded and it is resolved.
`abstract boolean`	`RVMType.isResolved()` Resolution status.
`boolean`	`UnboxedType.isResolved()`
`boolean`	`RVMArray.isResolved()`
`boolean`	`RVMClass.isResolved()`
`boolean`	`TypeReference.isRuntimeTable()` Does 'this' refer to a runtime table type?
`boolean`	`TypeReference.isShortType()` Is this the type reference for the short primitive type?
`boolean`	`RVMType.isShortType()`
`boolean`	`RVMClass.isSpecial()` Use new-style "invokespecial" semantics for method calls in this class?
`boolean`	`RVMField.isStatic()` Shared among all instances of this class?
`boolean`	`RVMMethod.isStatic()` Declared as statically dispatched?
`boolean`	`RVMMethod.isSynchronized()` Guarded by monitorenter/monitorexit?
`boolean`	`RVMField.isTransient()` Value not to be written/read by persistent object manager?
`boolean`	`TypeReference.isUnboxedArrayType()` Does 'this' refer to WordArray, AddressArray, OffsetArray or ExtentArray
`boolean`	`Primitive.isUnboxedType()`
`boolean`	`TypeReference.isUnboxedType()` Does 'this' refer to an unboxed type.
`abstract boolean`	`RVMType.isUnboxedType()` Is this an unboxed type?
`boolean`	`UnboxedType.isUnboxedType()`
`boolean`	`RVMArray.isUnboxedType()`
`boolean`	`RVMClass.isUnboxedType()`
`boolean`	`TypeReference.isVoidType()` Is this the type reference for the void primitive type?
`boolean`	`RVMType.isVoidType()`
`boolean`	`RVMField.isVolatile()` Value not to be cached in a register?
`boolean`	`TypeReference.isWordArrayType()` Does 'this' refer to WordArray, AddressArray, OffsetArray or ExtentArray
`boolean`	`TypeReference.isWordLikeType()` Does 'this' refer to Word, Address, Offset or Extent
`boolean`	`TypeReference.isWordType()` Does 'this' refer to Word
`int`	`Atom.length()`
`boolean`	`RVMField.madeTraced()` Does the field hold a made-traced reference?
`static int`	`RVMType.numTypes()` How many types have been created?
`(package private) static int`	`ClassFileReader.packCPEntry(byte type, int value)`
`(package private) static boolean`	`ClassFileReader.packedCPTypeIsClassType(int cpValue)`
`(package private) static int`	`ClassFileReader.packTempCPEntry(int index1, int index2)`
`byte`	`Atom.parseForArrayElementTypeCode()` Parse "this" array descriptor to obtain type code for its element type.
`RVMType`	`TypeReference.peekType()`
`private void`	`RVMArray.publishResolved(TIB allocatedTib, short[] superclassIds, int[] doesImplement)` Atomically initialize the important parts of the TIB and let the world know this type is resolved.
`private void`	`RVMClass.publishResolved(TIB allocatedTib, short[] superclassIds, int[] doesImplement)` Atomically initialize the important parts of the TIB and let the world know this type is resolved.
`void`	`RVMClass.setInstanceSizeInternal(int size)` Set the size of the instance.
`void`	`Atom.sysWrite()`
`byte[]`	`Atom.toByteArray()` Get at a string-like representation without doing any heap allocation.
`(package private) static byte`	`ClassFileReader.unpackCPType(int cpValue)`
`(package private) static int`	`ClassFileReader.unpackSignedCPValue(int cpValue)`
`(package private) static int`	`ClassFileReader.unpackTempCPIndex1(int cpValue)`
`(package private) static int`	`ClassFileReader.unpackTempCPIndex2(int cpValue)`
`(package private) static int`	`ClassFileReader.unpackUnsignedCPValue(int cpValue)`

Uses of Uninterruptible in org.jikesrvm.compilers.baseline

Classes in org.jikesrvm.compilers.baseline with annotations of type Uninterruptible
`(package private) class`	`JSRInfo` Scratch space for JSR processing.
`class`	`ReferenceMaps` class that provides stack (and local var) map for a baseline compiled method GC uses the methods provided here
`(package private) class`	`UnusualMaps` Unusual maps are maps to track references that don't take the usual format.

Methods in org.jikesrvm.compilers.baseline with annotations of type Uninterruptible
`int`	`BaselineCompiledMethod.findBytecodeIndexForInstruction(Offset instructionOffset)` Find bytecode index corresponding to one of this method's machine instructions.
`int`	`BaselineCompiledMethod.findLineNumberForInstruction(Offset instructionOffset)`
`int`	`BaselineCompiledMethod.getCompilerType()`
`void`	`BaselineCompiledMethod.getDynamicLink(DynamicLink dynamicLink, Offset instructionOffset)`
`ExceptionDeliverer`	`BaselineCompiledMethod.getExceptionDeliverer()` Get the exception deliverer for this kind of compiled method
`short`	`BaselineCompiledMethod.getFloatLocalLocation(int localIndex)` Location of local floating point variable.
`short`	`BaselineCompiledMethod.getFloatStackLocation(int stackIndex)` Offset onto stack of a particular operand stack location for a floating point value
`short`	`BaselineCompiledMethod.getGeneralLocalLocation(int localIndex)` Location of local general purpose variable.
`short`	`BaselineCompiledMethod.getGeneralStackLocation(int stackIndex)` Offset onto stack of a particular general purpose operand stack location
`int`	`BaselineCompiledMethod.getLastFixedStackRegister()` Last general purpose register holding part of the operand stack
`int`	`BaselineCompiledMethod.getLastFloatStackRegister()` Last floating point register holding part of the operand stack
`Offset`	`BaselineCompiledMethod.getLockAcquisitionOffset()` Get the lock acquisition offset
`boolean`	`BaselineCompiledMethod.hasCounterArray()` Does the method have a counters array?

Uses of Uninterruptible in org.jikesrvm.compilers.baseline.ia32

Classes in org.jikesrvm.compilers.baseline.ia32 with annotations of type Uninterruptible
`class`	`BaselineGCMapIterator` Iterator for stack frame built by the Baseline compiler.

Methods in org.jikesrvm.compilers.baseline.ia32 with annotations of type Uninterruptible
`private static void`	`BaselineMagic.check(ObjectReference value)` Method called to check an object reference is valid
`static int`	`BaselineCompilerImpl.getEmptyStackOffset(NormalMethod m)` The last true local
`private static int`	`BaselineCompilerImpl.getFirstLocalOffset(NormalMethod method)` This is misnamed.
`static short`	`BaselineCompilerImpl.getFloatLocalLocation(int index, short[] localloc, NormalMethod m)`
`static short`	`BaselineCompilerImpl.getGeneralLocalLocation(int index, short[] localloc, NormalMethod m)`
`private static int`	`BaselineCompilerImpl.getStartLocalOffset(NormalMethod method)`
`static int`	`BaselineCompilerImpl.locationToOffset(short location)`
`static short`	`BaselineCompilerImpl.offsetToLocation(int offset)`

Uses of Uninterruptible in org.jikesrvm.compilers.common

Classes in org.jikesrvm.compilers.common with annotations of type Uninterruptible
`class`	`HardwareTrapGCMapIterator` Iterator for stack frames inserted by hardware trap handler.

Methods in org.jikesrvm.compilers.common with annotations of type Uninterruptible
`void`	`CompiledMethod.clearActiveOnStack()`
`ArchitectureSpecific.CodeArray`	`CompiledMethod.codeArrayForOffset(Offset offset)` Return the code array for this method that contains the given offset.
`static String`	`CompiledMethod.compilerTypeToString(int compilerType)`
`boolean`	`CompiledMethod.containsReturnAddress(Address ip)` Does the code for the compiled method contain the given return address?
`int`	`CompiledMethod.findLineNumberForInstruction(Offset instructionOffset)` Find source line number corresponding to one of this method's machine instructions.
`static CompiledMethod`	`CompiledMethods.findMethodForInstruction(Address ip)` Find the method whose machine code contains the specified instruction.
`static CompiledMethod`	`CompiledMethods.getCompiledMethod(int compiledMethodId)` Fetch a previously compiled method.
`static CompiledMethod`	`CompiledMethods.getCompiledMethodUnchecked(int cmid)` Fetch a previously compiled method without checking
`abstract int`	`CompiledMethod.getCompilerType()` Identify the compiler that produced this compiled method.
`int`	`HardwareTrapCompiledMethod.getCompilerType()`
`abstract void`	`CompiledMethod.getDynamicLink(DynamicLink dynamicLink, Offset instructionOffset)` Fetch symbolic reference to a method that's called by one of this method's instructions.
`void`	`HardwareTrapCompiledMethod.getDynamicLink(DynamicLink dynamicLink, Offset instructionOffset)`
`ArchitectureSpecific.CodeArray`	`CompiledMethod.getEntryCodeArray()`
`abstract ExceptionDeliverer`	`CompiledMethod.getExceptionDeliverer()` Get handler to deal with stack unwinding and exception delivery for this compiled method's stackframes.
`ExceptionDeliverer`	`HardwareTrapCompiledMethod.getExceptionDeliverer()`
`int`	`CompiledMethod.getId()` Return the compiled method id for this compiled method
`Address`	`CompiledMethod.getInstructionAddress(Offset offset)` Return the address of the instruction at offset offset in the method's instruction stream.
`Offset`	`CompiledMethod.getInstructionOffset(Address ip)` Return the offset in bytes of the given Address from the start of the machine code array.
`Offset`	`CompiledMethod.getInstructionOffset(Address ip, boolean dieOnFailure)` Return the offset in bytes of the given Address from the start of the machine code array.
`RVMMethod`	`CompiledMethod.getMethod()` Return the RVMMethod associated with this compiled method
`boolean`	`CompiledMethod.hasBridgeFromNativeAnnotation()` Does this method have a bridge from native annotation, important when walking the stack
`boolean`	`CompiledMethod.isActiveOnStack()`
`boolean`	`CompiledMethod.isCompiled()` Has compilation completed?
`boolean`	`CompiledMethod.isInvalid()` Is the compiled code invalid?
`boolean`	`CompiledMethod.isObsolete()` Is the compiled code obsolete?
`boolean`	`CompiledMethod.isOutdated()` Check if the compiled method is marked as outdated, called by Thread
`int`	`CompiledMethod.numberOfInstructions()`
`static int`	`CompiledMethods.numCompiledMethods()` Get number of methods compiled so far.
`void`	`CompiledMethod.setActiveOnStack()`
`private static void`	`CompiledMethods.setCompiledMethod(int cmid, CompiledMethod cm)` Set entry in compiled method lookup
`void`	`CompiledMethod.setObsolete()` Mark the compiled method as obsolete (ie a candidate for eventual GC)
`void`	`CompiledMethod.setOutdated()` Mark the compiled method as outdated (i.e. requires OSR), the flag is set in AnalyticModel
`static void`	`CompiledMethods.snipObsoleteCompiledMethods()` Snip reference to CompiledMethod so that we can reclaim code space.

Uses of Uninterruptible in org.jikesrvm.compilers.opt.runtimesupport

Classes in org.jikesrvm.compilers.opt.runtimesupport with annotations of type Uninterruptible
`class`	`OptCompiledMethod` An implementation of CompiledMethod for the OPT compiler.
`class`	`OptEncodedCallSiteTree` Suppose the following inlining actions have been taken (<callerMID, bcIndex, calleeMID>): <A, 12, B>, <A,14,C>, <A,16,D>, < B,3,E>, < B,5,F >, <C,10,G>, <G,20,H>, <H,30,I> Then the `OptEncodedCallSiteTree` would be: -1, A, -2, 12, B, 14, C, 16, D, -6, 3, E, 5, F, -9, 10, G, -2, 20 H -2 30 I
`class`	`OptGCMap` A class that encapsulates the GCMap portion of the machine code maps.
`class`	`OptGenericGCMapIterator` This class contains its architecture-independent code for iteration across the references represented by a frame built by the OPT compiler.

Methods in org.jikesrvm.compilers.opt.runtimesupport with annotations of type Uninterruptible
`int`	`OptMachineCodeMap.findGCMapIndex(Offset MCOffset)` This method searches for the GC map corresponding to the passed machine code offset.
`private int`	`OptMachineCodeMap.findMCEntry(Offset MCOffset)` Do a binary search of the machine code maps to find the index in MCInformation where the entry for the argument machine code offset starts.
`int`	`OptMachineCodeMap.gcMapInformation(int index)` Returns the GC map information for the GC map information entry passed
`private int`	`OptMachineCodeMap.getBytecodeIndex(int entry)` Returns the Bytecode index for the entry passed
`int`	`OptMachineCodeMap.getBytecodeIndexForMCOffset(Offset MCOffset)` Get the bytecode index for a machine instruction offset.
`private int`	`OptMachineCodeMap.getCallInfo(int entry)` Returns the call info for the entry passed.
`private int`	`OptMachineCodeMap.getGCMapIndex(int entry)` Returns the GC map index for the entry passed
`int`	`OptMachineCodeMap.getInlineEncodingForMCOffset(Offset MCOffset)` Return the inlining encoding index for the machine instruction offset.
`private int`	`OptMachineCodeMap.getInlineEncodingIndex(int entry)` Returns the inline encoding index for the entry passed.
`private int`	`OptMachineCodeMap.getMCOffset(int entry)` Returns the MCOffset for the entry passed
`NormalMethod`	`OptMachineCodeMap.getMethodForMCOffset(Offset MCOffset)` Get the RVMMethod for a machine instruction offset.
`private boolean`	`OptMachineCodeMap.isBigEntry(int entry)` Is the entry a big entry?
`private boolean`	`OptMachineCodeMap.isHugeEntry(int entry)` Is the entry a big entry?
`int`	`OptMachineCodeMap.nextLocation(int currentIndex)`
`boolean`	`OptMachineCodeMap.registerIsSet(int entry, int registerNumber)` Determines if the register map information for the entry passed is true

Uses of Uninterruptible in org.jikesrvm.compilers.opt.runtimesupport.ia32

Classes in org.jikesrvm.compilers.opt.runtimesupport.ia32 with annotations of type Uninterruptible
`class`	`OptGCMapIterator` An instance of this class provides iteration across the references represented by a frame built by the OPT compiler.

Uses of Uninterruptible in org.jikesrvm.ia32

Classes in org.jikesrvm.ia32 with annotations of type Uninterruptible
`class`	`CodeArray` CodeArray represents a code object (contiguous memory region containing code).
`class`	`DynamicLinkerHelper` Machine specific helper functions for dynamic linking.
`class`	`Registers` The machine state comprising a thread's execution context, used both for thread context switching and for software/hardware exception reporting/delivery.

Methods in org.jikesrvm.ia32 with annotations of type Uninterruptible
`void`	`MachineSpecificIA.adjustESP(ArchitectureSpecific.Registers registers, Offset delta, boolean traceAdjustments)`
`static void`	`ThreadLocalState.boot()` The C bootstrap program has placed a pointer to the initial RVMThread in ESI.
`static RVMThread`	`ThreadLocalState.getCurrentThread()` Return the current RVMThread object
`void`	`MachineSpecificIA.initializeStack(ArchitectureSpecific.Registers contextRegisters, Address ip, Address sp)`
`static void`	`ThreadLocalState.setCurrentThread(RVMThread p)` Set the current RVMThread object

Uses of Uninterruptible in org.jikesrvm.jni

Methods in org.jikesrvm.jni with annotations of type Uninterruptible
`private void`	`JNIEnvironment.checkPush(Object ref, boolean canGrow)` Check push of reference can succeed
`private static void`	`JNIGlobalRefTable.copyAndReplaceGlobalRefs(AddressArray newGlobalRefs)`
`void`	`JNIEnvironment.dumpJniRefsStack()` Dump the JNIRefs stack to the sysWrite stream
`void`	`JNIEnvironment.entryToJNI(int encodedReferenceOffsets)` Save data and perform necessary conversions for entry into JNI.
`ArchitectureSpecific.CodeArray`	`FunctionTable.get(int index)` Get an ITable entry.
`AddressArray`	`LinkageTripletTable.get(int index)` Get a LinkageTripletTable entry.
`int`	`JNICompiledMethod.getCompilerType()`
`void`	`JNICompiledMethod.getDynamicLink(DynamicLink dynamicLink, Offset instructionOffset)`
`ExceptionDeliverer`	`JNICompiledMethod.getExceptionDeliverer()`
`(package private) static Object`	`JNIGlobalRefTable.globalRef(int index)`
`boolean`	`JNIEnvironment.hasNativeStackFrame()`
`(package private) static boolean`	`JNIGlobalRefTable.isWeakRef(int index)`
`int`	`FunctionTable.length()` Return the length of the ITable
`int`	`LinkageTripletTable.length()` Return the length of the LinkageTripletTable
`(package private) static Object`	`JNIGlobalRefTable.ref(int index)`
`AddressArray`	`JNIEnvironment.refsArray()`
`int`	`JNIEnvironment.refsTop()`
`private void`	`JNIEnvironment.replaceJNIRefs(AddressArray newrefs)` Atomically copy and install a new JNIRefArray
`int`	`JNIEnvironment.savedRefsFP()`
`Address`	`JNIEnvironment.topJavaFP()`
`private int`	`JNIEnvironment.uninterruptiblePushJNIRef(Address ref, boolean isRef)` Push a JNI ref, used on entry to JNI NB only used for Intel
`(package private) static Object`	`JNIGlobalRefTable.weakRef(int index)`

Uses of Uninterruptible in org.jikesrvm.jni.ia32

Classes in org.jikesrvm.jni.ia32 with annotations of type Uninterruptible
`class`	`JNIGCMapIterator` Iterator for stack frames inserted at the transition from Java to JNI Native C.

Methods in org.jikesrvm.jni.ia32 with annotations of type Uninterruptible
`void`	`JNIExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)` Deliver exception, not possible for JNI methods
`void`	`JNIExceptionDeliverer.unwindStackFrame(CompiledMethod compiledMethod, ArchitectureSpecific.Registers registers)` Unwind registers/stack through JNI method

Uses of Uninterruptible in org.jikesrvm.mm.mminterface

Classes in org.jikesrvm.mm.mminterface with annotations of type Uninterruptible
`class`	`Barriers`
`class`	`DebugUtil` Common debugging utility functions used by various garbage collectors
`class`	`GCMapIterator` Base class for iterators that identify object references and JSR return addresses held in stackframes produced by each of our compilers (baseline, opt, etc.).
`class`	`MemoryManager` The interface that the MMTk memory manager presents to Jikes RVM
`static class`	`Selected.Collector`
`static class`	`Selected.Constraints`
`static class`	`Selected.Mutator`
`static class`	`Selected.Plan`
`class`	`SpecializedScanMethod` A method that scan objects and is specialized to a specific MMTk TransitiveClosure type.
`class`	`ThreadContext` RVMThread must extend this class to associate appropriate context with processor.

Methods in org.jikesrvm.mm.mminterface with annotations of type Uninterruptible
`static void`	`DebugUtil.dumpAllThreadStacks()` Dump all threads & their stacks starting at the frame identified by the threads saved contextRegisters (ip & fp fields).
`static void`	`DebugUtil.dumpRef(ObjectReference ref)`
`static int`	`AlignmentEncoding.extractTibCode(Address address)` Extract the encoded value from a TIB pointer, represented as a raw address.
`GCMapIterator`	`GCMapIteratorGroup.getJniIterator()` get the GCMapIterator used for scanning JNI native stack frames.
`ScanThread`	`CollectorThread.getThreadScanner()`
`static int`	`AlignmentEncoding.getTibCode(ObjectReference object)` Extract the encoded value from an object's TIB pointer
`static boolean`	`DebugUtil.mappedVMRef(ObjectReference ref)`
`void`	`GCMapIteratorGroup.newStackWalk(RVMThread thread, Address registerLocation)` Prepare to scan a thread's stack for object references.
`static void`	`HandInlinedScanning.scanObject(int code, int id, Object object, TransitiveClosure trace)` Hand-inlined scanning of objects.
`private static void`	`HandInlinedScanning.scanObject(int code, int id, Object object, TransitiveClosure trace, boolean specialize)`
`static void`	`HandInlinedScanning.scanObject(int code, Object object, TransitiveClosure trace)` Hand-inlined scanning of objects.
`GCMapIterator`	`GCMapIteratorGroup.selectIterator(CompiledMethod compiledMethod)` Select iterator for scanning for object references in a stackframe.
`static boolean`	`DebugUtil.validObject(Object ref)` Check if a ref, its tib pointer & type pointer are all in the heap
`static boolean`	`DebugUtil.validRef(ObjectReference ref)`
`static boolean`	`DebugUtil.validType(ObjectReference typeAddress)` Check if an address appears to point to an instance of RVMType

Uses of Uninterruptible in org.jikesrvm.mm.mmtk

Classes in org.jikesrvm.mm.mmtk with annotations of type Uninterruptible
`class`	`ActivePlan` This class contains interfaces to access the current plan, plan local and plan constraints instances.
`class`	`Assert`
`class`	`Barriers`
`class`	`Collection`
`class`	`Debug` Debugger support for the MMTk harness
`class`	`FinalizableProcessor` This class manages the processing of finalizable objects.
`class`	`Lock` Adaptive mutex with a spinlock fast path.
`class`	`Memory`
`class`	`MMTk_Events` Implementation of simple MMTK event generation hooks to allow MMTk to generate TuningFork events.
`class`	`Monitor` Provides MMTk access to a heavy lock with condition variable.
`class`	`ObjectModel`
`class`	`ReferenceProcessor` This class manages SoftReferences, WeakReferences, and PhantomReferences.
`class`	`Scanning`
`class`	`ScanThread` Class that supports scanning thread stacks for references during collections.
`class`	`Statistics`
`class`	`Strings`
`class`	`SynchronizedCounter` A counter that supports atomic increment and reset.
`class`	`TraceInterface` Class that supports scanning Objects or Arrays for references during tracing, handling those references, and computing death times

Methods in org.jikesrvm.mm.mmtk with annotations of type Uninterruptible
`private static void`	`ScanBootImage.checkReference(Address refaddr)` Check that a reference encountered during scanning is valid.
`private static void`	`ScanStatics.checkReference(Address refaddr, int slot)` Check that a reference encountered during scanning is valid.
`private static Offset`	`ScanBootImage.decodeLongEncoding(Address cursor)` Decode a 4-byte encoding, taking a pointer to the first byte of the encoding, and returning the encoded value as an `Offset`
`private static int`	`ScanBootImage.decodeLongEncoding(byte[] code, int index)` Decode a 4-byte encoding, taking a byte array and an index into it and returning the encoded value as an integer
`void`	`Assert.exit(int rc)`
`private static boolean`	`ScanBootImage.isAddressAligned(Address address)` Return true if the given address is address-aligned
`private static boolean`	`ScanBootImage.isAddressAligned(Offset offset)` Return true if the given offset is address-aligned
`private static void`	`ScanBootImage.processChunk(Address chunkStart, Address imageStart, Address mapStart, Address mapEnd, TraceLocal trace)` Process a chunk of encoded reference data, enqueuing each reference (optionally filtering them on whether they point outside the boot image).
`static void`	`ScanBootImage.scanBootImage(TraceLocal trace)` Scan the boot image for object references.
`static void`	`ScanStatics.scanStatics(TraceLocal trace)` Scan static variables (JTOC) for object references.
`static void`	`Collection.scheduleFinalizerThread()` Schedule the finalizerThread, if there are objects to be finalized and the finalizerThread is on its queue (ie. currently idle).

Uses of Uninterruptible in org.jikesrvm.mm.mmtk.gcspy

Classes in org.jikesrvm.mm.mmtk.gcspy with annotations of type Uninterruptible
`class`	`ByteStream` Set up a GCspy Stream with data type BYTE_TYPE.
`class`	`IntStream` Set up a GCspy Stream with data type INT_TYPE.
`class`	`ServerInterpreter` Generic GCspy Server Interpreter.
`class`	`ServerSpace` This class implements the GCspy Space abstraction.
`class`	`ShortStream` Set up a GCspy Stream with data type SHORT_TYPE.
`class`	`Util` This class provides generally useful methods.

Uses of Uninterruptible in org.jikesrvm.objectmodel

Classes in org.jikesrvm.objectmodel with annotations of type Uninterruptible
`class`	`JavaHeader` Defines the JavaHeader portion of the object header for the default JikesRVM object model.
`class`	`MiscHeader` Defines other header words not used for core Java language support of memory allocation.
`class`	`ObjectModel` The interface to the object model definition accessible to the virtual machine.
`class`	`TIB` This class represents an instance of a type information block, at runtime it is an array with Object elements.

Methods in org.jikesrvm.objectmodel with annotations of type Uninterruptible
`ITable`	`ITableArray.get(int index)` Get an `ITable` entry from the array.
`ArchitectureSpecific.CodeArray`	`IMT.get(int index)` Gets an entry in the IMT.
`Object`	`ITable.get(int index)` Gets an entry in the ITable.
`static void`	`MiscHeader.initializeHeader(Object obj, TIB tib, int size, boolean isScalar)` Perform any required initialization of the MISC portion of the header.
`boolean`	`ITable.isFor(RVMType I)` Does this ITable correspond to the given interface?
`int`	`ITableArray.length()` Return the length of the array of `ITable`
`int`	`IMT.length()` Returns the length of the IMT
`int`	`ITable.length()` Return the length of the ITable

Uses of Uninterruptible in org.jikesrvm.options

Methods in org.jikesrvm.options with annotations of type Uninterruptible
`protected int`	`OptionSet.bytesToPages(Extent bytes)`
`protected Extent`	`OptionSet.pagesToBytes(int pages)`

Uses of Uninterruptible in org.jikesrvm.osr

Classes in org.jikesrvm.osr with annotations of type Uninterruptible
`class`	`ObjectHolder` ObjectHolder helps the specialized prologue to load reference get around of GC problem

Uses of Uninterruptible in org.jikesrvm.osr.ia32

Classes in org.jikesrvm.osr.ia32 with annotations of type Uninterruptible
`class`	`PostThreadSwitch` A class helps schedule OSRed method, it is called right after thread switch and highly depends on the calling convention.

Uses of Uninterruptible in org.jikesrvm.runtime

Classes in org.jikesrvm.runtime with annotations of type Uninterruptible
`class`	`DynamicLink` Place for CompiledMethod.getDynamicLink() to deposit return information.
`class`	`Memory` Low level memory management functions.
`class`	`SysCall` Support for lowlevel (i.e. non-JNI) invocation of C functions with static addresses.
`class`	`Time` Primitives from which to build interval and absolute timers.

Methods in org.jikesrvm.runtime with annotations of type Uninterruptible
`(package private) static void`	`RuntimeEntrypoints.aastoreUninterruptible(Object[] arrayRef, int index, Object value)` Perform uninterruptible aastore bytecode
`private static boolean`	`RuntimeEntrypoints.canForceGC()` Return `true` if we are stress testing garbage collector and the system is in state where we can force a garbage collection.
`private int`	`StackTrace.countFramesUninterruptible(RVMThread stackTraceThread)` Walk the stack counting the number of stack frames encountered.
`static int`	`Statics.getNumberOfNumericSlots()` Fetch number of numeric JTOC slots currently allocated.
`static int`	`Statics.getNumberOfReferenceSlots()` Fetch number of reference JTOC slots currently allocated.
`static int`	`Statics.getReferenceSlotSize()` Get size occupied by a reference
`static Address`	`Magic.getReturnAddress(Address fp)` Get return address for a frame in the current thread
`static Address`	`Magic.getReturnAddress(Address fp, RVMThread thread)` Get return address for a frame in a specific thread
`static Address`	`Magic.getReturnAddressUnchecked(Address fp)` Get return address for a frame in a case where the frame is known not to be a trampoline frame.
`static int`	`Statics.getSlotContentsAsInt(Offset offset)` Fetch contents of a slot, as an integer
`static long`	`Statics.getSlotContentsAsLong(Offset offset)` Fetch contents of a slot-pair, as a long integer.
`static Object`	`Statics.getSlotContentsAsObject(Offset offset)` Fetch contents of a slot, as an object.
`static Address`	`Statics.getSlots()` Fetch JTOC object (for JNI environment and GC).
`static int[]`	`Statics.getSlotsAsIntArray()` Fetch JTOC object (for JNI environment and GC).
`static int`	`Statics.getTotalNumberOfSlots()` Fetch total number of slots comprising the JTOC.
`static boolean`	`Statics.isReference(int slot)` Does specified JTOC slot contain a reference?
`static int`	`Statics.offsetAsSlot(Offset offset)` Conversion from JTOC offset to JTOC slot index.
`static long`	`Magic.prepareLong(Object object, Offset offset)` Get contents of (object + offset) and begin conditional critical section.
`private void`	`StackTrace.recordFramesUninterruptible(RVMThread stackTraceThread)` Walk the stack recording the stack frames encountered The stack being walked is our stack, so code is Uninterrupible to stop the stack moving.
`void`	`BootRecord.setHeapRange(int id, Address start, Address end)`
`static void`	`Magic.setReturnAddress(Address fp, Address v)` Get return address for a frame
`static void`	`Statics.setSlotContents(Offset offset, Address value)` Set contents of a slot, as a Address
`static void`	`Statics.setSlotContents(Offset offset, ArchitectureSpecific.CodeArray code)` Set contents of a slot, as a CodeArray.
`static void`	`Statics.setSlotContents(Offset offset, double value)` Set contents of a slot, as a double.
`static void`	`Statics.setSlotContents(Offset offset, Extent value)` Set contents of a slot, as a Extent
`static void`	`Statics.setSlotContents(Offset offset, float value)` Set contents of a slot, as an float.
`static void`	`Statics.setSlotContents(Offset offset, int value)` Set contents of a slot, as an integer.
`static void`	`Statics.setSlotContents(Offset offset, long value)` Set contents of a slot, as a long integer.
`static void`	`Statics.setSlotContents(Offset offset, Offset value)` Set contents of a slot, as a Offset
`static void`	`Statics.setSlotContents(Offset offset, TIB tib)` Set contents of a slot, as a CodeArray.
`static void`	`Statics.setSlotContents(Offset offset, Word word)` Set contents of a slot, as a Word.
`static Offset`	`Statics.slotAsOffset(int slot)` Conversion from JTOC slot index to JTOC offset.
`private static void`	`RuntimeEntrypoints.unwindInvisibleStackFrame(ArchitectureSpecific.Registers registers)` Unwind stack frame for an .
`static Address`	`RuntimeEntrypoints.unwindNativeStackFrame(Address currfp)` Skip over all frames below currfp with saved code pointers outside of heap (C frames), stopping at the native frame immediately preceding the glue frame which contains the method ID of the native method (this is necessary to allow retrieving the return address of the glue frame).
`static Address`	`RuntimeEntrypoints.unwindNativeStackFrameForGC(Address currfp)` The current frame is expected to be one of the JNI functions called from C, below which is one or more native stack frames.

Uses of Uninterruptible in org.jikesrvm.scheduler

Classes in org.jikesrvm.scheduler with annotations of type Uninterruptible
`class`	`LightMonitor` A light-weigh condition variable and lock, like Monitor, but this one is movable and can be garbage collected.
`class`	`Lock` Lock provides RVM support for monitors and Java level synchronization.
`class`	`Monitor` Implementation of a heavy lock and condition variable implemented using the primitives available from the operating system.
`class`	`NoYieldpointsMonitor` A heavy condition variable and lock that also disables interrupts while the lock is held.
`class`	`RVMThread` A generic java thread's execution context.
`(package private) static class`	`RVMThread.AllButGCHardHandshakeVisitor`
`static class`	`RVMThread.BlockAdapter` A block adapter specifies the reason for blocking or unblocking a thread.
`static class`	`RVMThread.GCBlockAdapter`
`static class`	`RVMThread.HandshakeBlockAdapter`
`static class`	`RVMThread.HardHandshakeVisitor`
`static class`	`RVMThread.SoftHandshakeVisitor`
`static class`	`RVMThread.SuspendBlockAdapter`
`class`	`SpinLock` Alternative (to Java monitors) light-weight synchronization mechanism to implement Java monitors `Lock`.
`class`	`Synchronization` Class to provide synchronization methods where java language synchronization is insufficient and Magic.prepare and Magic.attempt are at too low a level.
`class`	`SystemThread`
`class`	`ThinLock` Implementation of thin locks.
`class`	`ThreadQueue` An unsynchronized queue data structure for Threads.
`class`	`TimerThread` The timer thread.

Methods in org.jikesrvm.scheduler with annotations of type Uninterruptible
`static void`	`Lock.addLock(Lock l)` Add a lock to the lock table
`static boolean`	`ThinLock.attemptToMarkDeflated(Object o, Offset lockOffset, Word oldLockWord)`
`private static Word`	`ThinLock.biasBitsToThinBits(Word bits)`
`void`	`RVMThread.deInstallStackTrampoline()` de-install the stack trampoline (disabling return barriers).
`void`	`RVMThread.endPairHandshake()`
`static RVMThread`	`RVMThread.getCurrentThread()`
`static Address`	`RVMThread.getHijackedReturnAddress(Address hijackedFp)` Given a frame that has been hijacked by the stack trampoline, return the real (hijacked) return address.
`static int`	`ThinLock.getLockIndex(Word lockWord)` Return the lock index for a given lock word.
`static int`	`ThinLock.getLockOwner(Word lockWord)`
`static int`	`ThinLock.getRecCount(Word lockWord)`
`static boolean`	`ThinLock.holdsLock(Object o, Offset lockOffset, RVMThread thread)`
`void`	`RVMThread.installStackTrampolineBridge(Address targetFp)` Install the stack trampoline bridge at a given frame, hijacking that frame, saving the hijacked return address and callee fp in thread-local state to allow execution of the hijacked frame later.
`static boolean`	`ThinLock.isFat(Word lockWord)`
`static void`	`ThinLock.markDeflated(Object o, Offset lockOffset, int id)`
`void`	`Latch.openNoHandshake()` Like open(), but does it without letting the system know that we could potentially block.
`static void`	`RVMThread.returnBarrier()` The return barrier.
`static void`	`FinalizerThread.schedule()`

Uses of Uninterruptible in org.jikesrvm.tuningfork

Classes in org.jikesrvm.tuningfork with annotations of type Uninterruptible
`class`	`EventChunkQueue` A Queue of EventChunks.
`class`	`Feedlet` A Feedlet is a entity that is a unit of trace generation for TuningFork.

Methods in org.jikesrvm.tuningfork with annotations of type Uninterruptible
`(package private) EventChunk`	`TraceEngine.getEventChunk()`
`void`	`TraceEngine.returnFullEventChunk(EventChunk events)`

Uses of Uninterruptible in org.mmtk.plan

Classes in org.mmtk.plan with annotations of type Uninterruptible
`class`	`CollectorContext` This class (and its sub-classes) implement per-collector thread behavior.
`class`	`ComplexPhase` Phases of a garbage collection.
`class`	`ConcurrentPhase` Phases of a garbage collection.
`class`	`ControllerCollectorContext`
`class`	`MutatorContext` This class (and its sub-classes) implement per-mutator thread behavior.
`class`	`ParallelCollector` TODO: Documentation.
`class`	`ParallelCollectorGroup` This class represents a pool of collector contexts that can be triggered to perform collection activity.
`class`	`Phase` A garbage collection proceeds as a sequence of phases.
`class`	`Plan` This abstract class implements the global core functionality for all memory management schemes.
`class`	`PlanConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`Simple` This abstract class implements the core functionality for simple collectors.
`class`	`SimpleCollector` This class (and its sub-classes) implement per-collector thread behavior and state.
`class`	`SimpleConstraints` Constraints specific to simple collectors.
`class`	`SimpleMutator` This class (and its sub-classes) implement per-mutator thread behavior and state.
`class`	`SimplePhase` Phases of a garbage collection.
`class`	`StopTheWorld` This abstract class implements the core functionality for stop-the-world collectors.
`class`	`StopTheWorldCollector` This class (and its sub-classes) implement per-collector thread behavior and state.
`class`	`StopTheWorldConstraints` Constraints specific to Stop-the-world collectors.
`class`	`StopTheWorldMutator` This class (and its sub-classes) implement per-mutator thread behavior and state.
`class`	`Trace` This abstract class implements the core functionality for a transitive closure over the heap.
`class`	`TraceLocal` This abstract class and its global counterpart implement the core functionality for a transitive closure over the heap graph.
`class`	`TraceWriteBuffer` This class is used to push values in one direction during a trace.
`class`	`TransitiveClosure` This abstract class is the fundamental mechanism for performing a transitive closure over an object graph.

Uses of Uninterruptible in org.mmtk.plan.concurrent

Classes in org.mmtk.plan.concurrent with annotations of type Uninterruptible
`class`	`Concurrent` This class implements the global state of a concurrent collector.
`class`	`ConcurrentCollector` This class implements per-collector thread behavior and state for a concurrent collector.
`class`	`ConcurrentConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`ConcurrentMutator` This class implements per-mutator thread behavior and state for a simple whole-heap concurrent collector.

Uses of Uninterruptible in org.mmtk.plan.concurrent.marksweep

Classes in org.mmtk.plan.concurrent.marksweep with annotations of type Uninterruptible
`class`	`CMS` This class implements the global state of a concurrent mark-sweep collector.
`class`	`CMSCollector` This class implements per-collector thread behavior and state for the CMS plan, which implements a full-heap concurrent mark-sweep collector.
`class`	`CMSConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`CMSMutator` This class implements per-mutator thread behavior and state for the CMS plan, which implements a full-heap concurrent mark-sweep collector.
`class`	`CMSTraceLocal` This class implements the thread-local functionality for a transitive closure over a mark-sweep space.

Uses of Uninterruptible in org.mmtk.plan.copyms

Classes in org.mmtk.plan.copyms with annotations of type Uninterruptible
`class`	`CopyMS` This class implements the global state of a full-heap collector with a copying nursery and mark-sweep mature space.
`class`	`CopyMSCollector` This class implements per-collector thread behavior and state for the CopyMS plan.
`class`	`CopyMSConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`CopyMSMutator` This class implements per-mutator thread behavior and state for the CopyMS plan.
`class`	`CopyMSTraceLocal` This class implements the thread-local functionality for a transitive closure over a coping/mark-sweep hybrid collector.

Uses of Uninterruptible in org.mmtk.plan.generational

Classes in org.mmtk.plan.generational with annotations of type Uninterruptible
`class`	`Gen` This abstract class implements the core functionality of generic two-generation copying collectors.
`class`	`GenCollector` This abstract class implements per-collector thread behavior and state for generational copying collectors.
`class`	`GenConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`GenMatureTraceLocal` This abstract class implements the core functionality for a transitive closure over the heap graph.
`class`	`GenMutator` This abstract class implements per-mutator thread behavior and state for generational copying collectors.
`class`	`GenNurseryTraceLocal` This class implements the core functionality for a transitive closure over the heap graph.

Uses of Uninterruptible in org.mmtk.plan.generational.copying

Classes in org.mmtk.plan.generational.copying with annotations of type Uninterruptible
`class`	`GenCopy` This class implements the functionality of a standard two-generation copying collector.
`class`	`GenCopyCollector` This class implements per-collector thread behavior and state for the `GenCopy` two-generational copying collector.
`class`	`GenCopyConstraints` GenCopy constants.
`class`	`GenCopyMatureTraceLocal` This class implements the core functionality for a transitive closure over the heap graph, specifically in a Generational copying collector.
`class`	`GenCopyMutator` This class implements per-mutator thread behavior and state for the `GenCopy` two-generational copying collector.

Uses of Uninterruptible in org.mmtk.plan.generational.immix

Classes in org.mmtk.plan.generational.immix with annotations of type Uninterruptible
`class`	`GenImmix` This class implements the functionality of a two-generation copying collector where the higher generation is an immix space.
`class`	`GenImmixCollector` This class implements per-collector thread behavior and state for the `GenImmix` two-generational copying collector.
`class`	`GenImmixConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`GenImmixMatureDefragTraceLocal` This class implements the core functionality for a transitive closure over the heap graph, specifically in a defragmenting pass over a generational immix collector.
`class`	`GenImmixMatureTraceLocal` This class implements the core functionality for a transitive closure over the heap graph, specifically in a generational immix collector.
`class`	`GenImmixMutator` This class implements per-mutator thread behavior and state for the `GenImmix` two-generational copying collector.

Uses of Uninterruptible in org.mmtk.plan.generational.marksweep

Classes in org.mmtk.plan.generational.marksweep with annotations of type Uninterruptible
`class`	`GenMS` This class implements the functionality of a two-generation copying collector where the higher generation is a mark-sweep space (free list allocation, mark-sweep collection).
`class`	`GenMSCollector` This class implements per-collector thread behavior and state for the `GenMS` two-generational copying collector.
`class`	`GenMSConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`GenMSMatureTraceLocal` This class implements the core functionality for a transitive closure over the heap graph, specifically in a Generational Mark-Sweep collector.
`class`	`GenMSMutator` This class implements per-mutator thread behavior and state for the `GenMS` two-generational copying collector.

Uses of Uninterruptible in org.mmtk.plan.immix

Classes in org.mmtk.plan.immix with annotations of type Uninterruptible
`class`	`Immix` This class implements the global state of an immix collector.
`class`	`ImmixCollector` This class implements per-collector thread behavior and state for the Immix plan, which implements a full-heap immix collector.
`class`	`ImmixConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`ImmixDefragTraceLocal` This class implements the thread-local functionality for a defragmenting transitive closure over an immix space.
`class`	`ImmixMutator` This class implements per-mutator thread behavior and state for the Immix plan, which implements a full-heap immix collector.
`class`	`ImmixTraceLocal` This class implements the thread-local functionality for a transitive closure over an immix space.

Uses of Uninterruptible in org.mmtk.plan.markcompact

Classes in org.mmtk.plan.markcompact with annotations of type Uninterruptible
`class`	`MC` This class implements the global state of a simple sliding mark-compact collector.
`class`	`MCCollector` This class implements per-collector thread behavior and state for the MC plan, which implements a full-heap mark-compact collector.
`class`	`MCConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`MCForwardTraceLocal` This class implements the thread-local functionality for a transitive closure over a mark-compact space during the forwarding phase.
`class`	`MCMarkTraceLocal` This class implements the thread-local functionality for a transitive closure over a mark-compact space during the initial marking phase.
`class`	`MCMutator` This class implements per-mutator thread behavior and state for the MC plan, which implements a full-heap mark-compact collector.

Uses of Uninterruptible in org.mmtk.plan.marksweep

Classes in org.mmtk.plan.marksweep with annotations of type Uninterruptible
`class`	`MS` This class implements the global state of a simple mark-sweep collector.
`class`	`MSCollector` This class implements per-collector thread behavior and state for the MS plan, which implements a full-heap mark-sweep collector.
`class`	`MSConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`MSMutator` This class implements per-mutator thread behavior and state for the MS plan, which implements a full-heap mark-sweep collector.
`class`	`MSTraceLocal` This class implements the thread-local functionality for a transitive closure over a mark-sweep space.

Uses of Uninterruptible in org.mmtk.plan.nogc

Classes in org.mmtk.plan.nogc with annotations of type Uninterruptible
`class`	`NoGC` This class implements the global state of a a simple allocator without a collector.
`class`	`NoGCCollector` This class implements per-collector thread behavior and state for the NoGC plan, which simply allocates (without ever collecting until the available space is exhausted.
`class`	`NoGCConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`NoGCMutator` This class implements per-mutator thread behavior and state for the NoGC plan, which simply allocates (without ever collecting until the available space is exhausted.
`class`	`NoGCTraceLocal` This class implements the thread-local core functionality for a transitive closure over the heap graph.

Uses of Uninterruptible in org.mmtk.plan.poisoned

Classes in org.mmtk.plan.poisoned with annotations of type Uninterruptible
`class`	`Poisoned` This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.
`class`	`PoisonedCollector` This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.
`class`	`PoisonedConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`PoisonedMutator` This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.

Uses of Uninterruptible in org.mmtk.plan.refcount

Classes in org.mmtk.plan.refcount with annotations of type Uninterruptible
`class`	`RCBase` This class implements the global state of a reference counting collector.
`class`	`RCBaseCollector` This class implements the collector context for a reference counting collector.
`class`	`RCBaseConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`RCBaseMutator` This class implements the mutator context for a reference counting collector.
`class`	`RCDecBuffer` This class implements a dec-buffer for a reference counting collector
`class`	`RCHeader`
`class`	`RCZero` This class is the fundamental mechanism for performing a transitive closure over an object graph.

Methods in org.mmtk.plan.refcount with annotations of type Uninterruptible
`static boolean`	`RCHeader.attemptToLog(ObjectReference object)` Attempt to log `object` for coalescing RC.
`static int`	`RCHeader.decRC(ObjectReference object)` Decrement the reference count of an object.
`static int`	`RCHeader.getRC(ObjectReference object)` Return the reference count for the object.
`static boolean`	`RCHeader.isLiveRC(ObjectReference object)` Return `true` if given object is live
`static boolean`	`RCHeader.logRequired(ObjectReference object)` Return `true` if `object` is yet to be logged (for coalescing RC).
`static void`	`RCHeader.makeLogged(ObjectReference object)` Signify completion of logging `object`.
`static void`	`RCHeader.makeUnlogged(ObjectReference object)` Change `object`'s state to `UNLOGGED`.

Uses of Uninterruptible in org.mmtk.plan.refcount.backuptrace

Classes in org.mmtk.plan.refcount.backuptrace with annotations of type Uninterruptible
`class`	`BTFreeLargeObjectSweeper` This class implements the freeing of large objects during a backup trace.
`class`	`BTSweeper` This class implements the thread-local core functionality for a transitive closure over the heap graph.
`class`	`BTSweepImmortalScanner` This class is used in backup tracing to sweep and zero any dead 'immortal' objects.
`class`	`BTTraceLocal` This class implements the thread-local core functionality for a transitive closure over the heap graph.

Uses of Uninterruptible in org.mmtk.plan.refcount.fullheap

Classes in org.mmtk.plan.refcount.fullheap with annotations of type Uninterruptible
`class`	`RC` This class implements the global state of a reference counting collector.
`class`	`RCCollector` This class implements the collector context for a reference counting collector.
`class`	`RCConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`RCFindRootSetTraceLocal` This class implements the thread-local core functionality for a transitive closure over the heap graph.
`class`	`RCModifiedProcessor` This class is the fundamental mechanism for performing a transitive closure over an object graph.
`class`	`RCMutator` This class implements the mutator context for a reference counting collector.

Uses of Uninterruptible in org.mmtk.plan.refcount.generational

Classes in org.mmtk.plan.refcount.generational with annotations of type Uninterruptible
`class`	`GenRC` This class implements the global state of a a simple reference counting collector.
`class`	`GenRCCollector` This class implements the collector context for a simple reference counting collector.
`class`	`GenRCConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`GenRCFindRootSetTraceLocal` This class implements the thread-local core functionality for a transitive closure over the heap graph.
`class`	`GenRCModifiedProcessor` This class is the fundamental mechanism for performing a transitive closure over an object graph.
`class`	`GenRCMutator` This class implements the mutator context for a simple reference counting collector.

Uses of Uninterruptible in org.mmtk.plan.semispace

Classes in org.mmtk.plan.semispace with annotations of type Uninterruptible
`class`	`SS` This class implements a simple semi-space collector.
`class`	`SSCollector` This class implements per-collector thread behavior and state for the SS plan, which implements a full-heap semi-space collector.
`class`	`SSConstraints` SemiSpace common constants.
`class`	`SSMutator` This class implements per-mutator thread behavior and state for the SS plan, which implements a full-heap semi-space collector.
`class`	`SSTraceLocal` This class implements the core functionality for a transitive closure over the heap graph.

Uses of Uninterruptible in org.mmtk.plan.semispace.gcspy

Classes in org.mmtk.plan.semispace.gcspy with annotations of type Uninterruptible
`class`	`SSGCspy` This class extends a simple semi-space collector to instrument it for GCspy.
`class`	`SSGCspyCollector` This class implements per-collector thread behavior and state for the SSGCspy plan.
`class`	`SSGCspyConstraints` Semi space GCspy constants.
`class`	`SSGCspyMutator` This class implements per-mutator thread behavior and state for the SSGCspy plan.
`class`	`SSGCspyTraceLocal` This class implements the core functionality for a transitive closure over the heap graph.

Uses of Uninterruptible in org.mmtk.plan.semispace.gctrace

Classes in org.mmtk.plan.semispace.gctrace with annotations of type Uninterruptible
`class`	`GCTrace` This plan has been modified slightly to perform the processing necessary for GC trace generation.
`class`	`GCTraceCollector` This class implements per-collector thread behavior and state for the GCTrace plan, which implements a GC tracing algorithm.
`class`	`GCTraceConstraints` GCTrace constants.
`class`	`GCTraceMutator` This class implements per-mutator thread behavior and state for the GCTrace plan, which implements a GC tracing algorithm.
`class`	`GCTraceTraceLocal` This plan has been modified slightly to perform the processing necessary for GC trace generation.

Uses of Uninterruptible in org.mmtk.plan.semispace.usePrimitiveWriteBarriers

Classes in org.mmtk.plan.semispace.usePrimitiveWriteBarriers with annotations of type Uninterruptible
`class`	`UsePrimitiveWriteBarriers` This class exercises primitive write barriers The write barriers contain no payloads but merely perform a write to the heap
`class`	`UsePrimitiveWriteBarriersCollector` This class extends the `SSCollector` class as part of the `UsePrimitiveWriteBarriers` collector.
`class`	`UsePrimitiveWriteBarriersConstraints` UsePrimitiveWriteBarriers common constants.
`class`	`UsePrimitiveWriteBarriersMutator` This class extends the `SSMutator` class as part of the `UsePrimitiveWriteBarriers` collector.

Uses of Uninterruptible in org.mmtk.plan.stickyimmix

Classes in org.mmtk.plan.stickyimmix with annotations of type Uninterruptible
`class`	`StickyImmix` This class implements the global state of a simple sticky mark bits collector, based on an immix collector.
`class`	`StickyImmixCollector` This class implements per-collector thread behavior and state for the StickMS plan, which implements a generational sticky mark bits immix collector.
`class`	`StickyImmixConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`StickyImmixMutator` This class implements per-mutator thread behavior and state for the StickyImmix plan, which implements a generational mark-sweep collector.
`class`	`StickyImmixNurseryTraceLocal` This class implements the thread-local functionality for a transitive closure over a sticky-immix space.

Uses of Uninterruptible in org.mmtk.plan.stickyms

Classes in org.mmtk.plan.stickyms with annotations of type Uninterruptible
`class`	`StickyMS` This class implements the global state of a simple sticky mark bits collector, based a simple on mark-sweep collector.
`class`	`StickyMSCollector` This class implements per-collector thread behavior and state for the StickMS plan, which implements a generational sticky mark bits mark-sweep collector.
`class`	`StickyMSConstraints` This class and its subclasses communicate to the host VM/Runtime any features of the selected plan that it needs to know.
`class`	`StickyMSMutator` This class implements per-mutator thread behavior and state for the StickyMS plan, which implements a generational mark-sweep collector.
`class`	`StickyMSNurseryTraceLocal` This class implements the thread-local functionality for a transitive closure over a mark-sweep space.

Uses of Uninterruptible in org.mmtk.policy

Classes in org.mmtk.policy with annotations of type Uninterruptible
`class`	`BaseLargeObjectSpace` Each instance of this class corresponds to one treadmill space.
`class`	`CopyLocal` This class implements unsynchronized (local) elements of a copying collector.
`class`	`CopySpace` This class implements tracing functionality for a simple copying space.
`class`	`ExplicitFreeListLocal` This class implements unsynchronized (local) elements of an explicitly managed collector.
`class`	`ExplicitFreeListSpace` Each instance of this class corresponds to one space.
`class`	`ExplicitLargeObjectSpace` Each instance of this class corresponds to one explicitly managed large object space.
`static class`	`ExplicitLargeObjectSpace.Sweeper` A callback used to perform sweeping of the large object space.
`class`	`ImmortalLocal` This class implements unsynchronized (local) elements of an immortal space.
`class`	`ImmortalSpace` This class implements tracing for a simple immortal collection policy.
`class`	`LargeObjectLocal` Each instance of this class is intended to provide fast, unsynchronized access to a treadmill.
`class`	`LargeObjectSpace` Each instance of this class corresponds to one explicitly managed large object space.
`class`	`MarkCompactCollector` This class implements unsynchronized (local) per-collector-thread elements of a sliding mark-compact collector.
`private static class`	`MarkCompactCollector.FromCursor` Subclass for the read-only cursor that leads the scan of regions.
`private static class`	`MarkCompactCollector.RegionCursor` Both the 'compact' and 'calculate' phases can be thought of as sweeping a pair of cursors across a linked list of regions.
`private static class`	`MarkCompactCollector.ToCursor` Subclass for the read-only cursor that follows the 'from' cursor, writing or calculating the position of copied objects
`class`	`MarkCompactLocal` This class implements unsynchronized (local) elements of a sliding mark-compact collector.
`class`	`MarkCompactSpace` This class implements functionality for a simple sliding mark-compact space.
`class`	`MarkSweepLocal` This class implements unsynchronized (local) elements of a mark-sweep collector.
`class`	`MarkSweepSpace` Each instance of this class corresponds to one mark-sweep space.
`class`	`RawPageSpace` Each instance of this class corresponds to one raw page space.
`class`	`SegregatedFreeListSpace` Each instance of this class corresponds to one mark-sweep space.
`static class`	`SegregatedFreeListSpace.Sweeper` A callback used to perform sweeping of a free list space.
`class`	`Space` This class defines and manages spaces.

Uses of Uninterruptible in org.mmtk.policy.immix

Classes in org.mmtk.policy.immix with annotations of type Uninterruptible
`class`	`Block` This class defines operations over block-granularity meta-data
`class`	`Chunk`
`class`	`ChunkList`
`class`	`CollectorLocal` This class implements unsynchronized (local) elements of an immix collector.
`class`	`Defrag`
`class`	`ImmixSpace` Each instance of this class corresponds to one immix space.
`class`	`Line`
`class`	`MutatorLocal`
`class`	`ObjectHeader`

Uses of Uninterruptible in org.mmtk.utility

Classes in org.mmtk.utility with annotations of type Uninterruptible
`(package private) class`	`BaseGenericFreeList` This is a very simple, generic malloc-free allocator.
`class`	`Conversions`
`(package private) class`	`CycleDetector`
`class`	`DoublyLinkedList` FIXME This class must be re-written as it makes the assumption that the implementation language (Java) and the language being implemented are the same.
`class`	`ForwardingWord` This class provides generic support for object forwarding, which is specific to a few policies that support copying.
`class`	`GenericFreeList` This is a very simple, generic malloc-free allocator.
`class`	`HeaderByte` This class provides generic support for operations over the GC byte within each object's header word.
`class`	`Log` Error and trace logging.
`class`	`Memory` This class implements basic memory copying, setting and clearing operations.
`class`	`SimpleHashtable` This class implements a simple hashtable.
`class`	`TraceGenerator` Class that supports scanning Objects and Arrays for references during tracing, handling those references, and computing death times
`class`	`Treadmill` FIXME The DoublyLinkedList class, upon which this depends, must be re-written as it makes the assumption that the implementation language (Java) and the language being implemented are the same.

Uses of Uninterruptible in org.mmtk.utility.alloc

Classes in org.mmtk.utility.alloc with annotations of type Uninterruptible
`class`	`Allocator` This abstract base class provides the basis for processor-local allocation.
`class`	`BlockAllocator` This class implements "block" data structures of various sizes.
`class`	`BumpPointer` This class implements a bump pointer allocator that allows linearly scanning through the allocated objects.
`class`	`DumpLinearScan` Simple linear scan to dump object information.
`class`	`EmbeddedMetaData` This plan implements constants and access methods for meta data that is embedded in allocation spaces (rather than kept on the side).
`class`	`ImmixAllocator`
`class`	`LargeObjectAllocator` This abstract class implements core functionality for a generic large object allocator.
`class`	`LinearScan` Callbacks from BumpPointer during a linear scan are dispatched through a subclass of this object.
`class`	`SegregatedFreeList<S extends SegregatedFreeListSpace>` This abstract class implements the fast past for a segregated free list.
`class`	`SegregatedFreeListLocal<S extends SegregatedFreeListSpace>` This abstract class implements a simple segregated free list.

Uses of Uninterruptible in org.mmtk.utility.deque

Classes in org.mmtk.utility.deque with annotations of type Uninterruptible
`class`	`AddressDeque` This supports unsynchronized enqueuing and dequeuing of addresses
`class`	`AddressPairDeque` This supports unsynchronized enqueuing and dequeuing of address pairs
`class`	`AddressTripleDeque` This supports unsynchronized enqueuing and dequeuing of address triples
`(package private) class`	`Deque` Class that defines a doubly-linked double-ended queue (deque).
`class`	`LocalDeque` Note this may perform poorly when being used as a FIFO structure with insertHead and pop operations operating on the same buffer.
`(package private) class`	`LocalQueue` This class implements a local (unsynchronized) queue.
`(package private) class`	`LocalSSB` This class implements a local (unsynchronized) sequential store buffer.
`class`	`ObjectReferenceBuffer` This class is a combination of a Deque and a TraceStep, designed to include intelligent processing of child references as objects are scanned.
`class`	`ObjectReferenceDeque` This supports unsynchronized enqueuing and dequeuing of object references
`class`	`SharedDeque` This supports unsynchronized enqueuing and dequeuing of buffers for shared use.
`class`	`SortSharedDeque` This supports unsynchronized enqueuing and dequeuing of buffers for shared use.
`class`	`SortTODAddressStack` This supports unsynchronized pushing and popping of addresses.
`class`	`SortTODObjectReferenceStack` This supports unsynchronized pushing and popping of object references.
`class`	`SortTODSharedDeque` This class specializes SortSharedQueue to sort objects according to their time of death (TOD).
`class`	`TraceBuffer` This supports unsynchronized enqueuing and dequeuing of tracing data and bulk processing of the buffer.
`class`	`WriteBuffer` This supports unsynchronized insertion of write buffer values.

Uses of Uninterruptible in org.mmtk.utility.gcspy

Classes in org.mmtk.utility.gcspy with annotations of type Uninterruptible
`class`	`Color` Cut-down implementation of java.awt.Color sufficient to provide the server side (Stream) with colours
`class`	`GCspy` This class implements collector-independent GCspy functionality to start the GCspy server.
`class`	`LinearScan` This class is only necessary because we cannot implement org.mmtk.utility.alloc.LinearScan as an interface since the invokeinterface bytecode is forbidden in uninterruptible code.
`class`	`Subspace` This class is an abstraction of a contiguous region of a Space.

Uses of Uninterruptible in org.mmtk.utility.gcspy.drivers

Classes in org.mmtk.utility.gcspy.drivers with annotations of type Uninterruptible
`class`	`AbstractDriver` Abstract GCspy driver for MMTk collectors.
`class`	`GenImmortalSpaceDriver` GCspy driver for the MMTk generational immortal space.
`class`	`GenLOSDriver` This class extends a simple driver for the MMTk LargeObjectSpace for Generational Collectors.
`class`	`ImmortalSpaceDriver` GCspy driver for the contiguous MMTk ImmortalSpace.
`private class`	`ImmortalSpaceDriver.Closure` Used to visit the edges in the immortal object.
`class`	`LinearSpaceDriver` GCspy driver for the MMTk ContigousSpace.
`class`	`TreadmillDriver` This class implements a simple driver for the MMTk LargeObjectSpace.

Uses of Uninterruptible in org.mmtk.utility.heap

Classes in org.mmtk.utility.heap with annotations of type Uninterruptible
`class`	`ConcurrentZeroingContext` This context concurrently zeroes a space when triggered.
`class`	`FreeListPageResource` This class manages the allocation of pages for a space.
`class`	`HeapGrowthManager` This class is responsible for growing and shrinking the heap size by observing heap utilization and GC load.
`class`	`Map` This class manages the mapping of spaces to virtual memory ranges.
`class`	`Mmapper` This class implements mmapping and protection of virtual memory.
`class`	`MonotonePageResource` This class manages the allocation of pages for a space.
`class`	`PageResource` This class manages the allocation of pages for a space.
`class`	`SpaceDescriptor` This class manages the encoding and decoding of space descriptors.

Methods in org.mmtk.utility.heap with annotations of type Uninterruptible
`static boolean`	`Mmapper.addressIsMapped(Address addr)` Return `true` if the given address has been mmapped
`static boolean`	`Mmapper.objectIsMapped(ObjectReference object)` Return `true` if the given object has been mmapped

Uses of Uninterruptible in org.mmtk.utility.options

Classes in org.mmtk.utility.options with annotations of type Uninterruptible
`class`	`NurseryZeroing` The zeroing approach to use for new object allocations.

Methods in org.mmtk.utility.options with annotations of type Uninterruptible
`int`	`NurserySize.getMaxNursery()` Read the upper bound of the nursery size.
`int`	`NurserySize.getMinNursery()` Read the lower bound of the nursery size.
`int`	`TraceRate.getValue()` Return the appropriate value.

Uses of Uninterruptible in org.mmtk.utility.sanitychecker

Classes in org.mmtk.utility.sanitychecker with annotations of type Uninterruptible
`class`	`SanityChecker` This class performs sanity checks for Simple collectors.
`class`	`SanityCheckerLocal` This class performs sanity checks for Simple collectors.
`class`	`SanityDataTable` This class implements a simple hashtable to store and retrieve per object information for sanity checking.
`(package private) class`	`SanityLinearScan` This class performs sanity checks for Simple collectors.
`class`	`SanityRootTraceLocal` This class implements the parallel root-gathering part of a sanity check.
`class`	`SanityTraceLocal` This class implements the simply sanity closure.

Uses of Uninterruptible in org.mmtk.utility.statistics

Classes in org.mmtk.utility.statistics with annotations of type Uninterruptible
`class`	`BooleanCounter` This class implements a simple boolean counter (counting number of phases where some boolean event is true).
`class`	`Counter` This abstract class describes the interface of a generic counter.
`class`	`EventCounter` This class implements a simple event counter (counting number events that occur for each phase).
`class`	`LongCounter` This abstract class implements a simple counter (counting some integer (long) value for each phase).
`class`	`PerfEvent` This class represents a perf event, such as cache misses, etc.
`class`	`SizeCounter` This class implements a simple counter of events of different sizes (eg object allocations, where total number of objects and total volume of objects would be counted).
`class`	`Stats` This class implements basic statistics functionality
`class`	`Timer` This class implements a simple timer.
`class`	`Xml` Utility class for writing statistics out in XML format.

Uses of Uninterruptible in org.mmtk.vm

Classes in org.mmtk.vm with annotations of type Uninterruptible
`class`	`ActivePlan` Stub to give access to plan local, constraint and global instances
`class`	`Assert`
`class`	`Barriers`
`class`	`Collection`
`class`	`Debug`
`class`	`FinalizableProcessor` This class manages finalizable objects.
`class`	`Lock` Simple, fair locks with deadlock detection.
`class`	`Memory`
`class`	`MMTk_Events` Event generation interface for MMTk.
`class`	`Monitor` Provides MMTk access to a heavy lock with condition variable.
`class`	`ObjectModel`
`class`	`ReferenceProcessor` This class manages SoftReferences, WeakReferences, and PhantomReferences.
`class`	`Scanning`
`class`	`Statistics`
`class`	`Strings`
`class`	`SynchronizedCounter` A counter that supports atomic increment and reset.
`class`	`TraceInterface` Class that supports scanning Objects or Arrays for references during tracing, handling those references, and computing death times

Uses of Uninterruptible in org.mmtk.vm.gcspy

Classes in org.mmtk.vm.gcspy with annotations of type Uninterruptible
`class`	`ByteStream` Set up a GCspy Stream with data type BYTE_TYPE
`class`	`IntStream` Set up a GCspy Stream with data type INT_TYPE.
`class`	`ServerInterpreter` Abstract class for the GCspy server interpreter Implementing classes will mostly forward calls to the C gcspy library.
`class`	`ServerSpace` Abstract class for the GCspy Space abstraction.
`class`	`ShortStream` Set up a GCspy Stream with data type SHORT_TYPE.
`class`	`Stream` Abstract class for a GCspy Stream.
`class`	`Util` Abstract class that provides generally useful methods.

Uses of Uninterruptible in org.vmmagic.unboxed

Classes in org.vmmagic.unboxed with annotations of type Uninterruptible
`(package private) class`	`ArchitecturalWord`

Uses of Uninterruptible in org.vmutil.options

Methods in org.vmutil.options with annotations of type Uninterruptible
`protected abstract int`	`OptionSet.bytesToPages(Extent bytes)` Convert bytes into pages, rounding up if necessary.
`Extent`	`PagesOption.getBytes()` Read the current value of the option in bytes.
`Extent`	`PagesOption.getDefaultBytes()` Read the default value of the option in bytes.
`int`	`MicrosecondsOption.getDefaultMicroseconds()` Read the default value of the option in microseconds.
`int`	`MicrosecondsOption.getDefaultMilliseconds()` Read the default value of the option in milliseconds.
`int`	`PagesOption.getDefaultPages()` Read the default value of the option in pages.
`Address`	`AddressOption.getDefaultValue()` Read the default value of the option.
`String`	`StringOption.getDefaultValue()` Read the default value of the option
`int`	`IntOption.getDefaultValue()` Read the default value of the option.
`float`	`FloatOption.getDefaultValue()` Read the default value of the option
`int`	`EnumOption.getDefaultValue()` Read the default value of the option.
`boolean`	`BooleanOption.getDefaultValue()` Read the default value of the option.
`String`	`EnumOption.getDefaultValueString()` Read the string for the default value of the option.
`int`	`MicrosecondsOption.getMicroseconds()` Read the current value of the option in microseconds.
`int`	`MicrosecondsOption.getMilliseconds()` Read the current value of the option in milliseconds.
`int`	`PagesOption.getPages()` Read the current value of the option in pages.
`Address`	`AddressOption.getValue()` Read the current value of the option.
`String`	`StringOption.getValue()` Read the current value of the option.
`int`	`IntOption.getValue()` Read the current value of the option.
`float`	`FloatOption.getValue()` Read the current value of the option.
`int`	`EnumOption.getValue()` Read the current value of the option.
`boolean`	`BooleanOption.getValue()` Read the current value of the option.
`String`	`EnumOption.getValueString()` Read the string for the current value of the option.
`protected abstract Extent`	`OptionSet.pagesToBytes(int pages)` Convert from pages into bytes.

Overview

Package

Class

Use

Tree

Serialized

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Classorg.vmmagic.pragma.Uninterruptible

Uses of Class
org.vmmagic.pragma.Uninterruptible