Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | f08d439fab8c |
| children | f34d701e952e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2365
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
2 * Copyright (c) 2001, 2011, 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 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPTHREAD_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPTHREAD_HPP | |
| 27 | |
| 28 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp" | |
| 29 #include "gc_implementation/shared/concurrentGCThread.hpp" | |
| 30 #ifdef TARGET_OS_FAMILY_linux | |
| 31 # include "thread_linux.inline.hpp" | |
| 32 #endif | |
| 33 #ifdef TARGET_OS_FAMILY_solaris | |
| 34 # include "thread_solaris.inline.hpp" | |
| 35 #endif | |
| 36 #ifdef TARGET_OS_FAMILY_windows | |
| 37 # include "thread_windows.inline.hpp" | |
| 38 #endif | |
| 3960 | 39 #ifdef TARGET_OS_FAMILY_bsd |
| 40 # include "thread_bsd.inline.hpp" | |
| 41 #endif | |
| 1972 | 42 |
| 0 | 43 class ConcurrentMarkSweepGeneration; |
| 44 class CMSCollector; | |
| 45 | |
|
2365
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
46 // The Concurrent Mark Sweep GC Thread |
| 0 | 47 class ConcurrentMarkSweepThread: public ConcurrentGCThread { |
| 48 friend class VMStructs; | |
| 49 friend class ConcurrentMarkSweepGeneration; // XXX should remove friendship | |
| 50 friend class CMSCollector; | |
| 51 public: | |
| 52 virtual void run(); | |
| 53 | |
| 54 private: | |
| 55 static ConcurrentMarkSweepThread* _cmst; | |
| 56 static CMSCollector* _collector; | |
| 57 static SurrogateLockerThread* _slt; | |
| 58 static SurrogateLockerThread::SLT_msg_type _sltBuffer; | |
| 59 static Monitor* _sltMonitor; | |
| 60 | |
| 61 static bool _should_terminate; | |
| 62 | |
| 63 enum CMS_flag_type { | |
| 64 CMS_nil = NoBits, | |
| 65 CMS_cms_wants_token = nth_bit(0), | |
| 66 CMS_cms_has_token = nth_bit(1), | |
| 67 CMS_vm_wants_token = nth_bit(2), | |
| 68 CMS_vm_has_token = nth_bit(3) | |
| 69 }; | |
| 70 | |
| 71 static int _CMS_flag; | |
| 72 | |
| 73 static bool CMS_flag_is_set(int b) { return (_CMS_flag & b) != 0; } | |
| 74 static bool set_CMS_flag(int b) { return (_CMS_flag |= b) != 0; } | |
| 75 static bool clear_CMS_flag(int b) { return (_CMS_flag &= ~b) != 0; } | |
| 76 void sleepBeforeNextCycle(); | |
| 77 | |
| 78 // CMS thread should yield for a young gen collection, direct allocation, | |
| 79 // and iCMS activity. | |
| 80 static char _pad_1[64 - sizeof(jint)]; // prevent cache-line sharing | |
| 81 static volatile jint _pending_yields; | |
| 82 static volatile jint _pending_decrements; // decrements to _pending_yields | |
| 83 static char _pad_2[64 - sizeof(jint)]; // prevent cache-line sharing | |
| 84 | |
| 85 // Tracing messages, enabled by CMSTraceThreadState. | |
| 86 static inline void trace_state(const char* desc); | |
| 87 | |
|
2365
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
88 static volatile int _icms_disabled; // a counter to track #iCMS disable & enable |
| 0 | 89 static volatile bool _should_run; // iCMS may run |
| 90 static volatile bool _should_stop; // iCMS should stop | |
| 91 | |
| 92 // debugging | |
| 93 void verify_ok_to_terminate() const PRODUCT_RETURN; | |
| 94 | |
| 95 public: | |
| 96 // Constructor | |
| 97 ConcurrentMarkSweepThread(CMSCollector* collector); | |
| 98 | |
| 99 static void makeSurrogateLockerThread(TRAPS); | |
| 100 static SurrogateLockerThread* slt() { return _slt; } | |
| 101 | |
| 102 // Tester | |
| 103 bool is_ConcurrentGC_thread() const { return true; } | |
| 104 | |
| 105 static void threads_do(ThreadClosure* tc); | |
| 106 | |
| 107 // Printing | |
| 108 void print_on(outputStream* st) const; | |
| 109 void print() const { print_on(tty); } | |
| 110 static void print_all_on(outputStream* st); | |
| 111 static void print_all() { print_all_on(tty); } | |
| 112 | |
| 113 // Returns the CMS Thread | |
| 114 static ConcurrentMarkSweepThread* cmst() { return _cmst; } | |
| 115 static CMSCollector* collector() { return _collector; } | |
| 116 | |
| 117 // Create and start the CMS Thread, or stop it on shutdown | |
| 118 static ConcurrentMarkSweepThread* start(CMSCollector* collector); | |
| 119 static void stop(); | |
| 120 static bool should_terminate() { return _should_terminate; } | |
| 121 | |
| 122 // Synchronization using CMS token | |
| 123 static void synchronize(bool is_cms_thread); | |
| 124 static void desynchronize(bool is_cms_thread); | |
| 125 static bool vm_thread_has_cms_token() { | |
| 126 return CMS_flag_is_set(CMS_vm_has_token); | |
| 127 } | |
| 128 static bool cms_thread_has_cms_token() { | |
| 129 return CMS_flag_is_set(CMS_cms_has_token); | |
| 130 } | |
| 131 static bool vm_thread_wants_cms_token() { | |
| 132 return CMS_flag_is_set(CMS_vm_wants_token); | |
| 133 } | |
| 134 static bool cms_thread_wants_cms_token() { | |
| 135 return CMS_flag_is_set(CMS_cms_wants_token); | |
| 136 } | |
| 137 | |
| 138 // Wait on CMS lock until the next synchronous GC | |
|
1887
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
139 // or given timeout, whichever is earlier. A timeout value |
|
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
140 // 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
|
141 // A concurrent full gc request terminates the wait. |
|
cd3ef3fd20dd
6992998: CMSWaitDuration=0 causes hangs with +ExplicitGCInvokesConcurrent
ysr
parents:
1837
diff
changeset
|
142 void wait_on_cms_lock(long t_millis); |
| 0 | 143 |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
144 // The CMS thread will yield during the work portion of its cycle |
| 0 | 145 // 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
|
146 // 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
|
147 // (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
|
148 // 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
|
149 // _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
|
150 // _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
|
151 // 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
|
152 // 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
|
153 // (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
|
154 // 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
|
155 // 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
|
156 // 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
|
157 // 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
|
158 // _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
|
159 // 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
|
160 // 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
|
161 // 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
|
162 // _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
|
163 // _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
|
164 // 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
|
165 // 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
|
166 // 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
|
167 // 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
|
168 // 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
|
169 // _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
|
170 // 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
|
171 // 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
|
172 // 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
|
173 // (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
|
174 // |
| 0 | 175 // Note that, while "_pending_yields >= _pending_decrements" is an invariant, |
| 176 // we cannot easily test that invariant, since the counters are manipulated via | |
| 177 // atomic instructions without explicit locking and we cannot read | |
| 178 // the two counters atomically together: one suggestion is to | |
| 179 // use (for example) 16-bit counters so as to be able to read the | |
| 180 // 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
|
181 // the second assert in acknowledge_yield_request() below does indeed |
| 0 | 182 // check a form of the above invariant, albeit indirectly. |
| 183 | |
| 184 static void increment_pending_yields() { | |
| 185 Atomic::inc(&_pending_yields); | |
| 186 assert(_pending_yields >= 0, "can't be negative"); | |
| 187 } | |
| 188 static void decrement_pending_yields() { | |
| 189 Atomic::dec(&_pending_yields); | |
| 190 assert(_pending_yields >= 0, "can't be negative"); | |
| 191 } | |
| 192 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
|
193 assert(CMSIncrementalMode, "Currently only used w/iCMS"); |
| 0 | 194 increment_pending_yields(); |
| 195 Atomic::inc(&_pending_decrements); | |
| 196 assert(_pending_decrements >= 0, "can't be negative"); | |
| 197 } | |
| 198 static void acknowledge_yield_request() { | |
| 199 jint decrement = _pending_decrements; | |
| 200 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
|
201 assert(CMSIncrementalMode, "Currently only used w/iCMS"); |
| 0 | 202 // Order important to preserve: _pending_yields >= _pending_decrements |
| 203 Atomic::add(-decrement, &_pending_decrements); | |
| 204 Atomic::add(-decrement, &_pending_yields); | |
| 205 assert(_pending_decrements >= 0, "can't be negative"); | |
| 206 assert(_pending_yields >= 0, "can't be negative"); | |
| 207 } | |
| 208 } | |
| 209 static bool should_yield() { return _pending_yields > 0; } | |
| 210 | |
| 211 // CMS incremental mode. | |
| 212 static void start_icms(); // notify thread to start a quantum of work | |
| 213 static void stop_icms(); // request thread to stop working | |
| 214 void icms_wait(); // if asked to stop, wait until notified to start | |
| 215 | |
| 216 // Incremental mode is enabled globally by the flag CMSIncrementalMode. It | |
| 217 // must also be enabled/disabled dynamically to allow foreground collections. | |
|
2365
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
218 #define ICMS_ENABLING_ASSERT \ |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
219 assert((CMSIncrementalMode && _icms_disabled >= 0) || \ |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
220 (!CMSIncrementalMode && _icms_disabled <= 0), "Error") |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
221 |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
222 static inline void enable_icms() { |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
223 ICMS_ENABLING_ASSERT; |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
224 Atomic::dec(&_icms_disabled); |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
225 } |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
226 static inline void disable_icms() { |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
227 ICMS_ENABLING_ASSERT; |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
228 Atomic::inc(&_icms_disabled); |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
229 } |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
230 static inline bool icms_is_disabled() { |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
231 ICMS_ENABLING_ASSERT; |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
232 return _icms_disabled > 0; |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
233 } |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
234 static inline bool icms_is_enabled() { |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
235 return !icms_is_disabled(); |
|
a181f3a124dd
6987703: iCMS: Intermittent hang with gc/gctests/CallGC/CallGC01 and +ExplicitGCInvokesConcurrent
ysr
parents:
1972
diff
changeset
|
236 } |
| 0 | 237 }; |
| 238 | |
| 239 inline void ConcurrentMarkSweepThread::trace_state(const char* desc) { | |
| 240 if (CMSTraceThreadState) { | |
| 241 char buf[128]; | |
| 242 TimeStamp& ts = gclog_or_tty->time_stamp(); | |
| 243 if (!ts.is_updated()) { | |
| 244 ts.update(); | |
| 245 } | |
| 246 jio_snprintf(buf, sizeof(buf), " [%.3f: CMSThread %s] ", | |
| 247 ts.seconds(), desc); | |
| 248 buf[sizeof(buf) - 1] = '\0'; | |
| 249 gclog_or_tty->print(buf); | |
| 250 } | |
| 251 } | |
| 252 | |
|
1837
c99c53f07c14
6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents:
1552
diff
changeset
|
253 // For scoped increment/decrement of (synchronous) yield requests |
| 0 | 254 class CMSSynchronousYieldRequest: public StackObj { |
| 255 public: | |
| 256 CMSSynchronousYieldRequest() { | |
| 257 ConcurrentMarkSweepThread::increment_pending_yields(); | |
| 258 } | |
| 259 ~CMSSynchronousYieldRequest() { | |
| 260 ConcurrentMarkSweepThread::decrement_pending_yields(); | |
| 261 } | |
| 262 }; | |
| 263 | |
| 264 // Used to emit a warning in case of unexpectedly excessive | |
| 265 // looping (in "apparently endless loops") in CMS code. | |
| 266 class CMSLoopCountWarn: public StackObj { | |
| 267 private: | |
| 268 const char* _src; | |
| 269 const char* _msg; | |
| 270 const intx _threshold; | |
| 271 intx _ticks; | |
| 272 | |
| 273 public: | |
| 274 inline CMSLoopCountWarn(const char* src, const char* msg, | |
| 275 const intx threshold) : | |
| 276 _src(src), _msg(msg), _threshold(threshold), _ticks(0) { } | |
| 277 | |
| 278 inline void tick() { | |
| 279 _ticks++; | |
| 280 if (CMSLoopWarn && _ticks % _threshold == 0) { | |
| 281 warning("%s has looped %d times %s", _src, _ticks, _msg); | |
| 282 } | |
| 283 } | |
| 284 }; | |
| 1972 | 285 |
| 286 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPTHREAD_HPP |