/dalvik/vm/ |
H A D | Atomic.cpp | 202 pthread_mutex_t* lock = GetSwapLock(addr); local 204 pthread_mutex_lock(lock); 209 pthread_mutex_unlock(lock); 223 pthread_mutex_t* lock = GetSwapLock(addr); local 225 pthread_mutex_lock(lock); 233 pthread_mutex_unlock(lock); 240 pthread_mutex_t* lock = GetSwapLock(addr); local 242 pthread_mutex_lock(lock); 244 pthread_mutex_unlock(lock);
|
H A D | Sync.cpp | 37 * The two states of an Object's lock are referred to as "thin" and 38 * "fat". A lock may transition from the "thin" state to the "fat" 39 * state and this transition is referred to as inflation. Once a lock 42 * The lock value itself is stored in Object.lock. The LSB of the 43 * lock encodes its state. When cleared, the lock is in the "thin" 47 * lock count thread id hash state 0 49 * When set, the lock is in the "fat" state and its bits are formatted 73 Thread* owner; /* which thread currently owns the lock 79 pthread_mutex_t lock; member in struct:Monitor 153 u4 lock; local 1236 u4 lock, owner, hashState; local [all...] |
H A D | Sync.h | 44 * lock. Performs no error checking. 52 * holding the lock. 60 * a lock has been recursively acquired. 71 * Returns true if the lock has been fattened. 73 #define IS_LOCK_FAT(lock) (LW_SHAPE(*(lock)) == LW_SHAPE_FAT) 132 * Get the thread that holds the lock on the specified object. The 135 * The caller must lock the thread list before calling here.
|
H A D | Hash.h | 79 pthread_mutex_t lock; member in struct:HashTable 115 dvmLockMutex(&pHashTable->lock); 118 dvmUnlockMutex(&pHashTable->lock); 143 * forget to lock the table before calling this. 215 * The caller should lock the table beforehand.
|
H A D | LinearAlloc.h | 35 pthread_mutex_t lock; /* controls updates to this struct */ member in struct:LinearAllocHdr
|
H A D | LinearAlloc.cpp | 212 dvmInitMutex(&pHdr->lock); 287 dvmLockMutex(&pHdr->lock); 388 dvmUnlockMutex(&pHdr->lock); 455 dvmLockMutex(&pHdr->lock); 526 dvmUnlockMutex(&pHdr->lock); 590 * We grab the lock so that the header contents and list output are 600 dvmLockMutex(&pHdr->lock); 651 dvmUnlockMutex(&pHdr->lock); 667 dvmLockMutex(&pHdr->lock); 685 dvmUnlockMutex(&pHdr->lock); [all...] |
H A D | Debugger.h | 103 pthread_mutex_t lock; member in struct:DebugInvokeReq
|
H A D | Hash.cpp | 54 dvmInitMutex(&pHashTable->lock); 128 * If multiple threads can access the hash table, the table's lock should 386 * The caller should lock the table before calling here.
|
H A D | Jni.cpp | 329 ScopedPthreadMutexLock lock(&gDvm.jniGlobalRefLock); 341 ScopedPthreadMutexLock lock(&gDvm.jniWeakGlobalRefLock); 473 ScopedPthreadMutexLock lock(&gDvm.jniGlobalRefLock); 525 ScopedPthreadMutexLock lock(&gDvm.jniWeakGlobalRefLock); 541 ScopedPthreadMutexLock lock(&gDvm.jniWeakGlobalRefLock); 560 ScopedPthreadMutexLock lock(&gDvm.jniGlobalRefLock); 588 ScopedPthreadMutexLock lock(&gDvm.jniPinRefLock); 631 ScopedPthreadMutexLock lock(&gDvm.jniPinRefLock); 2762 * a lock across the entire operation. What we can do is temporarily 3302 ScopedPthreadMutexLock lock( [all...] |
H A D | Debugger.cpp | 79 When a thread goes away, we lock the list and free the struct. To 81 under us, we want to acquire and hold the thread list lock while we're 1723 /* lock the thread list, so the thread doesn't vanish while we work */ 1771 /* lock the thread list, so the thread doesn't vanish while we work */ 1799 /* lock the thread list, so the thread doesn't vanish while we work */ 1826 /* lock the thread list, so the thread doesn't vanish while we work */ 1878 /* lock the thread list, so the thread doesn't vanish while we work */ 2573 * after the setup is complete, so we can safely release the lock. 2688 dvmLockMutex(&targetThread->invokeReq.lock); 2703 &targetThread->invokeReq.lock); [all...] |
H A D | Thread.cpp | 159 holding the thread list lock, it will prevent the GC or debugger from 161 section around the entire operation (enter critical, get lock, do stuff, 162 release lock, exit critical). 166 then gets blocked on the thread list lock knows that the thread it is 167 waiting for is also in a critical section, and will release the lock 182 above are followed you don't need to lock anything in the GC. The risk is 293 * We need to assign the threadId early so we can lock/notify 331 * Grab the suspend count global lock. 338 * this lock recursively. Doesn't work with "fast" pthread mutexes. 340 * This lock i [all...] |
/dalvik/dexgen/src/com/android/dexgen/util/ |
H A D | IndentingWriter.java | 92 synchronized (lock) { 140 synchronized (lock) { 152 synchronized (lock) {
|
/dalvik/dx/src/com/android/dx/util/ |
H A D | IndentingWriter.java | 92 synchronized (lock) { 140 synchronized (lock) { 152 synchronized (lock) {
|
/dalvik/vm/compiler/codegen/arm/Thumb2/ |
H A D | Gen.cpp | 211 * Handle simple case (thin lock) inline. If it's complicated, bail 212 * out to the heavyweight lock/unlock routines. We'll use dedicated 218 * r2 -> intial contents of object->lock, later result of strex 220 * r7 -> temp to hold new lock value [unlock only] 223 * The result of the strex is 0 if we acquire the lock. 225 * See comments in Sync.c for the layout of the lock word. 228 * simple case is thin lock, held by no-one. For monitor exit, 229 * the simple case is thin lock, held by the unlocking thread with 232 * A minor complication is that there is a field in the lock word 252 offsetof(Object, lock) >> [all...] |
/dalvik/vm/native/ |
H A D | dalvik_system_VMRuntime.cpp | 69 ScopedPthreadMutexLock lock(&gDvmJit.compilerLock);
|
/dalvik/vm/interp/ |
H A D | Interp.cpp | 93 /* grab lock before reading or writing anything else in here */ 94 pthread_mutex_t lock; member in struct:BreakpointSet 109 dvmInitMutex(&pSet->lock); 137 if (dvmTryLockMutex(&pSet->lock) != 0) { 140 dvmLockMutex(&pSet->lock); 150 dvmUnlockMutex(&pSet->lock); 164 * The BreakpointSet's lock must be acquired before calling here. 184 * The BreakpointSet's lock must be acquired before calling here. 229 * The BreakpointSet's lock must be acquired before calling here. 309 * The BreakpointSet's lock mus [all...] |
/dalvik/vm/mterp/common/ |
H A D | asm-constants.h | 209 MTERP_OFFSET(offObject_lock, Object, lock, 4)
|
/dalvik/vm/oo/ |
H A D | Object.h | 213 * A word containing either a "thin" lock or a "fat" monitor. See 216 u4 lock; member in struct:Object
|
/dalvik/vm/alloc/ |
H A D | Copying.cpp | 1289 if (LW_HASH_STATE(fromObj->lock) != LW_HASH_STATE_UNHASHED) { 1296 if (LW_HASH_STATE(fromObj->lock) == LW_HASH_STATE_HASHED_AND_MOVED) { 1309 if (LW_HASH_STATE(fromObj->lock) == LW_HASH_STATE_HASHED) { 1315 toObj->lock |= LW_HASH_STATE_HASHED_AND_MOVED << LW_HASH_STATE_SHIFT; 1529 /* the GC is running, so no lock required */ 1932 if (LW_HASH_STATE(obj->lock) == LW_HASH_STATE_HASHED_AND_MOVED) {
|
/dalvik/vm/jdwp/ |
H A D | JdwpEvent.cpp | 625 dvmDbgLockMutex(&pReq->lock); 627 dvmDbgUnlockMutex(&pReq->lock);
|