/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Dalvik.h"
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#include <errno.h>
/*
* Every Object has a monitor associated with it, but not every Object is
* actually locked. Even the ones that are locked do not need a
* full-fledged monitor until a) there is actual contention or b) wait()
* is called on the Object.
*
* For Dalvik, we have implemented a scheme similar to the one described
* in Bacon et al.'s "Thin locks: featherweight synchronization for Java"
* (ACM 1998). Things are even easier for us, though, because we have
* a full 32 bits to work with.
*
* The two states of an Object's lock are referred to as "thin" and
* "fat". A lock may transition from the "thin" state to the "fat"
* state and this transition is referred to as inflation. Once a lock
* has been inflated it remains in the "fat" state indefinitely.
*
* The lock value itself is stored in Object.lock. The LSB of the
* lock encodes its state. When cleared, the lock is in the "thin"
* state and its bits are formatted as follows:
*
* [31 ---- 19] [18 ---- 3] [2 ---- 1] [0]
* lock count thread id hash state 0
*
* When set, the lock is in the "fat" state and its bits are formatted
* as follows:
*
* [31 ---- 3] [2 ---- 1] [0]
* pointer hash state 1
*
* For an in-depth description of the mechanics of thin-vs-fat locking,
* read the paper referred to above.
*/
/*
* Monitors provide:
* - mutually exclusive access to resources
* - a way for multiple threads to wait for notification
*
* In effect, they fill the role of both mutexes and condition variables.
*
* Only one thread can own the monitor at any time. There may be several
* threads waiting on it (the wait call unlocks it). One or more waiting
* threads may be getting interrupted or notified at any given time.
*
* TODO: the various members of monitor are not SMP-safe.
*/
struct Monitor {
Thread* owner; /* which thread currently owns the lock? */
int lockCount; /* owner's recursive lock depth */
Object* obj; /* what object are we part of [debug only] */
Thread* waitSet; /* threads currently waiting on this monitor */
pthread_mutex_t lock;
Monitor* next;
/*
* Who last acquired this monitor, when lock sampling is enabled.
* Even when enabled, ownerMethod may be NULL.
*/
const Method* ownerMethod;
u4 ownerPc;
};
/*
* Create and initialize a monitor.
*/
Monitor* dvmCreateMonitor(Object* obj)
{
Monitor* mon;
mon = (Monitor*) calloc(1, sizeof(Monitor));
if (mon == NULL) {
ALOGE("Unable to allocate monitor");
dvmAbort();
}
mon->obj = obj;
dvmInitMutex(&mon->lock);
/* replace the head of the list with the new monitor */
do {
mon->next = gDvm.monitorList;
} while (android_atomic_release_cas((int32_t)mon->next, (int32_t)mon,
(int32_t*)(void*)&gDvm.monitorList) != 0);
return mon;
}
/*
* Free the monitor list. Only used when shutting the VM down.
*/
void dvmFreeMonitorList()
{
Monitor* mon;
Monitor* nextMon;
mon = gDvm.monitorList;
while (mon != NULL) {
nextMon = mon->next;
free(mon);
mon = nextMon;
}
}
/*
* Get the object that a monitor is part of.
*/
Object* dvmGetMonitorObject(Monitor* mon)
{
if (mon == NULL)
return NULL;
else
return mon->obj;
}
/*
* Returns the thread id of the thread owning the given lock.
*/
static u4 lockOwner(Object* obj)
{
Thread *owner;
u4 lock;
assert(obj != NULL);
/*
* Since we're reading the lock value multiple times, latch it so
* that it doesn't change out from under us if we get preempted.
*/
lock = obj->lock;
if (LW_SHAPE(lock) == LW_SHAPE_THIN) {
return LW_LOCK_OWNER(lock);
} else {
owner = LW_MONITOR(lock)->owner;
return owner ? owner->threadId : 0;
}
}
/*
* Get the thread that holds the lock on the specified object. The
* object may be unlocked, thin-locked, or fat-locked.
*
* The caller must lock the thread list before calling here.
*/
Thread* dvmGetObjectLockHolder(Object* obj)
{
u4 threadId = lockOwner(obj);
if (threadId == 0)
return NULL;
return dvmGetThreadByThreadId(threadId);
}
/*
* Checks whether the given thread holds the given
* objects's lock.
*/
bool dvmHoldsLock(Thread* thread, Object* obj)
{
if (thread == NULL || obj == NULL) {
return false;
} else {
return thread->threadId == lockOwner(obj);
}
}
/*
* Free the monitor associated with an object and make the object's lock
* thin again. This is called during garbage collection.
*/
static void freeMonitor(Monitor *mon)
{
assert(mon != NULL);
assert(mon->obj != NULL);
assert(LW_SHAPE(mon->obj->lock) == LW_SHAPE_FAT);
/* This lock is associated with an object
* that's being swept. The only possible way
* anyone could be holding this lock would be
* if some JNI code locked but didn't unlock
* the object, in which case we've got some bad
* native code somewhere.
*/
assert(pthread_mutex_trylock(&mon->lock) == 0);
assert(pthread_mutex_unlock(&mon->lock) == 0);
dvmDestroyMutex(&mon->lock);
free(mon);
}
/*
* Frees monitor objects belonging to unmarked objects.
*/
void dvmSweepMonitorList(Monitor** mon, int (*isUnmarkedObject)(void*))
{
Monitor handle;
Monitor *prev, *curr;
Object *obj;
assert(mon != NULL);
assert(isUnmarkedObject != NULL);
prev = &handle;
prev->next = curr = *mon;
while (curr != NULL) {
obj = curr->obj;
if (obj != NULL && (*isUnmarkedObject)(obj) != 0) {
prev->next = curr->next;
freeMonitor(curr);
curr = prev->next;
} else {
prev = curr;
curr = curr->next;
}
}
*mon = handle.next;
}
static char *logWriteInt(char *dst, int value)
{
*dst++ = EVENT_TYPE_INT;
set4LE((u1 *)dst, value);
return dst + 4;
}
static char *logWriteString(char *dst, const char *value, size_t len)
{
*dst++ = EVENT_TYPE_STRING;
len = len < 32 ? len : 32;
set4LE((u1 *)dst, len);
dst += 4;
memcpy(dst, value, len);
return dst + len;
}
#define EVENT_LOG_TAG_dvm_lock_sample 20003
static void logContentionEvent(Thread *self, u4 waitMs, u4 samplePercent,
const char *ownerFileName, u4 ownerLineNumber)
{
const StackSaveArea *saveArea;
const Method *meth;
u4 relativePc;
char eventBuffer[174];
const char *fileName;
char procName[33];
char *cp;
size_t len;
int fd;
/* When a thread is being destroyed it is normal that the frame depth is zero */
if (self->interpSave.curFrame == NULL) {
return;
}
saveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame);
meth = saveArea->method;
cp = eventBuffer;
/* Emit the event list length, 1 byte. */
*cp++ = 9;
/* Emit the process name, <= 37 bytes. */
fd = open("/proc/self/cmdline", O_RDONLY);
memset(procName, 0, sizeof(procName));
read(fd, procName, sizeof(procName) - 1);
close(fd);
len = strlen(procName);
cp = logWriteString(cp, procName, len);
/* Emit the sensitive thread ("main thread") status, 5 bytes. */
bool isSensitive = false;
if (gDvm.isSensitiveThreadHook != NULL) {
isSensitive = gDvm.isSensitiveThreadHook();
}
cp = logWriteInt(cp, isSensitive);
/* Emit self thread name string, <= 37 bytes. */
std::string selfName = dvmGetThreadName(self);
cp = logWriteString(cp, selfName.c_str(), selfName.size());
/* Emit the wait time, 5 bytes. */
cp = logWriteInt(cp, waitMs);
/* Emit the source code file name, <= 37 bytes. */
fileName = dvmGetMethodSourceFile(meth);
if (fileName == NULL) fileName = "";
cp = logWriteString(cp, fileName, strlen(fileName));
/* Emit the source code line number, 5 bytes. */
relativePc = saveArea->xtra.currentPc - saveArea->method->insns;
cp = logWriteInt(cp, dvmLineNumFromPC(meth, relativePc));
/* Emit the lock owner source code file name, <= 37 bytes. */
if (ownerFileName == NULL) {
ownerFileName = "";
} else if (strcmp(fileName, ownerFileName) == 0) {
/* Common case, so save on log space. */
ownerFileName = "-";
}
cp = logWriteString(cp, ownerFileName, strlen(ownerFileName));
/* Emit the source code line number, 5 bytes. */
cp = logWriteInt(cp, ownerLineNumber);
/* Emit the sample percentage, 5 bytes. */
cp = logWriteInt(cp, samplePercent);
assert((size_t)(cp - eventBuffer) <= sizeof(eventBuffer));
android_btWriteLog(EVENT_LOG_TAG_dvm_lock_sample,
EVENT_TYPE_LIST,
eventBuffer,
(size_t)(cp - eventBuffer));
}
/*
* Lock a monitor.
*/
static void lockMonitor(Thread* self, Monitor* mon)
{
ThreadStatus oldStatus;
u4 waitThreshold, samplePercent;
u8 waitStart, waitEnd, waitMs;
if (mon->owner == self) {
mon->lockCount++;
return;
}
if (dvmTryLockMutex(&mon->lock) != 0) {
oldStatus = dvmChangeStatus(self, THREAD_MONITOR);
waitThreshold = gDvm.lockProfThreshold;
if (waitThreshold) {
waitStart = dvmGetRelativeTimeUsec();
}
const Method* currentOwnerMethod = mon->ownerMethod;
u4 currentOwnerPc = mon->ownerPc;
dvmLockMutex(&mon->lock);
if (waitThreshold) {
waitEnd = dvmGetRelativeTimeUsec();
}
dvmChangeStatus(self, oldStatus);
if (waitThreshold) {
waitMs = (waitEnd - waitStart) / 1000;
if (waitMs >= waitThreshold) {
samplePercent = 100;
} else {
samplePercent = 100 * waitMs / waitThreshold;
}
if (samplePercent != 0 && ((u4)rand() % 100 < samplePercent)) {
const char* currentOwnerFileName = "no_method";
u4 currentOwnerLineNumber = 0;
if (currentOwnerMethod != NULL) {
currentOwnerFileName = dvmGetMethodSourceFile(currentOwnerMethod);
if (currentOwnerFileName == NULL) {
currentOwnerFileName = "no_method_file";
}
currentOwnerLineNumber = dvmLineNumFromPC(currentOwnerMethod, currentOwnerPc);
}
logContentionEvent(self, waitMs, samplePercent,
currentOwnerFileName, currentOwnerLineNumber);
}
}
}
mon->owner = self;
assert(mon->lockCount == 0);
// When debugging, save the current monitor holder for future
// acquisition failures to use in sampled logging.
if (gDvm.lockProfThreshold > 0) {
mon->ownerMethod = NULL;
mon->ownerPc = 0;
if (self->interpSave.curFrame == NULL) {
return;
}
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame);
if (saveArea == NULL) {
return;
}
mon->ownerMethod = saveArea->method;
mon->ownerPc = (saveArea->xtra.currentPc - saveArea->method->insns);
}
}
/*
* Try to lock a monitor.
*
* Returns "true" on success.
*/
#ifdef WITH_COPYING_GC
static bool tryLockMonitor(Thread* self, Monitor* mon)
{
if (mon->owner == self) {
mon->lockCount++;
return true;
} else {
if (dvmTryLockMutex(&mon->lock) == 0) {
mon->owner = self;
assert(mon->lockCount == 0);
return true;
} else {
return false;
}
}
}
#endif
/*
* Unlock a monitor.
*
* Returns true if the unlock succeeded.
* If the unlock failed, an exception will be pending.
*/
static bool unlockMonitor(Thread* self, Monitor* mon)
{
assert(self != NULL);
assert(mon != NULL);
if (mon->owner == self) {
/*
* We own the monitor, so nobody else can be in here.
*/
if (mon->lockCount == 0) {
mon->owner = NULL;
mon->ownerMethod = NULL;
mon->ownerPc = 0;
dvmUnlockMutex(&mon->lock);
} else {
mon->lockCount--;
}
} else {
/*
* We don't own this, so we're not allowed to unlock it.
* The JNI spec says that we should throw IllegalMonitorStateException
* in this case.
*/
dvmThrowIllegalMonitorStateException("unlock of unowned monitor");
return false;
}
return true;
}
/*
* Checks the wait set for circular structure. Returns 0 if the list
* is not circular. Otherwise, returns 1. Used only by asserts.
*/
#ifndef NDEBUG
static int waitSetCheck(Monitor *mon)
{
Thread *fast, *slow;
size_t n;
assert(mon != NULL);
fast = slow = mon->waitSet;
n = 0;
for (;;) {
if (fast == NULL) return 0;
if (fast->waitNext == NULL) return 0;
if (fast == slow && n > 0) return 1;
n += 2;
fast = fast->waitNext->waitNext;
slow = slow->waitNext;
}
}
#endif
/*
* Links a thread into a monitor's wait set. The monitor lock must be
* held by the caller of this routine.
*/
static void waitSetAppend(Monitor *mon, Thread *thread)
{
Thread *elt;
assert(mon != NULL);
assert(mon->owner == dvmThreadSelf());
assert(thread != NULL);
assert(thread->waitNext == NULL);
assert(waitSetCheck(mon) == 0);
if (mon->waitSet == NULL) {
mon->waitSet = thread;
return;
}
elt = mon->waitSet;
while (elt->waitNext != NULL) {
elt = elt->waitNext;
}
elt->waitNext = thread;
}
/*
* Unlinks a thread from a monitor's wait set. The monitor lock must
* be held by the caller of this routine.
*/
static void waitSetRemove(Monitor *mon, Thread *thread)
{
Thread *elt;
assert(mon != NULL);
assert(mon->owner == dvmThreadSelf());
assert(thread != NULL);
assert(waitSetCheck(mon) == 0);
if (mon->waitSet == NULL) {
return;
}
if (mon->waitSet == thread) {
mon->waitSet = thread->waitNext;
thread->waitNext = NULL;
return;
}
elt = mon->waitSet;
while (elt->waitNext != NULL) {
if (elt->waitNext == thread) {
elt->waitNext = thread->waitNext;
thread->waitNext = NULL;
return;
}
elt = elt->waitNext;
}
}
/*
* Converts the given relative waiting time into an absolute time.
*/
static void absoluteTime(s8 msec, s4 nsec, struct timespec *ts)
{
s8 endSec;
#ifdef HAVE_TIMEDWAIT_MONOTONIC
clock_gettime(CLOCK_MONOTONIC, ts);
#else
{
struct timeval tv;
gettimeofday(&tv, NULL);
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = tv.tv_usec * 1000;
}
#endif
endSec = ts->tv_sec + msec / 1000;
if (endSec >= 0x7fffffff) {
ALOGV("NOTE: end time exceeds epoch");
endSec = 0x7ffffffe;
}
ts->tv_sec = endSec;
ts->tv_nsec = (ts->tv_nsec + (msec % 1000) * 1000000) + nsec;
/* catch rollover */
if (ts->tv_nsec >= 1000000000L) {
ts->tv_sec++;
ts->tv_nsec -= 1000000000L;
}
}
int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex,
s8 msec, s4 nsec)
{
int ret;
struct timespec ts;
absoluteTime(msec, nsec, &ts);
#if defined(HAVE_TIMEDWAIT_MONOTONIC)
ret = pthread_cond_timedwait_monotonic(cond, mutex, &ts);
#else
ret = pthread_cond_timedwait(cond, mutex, &ts);
#endif
assert(ret == 0 || ret == ETIMEDOUT);
return ret;
}
/*
* Wait on a monitor until timeout, interrupt, or notification. Used for
* Object.wait() and (somewhat indirectly) Thread.sleep() and Thread.join().
*
* If another thread calls Thread.interrupt(), we throw InterruptedException
* and return immediately if one of the following are true:
* - blocked in wait(), wait(long), or wait(long, int) methods of Object
* - blocked in join(), join(long), or join(long, int) methods of Thread
* - blocked in sleep(long), or sleep(long, int) methods of Thread
* Otherwise, we set the "interrupted" flag.
*
* Checks to make sure that "nsec" is in the range 0-999999
* (i.e. fractions of a millisecond) and throws the appropriate
* exception if it isn't.
*
* The spec allows "spurious wakeups", and recommends that all code using
* Object.wait() do so in a loop. This appears to derive from concerns
* about pthread_cond_wait() on multiprocessor systems. Some commentary
* on the web casts doubt on whether these can/should occur.
*
* Since we're allowed to wake up "early", we clamp extremely long durations
* to return at the end of the 32-bit time epoch.
*/
static void waitMonitor(Thread* self, Monitor* mon, s8 msec, s4 nsec,
bool interruptShouldThrow)
{
struct timespec ts;
bool wasInterrupted = false;
bool timed;
int ret;
assert(self != NULL);
assert(mon != NULL);
/* Make sure that we hold the lock. */
if (mon->owner != self) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before wait()");
return;
}
/*
* Enforce the timeout range.
*/
if (msec < 0 || nsec < 0 || nsec > 999999) {
dvmThrowIllegalArgumentException("timeout arguments out of range");
return;
}
/*
* Compute absolute wakeup time, if necessary.
*/
if (msec == 0 && nsec == 0) {
timed = false;
} else {
absoluteTime(msec, nsec, &ts);
timed = true;
}
/*
* Add ourselves to the set of threads waiting on this monitor, and
* release our hold. We need to let it go even if we're a few levels
* deep in a recursive lock, and we need to restore that later.
*
* We append to the wait set ahead of clearing the count and owner
* fields so the subroutine can check that the calling thread owns
* the monitor. Aside from that, the order of member updates is
* not order sensitive as we hold the pthread mutex.
*/
waitSetAppend(mon, self);
int prevLockCount = mon->lockCount;
mon->lockCount = 0;
mon->owner = NULL;
const Method* savedMethod = mon->ownerMethod;
u4 savedPc = mon->ownerPc;
mon->ownerMethod = NULL;
mon->ownerPc = 0;
/*
* Update thread status. If the GC wakes up, it'll ignore us, knowing
* that we won't touch any references in this state, and we'll check
* our suspend mode before we transition out.
*/
if (timed)
dvmChangeStatus(self, THREAD_TIMED_WAIT);
else
dvmChangeStatus(self, THREAD_WAIT);
dvmLockMutex(&self->waitMutex);
/*
* Set waitMonitor to the monitor object we will be waiting on.
* When waitMonitor is non-NULL a notifying or interrupting thread
* must signal the thread's waitCond to wake it up.
*/
assert(self->waitMonitor == NULL);
self->waitMonitor = mon;
/*
* Handle the case where the thread was interrupted before we called
* wait().
*/
if (self->interrupted) {
wasInterrupted = true;
self->waitMonitor = NULL;
dvmUnlockMutex(&self->waitMutex);
goto done;
}
/*
* Release the monitor lock and wait for a notification or
* a timeout to occur.
*/
dvmUnlockMutex(&mon->lock);
if (!timed) {
ret = pthread_cond_wait(&self->waitCond, &self->waitMutex);
assert(ret == 0);
} else {
#ifdef HAVE_TIMEDWAIT_MONOTONIC
ret = pthread_cond_timedwait_monotonic(&self->waitCond, &self->waitMutex, &ts);
#else
ret = pthread_cond_timedwait(&self->waitCond, &self->waitMutex, &ts);
#endif
assert(ret == 0 || ret == ETIMEDOUT);
}
if (self->interrupted) {
wasInterrupted = true;
}
self->interrupted = false;
self->waitMonitor = NULL;
dvmUnlockMutex(&self->waitMutex);
/* Reacquire the monitor lock. */
lockMonitor(self, mon);
done:
/*
* We remove our thread from wait set after restoring the count
* and owner fields so the subroutine can check that the calling
* thread owns the monitor. Aside from that, the order of member
* updates is not order sensitive as we hold the pthread mutex.
*/
mon->owner = self;
mon->lockCount = prevLockCount;
mon->ownerMethod = savedMethod;
mon->ownerPc = savedPc;
waitSetRemove(mon, self);
/* set self->status back to THREAD_RUNNING, and self-suspend if needed */
dvmChangeStatus(self, THREAD_RUNNING);
if (wasInterrupted) {
/*
* We were interrupted while waiting, or somebody interrupted an
* un-interruptible thread earlier and we're bailing out immediately.
*
* The doc sayeth: "The interrupted status of the current thread is
* cleared when this exception is thrown."
*/
self->interrupted = false;
if (interruptShouldThrow) {
dvmThrowInterruptedException(NULL);
}
}
}
/*
* Notify one thread waiting on this monitor.
*/
static void notifyMonitor(Thread* self, Monitor* mon)
{
Thread* thread;
assert(self != NULL);
assert(mon != NULL);
/* Make sure that we hold the lock. */
if (mon->owner != self) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before notify()");
return;
}
/* Signal the first waiting thread in the wait set. */
while (mon->waitSet != NULL) {
thread = mon->waitSet;
mon->waitSet = thread->waitNext;
thread->waitNext = NULL;
dvmLockMutex(&thread->waitMutex);
/* Check to see if the thread is still waiting. */
if (thread->waitMonitor != NULL) {
pthread_cond_signal(&thread->waitCond);
dvmUnlockMutex(&thread->waitMutex);
return;
}
dvmUnlockMutex(&thread->waitMutex);
}
}
/*
* Notify all threads waiting on this monitor.
*/
static void notifyAllMonitor(Thread* self, Monitor* mon)
{
Thread* thread;
assert(self != NULL);
assert(mon != NULL);
/* Make sure that we hold the lock. */
if (mon->owner != self) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before notifyAll()");
return;
}
/* Signal all threads in the wait set. */
while (mon->waitSet != NULL) {
thread = mon->waitSet;
mon->waitSet = thread->waitNext;
thread->waitNext = NULL;
dvmLockMutex(&thread->waitMutex);
/* Check to see if the thread is still waiting. */
if (thread->waitMonitor != NULL) {
pthread_cond_signal(&thread->waitCond);
}
dvmUnlockMutex(&thread->waitMutex);
}
}
/*
* Changes the shape of a monitor from thin to fat, preserving the
* internal lock state. The calling thread must own the lock.
*/
static void inflateMonitor(Thread *self, Object *obj)
{
Monitor *mon;
u4 thin;
assert(self != NULL);
assert(obj != NULL);
assert(LW_SHAPE(obj->lock) == LW_SHAPE_THIN);
assert(LW_LOCK_OWNER(obj->lock) == self->threadId);
/* Allocate and acquire a new monitor. */
mon = dvmCreateMonitor(obj);
lockMonitor(self, mon);
/* Propagate the lock state. */
thin = obj->lock;
mon->lockCount = LW_LOCK_COUNT(thin);
thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT;
thin |= (u4)mon | LW_SHAPE_FAT;
/* Publish the updated lock word. */
android_atomic_release_store(thin, (int32_t *)&obj->lock);
}
/*
* Implements monitorenter for "synchronized" stuff.
*
* This does not fail or throw an exception (unless deadlock prediction
* is enabled and set to "err" mode).
*/
void dvmLockObject(Thread* self, Object *obj)
{
volatile u4 *thinp;
ThreadStatus oldStatus;
struct timespec tm;
long sleepDelayNs;
long minSleepDelayNs = 1000000; /* 1 millisecond */
long maxSleepDelayNs = 1000000000; /* 1 second */
u4 thin, newThin, threadId;
assert(self != NULL);
assert(obj != NULL);
threadId = self->threadId;
thinp = &obj->lock;
retry:
thin = *thinp;
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
/*
* The lock is a thin lock. The owner field is used to
* determine the acquire method, ordered by cost.
*/
if (LW_LOCK_OWNER(thin) == threadId) {
/*
* The calling thread owns the lock. Increment the
* value of the recursion count field.
*/
obj->lock += 1 << LW_LOCK_COUNT_SHIFT;
if (LW_LOCK_COUNT(obj->lock) == LW_LOCK_COUNT_MASK) {
/*
* The reacquisition limit has been reached. Inflate
* the lock so the next acquire will not overflow the
* recursion count field.
*/
inflateMonitor(self, obj);
}
} else if (LW_LOCK_OWNER(thin) == 0) {
/*
* The lock is unowned. Install the thread id of the
* calling thread into the owner field. This is the
* common case. In performance critical code the JIT
* will have tried this before calling out to the VM.
*/
newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT);
if (android_atomic_acquire_cas(thin, newThin,
(int32_t*)thinp) != 0) {
/*
* The acquire failed. Try again.
*/
goto retry;
}
} else {
ALOGV("(%d) spin on lock %p: %#x (%#x) %#x",
threadId, &obj->lock, 0, *thinp, thin);
/*
* The lock is owned by another thread. Notify the VM
* that we are about to wait.
*/
oldStatus = dvmChangeStatus(self, THREAD_MONITOR);
/*
* Spin until the thin lock is released or inflated.
*/
sleepDelayNs = 0;
for (;;) {
thin = *thinp;
/*
* Check the shape of the lock word. Another thread
* may have inflated the lock while we were waiting.
*/
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
if (LW_LOCK_OWNER(thin) == 0) {
/*
* The lock has been released. Install the
* thread id of the calling thread into the
* owner field.
*/
newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT);
if (android_atomic_acquire_cas(thin, newThin,
(int32_t *)thinp) == 0) {
/*
* The acquire succeed. Break out of the
* loop and proceed to inflate the lock.
*/
break;
}
} else {
/*
* The lock has not been released. Yield so
* the owning thread can run.
*/
if (sleepDelayNs == 0) {
sched_yield();
sleepDelayNs = minSleepDelayNs;
} else {
tm.tv_sec = 0;
tm.tv_nsec = sleepDelayNs;
nanosleep(&tm, NULL);
/*
* Prepare the next delay value. Wrap to
* avoid once a second polls for eternity.
*/
if (sleepDelayNs < maxSleepDelayNs / 2) {
sleepDelayNs *= 2;
} else {
sleepDelayNs = minSleepDelayNs;
}
}
}
} else {
/*
* The thin lock was inflated by another thread.
* Let the VM know we are no longer waiting and
* try again.
*/
ALOGV("(%d) lock %p surprise-fattened",
threadId, &obj->lock);
dvmChangeStatus(self, oldStatus);
goto retry;
}
}
ALOGV("(%d) spin on lock done %p: %#x (%#x) %#x",
threadId, &obj->lock, 0, *thinp, thin);
/*
* We have acquired the thin lock. Let the VM know that
* we are no longer waiting.
*/
dvmChangeStatus(self, oldStatus);
/*
* Fatten the lock.
*/
inflateMonitor(self, obj);
ALOGV("(%d) lock %p fattened", threadId, &obj->lock);
}
} else {
/*
* The lock is a fat lock.
*/
assert(LW_MONITOR(obj->lock) != NULL);
lockMonitor(self, LW_MONITOR(obj->lock));
}
}
/*
* Implements monitorexit for "synchronized" stuff.
*
* On failure, throws an exception and returns "false".
*/
bool dvmUnlockObject(Thread* self, Object *obj)
{
u4 thin;
assert(self != NULL);
assert(self->status == THREAD_RUNNING);
assert(obj != NULL);
/*
* Cache the lock word as its value can change while we are
* examining its state.
*/
thin = *(volatile u4 *)&obj->lock;
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
/*
* The lock is thin. We must ensure that the lock is owned
* by the given thread before unlocking it.
*/
if (LW_LOCK_OWNER(thin) == self->threadId) {
/*
* We are the lock owner. It is safe to update the lock
* without CAS as lock ownership guards the lock itself.
*/
if (LW_LOCK_COUNT(thin) == 0) {
/*
* The lock was not recursively acquired, the common
* case. Unlock by clearing all bits except for the
* hash state.
*/
thin &= (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT);
android_atomic_release_store(thin, (int32_t*)&obj->lock);
} else {
/*
* The object was recursively acquired. Decrement the
* lock recursion count field.
*/
obj->lock -= 1 << LW_LOCK_COUNT_SHIFT;
}
} else {
/*
* We do not own the lock. The JVM spec requires that we
* throw an exception in this case.
*/
dvmThrowIllegalMonitorStateException("unlock of unowned monitor");
return false;
}
} else {
/*
* The lock is fat. We must check to see if unlockMonitor has
* raised any exceptions before continuing.
*/
assert(LW_MONITOR(obj->lock) != NULL);
if (!unlockMonitor(self, LW_MONITOR(obj->lock))) {
/*
* An exception has been raised. Do not fall through.
*/
return false;
}
}
return true;
}
/*
* Object.wait(). Also called for class init.
*/
void dvmObjectWait(Thread* self, Object *obj, s8 msec, s4 nsec,
bool interruptShouldThrow)
{
Monitor* mon;
u4 thin = *(volatile u4 *)&obj->lock;
/* If the lock is still thin, we need to fatten it.
*/
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
/* Make sure that 'self' holds the lock.
*/
if (LW_LOCK_OWNER(thin) != self->threadId) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before wait()");
return;
}
/* This thread holds the lock. We need to fatten the lock
* so 'self' can block on it. Don't update the object lock
* field yet, because 'self' needs to acquire the lock before
* any other thread gets a chance.
*/
inflateMonitor(self, obj);
ALOGV("(%d) lock %p fattened by wait()", self->threadId, &obj->lock);
}
mon = LW_MONITOR(obj->lock);
waitMonitor(self, mon, msec, nsec, interruptShouldThrow);
}
/*
* Object.notify().
*/
void dvmObjectNotify(Thread* self, Object *obj)
{
u4 thin = *(volatile u4 *)&obj->lock;
/* If the lock is still thin, there aren't any waiters;
* waiting on an object forces lock fattening.
*/
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
/* Make sure that 'self' holds the lock.
*/
if (LW_LOCK_OWNER(thin) != self->threadId) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before notify()");
return;
}
/* no-op; there are no waiters to notify.
*/
} else {
/* It's a fat lock.
*/
notifyMonitor(self, LW_MONITOR(thin));
}
}
/*
* Object.notifyAll().
*/
void dvmObjectNotifyAll(Thread* self, Object *obj)
{
u4 thin = *(volatile u4 *)&obj->lock;
/* If the lock is still thin, there aren't any waiters;
* waiting on an object forces lock fattening.
*/
if (LW_SHAPE(thin) == LW_SHAPE_THIN) {
/* Make sure that 'self' holds the lock.
*/
if (LW_LOCK_OWNER(thin) != self->threadId) {
dvmThrowIllegalMonitorStateException(
"object not locked by thread before notifyAll()");
return;
}
/* no-op; there are no waiters to notify.
*/
} else {
/* It's a fat lock.
*/
notifyAllMonitor(self, LW_MONITOR(thin));
}
}
/*
* This implements java.lang.Thread.sleep(long msec, int nsec).
*
* The sleep is interruptible by other threads, which means we can't just
* plop into an OS sleep call. (We probably could if we wanted to send
* signals around and rely on EINTR, but that's inefficient and relies
* on native code respecting our signal mask.)
*
* We have to do all of this stuff for Object.wait() as well, so it's
* easiest to just sleep on a private Monitor.
*
* It appears that we want sleep(0,0) to go through the motions of sleeping
* for a very short duration, rather than just returning.
*/
void dvmThreadSleep(u8 msec, u4 nsec)
{
Thread* self = dvmThreadSelf();
Monitor* mon = gDvm.threadSleepMon;
/* sleep(0,0) wakes up immediately, wait(0,0) means wait forever; adjust */
if (msec == 0 && nsec == 0)
nsec++;
lockMonitor(self, mon);
waitMonitor(self, mon, msec, nsec, true);
unlockMonitor(self, mon);
}
/*
* Implement java.lang.Thread.interrupt().
*/
void dvmThreadInterrupt(Thread* thread)
{
assert(thread != NULL);
dvmLockMutex(&thread->waitMutex);
/*
* If the interrupted flag is already set no additional action is
* required.
*/
if (thread->interrupted == true) {
dvmUnlockMutex(&thread->waitMutex);
return;
}
/*
* Raise the "interrupted" flag. This will cause it to bail early out
* of the next wait() attempt, if it's not currently waiting on
* something.
*/
thread->interrupted = true;
/*
* Is the thread waiting?
*
* Note that fat vs. thin doesn't matter here; waitMonitor
* is only set when a thread actually waits on a monitor,
* which implies that the monitor has already been fattened.
*/
if (thread->waitMonitor != NULL) {
pthread_cond_signal(&thread->waitCond);
}
dvmUnlockMutex(&thread->waitMutex);
}
#ifndef WITH_COPYING_GC
u4 dvmIdentityHashCode(Object *obj)
{
return (u4)obj;
}
#else
/*
* Returns the identity hash code of the given object.
*/
u4 dvmIdentityHashCode(Object *obj)
{
Thread *self, *thread;
volatile u4 *lw;
size_t size;
u4 lock, owner, hashState;
if (obj == NULL) {
/*
* Null is defined to have an identity hash code of 0.
*/
return 0;
}
lw = &obj->lock;
retry:
hashState = LW_HASH_STATE(*lw);
if (hashState == LW_HASH_STATE_HASHED) {
/*
* The object has been hashed but has not had its hash code
* relocated by the garbage collector. Use the raw object
* address.
*/
return (u4)obj >> 3;
} else if (hashState == LW_HASH_STATE_HASHED_AND_MOVED) {
/*
* The object has been hashed and its hash code has been
* relocated by the collector. Use the value of the naturally
* aligned word following the instance data.
*/
assert(!dvmIsClassObject(obj));
if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISARRAY)) {
size = dvmArrayObjectSize((ArrayObject *)obj);
size = (size + 2) & ~2;
} else {
size = obj->clazz->objectSize;
}
return *(u4 *)(((char *)obj) + size);
} else if (hashState == LW_HASH_STATE_UNHASHED) {
/*
* The object has never been hashed. Change the hash state to
* hashed and use the raw object address.
*/
self = dvmThreadSelf();
if (self->threadId == lockOwner(obj)) {
/*
* We already own the lock so we can update the hash state
* directly.
*/
*lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT);
return (u4)obj >> 3;
}
/*
* We do not own the lock. Try acquiring the lock. Should
* this fail, we must suspend the owning thread.
*/
if (LW_SHAPE(*lw) == LW_SHAPE_THIN) {
/*
* If the lock is thin assume it is unowned. We simulate
* an acquire, update, and release with a single CAS.
*/
lock = (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT);
if (android_atomic_acquire_cas(
0,
(int32_t)lock,
(int32_t *)lw) == 0) {
/*
* A new lockword has been installed with a hash state
* of hashed. Use the raw object address.
*/
return (u4)obj >> 3;
}
} else {
if (tryLockMonitor(self, LW_MONITOR(*lw))) {
/*
* The monitor lock has been acquired. Change the
* hash state to hashed and use the raw object
* address.
*/
*lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT);
unlockMonitor(self, LW_MONITOR(*lw));
return (u4)obj >> 3;
}
}
/*
* At this point we have failed to acquire the lock. We must
* identify the owning thread and suspend it.
*/
dvmLockThreadList(self);
/*
* Cache the lock word as its value can change between
* determining its shape and retrieving its owner.
*/
lock = *lw;
if (LW_SHAPE(lock) == LW_SHAPE_THIN) {
/*
* Find the thread with the corresponding thread id.
*/
owner = LW_LOCK_OWNER(lock);
assert(owner != self->threadId);
/*
* If the lock has no owner do not bother scanning the
* thread list and fall through to the failure handler.
*/
thread = owner ? gDvm.threadList : NULL;
while (thread != NULL) {
if (thread->threadId == owner) {
break;
}
thread = thread->next;
}
} else {
thread = LW_MONITOR(lock)->owner;
}
/*
* If thread is NULL the object has been released since the
* thread list lock was acquired. Try again.
*/
if (thread == NULL) {
dvmUnlockThreadList();
goto retry;
}
/*
* Wait for the owning thread to suspend.
*/
dvmSuspendThread(thread);
if (dvmHoldsLock(thread, obj)) {
/*
* The owning thread has been suspended. We can safely
* change the hash state to hashed.
*/
*lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT);
dvmResumeThread(thread);
dvmUnlockThreadList();
return (u4)obj >> 3;
}
/*
* The wrong thread has been suspended. Try again.
*/
dvmResumeThread(thread);
dvmUnlockThreadList();
goto retry;
}
ALOGE("object %p has an unknown hash state %#x", obj, hashState);
dvmDumpThread(dvmThreadSelf(), false);
dvmAbort();
return 0; /* Quiet the compiler. */
}
#endif /* WITH_COPYING_GC */