Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp @ 1951:899bbbdcb6ea
6997298: fatal error: must own lock CMS_markBitMap_lock during heap dump
Summary: Since we are at a stop-world pause, the existing CMS-phase checks are sufficient for safety, and the locking check can be safely elided. Elaborated documentation comment to the case where class unloading and verification are disabled, and the query happens when we aren't in the sweeping phase, where the answer "false" would be (almost everywhere) too pessimistic.
Reviewed-by: jmasa, johnc, tonyp
| author | ysr |
|---|---|
| date | Fri, 05 Nov 2010 13:20:37 -0700 |
| parents | cd3ef3fd20dd |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
2 * Copyright (c) 2001, 2010, 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 ConcurrentMarkSweepGeneration; | |
| 26 class CMSCollector; | |
| 27 | |
| 28 // The Concurrent Mark Sweep GC Thread (could be several in the future). | |
| 29 class ConcurrentMarkSweepThread: public ConcurrentGCThread { | |
| 30 friend class VMStructs; | |
| 31 friend class ConcurrentMarkSweepGeneration; // XXX should remove friendship | |
| 32 friend class CMSCollector; | |
| 33 public: | |
| 34 virtual void run(); | |
| 35 | |
| 36 private: | |
| 37 static ConcurrentMarkSweepThread* _cmst; | |
| 38 static CMSCollector* _collector; | |
| 39 static SurrogateLockerThread* _slt; | |
| 40 static SurrogateLockerThread::SLT_msg_type _sltBuffer; | |
| 41 static Monitor* _sltMonitor; | |
| 42 | |
| 43 ConcurrentMarkSweepThread* _next; | |
| 44 | |
| 45 static bool _should_terminate; | |
| 46 | |
| 47 enum CMS_flag_type { | |
| 48 CMS_nil = NoBits, | |
| 49 CMS_cms_wants_token = nth_bit(0), | |
| 50 CMS_cms_has_token = nth_bit(1), | |
| 51 CMS_vm_wants_token = nth_bit(2), | |
| 52 CMS_vm_has_token = nth_bit(3) | |
| 53 }; | |
| 54 | |
| 55 static int _CMS_flag; | |
| 56 | |
| 57 static bool CMS_flag_is_set(int b) { return (_CMS_flag & b) != 0; } | |
| 58 static bool set_CMS_flag(int b) { return (_CMS_flag |= b) != 0; } | |
| 59 static bool clear_CMS_flag(int b) { return (_CMS_flag &= ~b) != 0; } | |
| 60 void sleepBeforeNextCycle(); | |
| 61 | |
| 62 // CMS thread should yield for a young gen collection, direct allocation, | |
| 63 // and iCMS activity. | |
| 64 static char _pad_1[64 - sizeof(jint)]; // prevent cache-line sharing | |
| 65 static volatile jint _pending_yields; | |
| 66 static volatile jint _pending_decrements; // decrements to _pending_yields | |
| 67 static char _pad_2[64 - sizeof(jint)]; // prevent cache-line sharing | |
| 68 | |
| 69 // Tracing messages, enabled by CMSTraceThreadState. | |
| 70 static inline void trace_state(const char* desc); | |
| 71 | |
| 72 static volatile bool _icms_enabled; // iCMS enabled? | |
| 73 static volatile bool _should_run; // iCMS may run | |
| 74 static volatile bool _should_stop; // iCMS should stop | |
| 75 | |
| 76 // debugging | |
| 77 void verify_ok_to_terminate() const PRODUCT_RETURN; | |
| 78 | |
| 79 public: | |
| 80 // Constructor | |
| 81 ConcurrentMarkSweepThread(CMSCollector* collector); | |
| 82 | |
| 83 static void makeSurrogateLockerThread(TRAPS); | |
| 84 static SurrogateLockerThread* slt() { return _slt; } | |
| 85 | |
| 86 // Tester | |
| 87 bool is_ConcurrentGC_thread() const { return true; } | |
| 88 | |
| 89 static void threads_do(ThreadClosure* tc); | |
| 90 | |
| 91 // Printing | |
| 92 void print_on(outputStream* st) const; | |
| 93 void print() const { print_on(tty); } | |
| 94 static void print_all_on(outputStream* st); | |
| 95 static void print_all() { print_all_on(tty); } | |
| 96 | |
| 97 // Returns the CMS Thread | |
| 98 static ConcurrentMarkSweepThread* cmst() { return _cmst; } | |
| 99 static CMSCollector* collector() { return _collector; } | |
| 100 | |
| 101 // Create and start the CMS Thread, or stop it on shutdown | |
| 102 static ConcurrentMarkSweepThread* start(CMSCollector* collector); | |
| 103 static void stop(); | |
| 104 static bool should_terminate() { return _should_terminate; } | |
| 105 | |
| 106 // Synchronization using CMS token | |
| 107 static void synchronize(bool is_cms_thread); | |
| 108 static void desynchronize(bool is_cms_thread); | |
| 109 static bool vm_thread_has_cms_token() { | |
| 110 return CMS_flag_is_set(CMS_vm_has_token); | |
| 111 } | |
| 112 static bool cms_thread_has_cms_token() { | |
| 113 return CMS_flag_is_set(CMS_cms_has_token); | |
| 114 } | |
| 115 static bool vm_thread_wants_cms_token() { | |
| 116 return CMS_flag_is_set(CMS_vm_wants_token); | |
| 117 } | |
| 118 static bool cms_thread_wants_cms_token() { | |
| 119 return CMS_flag_is_set(CMS_cms_wants_token); | |
| 120 } | |
| 121 | |
| 122 // Wait on CMS lock until the next synchronous GC | |
|
1887
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
123 // or given timeout, whichever is earlier. A timeout value |
|
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
124 // of 0 indicates that there is no upper bound on the wait time. |
|
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
125 // A concurrent full gc request terminates the wait. |
|
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
126 void wait_on_cms_lock(long t_millis); |
| 0 | 127 |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
128 // The CMS thread will yield during the work portion of its cycle |
| 0 | 129 // only when requested to. Both synchronous and asychronous requests |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
130 // are provided: |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
131 // (1) A synchronous request is used for young gen collections and |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
132 // for direct allocations. The requesting thread increments |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
133 // _pending_yields at the beginning of an operation, and decrements |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
134 // _pending_yields when that operation is completed. |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
135 // In turn, the CMS thread yields when _pending_yields is positive, |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
136 // and continues to yield until the value reverts to 0. |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
137 // (2) An asynchronous request, on the other hand, is used by iCMS |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
138 // for the stop_icms() operation. A single yield satisfies all of |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
139 // the outstanding asynch yield requests, of which there may |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
140 // occasionally be several in close succession. To accomplish |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
141 // this, an asynch-requesting thread atomically increments both |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
142 // _pending_yields and _pending_decrements. An asynchr requesting |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
143 // thread does not wait and "acknowledge" completion of an operation |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
144 // and deregister the request, like the synchronous version described |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
145 // above does. In turn, after yielding, the CMS thread decrements both |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
146 // _pending_yields and _pending_decrements by the value seen in |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
147 // _pending_decrements before the decrement. |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
148 // NOTE: The above scheme is isomorphic to having two request counters, |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
149 // one for async requests and one for sync requests, and for the CMS thread |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
150 // to check the sum of the two counters to decide whether it should yield |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
151 // and to clear only the async counter when it yields. However, it turns out |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
152 // to be more efficient for CMS code to just check a single counter |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
153 // _pending_yields that holds the sum (of both sync and async requests), and |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
154 // a second counter _pending_decrements that only holds the async requests, |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
155 // for greater efficiency, since in a typical CMS run, there are many more |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
156 // pontential (i.e. static) yield points than there are actual |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
157 // (i.e. dynamic) yields because of requests, which are few and far between. |
|
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
158 // |
| 0 | 159 // Note that, while "_pending_yields >= _pending_decrements" is an invariant, |
| 160 // we cannot easily test that invariant, since the counters are manipulated via | |
| 161 // atomic instructions without explicit locking and we cannot read | |
| 162 // the two counters atomically together: one suggestion is to | |
| 163 // use (for example) 16-bit counters so as to be able to read the | |
| 164 // two counters atomically even on 32-bit platforms. Notice that | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
165 // the second assert in acknowledge_yield_request() below does indeed |
| 0 | 166 // check a form of the above invariant, albeit indirectly. |
| 167 | |
| 168 static void increment_pending_yields() { | |
| 169 Atomic::inc(&_pending_yields); | |
| 170 assert(_pending_yields >= 0, "can't be negative"); | |
| 171 } | |
| 172 static void decrement_pending_yields() { | |
| 173 Atomic::dec(&_pending_yields); | |
| 174 assert(_pending_yields >= 0, "can't be negative"); | |
| 175 } | |
| 176 static void asynchronous_yield_request() { | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
177 assert(CMSIncrementalMode, "Currently only used w/iCMS"); |
| 0 | 178 increment_pending_yields(); |
| 179 Atomic::inc(&_pending_decrements); | |
| 180 assert(_pending_decrements >= 0, "can't be negative"); | |
| 181 } | |
| 182 static void acknowledge_yield_request() { | |
| 183 jint decrement = _pending_decrements; | |
| 184 if (decrement > 0) { | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
185 assert(CMSIncrementalMode, "Currently only used w/iCMS"); |
| 0 | 186 // Order important to preserve: _pending_yields >= _pending_decrements |
| 187 Atomic::add(-decrement, &_pending_decrements); | |
| 188 Atomic::add(-decrement, &_pending_yields); | |
| 189 assert(_pending_decrements >= 0, "can't be negative"); | |
| 190 assert(_pending_yields >= 0, "can't be negative"); | |
| 191 } | |
| 192 } | |
| 193 static bool should_yield() { return _pending_yields > 0; } | |
| 194 | |
| 195 // CMS incremental mode. | |
| 196 static void start_icms(); // notify thread to start a quantum of work | |
| 197 static void stop_icms(); // request thread to stop working | |
| 198 void icms_wait(); // if asked to stop, wait until notified to start | |
| 199 | |
| 200 // Incremental mode is enabled globally by the flag CMSIncrementalMode. It | |
| 201 // must also be enabled/disabled dynamically to allow foreground collections. | |
| 202 static inline void enable_icms() { _icms_enabled = true; } | |
| 203 static inline void disable_icms() { _icms_enabled = false; } | |
| 204 static inline void set_icms_enabled(bool val) { _icms_enabled = val; } | |
| 205 static inline bool icms_enabled() { return _icms_enabled; } | |
| 206 }; | |
| 207 | |
| 208 inline void ConcurrentMarkSweepThread::trace_state(const char* desc) { | |
| 209 if (CMSTraceThreadState) { | |
| 210 char buf[128]; | |
| 211 TimeStamp& ts = gclog_or_tty->time_stamp(); | |
| 212 if (!ts.is_updated()) { | |
| 213 ts.update(); | |
| 214 } | |
| 215 jio_snprintf(buf, sizeof(buf), " [%.3f: CMSThread %s] ", | |
| 216 ts.seconds(), desc); | |
| 217 buf[sizeof(buf) - 1] = '\0'; | |
| 218 gclog_or_tty->print(buf); | |
| 219 } | |
| 220 } | |
| 221 | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
222 // For scoped increment/decrement of (synchronous) yield requests |
| 0 | 223 class CMSSynchronousYieldRequest: public StackObj { |
| 224 public: | |
| 225 CMSSynchronousYieldRequest() { | |
| 226 ConcurrentMarkSweepThread::increment_pending_yields(); | |
| 227 } | |
| 228 ~CMSSynchronousYieldRequest() { | |
| 229 ConcurrentMarkSweepThread::decrement_pending_yields(); | |
| 230 } | |
| 231 }; | |
| 232 | |
| 233 // Used to emit a warning in case of unexpectedly excessive | |
| 234 // looping (in "apparently endless loops") in CMS code. | |
| 235 class CMSLoopCountWarn: public StackObj { | |
| 236 private: | |
| 237 const char* _src; | |
| 238 const char* _msg; | |
| 239 const intx _threshold; | |
| 240 intx _ticks; | |
| 241 | |
| 242 public: | |
| 243 inline CMSLoopCountWarn(const char* src, const char* msg, | |
| 244 const intx threshold) : | |
| 245 _src(src), _msg(msg), _threshold(threshold), _ticks(0) { } | |
| 246 | |
| 247 inline void tick() { | |
| 248 _ticks++; | |
| 249 if (CMSLoopWarn && _ticks % _threshold == 0) { | |
| 250 warning("%s has looped %d times %s", _src, _ticks, _msg); | |
| 251 } | |
| 252 } | |
| 253 }; |