Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
org.vmmagic.pragma.Unpreemptible

Packages that use Unpreemptible
org.jikesrvm   
org.jikesrvm.adaptive   
org.jikesrvm.adaptive.measurements.organizers   
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.jni   
org.jikesrvm.mm.mminterface   
org.jikesrvm.mm.mmtk   
org.jikesrvm.objectmodel   
org.jikesrvm.runtime   
org.jikesrvm.scheduler   
org.mmtk.plan   
org.mmtk.plan.concurrent   
org.mmtk.vm   
 

Uses of Unpreemptible in org.jikesrvm
 

Methods in org.jikesrvm with annotations of type Unpreemptible
static void VM.disableGC()
          The disableGC() and enableGC() methods are for use as guards to protect code that must deal with raw object addresses in a collection-safe manner (i.e. code that holds raw pointers across "gc-sites").
static void VM.disableGC(boolean recursiveOK)
          disableGC: Disable GC if it hasn't already been disabled.
 

Uses of Unpreemptible in org.jikesrvm.adaptive
 

Classes in org.jikesrvm.adaptive with annotations of type Unpreemptible
 class OSRListener
          Code invoked from Thread.yieldpoint for the purposes of OSR.
 

Methods in org.jikesrvm.adaptive with annotations of type Unpreemptible
static void OnStackReplacementTrigger.trigger(int ypTakenInCMID, Offset tsFromFPoff, Offset ypTakenFPoff, int whereFrom)
          Trigger an OSR from a running thread.
 

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

Methods in org.jikesrvm.adaptive.measurements.organizers with annotations of type Unpreemptible
private  void Organizer.passivate()
           
 

Uses of Unpreemptible in org.jikesrvm.classloader
 

Methods in org.jikesrvm.classloader with annotations of type Unpreemptible
 CompiledMethod RVMMethod.getCurrentCompiledMethod()
          Get the current compiled method for this method.
 

Uses of Unpreemptible in org.jikesrvm.compilers.baseline
 

Methods in org.jikesrvm.compilers.baseline with annotations of type Unpreemptible
 int BaselineCompiledMethod.findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)
          Find a catch block within the compiled method
 

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

Methods in org.jikesrvm.compilers.baseline.ia32 with annotations of type Unpreemptible
 void BaselineExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Pass control to a catch block.
 void BaselineExceptionDeliverer.unwindStackFrame(CompiledMethod compiledMethod, ArchitectureSpecific.Registers registers)
          Unwind a stackframe.
 

Uses of Unpreemptible in org.jikesrvm.compilers.common
 

Methods in org.jikesrvm.compilers.common with annotations of type Unpreemptible
static int ExceptionTable.findCatchBlockForInstruction(int[] eTable, Offset instructionOffset, RVMType exceptionType)
          Return the machine code offset for the catch block that will handle the argument exceptionType,or -1 if no such catch block exists.
abstract  int CompiledMethod.findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)
          Find "catch" block for a machine instruction of this method that might be guarded against specified class of exceptions by a "try" block.
 int HardwareTrapCompiledMethod.findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)
           
 

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

Classes in org.jikesrvm.compilers.opt.runtimesupport with annotations of type Unpreemptible
 class OptSaveVolatile
          Contains routines that must be compiled with special prologues and eplilogues that save/restore all registers (both volatile and non-volatile).
 

Methods in org.jikesrvm.compilers.opt.runtimesupport with annotations of type Unpreemptible
 int OptCompiledMethod.findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)
          Find "catch" block for a machine instruction of this method.
 

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

Methods in org.jikesrvm.compilers.opt.runtimesupport.ia32 with annotations of type Unpreemptible
 void OptExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Pass control to a catch block.
 void OptExceptionDeliverer.unwindStackFrame(CompiledMethod compiledMethod, ArchitectureSpecific.Registers registers)
          Unwind a stackframe.
 

Uses of Unpreemptible in org.jikesrvm.jni
 

Methods in org.jikesrvm.jni with annotations of type Unpreemptible
 Object JNIEnvironment.exitFromJNI(int offset)
          Restore data, throw pending exceptions or convert return value for exit from JNI.
 int JNICompiledMethod.findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)
           
static void JNIEnvironment.throwPendingException()
          Return and clear the (known to be non-null) pending exception.
 

Uses of Unpreemptible in org.jikesrvm.mm.mminterface
 

Methods in org.jikesrvm.mm.mminterface with annotations of type Unpreemptible
static Object MemoryManager.allocateArray(int numElements, int logElementSize, int headerSize, TIB tib, int allocator, int align, int offset, int site)
          Allocate an array object.
static Object MemoryManager.getFinalizedObject()
          Gets an object from the list of objects that are to be reclaimed and need to have their finalize method called.
static byte[] MemoryManager.newStack(int bytes)
          Allocate a stack
 void CollectorThread.run()
          Collection entry point.
 

Uses of Unpreemptible in org.jikesrvm.mm.mmtk
 

Methods in org.jikesrvm.mm.mmtk with annotations of type Unpreemptible
static void FinalizableProcessor.addCandidate(Object object)
          Add a finalization candidate.
private  void ReferenceProcessor.addCandidate(Reference<?> ref, ObjectReference referent)
          Add a reference to the list of references.
 void Collection.blockForGC()
           
 boolean ReferenceProcessor.enqueueReference(ObjectReference addr)
          Put this Reference object on its ReferenceQueue (if it has one) when its referent is no longer sufficiently reachable.
static Object FinalizableProcessor.getForFinalize()
          Get an object to call the finalize() method on it.
 Object FinalizableProcessor.getReady()
          Get an object to run finalize().
 void Collection.resumeAllMutators()
           
 void Collection.stopAllMutators()
           
 

Uses of Unpreemptible in org.jikesrvm.objectmodel
 

Methods in org.jikesrvm.objectmodel with annotations of type Unpreemptible
static void ObjectModel.genericLock(Object o)
          Generic lock
static void JavaHeader.genericLock(Object o)
          Generic lock
static void ObjectModel.genericUnlock(Object o)
          Generic unlock
static void JavaHeader.genericUnlock(Object o)
          Generic unlock
static Lock ObjectModel.getHeavyLock(Object o, boolean create)
          Obtains the heavy-weight lock, if there is one, associated with the indicated object.
static Lock JavaHeader.getHeavyLock(Object o, boolean create)
          Obtains the heavy-weight lock, if there is one, associated with the indicated object.
 

Uses of Unpreemptible in org.jikesrvm.runtime
 

Methods in org.jikesrvm.runtime with annotations of type Unpreemptible
static void RuntimeEntrypoints.athrow(Throwable exceptionObject)
          Deliver a software exception to current java thread.
static int FileSystem.bytesAvailable(int fd)
           
abstract  void ExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Stackframe's method has a "catch" block for exception being thrown and control is to be passed to that catch block.
private static void RuntimeEntrypoints.deliverException(Throwable exceptionObject, ArchitectureSpecific.Registers exceptionRegisters)
          Deliver an exception to current java thread.
static int FileSystem.readByte(int fd)
          Read single byte from file.
static int FileSystem.readBytes(int fd, byte[] buf, int off, int cnt)
          Read multiple bytes.
static boolean FileSystem.sync(int fd)
           
abstract  void ExceptionDeliverer.unwindStackFrame(CompiledMethod compiledMethod, ArchitectureSpecific.Registers registers)
          Stackframe's method has no "catch" block for exception being thrown and stackframe is to be "unwound" as follows: 1. for a synchronized method, call ObjectModel.genericUnlock(), passing it the appropriate "lock" object for non-static methods, the lock is the method's first argument ("this") for static methods, the lock is the method's java.lang.Class 2. restore the non-volatile registers (including fp) that were saved in the method's prologue, by copying them from the method's stackframe save area into the provided "registers" object
static int FileSystem.writeByte(int fd, int b)
          Write single byte to file
static int FileSystem.writeBytes(int fd, byte[] buf, int off, int cnt)
          Write multiple bytes.
 

Uses of Unpreemptible in org.jikesrvm.scheduler
 

Classes in org.jikesrvm.scheduler with annotations of type Unpreemptible
 class Latch
          An implementation of a latch using the HeavyCondLock in "nice" mode.
 

Methods in org.jikesrvm.scheduler with annotations of type Unpreemptible
protected static Lock ThinLock.attemptToInflate(Object o, Offset lockOffset, Lock l)
          Promotes a light-weight lock to a heavy-weight lock.
static boolean ThinLock.attemptToMarkInflated(Object o, Offset lockOffset, Word oldLockWord, int lockId, int cnt)
           
 void RVMThread.beginPairHandshake()
           
 void RVMThread.beginPairWith(RVMThread other)
           
 void RVMThread.beginPairWithCurrent()
           
 int RVMThread.block(RVMThread.BlockAdapter ba)
           
(package private)  int RVMThread.block(RVMThread.BlockAdapter ba, boolean asynchronous)
          Attempt to block the thread, and return the state it is in after the attempt.
static void RVMThread.blockAllMutatorsForGC()
          Stop all mutator threads.
static boolean ThinLock.casFromBiased(Object o, Offset lockOffset, Word oldLockWord, Word changed, int cnt)
           
(package private)  void RVMThread.checkBlock()
          Check if the thread is supposed to block, and if so, block it.
private  void RVMThread.checkBlockNoSaveContext()
          A variant of checkBlock() that does not save the thread state.
static Lock ThinLock.getHeavyLock(Object o, Offset lockOffset, boolean create)
          Obtains the heavy-weight lock, if there is one, associated with the indicated object.
static void RVMThread.hardHandshakeResume()
           
static void RVMThread.hardHandshakeResume(RVMThread.BlockAdapter ba, RVMThread.HardHandshakeVisitor hhv)
           
static void RVMThread.hardHandshakeSuspend()
           
static void RVMThread.hardHandshakeSuspend(RVMThread.BlockAdapter ba, RVMThread.HardHandshakeVisitor hhv)
           
private static Lock ThinLock.inflate(Object o, Offset lockOffset)
          Promotes a light-weight lock to a heavy-weight lock.
private static boolean ThinLock.inflateAndLock(Object o, Offset lockOffset)
          Promotes a light-weight lock to a heavy-weight lock and locks it.
static void ThinLock.inlineLock(Object o, Offset lockOffset)
           
static void ThinLock.inlineUnlock(Object o, Offset lockOffset)
           
private  void RVMThread.leaveJNIBlocked()
           
static void RVMThread.leaveJNIBlockedFromCallIntoNative()
          Called when JNI code tried to transition from IN_JNI to IN_JAVA but failed
(package private) static void RVMThread.leaveJNIBlockedFromJNIFunctionCall()
           
static void RVMThread.leaveJNIFromCallIntoNative()
           
static void RVMThread.leaveJNIFromJNIFunctionCall()
           
static void RVMThread.leaveNative()
          Leave privileged code.
private  void RVMThread.leaveNativeBlocked()
           
private  void RVMThread.leaveNativeBlockedImpl()
           
static void ThinLock.lock(Object o, Offset lockOffset)
           
 void LightMonitor.lockedBroadcastWithHandshake()
           
 boolean Lock.lockHeavy(Object o)
          Acquires this heavy-weight lock on the indicated object.
 boolean Lock.lockHeavyLocked(Object o)
          Complete the task of acquiring the heavy lock, assuming that the mutex is already acquired (locked).
 void NoYieldpointsMonitor.lockWithHandshake()
           
 void Monitor.lockWithHandshake()
          Wait until it is possible to acquire the lock and then acquire it.
 void LightMonitor.lockWithHandshake()
           
static void Monitor.lockWithHandshake(Monitor m1, Word priority1, Monitor m2, Word priority2)
           
private  void Monitor.lockWithHandshakeNoRec()
           
private  void Monitor.lockWithHandshakeNoRecImpl()
           
 void Monitor.relockWithHandshake(int recCount)
          Relock the mutex after using unlockCompletely, but do so "nicely".
private  void Monitor.relockWithHandshakeImpl(int recCount)
           
static void RVMThread.resizeCurrentStack(int newSize, ArchitectureSpecific.Registers exceptionRegisters)
          Change the size of the currently executing thread's stack.
static void RVMThread.returnBarrier()
          The return barrier.
 int RVMThread.safeAsyncBlock(RVMThread.BlockAdapter ba)
           
 int RVMThread.safeBlock(RVMThread.BlockAdapter ba)
           
private  int RVMThread.safeBlock(RVMThread.BlockAdapter ba, boolean asynchronous)
           
private static void ThinLock.setDedicatedU16(Object o, Offset lockOffset, Word value)
          Set only the dedicated locking 16-bit part of the given value.
static void RVMThread.softHandshake(RVMThread.SoftHandshakeVisitor v)
          Tell each thread to take a yieldpoint and wait until all of them have done so at least once.
private  void RVMThread.terminateUnpreemptible()
          Unpreemptible portion of thread termination.
private static void RVMThread.throwFromUninterruptible(Throwable e)
           
 void Monitor.timedWaitAbsoluteWithHandshake(long whenWakeupNanos)
          Wait until someone calls broadcast, or until the clock reaches the given time.
private  void Monitor.timedWaitAbsoluteWithHandshakeImpl(long whenWakeupNanos)
           
 void Monitor.timedWaitRelativeWithHandshake(long delayNanos)
          Wait until someone calls broadcast, or until at least the given number of nanoseconds pass.
private  void Monitor.timedWaitRelativeWithHandshakeImpl(long delayNanos)
           
static void RVMThread.unblockAllMutatorsForGC()
          Unblock all mutators blocked for GC.
static void ThinLock.unlock(Object o, Offset lockOffset)
           
 void Lock.unlockHeavy(Object o)
          Releases this heavy-weight lock on the indicated object.
 void Monitor.waitWithHandshake()
          Wait until someone calls broadcast.
private  void Monitor.waitWithHandshakeImpl()
           
static void RVMThread.yieldpoint(int whereFrom, Address yieldpointServiceMethodFP)
          Process a taken yieldpoint.
static void RVMThread.yieldpointFromBackedge()
          Yieldpoint taken on backedge.
static void RVMThread.yieldpointFromEpilogue()
          Yieldpoint taken in epilogue.
static void RVMThread.yieldpointFromPrologue()
          Yieldpoint taken in prologue.
 

Uses of Unpreemptible in org.mmtk.plan
 

Methods in org.mmtk.plan with annotations of type Unpreemptible
 void StopTheWorldCollector.concurrentCollect()
          Perform some concurrent garbage collection
static void Plan.handleUserCollectionRequest()
          The application code has requested a collection.
static boolean Phase.notifyConcurrentPhaseComplete()
          Notify that the concurrent phase has completed successfully.
 void ParallelCollector.run()
          Entry point for the collector context.
 void ControllerCollectorContext.run()
          Main execution loop.
abstract  void CollectorContext.run()
          Entry point for the collector context.
 

Uses of Unpreemptible in org.mmtk.plan.concurrent
 

Methods in org.mmtk.plan.concurrent with annotations of type Unpreemptible
 void ConcurrentCollector.concurrentCollect()
          Perform some concurrent garbage collection
 void ConcurrentCollector.concurrentCollectionPhase(short phaseId)
          Perform some concurrent collection work.
 void ConcurrentCollector.run()
          Entry point for the collector context.
 

Uses of Unpreemptible in org.mmtk.vm
 

Methods in org.mmtk.vm with annotations of type Unpreemptible
abstract  void Collection.blockForGC()
          Block for the garbage collector.
abstract  void Collection.resumeAllMutators()
          Resume all mutators blocked for GC.
abstract  void Collection.stopAllMutators()
          Stop all mutator threads.
 

Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES