Mercurial > hg > truffle
annotate src/share/vm/runtime/mutex.hpp @ 1145:e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Wed, 23 Dec 2009 09:23:54 -0800 |
| parents | 354d3184f6b2 |
| children | c18cbe5936b8 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 1998-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // The SplitWord construct allows us to colocate the contention queue | |
| 26 // (cxq) with the lock-byte. The queue elements are ParkEvents, which are | |
| 27 // always aligned on 256-byte addresses - the least significant byte of | |
| 28 // a ParkEvent is always 0. Colocating the lock-byte with the queue | |
| 29 // allows us to easily avoid what would otherwise be a race in lock() | |
| 30 // if we were to use two completely separate fields for the contention queue | |
| 31 // and the lock indicator. Specifically, colocation renders us immune | |
| 32 // from the race where a thread might enqueue itself in the lock() slow-path | |
| 33 // immediately after the lock holder drops the outer lock in the unlock() | |
| 34 // fast-path. | |
| 35 // | |
| 36 // Colocation allows us to use a fast-path unlock() form that uses | |
| 37 // A MEMBAR instead of a CAS. MEMBAR has lower local latency than CAS | |
| 38 // on many platforms. | |
| 39 // | |
| 40 // See: | |
| 41 // + http://blogs.sun.com/dave/entry/biased_locking_in_hotspot | |
| 42 // + http://blogs.sun.com/dave/resource/synchronization-public2.pdf | |
| 43 // | |
| 44 // Note that we're *not* using word-tearing the classic sense. | |
| 45 // The lock() fast-path will CAS the lockword and the unlock() | |
| 46 // fast-path will store into the lock-byte colocated within the lockword. | |
| 47 // We depend on the fact that all our reference platforms have | |
| 48 // coherent and atomic byte accesses. More precisely, byte stores | |
| 49 // interoperate in a safe, sane, and expected manner with respect to | |
| 50 // CAS, ST and LDs to the full-word containing the byte. | |
| 51 // If you're porting HotSpot to a platform where that isn't the case | |
| 52 // then you'll want change the unlock() fast path from: | |
| 53 // STB;MEMBAR #storeload; LDN | |
| 54 // to a full-word CAS of the lockword. | |
| 55 | |
| 56 | |
| 57 union SplitWord { // full-word with separately addressable LSB | |
| 58 volatile intptr_t FullWord ; | |
| 59 volatile void * Address ; | |
| 60 volatile jbyte Bytes [sizeof(intptr_t)] ; | |
| 61 } ; | |
| 62 | |
| 63 // Endian-ness ... index of least-significant byte in SplitWord.Bytes[] | |
| 1010 | 64 #ifdef VM_LITTLE_ENDIAN |
| 0 | 65 #define _LSBINDEX 0 |
| 66 #else | |
| 67 #define _LSBINDEX (sizeof(intptr_t)-1) | |
| 68 #endif | |
| 69 | |
| 70 class ParkEvent ; | |
| 71 | |
| 72 // See orderAccess.hpp. We assume throughout the VM that mutex lock and | |
| 73 // try_lock do fence-lock-acquire, and that unlock does a release-unlock, | |
| 74 // *in that order*. If their implementations change such that these | |
| 75 // assumptions are violated, a whole lot of code will break. | |
| 76 | |
| 605 | 77 // The default length of monitor name is chosen to be 64 to avoid false sharing. |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
78 static const int MONITOR_NAME_LEN = 64; |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
79 |
| 0 | 80 class Monitor : public CHeapObj { |
| 81 | |
| 82 public: | |
| 83 // A special lock: Is a lock where you are guaranteed not to block while you are | |
| 84 // holding it, i.e., no vm operation can happen, taking other locks, etc. | |
| 85 // NOTE: It is critical that the rank 'special' be the lowest (earliest) | |
| 86 // (except for "event"?) for the deadlock dection to work correctly. | |
| 87 // The rank native is only for use in Mutex's created by JVM_RawMonitorCreate, | |
| 88 // which being external to the VM are not subject to deadlock detection. | |
| 89 // The rank safepoint is used only for synchronization in reaching a | |
| 90 // safepoint and leaving a safepoint. It is only used for the Safepoint_lock | |
| 91 // currently. While at a safepoint no mutexes of rank safepoint are held | |
| 92 // by any thread. | |
| 93 // The rank named "leaf" is probably historical (and should | |
| 94 // be changed) -- mutexes of this rank aren't really leaf mutexes | |
| 95 // at all. | |
| 96 enum lock_types { | |
| 97 event, | |
| 98 special, | |
| 99 suspend_resume, | |
| 100 leaf = suspend_resume + 2, | |
| 101 safepoint = leaf + 10, | |
| 102 barrier = safepoint + 1, | |
| 103 nonleaf = barrier + 1, | |
| 104 max_nonleaf = nonleaf + 900, | |
| 105 native = max_nonleaf + 1 | |
| 106 }; | |
| 107 | |
| 108 // The WaitSet and EntryList linked lists are composed of ParkEvents. | |
| 109 // I use ParkEvent instead of threads as ParkEvents are immortal and | |
| 110 // type-stable, meaning we can safely unpark() a possibly stale | |
| 111 // list element in the unlock()-path. | |
| 112 | |
| 113 protected: // Monitor-Mutex metadata | |
| 114 SplitWord _LockWord ; // Contention queue (cxq) colocated with Lock-byte | |
| 115 enum LockWordBits { _LBIT=1 } ; | |
| 116 Thread * volatile _owner; // The owner of the lock | |
| 117 // Consider sequestering _owner on its own $line | |
| 118 // to aid future synchronization mechanisms. | |
| 119 ParkEvent * volatile _EntryList ; // List of threads waiting for entry | |
| 120 ParkEvent * volatile _OnDeck ; // heir-presumptive | |
| 121 volatile intptr_t _WaitLock [1] ; // Protects _WaitSet | |
| 122 ParkEvent * volatile _WaitSet ; // LL of ParkEvents | |
| 123 volatile bool _snuck; // Used for sneaky locking (evil). | |
| 124 int NotifyCount ; // diagnostic assist | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
125 char _name[MONITOR_NAME_LEN]; // Name of mutex |
| 0 | 126 |
| 127 // Debugging fields for naming, deadlock detection, etc. (some only used in debug mode) | |
| 128 #ifndef PRODUCT | |
| 129 bool _allow_vm_block; | |
| 130 debug_only(int _rank;) // rank (to avoid/detect potential deadlocks) | |
| 131 debug_only(Monitor * _next;) // Used by a Thread to link up owned locks | |
| 132 debug_only(Thread* _last_owner;) // the last thread to own the lock | |
| 133 debug_only(static bool contains(Monitor * locks, Monitor * lock);) | |
| 134 debug_only(static Monitor * get_least_ranked_lock(Monitor * locks);) | |
| 135 debug_only(Monitor * get_least_ranked_lock_besides_this(Monitor * locks);) | |
| 136 #endif | |
| 137 | |
| 138 void set_owner_implementation(Thread* owner) PRODUCT_RETURN; | |
| 139 void check_prelock_state (Thread* thread) PRODUCT_RETURN; | |
| 140 void check_block_state (Thread* thread) PRODUCT_RETURN; | |
| 141 | |
| 142 // platform-dependent support code can go here (in os_<os_family>.cpp) | |
| 143 public: | |
| 144 enum { | |
| 145 _no_safepoint_check_flag = true, | |
| 146 _allow_vm_block_flag = true, | |
| 147 _as_suspend_equivalent_flag = true | |
| 148 }; | |
| 149 | |
| 150 enum WaitResults { | |
| 151 CONDVAR_EVENT, // Wait returned because of condition variable notification | |
| 152 INTERRUPT_EVENT, // Wait returned because waiting thread was interrupted | |
| 153 NUMBER_WAIT_RESULTS | |
| 154 }; | |
| 155 | |
| 156 private: | |
| 157 int TrySpin (Thread * Self) ; | |
| 158 int TryLock () ; | |
| 159 int TryFast () ; | |
| 160 int AcquireOrPush (ParkEvent * ev) ; | |
| 161 void IUnlock (bool RelaxAssert) ; | |
| 162 void ILock (Thread * Self) ; | |
| 163 int IWait (Thread * Self, jlong timo); | |
| 164 int ILocked () ; | |
| 165 | |
| 166 protected: | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
167 static void ClearMonitor (Monitor * m, const char* name = NULL) ; |
| 0 | 168 Monitor() ; |
| 169 | |
| 170 public: | |
| 171 Monitor(int rank, const char *name, bool allow_vm_block=false); | |
| 172 ~Monitor(); | |
| 173 | |
| 174 // Wait until monitor is notified (or times out). | |
| 175 // Defaults are to make safepoint checks, wait time is forever (i.e., | |
| 176 // zero), and not a suspend-equivalent condition. Returns true if wait | |
| 177 // times out; otherwise returns false. | |
| 178 bool wait(bool no_safepoint_check = !_no_safepoint_check_flag, | |
| 179 long timeout = 0, | |
| 180 bool as_suspend_equivalent = !_as_suspend_equivalent_flag); | |
| 181 bool notify(); | |
| 182 bool notify_all(); | |
| 183 | |
| 184 | |
| 185 void lock(); // prints out warning if VM thread blocks | |
| 186 void lock(Thread *thread); // overloaded with current thread | |
| 187 void unlock(); | |
| 188 bool is_locked() const { return _owner != NULL; } | |
| 189 | |
| 190 bool try_lock(); // Like lock(), but unblocking. It returns false instead | |
| 191 | |
| 192 // Lock without safepoint check. Should ONLY be used by safepoint code and other code | |
| 193 // that is guaranteed not to block while running inside the VM. | |
| 194 void lock_without_safepoint_check(); | |
| 195 void lock_without_safepoint_check (Thread * Self) ; | |
| 196 | |
| 197 // Current owner - not not MT-safe. Can only be used to guarantee that | |
| 198 // the current running thread owns the lock | |
| 199 Thread* owner() const { return _owner; } | |
| 200 bool owned_by_self() const; | |
| 201 | |
| 202 // Support for JVM_RawMonitorEnter & JVM_RawMonitorExit. These can be called by | |
| 203 // non-Java thread. (We should really have a RawMonitor abstraction) | |
| 204 void jvm_raw_lock(); | |
| 205 void jvm_raw_unlock(); | |
| 206 const char *name() const { return _name; } | |
| 207 | |
| 208 void print_on_error(outputStream* st) const; | |
| 209 | |
| 210 #ifndef PRODUCT | |
| 211 void print_on(outputStream* st) const; | |
| 212 void print() const { print_on(tty); } | |
| 213 debug_only(int rank() const { return _rank; }) | |
| 214 bool allow_vm_block() { return _allow_vm_block; } | |
| 215 | |
| 216 debug_only(Monitor *next() const { return _next; }) | |
| 217 debug_only(void set_next(Monitor *next) { _next = next; }) | |
| 218 #endif | |
| 219 | |
| 220 void set_owner(Thread* owner) { | |
| 221 #ifndef PRODUCT | |
| 222 set_owner_implementation(owner); | |
| 223 debug_only(void verify_Monitor(Thread* thr)); | |
| 224 #else | |
| 225 _owner = owner; | |
| 226 #endif | |
| 227 } | |
| 228 | |
| 229 }; | |
| 230 | |
| 231 // Normally we'd expect Monitor to extend Mutex in the sense that a monitor | |
| 232 // constructed from pthreads primitives might extend a mutex by adding | |
| 233 // a condvar and some extra metadata. In fact this was the case until J2SE7. | |
| 234 // | |
| 235 // Currently, however, the base object is a monitor. Monitor contains all the | |
| 236 // logic for wait(), notify(), etc. Mutex extends monitor and restricts the | |
| 237 // visiblity of wait(), notify(), and notify_all(). | |
| 238 // | |
| 239 // Another viable alternative would have been to have Monitor extend Mutex and | |
| 240 // implement all the normal mutex and wait()-notify() logic in Mutex base class. | |
| 241 // The wait()-notify() facility would be exposed via special protected member functions | |
| 242 // (e.g., _Wait() and _Notify()) in Mutex. Monitor would extend Mutex and expose wait() | |
| 243 // as a call to _Wait(). That is, the public wait() would be a wrapper for the protected | |
| 244 // _Wait(). | |
| 245 // | |
| 246 // An even better alternative is to simply eliminate Mutex:: and use Monitor:: instead. | |
| 247 // After all, monitors are sufficient for Java-level synchronization. At one point in time | |
| 248 // there may have been some benefit to having distinct mutexes and monitors, but that time | |
| 249 // has past. | |
| 250 // | |
| 251 // The Mutex/Monitor design parallels that of Java-monitors, being based on | |
| 252 // thread-specific park-unpark platform-specific primitives. | |
| 253 | |
| 254 | |
| 255 class Mutex : public Monitor { // degenerate Monitor | |
| 256 public: | |
| 257 Mutex (int rank, const char *name, bool allow_vm_block=false); | |
| 258 ~Mutex () ; | |
| 259 private: | |
| 260 bool notify () { ShouldNotReachHere(); return false; } | |
| 261 bool notify_all() { ShouldNotReachHere(); return false; } | |
| 262 bool wait (bool no_safepoint_check, long timeout, bool as_suspend_equivalent) { | |
| 263 ShouldNotReachHere() ; | |
| 264 return false ; | |
| 265 } | |
| 266 }; | |
| 267 | |
| 268 /* | |
| 269 * Per-thread blocking support for JSR166. See the Java-level | |
| 270 * Documentation for rationale. Basically, park acts like wait, unpark | |
| 271 * like notify. | |
| 272 * | |
| 273 * 6271289 -- | |
| 274 * To avoid errors where an os thread expires but the JavaThread still | |
| 275 * exists, Parkers are immortal (type-stable) and are recycled across | |
| 276 * new threads. This parallels the ParkEvent implementation. | |
| 277 * Because park-unpark allow spurious wakeups it is harmless if an | |
| 278 * unpark call unparks a new thread using the old Parker reference. | |
| 279 * | |
| 280 * In the future we'll want to think about eliminating Parker and using | |
| 281 * ParkEvent instead. There's considerable duplication between the two | |
| 282 * services. | |
| 283 * | |
| 284 */ | |
| 285 | |
| 286 class Parker : public os::PlatformParker { | |
| 287 private: | |
| 288 volatile int _counter ; | |
| 289 Parker * FreeNext ; | |
| 290 JavaThread * AssociatedWith ; // Current association | |
| 291 | |
| 292 public: | |
| 293 Parker() : PlatformParker() { | |
| 294 _counter = 0 ; | |
| 295 FreeNext = NULL ; | |
| 296 AssociatedWith = NULL ; | |
| 297 } | |
| 298 protected: | |
| 299 ~Parker() { ShouldNotReachHere(); } | |
| 300 public: | |
| 301 // For simplicity of interface with Java, all forms of park (indefinite, | |
| 302 // relative, and absolute) are multiplexed into one call. | |
| 303 void park(bool isAbsolute, jlong time); | |
| 304 void unpark(); | |
| 305 | |
| 306 // Lifecycle operators | |
| 307 static Parker * Allocate (JavaThread * t) ; | |
| 308 static void Release (Parker * e) ; | |
| 309 private: | |
| 310 static Parker * volatile FreeList ; | |
| 311 static volatile int ListLock ; | |
| 312 }; |