Sync.h revision d862faa2ceae186da5518607505eb942d634ced9
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16/* 17 * Object synchronization functions. 18 */ 19#ifndef _DALVIK_SYNC 20#define _DALVIK_SYNC 21 22/* 23 * Monitor shape field. Used to distinguish immediate thin locks from 24 * indirecting fat locks. 25 */ 26#define LW_SHAPE_THIN 0 27#define LW_SHAPE_FAT 1 28#define LW_SHAPE_MASK 0x1 29#define LW_SHAPE(x) ((x) & LW_SHAPE_MASK) 30 31/* 32 * Hash state field. Used to signify that an object has had its 33 * identity hash code exposed or relocated. 34 */ 35#define LW_HASH_STATE_UNHASHED 0 36#define LW_HASH_STATE_HASHED 1 37#define LW_HASH_STATE_HASHED_AND_MOVED 3 38#define LW_HASH_STATE_MASK 0x3 39#define LW_HASH_STATE_SHIFT 1 40#define LW_HASH_STATE(x) (((x) >> LW_HASH_STATE_SHIFT) & LW_HASH_STATE_MASK) 41 42/* 43 * Monitor accessor. Extracts a monitor structure pointer from a fat 44 * lock. Performs no error checking. 45 */ 46#define LW_MONITOR(x) \ 47 ((Monitor*)((x) & ~((LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT) | \ 48 LW_SHAPE_MASK))) 49 50/* 51 * Lock owner field. Contains the thread id of the thread currently 52 * holding the lock. 53 */ 54#define LW_LOCK_OWNER_MASK 0xffff 55#define LW_LOCK_OWNER_SHIFT 3 56#define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK) 57 58/* 59 * Lock recursion count field. Contains a count of the numer of times 60 * a lock has been recursively acquired. 61 */ 62#define LW_LOCK_COUNT_MASK 0x1fff 63#define LW_LOCK_COUNT_SHIFT 19 64#define LW_LOCK_COUNT(x) (((x) >> LW_LOCK_COUNT_SHIFT) & LW_LOCK_COUNT_MASK) 65 66struct Object; 67struct Monitor; 68struct Thread; 69 70/* 71 * Returns true if the lock has been fattened. 72 */ 73#define IS_LOCK_FAT(lock) (LW_SHAPE(*(lock)) == LW_SHAPE_FAT) 74 75/* 76 * Acquire the object's monitor. 77 */ 78extern "C" void dvmLockObject(Thread* self, Object* obj); 79 80/* Returns true if the unlock succeeded. 81 * If the unlock failed, an exception will be pending. 82 */ 83extern "C" bool dvmUnlockObject(Thread* self, Object* obj); 84 85/* 86 * Implementations of some java/lang/Object calls. 87 */ 88void dvmObjectWait(Thread* self, Object* obj, 89 s8 timeout, s4 nanos, bool interruptShouldThrow); 90void dvmObjectNotify(Thread* self, Object* obj); 91void dvmObjectNotifyAll(Thread* self, Object* obj); 92 93/* 94 * Implementation of System.identityHashCode(). 95 */ 96u4 dvmIdentityHashCode(Object* obj); 97 98/* 99 * Implementation of Thread.sleep(). 100 */ 101void dvmThreadSleep(u8 msec, u4 nsec); 102 103/* 104 * Implementation of Thread.interrupt(). 105 * 106 * Interrupt a thread. If it's waiting on a monitor, wake it up. 107 */ 108void dvmThreadInterrupt(Thread* thread); 109 110/* create a new Monitor struct */ 111Monitor* dvmCreateMonitor(Object* obj); 112 113/* 114 * Frees unmarked monitors from the monitor list. The given callback 115 * routine should return a non-zero value when passed a pointer to an 116 * unmarked object. 117 */ 118void dvmSweepMonitorList(Monitor** mon, int (*isUnmarkedObject)(void*)); 119 120/* free monitor list */ 121void dvmFreeMonitorList(void); 122 123/* 124 * Get the object a monitor is part of. 125 * 126 * Returns NULL if "mon" is NULL or the monitor is not part of an object 127 * (which should only happen for Thread.sleep() in the current implementation). 128 */ 129Object* dvmGetMonitorObject(Monitor* mon); 130 131/* 132 * Get the thread that holds the lock on the specified object. The 133 * object may be unlocked, thin-locked, or fat-locked. 134 * 135 * The caller must lock the thread list before calling here. 136 */ 137Thread* dvmGetObjectLockHolder(Object* obj); 138 139/* 140 * Checks whether the object is held by the specified thread. 141 */ 142bool dvmHoldsLock(Thread* thread, Object* obj); 143 144/* 145 * Relative timed wait on condition 146 */ 147int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, 148 s8 msec, s4 nsec); 149 150#endif /*_DALVIK_SYNC*/ 151