Searched refs:lock (Results 1 - 20 of 20) sorted by relevance

/dalvik/vm/
H A DAtomic.cpp202 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 DSync.cpp37 * 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 DSync.h44 * 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 DHash.h79 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 DLinearAlloc.h35 pthread_mutex_t lock; /* controls updates to this struct */ member in struct:LinearAllocHdr
H A DLinearAlloc.cpp212 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 DDebugger.h103 pthread_mutex_t lock; member in struct:DebugInvokeReq
H A DHash.cpp54 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 DJni.cpp329 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 DDebugger.cpp79 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 DThread.cpp159 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 DIndentingWriter.java92 synchronized (lock) {
140 synchronized (lock) {
152 synchronized (lock) {
/dalvik/dx/src/com/android/dx/util/
H A DIndentingWriter.java92 synchronized (lock) {
140 synchronized (lock) {
152 synchronized (lock) {
/dalvik/vm/compiler/codegen/arm/Thumb2/
H A DGen.cpp211 * 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 Ddalvik_system_VMRuntime.cpp69 ScopedPthreadMutexLock lock(&gDvmJit.compilerLock);
/dalvik/vm/interp/
H A DInterp.cpp93 /* 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 Dasm-constants.h209 MTERP_OFFSET(offObject_lock, Object, lock, 4)
/dalvik/vm/oo/
H A DObject.h213 * A word containing either a "thin" lock or a "fat" monitor. See
216 u4 lock; member in struct:Object
/dalvik/vm/alloc/
H A DCopying.cpp1289 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 DJdwpEvent.cpp625 dvmDbgLockMutex(&pReq->lock);
627 dvmDbgUnlockMutex(&pReq->lock);

Completed in 444 milliseconds