org.jikesrvm.scheduler
Class RVMThread

java.lang.Object
  org.mmtk.plan.MutatorContext
      org.mmtk.plan.SimpleMutator
          org.mmtk.plan.StopTheWorldMutator
              org.mmtk.plan.generational.GenMutator
                  org.mmtk.plan.generational.immix.GenImmixMutator
                      org.jikesrvm.mm.mminterface.Selected.Mutator
                          org.jikesrvm.mm.mminterface.ThreadContext
                              org.jikesrvm.scheduler.RVMThread

All Implemented Interfaces:

HeapLayoutConstants, ThinLockConstants, TIBLayoutConstants, SizeConstants, Constants

public final class RVMThread
extends ThreadContext
implements Constants

A generic java thread's execution context.

Threads use a state machine to indicate to other threads, as well as VM services, how this thread should be treated in the case of an asynchronous request, for example in the case of GC. The state machine uses the following states:

• NEW
• IN_JAVA
• IN_NATIVE
• IN_JNI
• IN_JAVA_TO_BLOCK
• BLOCKED_IN_NATIVE
• BLOCKED_IN_JNI
• TERMINATED

• NEW to IN_JAVA: occurs when the thread is actually started. At this point it is safe to expect that the thread will reach a safe point in some bounded amount of time, at which point it will have a complete execution context, and this will be able to have its stack traces by GC.
• IN_JAVA to IN_JAVA_TO_BLOCK: occurs when an asynchronous request is made, for example to stop for GC, do a mutator flush, or do an isync on PPC.
• IN_JAVA to IN_NATIVE: occurs when the code opts to run in privileged mode, without synchronizing with GC. This state transition is only performed by HeavyCondLock, in cases where the thread is about to go idle while waiting for notifications (such as in the case of park, wait, or sleep).
• IN_JAVA to IN_JNI: occurs in response to a JNI downcall, or return from a JNI upcall.
• IN_JAVA_TO_BLOCK to BLOCKED_IN_NATIVE: occurs when a thread that had been asked to perform an async activity decides to go idle instead. This state always corresponds to a notification being sent to other threads, letting them know that this thread is idle. When the thread is idle, any asynchronous requests (such as mutator flushes) can instead be performed on behalf of this thread by other threads, since this thread is guaranteed not to be running any user Java code, and will not be able to return to running Java code without first blocking, and waiting to be unblocked (see BLOCKED_IN_NATIVE to IN_JAVA transition.
• IN_JAVA_TO_BLOCK to BLOCKED_IN_JNI: occurs when a thread that had been asked to perform an async activity decides to make a JNI downcall, or return from a JNI upcall, instead. In all other regards, this is identical to the IN_JAVA_TO_BLOCK to BLOCKED_IN_NATIVE transition.
• IN_NATIVE to IN_JAVA: occurs when a thread returns from idling or running privileged code to running Java code.
• BLOCKED_IN_NATIVE to IN_JAVA: occurs when a thread that had been asked to perform an async activity while running privileged code or idling decides to go back to running Java code. The actual transition is preceded by the thread first performing any requested actions (such as mutator flushes) and waiting for a notification that it is safe to continue running (for example, the thread may wait until GC is finished).
• IN_JNI to IN_JAVA: occurs when a thread returns from a JNI downcall, or makes a JNI upcall.
• BLOCKED_IN_JNI to IN_JAVA: same as BLOCKED_IN_NATIVE to IN_JAVA, except that this occurs in response to a return from a JNI downcall, or as the thread makes a JNI upcall.
• IN_JAVA to TERMINATED: the thread has terminated, and will never reach any more safe points, and thus will not be able to respond to any more requests for async activities.

See Also:

CollectorThread, FinalizerThread, Organizer

traceBlock

protected static final boolean traceBlock

Trace thread blockage

See Also:

Constant Field Values

traceReallyBlock

protected static final boolean traceReallyBlock

Trace when a thread is really blocked

See Also:

Constant Field Values

traceAboutToTerminate

protected static final boolean traceAboutToTerminate

See Also:

Constant Field Values

dumpStackOnBlock

protected static final boolean dumpStackOnBlock

See Also:

Constant Field Values

traceBind

protected static final boolean traceBind

See Also:

Constant Field Values

traceAcct

protected static final boolean traceAcct

Trace thread start/stop

See Also:

Constant Field Values

trace

protected static final boolean trace

Trace execution

See Also:

Constant Field Values

traceTermination

private static final boolean traceTermination

Trace thread termination

See Also:

Constant Field Values

traceAdjustments

private static final boolean traceAdjustments

Trace adjustments to stack size

See Also:

Constant Field Values

neverKillThreads

private static final boolean neverKillThreads

Never kill threads. Useful for testing bugs related to interaction of thread death with for example MMTk. For production, this should never be set to true.

See Also:

Constant Field Values

STATS

private static final boolean STATS

Generate statistics?

See Also:

Constant Field Values

waitOperations

static int waitOperations

Number of wait operations

timedWaitOperations

static int timedWaitOperations

Number of timed wait operations

notifyOperations

static int notifyOperations

Number of notify operations

notifyAllOperations

static int notifyAllOperations

Number of notifyAll operations

ALWAYS_LOCK_ON_STATE_TRANSITION

public static final boolean ALWAYS_LOCK_ON_STATE_TRANSITION

See Also:

Constant Field Values

NEW

public static final int NEW

Thread has not yet started. This state holds right up until just before we call pthread_create().

See Also:

Constant Field Values

IN_JAVA

public static final int IN_JAVA

Thread is executing "normal" Java bytecode

See Also:

Constant Field Values

IN_NATIVE

public static final int IN_NATIVE

A state used by the scheduler to mark that a thread is in privileged code that does not need to synchronize with the collector. This is a special state, similar to the IN_JNI state but requiring different interaction with the collector (as there is no JNI stack frame, the registers have to be saved in contextRegisters). As well, this state should only be entered from privileged code in the org.jikesrvm.scheduler package. Typically, this state is entered using a call to enterNative() just prior to idling the thread; though it would not be wrong to enter it prior to any other long-running activity that does not require interaction with the GC.

See Also:

Constant Field Values

IN_JNI

public static final int IN_JNI

Same as IN_NATIVE, except that we're executing JNI code and thus have a JNI stack frame and JNI environment, and thus the GC can load registers from there rather than using contextRegisters.

See Also:

Constant Field Values

IN_JAVA_TO_BLOCK

public static final int IN_JAVA_TO_BLOCK

thread is in Java code but is expected to block. the transition from IN_JAVA to IN_jAVA_TO_BLOCK happens as a result of an asynchronous call by the GC or any other internal VM code that requires this thread to perform an asynchronous activity (another example is the request to do an isync on PPC). the point is that we're waiting for the thread to reach a safe point and expect this to happen in bounded time; but if the thread were to escape to native we want to know about it. thus, transitions into native code while in the IN_JAVA_TO_BLOCK state result in a notification (broadcast on the thread's monitor) and a state change to BLOCKED_IN_NATIVE. Observe that it is always safe to conservatively change IN_JAVA to IN_JAVA_TO_BLOCK.

See Also:

Constant Field Values

BLOCKED_IN_NATIVE

public static final int BLOCKED_IN_NATIVE

thread is in native code, and is to block before returning to Java code. the transition from IN_NATIVE to BLOCKED_IN_NATIVE happens as a result of an asynchronous call by the GC or any other internal VM code that requires this thread to perform an asynchronous activity (another example is the request to do an isync on PPC). as well, code entering privileged code that would otherwise go from IN_JAVA to IN_NATIVE will go to BLOCKED_IN_NATIVE instead, if the state was IN_JAVA_TO_BLOCK.

the point of this state is that the thread is guaranteed not to execute any Java code until:

1. The state changes to IN_NATIVE, and
2. The thread gets a broadcast on its monitor.

Observe that it is always safe to conservatively change IN_NATIVE to BLOCKED_IN_NATIVE.

See Also:

Constant Field Values

BLOCKED_IN_JNI

public static final int BLOCKED_IN_JNI

like BLOCKED_IN_NATIVE, but indicates that the thread is in JNI rather than VM native code.

See Also:

Constant Field Values

TERMINATED

public static final int TERMINATED

Thread has died. As in, it's no longer executing any Java code and will never do so in the future. Once this is set, the GC will no longer mark any part of the thread as live; the thread's stack will be deleted. Note that this is distinct from the aboutToTerminate state.

See Also:

Constant Field Values

LAST_EXEC_STATUS

public static final int LAST_EXEC_STATUS

Not actually a state but just a marker.

See Also:

Constant Field Values

trampolineRegisters

private ArchitectureSpecific.Registers trampolineRegisters

Registers used by return barrier trampoline

hijackedReturnAddress

private Address hijackedReturnAddress

Return address of stack frame hijacked by return barrier

hijackedReturnCalleeFp

private Address hijackedReturnCalleeFp

Callee frame pointer for stack frame hijacked by return barrier

hijackedReturnCallerFp

private Address hijackedReturnCallerFp

Caller frame pointer for stack frame hijacked by return barrier

DEBUG_STACK_TRAMPOLINE

public static final boolean DEBUG_STACK_TRAMPOLINE

debugging flag for return barrier trampoline

See Also:

Constant Field Values

stackTrampolineBridgeInstructions

public static ArchitectureSpecific.CodeArray stackTrampolineBridgeInstructions

pointer to bridge code for return barrier trampoline

execStatus

private int execStatus

Thread state. Indicates if the thread is running, and if so, what mode of execution it is using (Java, VM native, or JNI)

isAboutToTerminate

private boolean isAboutToTerminate

Is the thread about to terminate? Protected by the thread's monitor. Note that this field is not set atomically with the entering of the thread onto the aboutToTerminate array - in fact it happens before that. When this field is set to true, the thread's stack will no longer be scanned by GC. Note that this is distinct from the TERMINATED state.

isBlocking

boolean isBlocking

Is this thread in the process of blocking?

isJoinable

boolean isJoinable

Is the thread no longer executing user code? Protected by the Java monitor associated with the Thread object.

next

RVMThread next

Link pointer for queues (specifically ThreadQueue). A thread can only be on one such queue at a time. The queue that a thread is on is indicated by queuedOn.

queuedOn

volatile ThreadQueue queuedOn

The queue that the thread is on, or null if the thread is not on a queue (specifically ThreadQueue). If the thread is on such a queue, the next field is used as a link pointer.

awaitingSpinLock

SpinLock awaitingSpinLock

Used to handle contention for spin locks

contenderLink

RVMThread contenderLink

thread

private Thread thread

java.lang.Thread wrapper for this Thread. Not final so it may be assigned during booting

name

private String name

Name of the thread (can be changed during execution)

daemon

protected boolean daemon

The virtual machine terminates when the last non-daemon (user) thread terminates.

priority

private int priority

Scheduling priority for this thread. Note that: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY.

threadSlot

public int threadSlot

Index of this thread in threadBySlot[]. This value must be non-zero because it is shifted and used in Object lock ownership tests.

lockingId

public int lockingId

systemThread

private final SystemThread systemThread

Non-null indicates this is a system thread, that is one used by the system and as such doesn't have a Runnable...

bootThread

public static RVMThread bootThread

The boot thread, can't be final so as to allow initialization during boot image writing.

threadingInitialized

public static boolean threadingInitialized

Is the threading system initialized?

timerTicks

public static long timerTicks

Number of timer ticks we've seen

yieldpointsTaken

private long yieldpointsTaken

yieldpointsTakenFully

private long yieldpointsTakenFully

nativeEnteredBlocked

private long nativeEnteredBlocked

jniEnteredBlocked

private long jniEnteredBlocked

disallowAllocationsByThisThread

private boolean disallowAllocationsByThisThread

Assertion checking while manipulating raw addresses -- see VM.disableGC()/VM.enableGC(). A value of "true" means it's an error for this thread to call "new". This is only used for assertion checking; we do not bother to set it when Configuration.VerifyAssertions is false.

disableGCDepth

private int disableGCDepth

Counts the depth of outstanding calls to VM.disableGC(). If this is set, then we should also have disallowAllocationsByThisThread set. The converse also holds.

barriersEntered

public int barriersEntered

barriersExited

public int barriersExited

stack

private byte[] stack

Execution stack for this thread.

stackLimit

public Address stackLimit

The Address of the guard area for stack.

framePointer

Address framePointer

FP for current frame, saved in the prologue of every method

hiddenSignatureId

int hiddenSignatureId

"hidden parameter" for interface invocation thru the IMT

arrayIndexTrapParam

int arrayIndexTrapParam

"hidden parameter" from ArrayIndexOutOfBounds trap to C trap handler

yieldToOSRRequested

public boolean yieldToOSRRequested

Is the next taken yieldpoint in response to a request to perform OSR?

yieldForCBSCall

public boolean yieldForCBSCall

Is CBS enabled for 'call' yieldpoints?

yieldForCBSMethod

public boolean yieldForCBSMethod

Is CBS enabled for 'method' yieldpoints?

numCBSCallSamples

public int numCBSCallSamples

Number of CBS samples to take in this window

countdownCBSCall

public int countdownCBSCall

Number of call yieldpoints between CBS samples

firstCBSCallSample

public int firstCBSCallSample

round robin starting point for CBS samples

numCBSMethodSamples

public int numCBSMethodSamples

Number of CBS samples to take in this window

countdownCBSMethod

public int countdownCBSMethod

Number of counter ticks between CBS samples

firstCBSMethodSample

public int firstCBSMethodSample

round robin starting point for CBS samples

codePatchSyncRequested

public boolean codePatchSyncRequested

flag indicating this processor needs to execute a memory synchronization sequence Used for code patching on SMP PowerPCs.

thread_cbs_counter

public int thread_cbs_counter

For builds using counter-based sampling. This field holds a processor-specific counter so that it can be updated efficiently on SMP's.

yieldpointsEnabledCount

private int yieldpointsEnabledCount

Should this thread yield at yieldpoints? A value of: 1 means "yes" (yieldpoints enabled) <= 0 means "no" (yieldpoints disabled)

yieldpointRequestPending

boolean yieldpointRequestPending

Is a takeYieldpoint request pending on this thread?

atYieldpoint

boolean atYieldpoint

Are we at a yieldpoint right now?

flushRequested

public boolean flushRequested

Is there a flush request for this thread? This is handled via a soft handshake.

softHandshakeRequested

public boolean softHandshakeRequested

Is a soft handshake requested? Logically, this field is protected by the thread's monitor - but it is typically only mucked with when both the thread's monitor and the softHandshakeDataLock are held.

softHandshakeLeft

public static int softHandshakeLeft

How many threads have not yet reached the soft handshake? (protected by softHandshakeDataLock)

softHandshakeDataLock

public static Monitor softHandshakeDataLock

Lock that protects soft handshake fields.

handshakeLock

public static Monitor handshakeLock

Lock that prevents multiple (soft or hard) handshakes from proceeding concurrently.

contextRegisters

public final ArchitectureSpecific.Registers contextRegisters

Place to save register state when this thread is not actually running.

contextRegistersShadow

private final ArchitectureSpecific.Registers contextRegistersShadow

contextRegistersSave

public final ArchitectureSpecific.Registers contextRegistersSave

Place to save register state when this thread is not actually running.

contextRegistersSaveShadow

private final ArchitectureSpecific.Registers contextRegistersSaveShadow

exceptionRegisters

private final ArchitectureSpecific.Registers exceptionRegisters

Place to save register state during hardware(C signal trap handler) or software (RuntimeEntrypoints.athrow) trap handling.

exceptionRegistersShadow

private final ArchitectureSpecific.Registers exceptionRegistersShadow

uncaughtExceptionCount

private int uncaughtExceptionCount

Count of recursive uncaught exceptions, we need to bail out at some point

cachedFreeLock

public Lock cachedFreeLock

A cached free lock. Not a free list; this will only ever contain 0 or 1 locks!

waitObject

protected Object waitObject

Place to save/restore this thread's monitor state during Object.wait() and Object.notify().

waitCount

protected int waitCount

Lock recursion count for this thread's monitor.

shouldSuspend

boolean shouldSuspend

Should the thread suspend?

shouldSuspendToken

int shouldSuspendToken

An integer token identifying the last suspend request

isSuspended

boolean isSuspended

Is the thread suspended?

shouldBlockForHandshake

boolean shouldBlockForHandshake

Should the thread block for handshake?

isBlockedForHandshake

boolean isBlockedForHandshake

Is the thread blocked for handshake?

shouldBlockForGC

boolean shouldBlockForGC

Should the thread block for a thread-to-thread communication?

isBlockedForGC

boolean isBlockedForGC

Is the thread blocked for thread-to-thread communication?

suspendBlockAdapter

public static final RVMThread.SuspendBlockAdapter suspendBlockAdapter

handshakeBlockAdapter

public static final RVMThread.HandshakeBlockAdapter handshakeBlockAdapter

gcBlockAdapter

public static final RVMThread.GCBlockAdapter gcBlockAdapter

blockAdapters

static final RVMThread.BlockAdapter[] blockAdapters

waiting

protected RVMThread.Waiting waiting

Accounting of whether or not a thread is waiting (in the Java thread state sense), and if so, how it's waiting.

Invariant: the RVM runtime does not ever use this field for any purpose other than updating it so that the java.lang.Thread knows the state. Thus, if you get sloppy with this field, the worst case outcome is that some Java program that queries the thread state will get something other than what it may or may not have expected.

asyncThrowable

Throwable asyncThrowable

Exception to throw in this thread at the earliest possible point.

hasInterrupt

boolean hasInterrupt

Has the thread been interrupted?

takeYieldpoint

public int takeYieldpoint

Should the next executed yieldpoint be taken? Can be true for a variety of reasons. See RVMThread.yieldpoint

To support efficient sampling of only prologue/epilogues we also encode some extra information into this field. 0 means that the yieldpoint should not be taken. >0 means that the next yieldpoint of any type should be taken <0 means that the next prologue/epilogue yieldpoint should be taken

Note the following rules:

1. If takeYieldpoint is set to 0 or -1 it is perfectly safe to set it to 1; this will have almost no effect on the system. Thus, setting takeYieldpoint to 1 can always be done without acquiring locks.
2. Setting takeYieldpoint to any value other than 1 should be done while holding the thread's monitor().
3. The exception to rule (2) above is that the yieldpoint itself sets takeYieldpoint to 0 without holding a lock - but this is done after it ensures that the yieldpoint is deferred by setting yieldpointRequestPending to true.

timeSliceExpired

public int timeSliceExpired

How many times has the "timeslice" expired? This is only used for profiling and OSR (in particular base-to-opt OSR).

parkingPermit

private boolean parkingPermit

Is a running thread permitted to ignore the next park request

jniEnv

private JNIEnvironment jniEnv

Cached JNI environment for this thread

jniEnvShadow

private JNIEnvironment jniEnvShadow

physicalAllocationFailed

private boolean physicalAllocationFailed

Used by GC to determine collection success

collectionAttempt

private int collectionAttempt

Used by GC to determine collection success

outOfMemoryError

private static OutOfMemoryError outOfMemoryError

The OOME to throw

PROLOGUE

public static final int PROLOGUE

See Also:

Constant Field Values

BACKEDGE

public static final int BACKEDGE

See Also:

Constant Field Values

EPILOGUE

public static final int EPILOGUE

See Also:

Constant Field Values

NATIVE_PROLOGUE

public static final int NATIVE_PROLOGUE

See Also:

Constant Field Values

NATIVE_EPILOGUE

public static final int NATIVE_EPILOGUE

See Also:

Constant Field Values

OSROPT

public static final int OSROPT

See Also:

Constant Field Values

onStackReplacementEvent

public final Object onStackReplacementEvent

Only used by OSR when VM.BuildForAdaptiveSystem. Declared as an Object to cut link to adaptive system. Ugh.

isWaitingForOsr

public boolean isWaitingForOsr

The flag indicates whether this thread is waiting for on stack replacement before being rescheduled.

bridgeInstructions

public ArchitectureSpecific.CodeArray bridgeInstructions

Before call new instructions, we need a bridge to recover register states from the stack frame.

fooFPOffset

public Offset fooFPOffset

Foo frame pointer offset

tsFPOffset

public Offset tsFPOffset

Thread switch frame pointer offset

requesting_osr

public boolean requesting_osr

Flag to synchronize with osr organizer, the trigger sets osr requests the organizer clear the requests

osr_done

public boolean osr_done

Flag to indicate that the last OSR request is done.

availableProcessors

public static int availableProcessors

The number of processors to use.

pthread_id

public Word pthread_id

Thread handle. Currently stores pthread_t, which we assume to be no larger than a pointer-sized word.

scratchStorage

private double scratchStorage

Scratch area for use for gpr <=> fpr transfers by PPC baseline compiler. Used to transfer x87 to SSE registers on IA32

threadIdx

private int threadIdx

Current index of this thread in the threads array. This may be changed by another thread, but only while the acctLock is held.

systemShuttingDown

private static boolean systemShuttingDown

Is the system in the process of shutting down (has System.exit been called)

debugRequested

public static volatile boolean debugRequested

Flag set by external signal to request debugger activation at next thread switch. See also: RunBootImage.C

asyncDebugRequestedForThisThread

public volatile boolean asyncDebugRequestedForThisThread

doProfileReport

public static Latch doProfileReport

The latch for reporting profile data.

inDumpStack

protected int inDumpStack

Number of times dump stack has been called recursively

activeMutatorContext

public boolean activeMutatorContext

Is this a "registered mutator?"

dumpLock

public static Monitor dumpLock

Lock used for dumping stack and such.

exitInProgress

protected static boolean exitInProgress

In dump stack and dying

worldStopped

private static boolean worldStopped

traceDetails

protected static final boolean traceDetails

Extra debug from traces

See Also:

Constant Field Values

SHOW_FP_IN_STACK_DUMP

private static final boolean SHOW_FP_IN_STACK_DUMP

Toggle display of frame pointer address in stack dump

See Also:

Constant Field Values

PRIMORDIAL_THREAD_INDEX

public static final int PRIMORDIAL_THREAD_INDEX

Index of thread in which "VM.boot()" runs

See Also:

Constant Field Values

LOG_MAX_THREADS

public static final int LOG_MAX_THREADS

Maximum number of RVMThread's that we can support.

See Also:

Constant Field Values

MAX_THREADS

public static final int MAX_THREADS

See Also:

Constant Field Values

threadBySlot

public static RVMThread[] threadBySlot

thread array - all threads are stored in this array according to their threadSlot.

monitorBySlot

private static final NoYieldpointsMonitor[] monitorBySlot

Per-thread monitors. Note that this array is statically initialized. It starts out all null. When a new thread slot is allocated, a monitor is added for that slot.

Question: what is the outcome, if any, of taking a yieldpoint while holding this lock?

1. If there is a GC request we will wait on this condition variable and thus release it. Someone else might then acquire the lock before realizing that there is a GC request and then do bad things.
2. The yieldpoint might acquire another thread's monitor. Thus, two threads may get into lock inversion with each other.
3. ???

communicationLockBySlot

private static final Monitor[] communicationLockBySlot

acctLock

public static NoYieldpointsMonitor acctLock

Lock (mutex) used for creating and destroying threads as well as thread accounting. This mutex should not be held while thread monitors (see monitorBySlot) are held. Use this mutex only to protect accesses to:

• the global thread lists, such as threadBySlot, aboutToTerminate, threads, and freeLots
• threadIdx field of RVMThread
• numThreads, numActiveThreads, numActiveDaemons static fields of RVMThread

debugLock

public static NoYieldpointsMonitor debugLock

Lock (mutex) used for servicing debug requests.

outputLock

private static NoYieldpointsMonitor outputLock

Lock used for generating debug output.

aboutToTerminate

private static final int[] aboutToTerminate

Thread slots of threads that are about to terminate. This must be an int array because it's accessed from code that cannot have barriers.

aboutToTerminateN

private static int aboutToTerminateN

Number of threads that are about to terminate.

freeSlots

private static final int[] freeSlots

Free thread slots

freeSlotN

private static int freeSlotN

Number of free thread slots.

nextSlot

public static int nextSlot

When there are no thread slots on the free list, this is the next one to use.

numThreads

public static int numThreads

Number of threads in the system (some of which may not be active).

threads

public static final RVMThread[] threads

Packed and unordered array or active threads. Only entries in the range 0 to numThreads-1 (inclusive) are defined. Note that it should be possible to scan this array without locking and get all of the threads - but only if you scan downward and place a memory fence between loads.

Note further that threads remain in this array even after the Java libraries no longer consider the thread to be active.

handshakeThreads

public static final RVMThread[] handshakeThreads

Preallocated array for use in handshakes. Protected by handshakeLock.

debugThreads

public static final RVMThread[] debugThreads

Preallocated array for use in debug requested. Protected by debugLock.

numActiveThreads

private static int numActiveThreads

Number of active threads in the system.

numActiveDaemons

private static int numActiveDaemons

Number of active daemon threads.

feedlet

public Feedlet feedlet

The Feedlet instance for this thread to use to make addEvent calls.

allButGC

public static final RVMThread.AllButGCHardHandshakeVisitor allButGC

totalSuspendTime

static long totalSuspendTime

totalResumeTime

static long totalResumeTime

sloppyExecStatusHistogram

static final int[] sloppyExecStatusHistogram

statusAtSTWHistogram

static final int[] statusAtSTWHistogram

execStatusTransitionHistogram

static final int[] execStatusTransitionHistogram

RVMThread

public RVMThread(byte[] stack,
                 Thread thread,
                 String name,
                 boolean daemon,
                 SystemThread systemThread,
                 int priority)

Create a new RVM Thread

Parameters:

stack - The stack on which to execute the thread.

thread - The corresponding java.lang.Thread.

name - The name of the thread

daemon - True if this is a daemon thread.

systemThread - True if this is a system thread.

priority - The threads execution priority.

RVMThread

public RVMThread(SystemThread systemThread,
                 String name)

Create a thread with default stack and with the given name.

RVMThread

public RVMThread(SystemThread systemThread,
                 byte[] stack,
                 String name)

Create a thread with the given stack and name. Used by CollectorThread and the boot image writer for the boot thread.

RVMThread

public RVMThread(Thread thread,
                 long stacksize,
                 String name,
                 boolean daemon,
                 int priority)

Create a thread with ... called by java.lang.VMThread.create. System thread isn't set.

notRunning

public static boolean notRunning(int state)

getHijackedReturnCalleeFp

public Address getHijackedReturnCalleeFp()

Returns:

the callee frame pointer for the stack frame hijacked by the return barrier

getExecStatus

public int getExecStatus()

attemptFastExecStatusTransition

private boolean attemptFastExecStatusTransition(int oldState,
                                                int newState)

setExecStatus

private void setExecStatus(int newState)

getIsAboutToTerminate

public boolean getIsAboutToTerminate()

isOnQueue

public boolean isOnQueue()

Returns:

True if this thread is currently on a queue.

monitorForSlot

static NoYieldpointsMonitor monitorForSlot(int slot)

Get a NoYieldpointsCondLock for a given thread slot.

monitor

public NoYieldpointsMonitor monitor()

Get the NoYieldpointsCondLock for this thread.

communicationLockForSlot

public Monitor communicationLockForSlot(int slot)

communicationLock

public Monitor communicationLock()

init

public static void init()

Initialize the threading subsystem for the boot image.

assertAcceptableStates

public void assertAcceptableStates(int expected)

assertAcceptableStates

public void assertAcceptableStates(int expected1,
                                   int expected2)

assertUnacceptableStates

public void assertUnacceptableStates(int unexpected)

assertUnacceptableStates

public void assertUnacceptableStates(int unexpected1,
                                     int unexpected2)

bind

static void bind(int cpuId)

bindIfRequested

static void bindIfRequested()

boot

public static void boot()

Boot the threading subsystem.

addAboutToTerminate

private void addAboutToTerminate()

Add this thread to the termination watchlist. Called by terminating threads before they finish terminating.

processAboutToTerminate

public static void processAboutToTerminate()

Method called after processing a list of threads, or before starting a new thread. This does two things. First, it guarantees that the thread slots used by any dead threads are freed. Second, it guarantees that each thread deregisters itself from GC. Thus, it is essential that after requesting things like mutator flushes, you call this, to ensure that any threads that had died before or during the mutator flush request do the Right Thing.

assignThreadSlot

void assignThreadSlot()

Find a thread slot not in use by any other live thread and bind the given thread to it. The thread's threadSlot field is set accordingly.

releaseThreadSlot

void releaseThreadSlot()

Release a thread's slot in the threads array.

acknowledgeBlockRequests

private void acknowledgeBlockRequests()

Check if the thread has block requests (for example, for suspension and GC). If it does, clear the requests and marked the thread as blocked for that request. If there were any block requests, do a broadcast() on the thread's monitor(). This is an internal method and should only be called from code that implements thread blocking. The monitor() lock must be held for this method to work properly.

isBlocked

public boolean isBlocked()

Checks if the thread system has acknowledged that the thread is supposed to be blocked. This will return true if the thread is actually blocking, or if the thread is running native code but is guaranteed to block before returning to Java. Only call this method when already holding the monitor(), for two reasons:

1. This method does not acquire the monitor() lock even though it needs to have it acquired given the data structures that it is accessing.
2. You will typically want to call this method to decide if you need to take action under the assumption that the thread is blocked (or not blocked). So long as you hold the lock the thread cannot change state from blocked to not blocked.

Returns:

if the thread is supposed to be blocked

isInJava

public boolean isInJava()

Checks if the thread is executing Java code. A thread is executing Java code if its execStatus is IN_JAVA or IN_JAVA_TO_BLOCK, and if it is not aboutToTerminate, and if it is not blocked. Only call this method when already holding the monitor(), and probably only after calling setBlockedExecStatus(), for two reasons:

1. This method does not acquire the monitor() lock even though it needs to have it acquired given the data structures that it is accessing.
2. You will typically want to call this method to decide if you need to take action under the assumption that the thread is running Java (or not running Java). So long as you hold the lock - and you have called setBlockedExecStatus() - the thread cannot change state from running-Java to not-running-Java.

Returns:

if the thread is running Java

shouldBeSampled

public boolean shouldBeSampled()

Should the thread by eligible for sampling by the timer thread? Heuristically, we use timer-based sampling the in the adaptive system to determine where the program is spending time (and thus what to optimize). This doesn't have to be a 100% accurate, but it must be non-blocking and also closely approximate whether or not the thread is executing. For now, approximate just as being in JAVA. As a future item, we may want to actually correctly attribute time spent in native code to the top native method on the frame when the timer goes off. This will require work in the JNI enter/exit sequence to deal with timer samples appropriately.

checkBlockNoSaveContext

private void checkBlockNoSaveContext()

A variant of checkBlock() that does not save the thread state.

checkBlock

void checkBlock()

Check if the thread is supposed to block, and if so, block it. This method will ensure that soft handshake requests are acknowledged or else inhibited, that any blocking request is handled, that the execution state of the thread (execStatus) is set to IN_JAVA once all blocking requests are cleared, and that other threads are notified that this thread is in the middle of blocking by setting the appropriate flag (isBlocking). Note that this thread acquires the monitor(), though it may release it completely either by calling wait() or by calling unlockCompletely(). Thus, although it isn't generally a problem to call this method while holding the monitor() lock, you should only do so if the loss of atomicity is acceptable.

Generally, this method should be called from the following four places:

1. The block() method, if the thread is requesting to block itself. Currently such requests only come when a thread calls suspend(). Doing so has unclear semantics (other threads may call resume() too early causing the well-known race) but must be supported because it's still part of the JDK. Why it's safe: the block() method needs to hold the monitor() for the time it takes it to make the block request, but does not need to continue to hold it when it calls checkBlock(). Thus, the fact that checkBlock() breaks atomicity is not a concern.
2. The yieldpoint. One of the purposes of a yieldpoint is to periodically check if the current thread should be blocked. This is accomplished by calling checkBlock(). Why it's safe: the yieldpoint performs several distinct actions, all of which individually require the monitor() lock - but the monitor() lock does not have to be held contiguously. Thus, the loss of atomicity from calling checkBlock() is fine.
3. The "WithHandshake" methods of HeavyCondLock. These methods allow you to block on a mutex or condition variable while notifying the system that you are not executing Java code. When these blocking methods return, they check if there had been a request to block, and if so, they call checkBlock(). Why it's safe: This is subtle. Two cases exist. The first case is when a WithHandshake method is called on a HeavyCondLock instance that is not a thread monitor(). In this case, it does not matter that checkBlock() may acquire and then completely release the monitor(), since the user was not holding the monitor(). However, this will break if the user is also holding the monitor() when calling the WithHandshake method on a different lock. This case should never happen because no other locks should ever be acquired when the monitor() is held. Additionally: there is the concern that some other locks should never be held while attempting to acquire the monitor(); the HeavyCondLock ensures that checkBlock() is only called when that lock itself is released. The other case is when a WithHandshake method is called on the monitor() itself. This should only be done when using your own monitor() - that is the monitor() of the thread your are running on. In this case, the WithHandshake methods work because: (i) lockWithHandshake() only calls checkBlock() on the initial lock entry (not on recursive entry), so atomicity is not broken, and (ii) waitWithHandshake() and friends only call checkBlock() after wait() returns - at which point it is safe to release and reacquire the lock, since there cannot be a race with broadcast() once we have committed to not calling wait() again.
4. Any code following a potentially-blocking native call. Case (3) above is somewhat subsumed in this except that it is special due to the fact that it's blocking on VM locks. So, this case refers specifically to JNI. The JNI epilogues will call leaveJNIBlocked(), which calls a variant of this method.

enterNativeBlockedImpl

private void enterNativeBlockedImpl(boolean jni)

Internal method for transitioning a thread from IN_JAVA or IN_JAVA_TO_BLOCK to either BLOCKED_IN_NATIVE or BLOCKED_IN_JNI, depending on the value of the jni parameter. It is always safe to conservatively call this method when transitioning to native code, though it is faster to call either enterNative(), enterJNIFromCallIntoNative(), or enterJNIFromJNIFunctionCall().

This method takes care of all bookkeeping and notifications required when a a thread that has been requested to block instead decides to run native code. Threads enter native code never need to block, since they will not be executing any Java code. However, such threads must ensure that any system services (like GC) that are waiting for this thread to stop are notified that the thread has instead chosen to exit Java. As well, any requests to perform a sot handshake must be serviced and acknowledged.

leaveNativeBlockedImpl

private void leaveNativeBlockedImpl()

enterNativeBlocked

private void enterNativeBlocked()

leaveNativeBlocked

private void leaveNativeBlocked()

enterJNIBlocked

private void enterJNIBlocked()

leaveJNIBlocked

private void leaveJNIBlocked()

enterJNIBlockedFromJNIFunctionCall

public static void enterJNIBlockedFromJNIFunctionCall()

enterJNIBlockedFromCallIntoNative

public static void enterJNIBlockedFromCallIntoNative()

leaveJNIBlockedFromJNIFunctionCall

static void leaveJNIBlockedFromJNIFunctionCall()

leaveJNIBlockedFromCallIntoNative

public static void leaveJNIBlockedFromCallIntoNative()

Called when JNI code tried to transition from IN_JNI to IN_JAVA but failed

setBlockedExecStatus

private int setBlockedExecStatus()

block

int block(RVMThread.BlockAdapter ba,
          boolean asynchronous)

Attempt to block the thread, and return the state it is in after the attempt. If we're blocking ourselves, this will always return IN_JAVA. If the thread signals to us the intention to die as we are trying to block it, this will return TERMINATED. NOTE: the thread's execStatus will not actually be TERMINATED at that point yet.

Note that this method is ridiculously dangerous, especially if you pass asynchronous==false. Waiting for another thread to stop is not in itself interruptible - so if you ask another thread to block and they ask you to block, you might deadlock.

blockedFor

public boolean blockedFor(RVMThread.BlockAdapter ba)

asyncBlock

public int asyncBlock(RVMThread.BlockAdapter ba)

block

public int block(RVMThread.BlockAdapter ba)

beginPairWith

public void beginPairWith(RVMThread other)

endPairWith

public void endPairWith(RVMThread other)

beginPairWithCurrent

public void beginPairWithCurrent()

endPairWithCurrent

public void endPairWithCurrent()

safeBlock

private int safeBlock(RVMThread.BlockAdapter ba,
                      boolean asynchronous)

safeAsyncBlock

public int safeAsyncBlock(RVMThread.BlockAdapter ba)

safeBlock

public int safeBlock(RVMThread.BlockAdapter ba)

beginPairHandshake

public void beginPairHandshake()

endPairHandshake

public void endPairHandshake()

saveThreadState

public static void saveThreadState()

Save the current thread state. Call this prior to calling enterNative(). You must be in a method that is marked BaselineSaveLSRegisters.

enterNative

public static void enterNative()

Indicate that we'd like the current thread to be executing privileged code that does not require synchronization with the GC. This call may be made on a thread that is IN_JAVA or IN_JAVA_TO_BLOCK, and will result in the thread being either IN_NATIVE or BLOCKED_IN_NATIVE. In the case of an IN_JAVA_TO_BLOCK->BLOCKED_IN_NATIVE transition, this call will acquire the thread's lock and send out a notification to any threads waiting for this thread to reach a safepoint. This notification serves to notify them that the thread is in GC-safe code, but will not reach an actual safepoint for an indetermined amount of time. This is significant, because safepoints may perform additional actions (such as handling handshake requests, which may include things like mutator flushes and running isync) that IN_NATIVE code will not perform until returning to IN_JAVA by way of a leaveNative() call.

attemptLeaveNativeNoBlock

public static boolean attemptLeaveNativeNoBlock()

Attempt to transition from IN_JNI or IN_NATIVE to IN_JAVA, fail if execStatus is anything but IN_JNI or IN_NATIVE.

Returns:

true if thread transitioned to IN_JAVA, otherwise false

leaveNative

public static void leaveNative()

Leave privileged code. This is valid for threads that are either IN_NATIVE, IN_JNI, BLOCKED_IN_NATIVE, or BLOCKED_IN_JNI, and always results in the thread being IN_JAVA. If the thread was previously BLOCKED_IN_NATIVE or BLOCKED_IN_JNI, the thread will block until notified that it can run again.

enterJNIFromCallIntoNative

public static void enterJNIFromCallIntoNative()

leaveJNIFromCallIntoNative

public static void leaveJNIFromCallIntoNative()

enterJNIFromJNIFunctionCall

public static void enterJNIFromJNIFunctionCall()

leaveJNIFromJNIFunctionCall

public static void leaveJNIFromJNIFunctionCall()

unblock

public void unblock(RVMThread.BlockAdapter ba)

handleDebugRequestForThread

private void handleDebugRequestForThread()

checkDebugRequest

public static void checkDebugRequest()

timerTick

void timerTick()

yieldpointsEnabled

public boolean yieldpointsEnabled()

Are we allowed to take yieldpoints?

enableYieldpoints

public void enableYieldpoints()

Enable yieldpoints on this thread.

disableYieldpoints

public void disableYieldpoints()

Disable yieldpoints on this thread.

failIfYieldpointsDisabled

public void failIfYieldpointsDisabled()

Fail if yieldpoints are disabled on this thread

getCurrentThread

public static RVMThread getCurrentThread()

Returns:

The currently executing thread

getCurrentThreadSlot

public static int getCurrentThreadSlot()

Returns:

the unique slot of the currently executing thread

getThreadSlot

public int getThreadSlot()

Returns:

the slot of this thread

setupBootJavaThread

public void setupBootJavaThread()

Called during booting to give the boot thread a java.lang.Thread

toString

public String toString()

String representation of thread

Overrides:

toString in class Object

getJavaLangThread

public Thread getJavaLangThread()

Get the current java.lang.Thread.

getJNIEnv

public JNIEnvironment getJNIEnv()

Get current thread's JNI environment.

getDisableGCDepth

public int getDisableGCDepth()

Get the disable GC depth

setDisableGCDepth

public void setDisableGCDepth(int d)

Modify the disable GC depth

getDisallowAllocationsByThisThread

public boolean getDisallowAllocationsByThisThread()

Are allocations allowed by this thread?

setDisallowAllocationsByThisThread

public void setDisallowAllocationsByThisThread()

Disallow allocations by this thread

clearDisallowAllocationsByThisThread

public void clearDisallowAllocationsByThisThread()

Allow allocations by this thread

initializeJNIEnv

public void initializeJNIEnv()

Initialize JNI environment for system threads. Called by VM.finishBooting

hasNativeStackFrame

public boolean hasNativeStackFrame()

Indicate whether the stack of this Thread contains any C frame (used in RuntimeEntrypoints.deliverHardwareException for stack resize)

Returns:

false during the prolog of the first Java to C transition true afterward

run

public void run()

Method to be executed when this thread starts running. Calls java.lang.Thread.run but system threads can override directly.

startoff

private static void startoff()

Begin execution of current thread by calling its "run" method. This method is at the bottom of all created method's stacks.

start

public void start()

Start execution of 'this' by putting it on the appropriate queue of an unspecified virtual processor.

terminate

public void terminate()

Terminate execution of current thread by abandoning all references to it and resuming execution in some other (ready) thread.

callSystemExit

private void callSystemExit(int exitStatus)

Call System.exit() with the correct security status.

Parameters:

exitStatus -

terminateUnpreemptible

private void terminateUnpreemptible()

Unpreemptible portion of thread termination. Unpreemptible to avoid a dead thread from being scheduled.

finishThreadTermination

void finishThreadTermination()

Uninterruptible final portion of thread termination.

yieldpointFromPrologue

public static void yieldpointFromPrologue()

Yieldpoint taken in prologue.

yieldpointFromBackedge

public static void yieldpointFromBackedge()

Yieldpoint taken on backedge.

returnBarrier

public static void returnBarrier()

The return barrier.

The following code implements return barriers as described for Lisp by Yuasa http://www.yuasa.kuis.kyoto-u.ac.jp/~yuasa/ilc2002/index.html http://dx.doi.org/10.1109/ISORC.2005.45 and for Jikes RVM by Kumar et al http://dx.doi.org/10.1145/2398857.2384639

This code is executed when a method returns into a frame that has been hijacked by the return barrier mechanism. The return barrier trampoline will save state, execute this method, and then upon return from this method will transparently return into the frame that had been hijacked.

In this default implementation, the barrier reinstalls itself in the caller's frame thus incrementally moving the barrier down the stack.

The execution of this method is fragile. It is generally safest to call some other method from here that does the substantive work of the barrier.

installStackTrampolineBridge

public void 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.

Parameters:

targetFp - The frame to be hijacked.

deInstallStackTrampoline

public void deInstallStackTrampoline()

de-install the stack trampoline (disabling return barriers).

getStackTrampolineBridgeIP

private Address getStackTrampolineBridgeIP()

Returns:

the address of the stack trampoline bridge code

getTrampolineHijackedReturnAddress

public Address getTrampolineHijackedReturnAddress()

Returns:

the hijacked return address

isTrampolineIP

public static boolean isTrampolineIP(Address ip)

Determine whether a given method is the stack trampoline

Parameters:

ip - the code to be checked

Returns:

true if the code is the stack trampoline.

getHijackedReturnAddress

public static Address getHijackedReturnAddress(Address hijackedFp)

Given a frame that has been hijacked by the stack trampoline, return the real (hijacked) return address.

Parameters:

hijackedFp - a frame that has been hijacked by the stack trampoline

Returns:

the return address for the frame that was hijacked.

dumpFrame

private static void dumpFrame(Address fp)

Dump the specified frame in a format useful for debugging the stack trampoline

Parameters:

fp - The frame to be dumped.

getNextUnencounteredFrame

public Address getNextUnencounteredFrame()

Returns:

the caller of the frame in which the trampoline is installed (STACKFRAME_SENTINEL_FP by default)

yieldpointFromEpilogue

public static void yieldpointFromEpilogue()

Yieldpoint taken in epilogue.

suspend

public void suspend()

Suspend execution of current thread until it is resumed. Call only if caller has appropriate security clearance.

resume

public void resume()

Resume execution of a thread that has been suspended. Call only if caller has appropriate security clearance.

yieldNoHandshake

public static void yieldNoHandshake()

yieldWithHandshake

public static void yieldWithHandshake()

sleep

public static void sleep(long ns)
                  throws InterruptedException

Suspend execution of current thread for specified number of seconds (or fraction).

Throws:

InterruptedException

sleep

public static void sleep(long millis,
                         int ns)
                  throws InterruptedException

Suspend execution of current thread for specified number of seconds (or fraction).

Throws:

InterruptedException

waitImpl

void waitImpl(Object o,
              boolean hasTimeout,
              long whenWakeupNanos)

wait

public static void wait(Object o)

Support for Java Object.wait() synchronization primitive.

Parameters:

o - the object synchronized on

wait

public static void wait(Object o,
                        long millis)

Support for Java Object.wait() synchronization primitive.

Parameters:

o - the object synchronized on

millis - the number of milliseconds to wait for notification

waitAbsoluteNanos

public static void waitAbsoluteNanos(Object o,
                                     long whenNanos)

Support for RTSJ- and pthread-style absolute wait.

Parameters:

o - the object synchronized on

whenNanos - the absolute time in nanoseconds when we should wake up

raiseIllegalMonitorStateException

public static void raiseIllegalMonitorStateException(String msg,
                                                     Object o)

notify

public static void notify(Object o)

Support for Java Object.notify() synchronization primitive.

Parameters:

o - the object synchronized on

notifyAll

public static void notifyAll(Object o)

Support for Java synchronization primitive.

Parameters:

o - the object synchronized on

See Also:

Object.notifyAll()

stop

public void stop(Throwable cause)

park

public void park(boolean isAbsolute,
                 long time)
          throws Throwable

Throws:

Throwable

unpark

public void unpark()

getLockingId

public int getLockingId()

Get this thread's id for use in lock ownership tests. This is just the thread's slot as returned by getThreadSlot(), shifted appropriately so it can be directly used in the ownership tests.

snapshotHandshakeThreads

public static int snapshotHandshakeThreads(RVMThread.SoftHandshakeVisitor v)

softHandshake

public static void softHandshake(RVMThread.SoftHandshakeVisitor v)

Tell each thread to take a yieldpoint and wait until all of them have done so at least once. Additionally, call the visitor on each thread when making the yieldpoint request; the purpose of the visitor is to set any additional fields as needed to make specific requests to the threads that yield. Note that the visitor's visit() method is called with both the thread's monitor held, and the softHandshakeDataLock held.

Currently we only use this mechanism for code patch isync requests on PPC, but this mechanism is powerful enough to be used by sliding-views style concurrent GC.

softRendezvousCheckAndClear

public boolean softRendezvousCheckAndClear()

Check and clear the need for a soft handshake rendezvous. This method cannot do anything that leads to a write barrier or allocation.

softRendezvousCommit

public void softRendezvousCommit()

Commit the soft handshake rendezvous. This method cannot do anything that leads to a write barrier or allocation.

softRendezvous

public void softRendezvous()

Rendezvous with a soft handshake request. Can only be called when the thread's monitor is held.

handleHandshakeRequest

void handleHandshakeRequest()

Handle requests that required a soft handshake. May be called after we acknowledged the soft handshake. Thus - this is for actions in which it is sufficient for the thread to acknowledge that it plans to act upon the request in the immediate future, rather than that the thread acts upon the request prior to acknowledging.

This is almost always called with the monitor() lock held, but that's not guaranteed. If you need that lock, you can grab it (since it's a recursive lock). But you should avoid grabbing other sorts of locks since that might cause deadlock.

blockAllMutatorsForGC

public static void blockAllMutatorsForGC()

Stop all mutator threads. This is current intended to be run by a single thread. Fixpoint until there are no threads that we haven't blocked. Fixpoint is needed to catch the (unlikely) case that a thread spawns another thread while we are waiting.

unblockAllMutatorsForGC

public static void unblockAllMutatorsForGC()

Unblock all mutators blocked for GC.

hardHandshakeSuspend

public static void hardHandshakeSuspend(RVMThread.BlockAdapter ba,
                                        RVMThread.HardHandshakeVisitor hhv)

hardHandshakeResume

public static void hardHandshakeResume(RVMThread.BlockAdapter ba,
                                       RVMThread.HardHandshakeVisitor hhv)

hardHandshakeSuspend

public static void hardHandshakeSuspend()

hardHandshakeResume

public static void hardHandshakeResume()