Print this page
rev 2755 : 7099824: G1: we should take the pending list lock before doing the remark pause
Summary: Acquire the pending list lock in the prologue method of G1's
concurrent VM_Operation and release the lock in the epilogue() method.
The locking/unlocking order of the pending list lock and the Heap_lock
should match that in the prologue and epilogue methods of VM_GC_Operation.
Reviewed-by:
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp
+++ new/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp
1 1 /*
2 2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation.
8 8 *
9 9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 12 * version 2 for more details (a copy is included in the LICENSE file that
13 13 * accompanied this code).
14 14 *
15 15 * You should have received a copy of the GNU General Public License version
16 16 * 2 along with this work; if not, write to the Free Software Foundation,
17 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 18 *
19 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 20 * or visit www.oracle.com if you need additional information or have any
21 21 * questions.
22 22 *
23 23 */
24 24
25 25 #include "precompiled.hpp"
26 26 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
27 27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
28 28 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
29 29 #include "gc_implementation/g1/g1MMUTracker.hpp"
30 30 #include "gc_implementation/g1/vm_operations_g1.hpp"
31 31 #include "memory/resourceArea.hpp"
32 32 #include "runtime/vmThread.hpp"
33 33
34 34 // ======= Concurrent Mark Thread ========
35 35
36 36 // The CM thread is created when the G1 garbage collector is used
37 37
38 38 SurrogateLockerThread*
39 39 ConcurrentMarkThread::_slt = NULL;
40 40
41 41 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) :
42 42 ConcurrentGCThread(),
43 43 _cm(cm),
44 44 _started(false),
45 45 _in_progress(false),
46 46 _vtime_accum(0.0),
47 47 _vtime_mark_accum(0.0),
48 48 _vtime_count_accum(0.0)
49 49 {
50 50 create_and_start();
51 51 }
52 52
53 53 class CMCheckpointRootsFinalClosure: public VoidClosure {
54 54
55 55 ConcurrentMark* _cm;
56 56 public:
57 57
58 58 CMCheckpointRootsFinalClosure(ConcurrentMark* cm) :
59 59 _cm(cm) {}
60 60
61 61 void do_void(){
62 62 _cm->checkpointRootsFinal(false); // !clear_all_soft_refs
63 63 }
64 64 };
65 65
66 66 class CMCleanUp: public VoidClosure {
67 67 ConcurrentMark* _cm;
68 68 public:
69 69
70 70 CMCleanUp(ConcurrentMark* cm) :
71 71 _cm(cm) {}
72 72
73 73 void do_void(){
74 74 _cm->cleanup();
75 75 }
76 76 };
77 77
78 78
79 79
80 80 void ConcurrentMarkThread::run() {
81 81 initialize_in_thread();
82 82 _vtime_start = os::elapsedVTime();
83 83 wait_for_universe_init();
84 84
85 85 G1CollectedHeap* g1h = G1CollectedHeap::heap();
86 86 G1CollectorPolicy* g1_policy = g1h->g1_policy();
87 87 G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker();
88 88 Thread *current_thread = Thread::current();
89 89
90 90 while (!_should_terminate) {
91 91 // wait until started is set.
92 92 sleepBeforeNextCycle();
93 93 {
94 94 ResourceMark rm;
95 95 HandleMark hm;
96 96 double cycle_start = os::elapsedVTime();
97 97 double mark_start_sec = os::elapsedTime();
98 98 char verbose_str[128];
99 99
100 100 if (PrintGC) {
101 101 gclog_or_tty->date_stamp(PrintGCDateStamps);
102 102 gclog_or_tty->stamp(PrintGCTimeStamps);
103 103 gclog_or_tty->print_cr("[GC concurrent-mark-start]");
104 104 }
105 105
106 106 int iter = 0;
107 107 do {
108 108 iter++;
109 109 if (!cm()->has_aborted()) {
110 110 _cm->markFromRoots();
111 111 }
112 112
113 113 double mark_end_time = os::elapsedVTime();
114 114 double mark_end_sec = os::elapsedTime();
115 115 _vtime_mark_accum += (mark_end_time - cycle_start);
116 116 if (!cm()->has_aborted()) {
117 117 if (g1_policy->adaptive_young_list_length()) {
118 118 double now = os::elapsedTime();
119 119 double remark_prediction_ms = g1_policy->predict_remark_time_ms();
120 120 jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms);
121 121 os::sleep(current_thread, sleep_time_ms, false);
122 122 }
123 123
124 124 if (PrintGC) {
125 125 gclog_or_tty->date_stamp(PrintGCDateStamps);
126 126 gclog_or_tty->stamp(PrintGCTimeStamps);
127 127 gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf sec]",
128 128 mark_end_sec - mark_start_sec);
129 129 }
130 130
131 131 CMCheckpointRootsFinalClosure final_cl(_cm);
132 132 sprintf(verbose_str, "GC remark");
133 133 VM_CGC_Operation op(&final_cl, verbose_str);
134 134 VMThread::execute(&op);
135 135 }
136 136 if (cm()->restart_for_overflow() &&
137 137 G1TraceMarkStackOverflow) {
138 138 gclog_or_tty->print_cr("Restarting conc marking because of MS overflow "
139 139 "in remark (restart #%d).", iter);
|
↓ open down ↓ |
139 lines elided |
↑ open up ↑ |
140 140 }
141 141
142 142 if (cm()->restart_for_overflow()) {
143 143 if (PrintGC) {
144 144 gclog_or_tty->date_stamp(PrintGCDateStamps);
145 145 gclog_or_tty->stamp(PrintGCTimeStamps);
146 146 gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]");
147 147 }
148 148 }
149 149 } while (cm()->restart_for_overflow());
150 - double counting_start_time = os::elapsedVTime();
151 -
152 - // YSR: These look dubious (i.e. redundant) !!! FIX ME
153 - slt()->manipulatePLL(SurrogateLockerThread::acquirePLL);
154 - slt()->manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);
155 150
151 + double counting_start_time = os::elapsedVTime();
156 152 if (!cm()->has_aborted()) {
157 153 double count_start_sec = os::elapsedTime();
158 154 if (PrintGC) {
159 155 gclog_or_tty->date_stamp(PrintGCDateStamps);
160 156 gclog_or_tty->stamp(PrintGCTimeStamps);
161 157 gclog_or_tty->print_cr("[GC concurrent-count-start]");
162 158 }
163 159
164 160 _sts.join();
165 161 _cm->calcDesiredRegions();
166 162 _sts.leave();
167 163
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
168 164 if (!cm()->has_aborted()) {
169 165 double count_end_sec = os::elapsedTime();
170 166 if (PrintGC) {
171 167 gclog_or_tty->date_stamp(PrintGCDateStamps);
172 168 gclog_or_tty->stamp(PrintGCTimeStamps);
173 169 gclog_or_tty->print_cr("[GC concurrent-count-end, %1.7lf]",
174 170 count_end_sec - count_start_sec);
175 171 }
176 172 }
177 173 }
174 +
178 175 double end_time = os::elapsedVTime();
179 176 _vtime_count_accum += (end_time - counting_start_time);
180 177 // Update the total virtual time before doing this, since it will try
181 178 // to measure it to get the vtime for this marking. We purposely
182 179 // neglect the presumably-short "completeCleanup" phase here.
183 180 _vtime_accum = (end_time - _vtime_start);
184 181 if (!cm()->has_aborted()) {
185 182 if (g1_policy->adaptive_young_list_length()) {
186 183 double now = os::elapsedTime();
187 184 double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms();
188 185 jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms);
189 186 os::sleep(current_thread, sleep_time_ms, false);
190 187 }
191 188
192 189 CMCleanUp cl_cl(_cm);
193 190 sprintf(verbose_str, "GC cleanup");
194 191 VM_CGC_Operation op(&cl_cl, verbose_str);
195 192 VMThread::execute(&op);
196 193 } else {
197 194 g1h->set_marking_complete();
198 195 }
199 196
200 197 // Check if cleanup set the free_regions_coming flag. If it
201 198 // hasn't, we can just skip the next step.
202 199 if (g1h->free_regions_coming()) {
203 200 // The following will finish freeing up any regions that we
204 201 // found to be empty during cleanup. We'll do this part
205 202 // without joining the suspendible set. If an evacuation pause
206 203 // takes place, then we would carry on freeing regions in
207 204 // case they are needed by the pause. If a Full GC takes
208 205 // place, it would wait for us to process the regions
209 206 // reclaimed by cleanup.
210 207
211 208 double cleanup_start_sec = os::elapsedTime();
212 209 if (PrintGC) {
213 210 gclog_or_tty->date_stamp(PrintGCDateStamps);
214 211 gclog_or_tty->stamp(PrintGCTimeStamps);
215 212 gclog_or_tty->print_cr("[GC concurrent-cleanup-start]");
216 213 }
217 214
218 215 // Now do the concurrent cleanup operation.
219 216 _cm->completeCleanup();
220 217
221 218 // Notify anyone who's waiting that there are no more free
222 219 // regions coming. We have to do this before we join the STS
223 220 // (in fact, we should not attempt to join the STS in the
224 221 // interval between finishing the cleanup pause and clearing
225 222 // the free_regions_coming flag) otherwise we might deadlock:
226 223 // a GC worker could be blocked waiting for the notification
227 224 // whereas this thread will be blocked for the pause to finish
228 225 // while it's trying to join the STS, which is conditional on
229 226 // the GC workers finishing.
230 227 g1h->reset_free_regions_coming();
231 228
232 229 double cleanup_end_sec = os::elapsedTime();
233 230 if (PrintGC) {
234 231 gclog_or_tty->date_stamp(PrintGCDateStamps);
235 232 gclog_or_tty->stamp(PrintGCTimeStamps);
236 233 gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf]",
237 234 cleanup_end_sec - cleanup_start_sec);
238 235 }
239 236 }
240 237 guarantee(cm()->cleanup_list_is_empty(),
241 238 "at this point there should be no regions on the cleanup list");
242 239
243 240 // There is a tricky race before recording that the concurrent
244 241 // cleanup has completed and a potential Full GC starting around
245 242 // the same time. We want to make sure that the Full GC calls
246 243 // abort() on concurrent mark after
247 244 // record_concurrent_mark_cleanup_completed(), since abort() is
248 245 // the method that will reset the concurrent mark state. If we
249 246 // end up calling record_concurrent_mark_cleanup_completed()
250 247 // after abort() then we might incorrectly undo some of the work
251 248 // abort() did. Checking the has_aborted() flag after joining
252 249 // the STS allows the correct ordering of the two methods. There
253 250 // are two scenarios:
254 251 //
255 252 // a) If we reach here before the Full GC, the fact that we have
256 253 // joined the STS means that the Full GC cannot start until we
257 254 // leave the STS, so record_concurrent_mark_cleanup_completed()
258 255 // will complete before abort() is called.
259 256 //
260 257 // b) If we reach here during the Full GC, we'll be held up from
261 258 // joining the STS until the Full GC is done, which means that
262 259 // abort() will have completed and has_aborted() will return
263 260 // true to prevent us from calling
264 261 // record_concurrent_mark_cleanup_completed() (and, in fact, it's
265 262 // not needed any more as the concurrent mark state has been
266 263 // already reset).
267 264 _sts.join();
268 265 if (!cm()->has_aborted()) {
269 266 g1_policy->record_concurrent_mark_cleanup_completed();
270 267 }
271 268 _sts.leave();
272 269
273 270 if (cm()->has_aborted()) {
274 271 if (PrintGC) {
275 272 gclog_or_tty->date_stamp(PrintGCDateStamps);
276 273 gclog_or_tty->stamp(PrintGCTimeStamps);
277 274 gclog_or_tty->print_cr("[GC concurrent-mark-abort]");
278 275 }
279 276 }
280 277
281 278 // We now want to allow clearing of the marking bitmap to be
282 279 // suspended by a collection pause.
283 280 _sts.join();
284 281 _cm->clearNextBitmap();
285 282 _sts.leave();
286 283 }
287 284
288 285 // Update the number of full collections that have been
289 286 // completed. This will also notify the FullGCCount_lock in case a
290 287 // Java thread is waiting for a full GC to happen (e.g., it
291 288 // called System.gc() with +ExplicitGCInvokesConcurrent).
292 289 _sts.join();
293 290 g1h->increment_full_collections_completed(true /* concurrent */);
294 291 _sts.leave();
295 292 }
296 293 assert(_should_terminate, "just checking");
297 294
298 295 terminate();
299 296 }
300 297
301 298
302 299 void ConcurrentMarkThread::yield() {
303 300 _sts.yield("Concurrent Mark");
304 301 }
305 302
306 303 void ConcurrentMarkThread::stop() {
307 304 // it is ok to take late safepoints here, if needed
308 305 MutexLockerEx mu(Terminator_lock);
309 306 _should_terminate = true;
310 307 while (!_has_terminated) {
311 308 Terminator_lock->wait();
312 309 }
313 310 }
314 311
315 312 void ConcurrentMarkThread::print() const {
316 313 print_on(tty);
317 314 }
318 315
319 316 void ConcurrentMarkThread::print_on(outputStream* st) const {
320 317 st->print("\"G1 Main Concurrent Mark GC Thread\" ");
321 318 Thread::print_on(st);
322 319 st->cr();
323 320 }
324 321
325 322 void ConcurrentMarkThread::sleepBeforeNextCycle() {
326 323 // We join here because we don't want to do the "shouldConcurrentMark()"
327 324 // below while the world is otherwise stopped.
|
↓ open down ↓ |
140 lines elided |
↑ open up ↑ |
328 325 assert(!in_progress(), "should have been cleared");
329 326
330 327 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
331 328 while (!started()) {
332 329 CGC_lock->wait(Mutex::_no_safepoint_check_flag);
333 330 }
334 331 set_in_progress();
335 332 clear_started();
336 333 }
337 334
338 -// Note: this method, although exported by the ConcurrentMarkSweepThread,
335 +// Note: this method, although exported by the ConcurrentMarkThread,
339 336 // which is a non-JavaThread, can only be called by a JavaThread.
340 337 // Currently this is done at vm creation time (post-vm-init) by the
341 338 // main/Primordial (Java)Thread.
342 -// XXX Consider changing this in the future to allow the CMS thread
339 +// XXX Consider changing this in the future to allow the CM thread
343 340 // itself to create this thread?
344 341 void ConcurrentMarkThread::makeSurrogateLockerThread(TRAPS) {
342 + assert(UseG1GC, "SLT thread needed only for concurrent GC");
343 + assert(THREAD->is_Java_thread(), "must be a Java thread");
345 344 assert(_slt == NULL, "SLT already created");
346 345 _slt = SurrogateLockerThread::make(THREAD);
347 346 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX