Mercurial > hg > truffle
annotate src/share/vm/runtime/synchronizer.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | bfc89697cccb |
| children | fa83ab460c54 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 class BasicLock VALUE_OBJ_CLASS_SPEC { | |
| 26 friend class VMStructs; | |
| 27 private: | |
| 28 volatile markOop _displaced_header; | |
| 29 public: | |
| 30 markOop displaced_header() const { return _displaced_header; } | |
| 31 void set_displaced_header(markOop header) { _displaced_header = header; } | |
| 32 | |
| 33 void print_on(outputStream* st) const; | |
| 34 | |
| 35 // move a basic lock (used during deoptimization | |
| 36 void move_to(oop obj, BasicLock* dest); | |
| 37 | |
| 38 static int displaced_header_offset_in_bytes() { return offset_of(BasicLock, _displaced_header); } | |
| 39 }; | |
| 40 | |
| 41 // A BasicObjectLock associates a specific Java object with a BasicLock. | |
| 42 // It is currently embedded in an interpreter frame. | |
| 43 | |
| 44 // Because some machines have alignment restrictions on the control stack, | |
| 45 // the actual space allocated by the interpreter may include padding words | |
| 46 // after the end of the BasicObjectLock. Also, in order to guarantee | |
| 47 // alignment of the embedded BasicLock objects on such machines, we | |
| 48 // put the embedded BasicLock at the beginning of the struct. | |
| 49 | |
| 50 class BasicObjectLock VALUE_OBJ_CLASS_SPEC { | |
| 51 friend class VMStructs; | |
| 52 private: | |
| 53 BasicLock _lock; // the lock, must be double word aligned | |
| 54 oop _obj; // object holds the lock; | |
| 55 | |
| 56 public: | |
| 57 // Manipulation | |
| 58 oop obj() const { return _obj; } | |
| 59 void set_obj(oop obj) { _obj = obj; } | |
| 60 BasicLock* lock() { return &_lock; } | |
| 61 | |
| 62 // Note: Use frame::interpreter_frame_monitor_size() for the size of BasicObjectLocks | |
| 63 // in interpreter activation frames since it includes machine-specific padding. | |
| 64 static int size() { return sizeof(BasicObjectLock)/wordSize; } | |
| 65 | |
| 66 // GC support | |
| 67 void oops_do(OopClosure* f) { f->do_oop(&_obj); } | |
| 68 | |
| 69 static int obj_offset_in_bytes() { return offset_of(BasicObjectLock, _obj); } | |
| 70 static int lock_offset_in_bytes() { return offset_of(BasicObjectLock, _lock); } | |
| 71 }; | |
| 72 | |
| 73 class ObjectMonitor; | |
| 74 | |
| 75 class ObjectSynchronizer : AllStatic { | |
| 76 friend class VMStructs; | |
| 77 public: | |
| 78 typedef enum { | |
| 79 owner_self, | |
| 80 owner_none, | |
| 81 owner_other | |
| 82 } LockOwnership; | |
| 83 // exit must be implemented non-blocking, since the compiler cannot easily handle | |
| 84 // deoptimization at monitor exit. Hence, it does not take a Handle argument. | |
| 85 | |
| 86 // This is full version of monitor enter and exit. I choose not | |
| 87 // to use enter() and exit() in order to make sure user be ware | |
| 88 // of the performance and semantics difference. They are normally | |
| 89 // used by ObjectLocker etc. The interpreter and compiler use | |
| 90 // assembly copies of these routines. Please keep them synchornized. | |
| 91 // | |
| 92 // attempt_rebias flag is used by UseBiasedLocking implementation | |
| 93 static void fast_enter (Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS); | |
| 94 static void fast_exit (oop obj, BasicLock* lock, Thread* THREAD); | |
| 95 | |
| 96 // WARNING: They are ONLY used to handle the slow cases. They should | |
| 97 // only be used when the fast cases failed. Use of these functions | |
| 98 // without previous fast case check may cause fatal error. | |
| 99 static void slow_enter (Handle obj, BasicLock* lock, TRAPS); | |
| 100 static void slow_exit (oop obj, BasicLock* lock, Thread* THREAD); | |
| 101 | |
| 102 // Used only to handle jni locks or other unmatched monitor enter/exit | |
| 103 // Internally they will use heavy weight monitor. | |
| 104 static void jni_enter (Handle obj, TRAPS); | |
| 105 static bool jni_try_enter(Handle obj, Thread* THREAD); // Implements Unsafe.tryMonitorEnter | |
| 106 static void jni_exit (oop obj, Thread* THREAD); | |
| 107 | |
| 108 // Handle all interpreter, compiler and jni cases | |
| 109 static void wait (Handle obj, jlong millis, TRAPS); | |
| 110 static void notify (Handle obj, TRAPS); | |
| 111 static void notifyall (Handle obj, TRAPS); | |
| 112 | |
| 113 // Special internal-use-only method for use by JVM infrastructure | |
| 114 // that needs to wait() on a java-level object but that can't risk | |
| 115 // throwing unexpected InterruptedExecutionExceptions. | |
| 116 static void waitUninterruptibly (Handle obj, jlong Millis, Thread * THREAD) ; | |
| 117 | |
| 118 // used by classloading to free classloader object lock, | |
| 119 // wait on an internal lock, and reclaim original lock | |
| 120 // with original recursion count | |
| 121 static intptr_t complete_exit (Handle obj, TRAPS); | |
| 122 static void reenter (Handle obj, intptr_t recursion, TRAPS); | |
| 123 | |
| 124 // thread-specific and global objectMonitor free list accessors | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
125 // static void verifyInUse (Thread * Self) ; too slow for general assert/debug |
| 0 | 126 static ObjectMonitor * omAlloc (Thread * Self) ; |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
127 static void omRelease (Thread * Self, ObjectMonitor * m, bool FromPerThreadAlloc) ; |
| 0 | 128 static void omFlush (Thread * Self) ; |
| 129 | |
| 130 // Inflate light weight monitor to heavy weight monitor | |
| 131 static ObjectMonitor* inflate(Thread * Self, oop obj); | |
| 132 // This version is only for internal use | |
| 133 static ObjectMonitor* inflate_helper(oop obj); | |
| 134 | |
| 135 // Returns the identity hash value for an oop | |
| 136 // NOTE: It may cause monitor inflation | |
| 137 static intptr_t identity_hash_value_for(Handle obj); | |
| 138 static intptr_t FastHashCode (Thread * Self, oop obj) ; | |
| 139 | |
| 140 // java.lang.Thread support | |
| 141 static bool current_thread_holds_lock(JavaThread* thread, Handle h_obj); | |
| 142 static LockOwnership query_lock_ownership(JavaThread * self, Handle h_obj); | |
| 143 | |
| 144 static JavaThread* get_lock_owner(Handle h_obj, bool doLock); | |
| 145 | |
| 146 // JNI detach support | |
| 147 static void release_monitors_owned_by_thread(TRAPS); | |
| 148 static void monitors_iterate(MonitorClosure* m); | |
| 149 | |
| 150 // GC: we current use aggressive monitor deflation policy | |
| 151 // Basically we deflate all monitors that are not busy. | |
| 152 // An adaptive profile-based deflation policy could be used if needed | |
| 153 static void deflate_idle_monitors(); | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
154 static int walk_monitor_list(ObjectMonitor** listheadp, |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
155 ObjectMonitor** FreeHeadp, |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
156 ObjectMonitor** FreeTailp); |
| 1587 | 157 static bool deflate_monitor(ObjectMonitor* mid, oop obj, ObjectMonitor** FreeHeadp, |
| 158 ObjectMonitor** FreeTailp); | |
| 0 | 159 static void oops_do(OopClosure* f); |
| 160 | |
| 161 // debugging | |
| 162 static void trace_locking(Handle obj, bool is_compiled, bool is_method, bool is_locking) PRODUCT_RETURN; | |
| 163 static void verify() PRODUCT_RETURN; | |
| 164 static int verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0; | |
| 165 | |
| 166 private: | |
| 167 enum { _BLOCKSIZE = 128 }; | |
| 168 static ObjectMonitor* gBlockList; | |
| 169 static ObjectMonitor * volatile gFreeList; | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
170 static ObjectMonitor * volatile gOmInUseList; // for moribund thread, so monitors they inflated still get scanned |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
171 static int gOmInUseCount; |
| 0 | 172 |
| 173 public: | |
| 174 static void Initialize () ; | |
| 175 static PerfCounter * _sync_ContendedLockAttempts ; | |
| 176 static PerfCounter * _sync_FutileWakeups ; | |
| 177 static PerfCounter * _sync_Parks ; | |
| 178 static PerfCounter * _sync_EmptyNotifications ; | |
| 179 static PerfCounter * _sync_Notifications ; | |
| 180 static PerfCounter * _sync_SlowEnter ; | |
| 181 static PerfCounter * _sync_SlowExit ; | |
| 182 static PerfCounter * _sync_SlowNotify ; | |
| 183 static PerfCounter * _sync_SlowNotifyAll ; | |
| 184 static PerfCounter * _sync_FailedSpins ; | |
| 185 static PerfCounter * _sync_SuccessfulSpins ; | |
| 186 static PerfCounter * _sync_PrivateA ; | |
| 187 static PerfCounter * _sync_PrivateB ; | |
| 188 static PerfCounter * _sync_MonInCirculation ; | |
| 189 static PerfCounter * _sync_MonScavenged ; | |
| 190 static PerfCounter * _sync_Inflations ; | |
| 191 static PerfCounter * _sync_Deflations ; | |
| 192 static PerfLongVariable * _sync_MonExtant ; | |
| 193 | |
| 194 public: | |
| 195 static void RegisterSpinCallback (int (*)(intptr_t, int), intptr_t) ; | |
| 196 | |
| 197 }; | |
| 198 | |
| 199 // ObjectLocker enforced balanced locking and can never thrown an | |
| 200 // IllegalMonitorStateException. However, a pending exception may | |
| 201 // have to pass through, and we must also be able to deal with | |
| 202 // asynchronous exceptions. The caller is responsible for checking | |
| 203 // the threads pending exception if needed. | |
| 204 // doLock was added to support classloading with UnsyncloadClass which | |
| 205 // requires flag based choice of locking the classloader lock. | |
| 206 class ObjectLocker : public StackObj { | |
| 207 private: | |
| 208 Thread* _thread; | |
| 209 Handle _obj; | |
| 210 BasicLock _lock; | |
| 211 bool _dolock; // default true | |
| 212 public: | |
| 213 ObjectLocker(Handle obj, Thread* thread, bool doLock = true); | |
| 214 ~ObjectLocker(); | |
| 215 | |
| 216 // Monitor behavior | |
| 217 void wait (TRAPS) { ObjectSynchronizer::wait (_obj, 0, CHECK); } // wait forever | |
| 218 void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); } | |
| 219 void waitUninterruptibly (TRAPS) { ObjectSynchronizer::waitUninterruptibly (_obj, 0, CHECK);} | |
| 220 // complete_exit gives up lock completely, returning recursion count | |
| 221 // reenter reclaims lock with original recursion count | |
| 222 intptr_t complete_exit(TRAPS) { return ObjectSynchronizer::complete_exit(_obj, CHECK_0); } | |
| 223 void reenter(intptr_t recursion, TRAPS) { ObjectSynchronizer::reenter(_obj, recursion, CHECK); } | |
| 224 }; |