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_H_ 20 #define DALVIK_SYNC_H_ 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 66 struct Object; 67 struct Monitor; 68 struct 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 */ 78 extern "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 */ 83 extern "C" bool dvmUnlockObject(Thread* self, Object* obj); 84 85 /* 86 * Implementations of some java/lang/Object calls. 87 */ 88 void dvmObjectWait(Thread* self, Object* obj, 89 s8 timeout, s4 nanos, bool interruptShouldThrow); 90 void dvmObjectNotify(Thread* self, Object* obj); 91 void dvmObjectNotifyAll(Thread* self, Object* obj); 92 93 /* 94 * Implementation of System.identityHashCode(). 95 */ 96 u4 dvmIdentityHashCode(Object* obj); 97 98 /* 99 * Implementation of Thread.sleep(). 100 */ 101 void 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 */ 108 void dvmThreadInterrupt(Thread* thread); 109 110 /* create a new Monitor struct */ 111 Monitor* 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 */ 118 void dvmSweepMonitorList(Monitor** mon, int (*isUnmarkedObject)(void*)); 119 120 /* free monitor list */ 121 void 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 */ 129 Object* 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 */ 137 Thread* dvmGetObjectLockHolder(Object* obj); 138 139 /* 140 * Checks whether the object is held by the specified thread. 141 */ 142 bool dvmHoldsLock(Thread* thread, Object* obj); 143 144 /* 145 * Relative timed wait on condition 146 */ 147 int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, 148 s8 msec, s4 nsec); 149 150 #endif // DALVIK_SYNC_H_ 151