1 /*
2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
28 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
29 #include "gc_implementation/g1/g1MMUTracker.hpp"
30 #include "gc_implementation/g1/vm_operations_g1.hpp"
31 #include "memory/resourceArea.hpp"
32 #include "runtime/vmThread.hpp"
33
34 // ======= Concurrent Mark Thread ========
35
36 // The CM thread is created when the G1 garbage collector is used
37
38 SurrogateLockerThread*
39 ConcurrentMarkThread::_slt = NULL;
40
41 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) :
42 ConcurrentGCThread(),
43 _cm(cm),
44 _started(false),
45 _in_progress(false),
46 _vtime_accum(0.0),
47 _vtime_mark_accum(0.0),
48 _vtime_count_accum(0.0)
49 {
50 create_and_start();
51 }
52
53 class CMCheckpointRootsInitialClosure: public VoidClosure {
54
55 ConcurrentMark* _cm;
56 public:
57
58 CMCheckpointRootsInitialClosure(ConcurrentMark* cm) :
59 _cm(cm) {}
60
61 void do_void(){
62 _cm->checkpointRootsInitial();
63 }
64 };
65
66 class CMCheckpointRootsFinalClosure: public VoidClosure {
67
68 ConcurrentMark* _cm;
69 public:
70
71 CMCheckpointRootsFinalClosure(ConcurrentMark* cm) :
72 _cm(cm) {}
73
74 void do_void(){
75 _cm->checkpointRootsFinal(false); // !clear_all_soft_refs
76 }
77 };
78
79 class CMCleanUp: public VoidClosure {
80 ConcurrentMark* _cm;
81 public:
82
83 CMCleanUp(ConcurrentMark* cm) :
84 _cm(cm) {}
85
86 void do_void(){
87 _cm->cleanup();
88 }
89 };
90
91
92
93 void ConcurrentMarkThread::run() {
94 initialize_in_thread();
95 _vtime_start = os::elapsedVTime();
96 wait_for_universe_init();
97
98 G1CollectedHeap* g1 = G1CollectedHeap::heap();
99 G1CollectorPolicy* g1_policy = g1->g1_policy();
100 G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker();
101 Thread *current_thread = Thread::current();
102
103 while (!_should_terminate) {
104 // wait until started is set.
105 sleepBeforeNextCycle();
106 {
107 ResourceMark rm;
108 HandleMark hm;
109 double cycle_start = os::elapsedVTime();
110 double mark_start_sec = os::elapsedTime();
111 char verbose_str[128];
112
113 if (PrintGC) {
114 gclog_or_tty->date_stamp(PrintGCDateStamps);
115 gclog_or_tty->stamp(PrintGCTimeStamps);
116 gclog_or_tty->print_cr("[GC concurrent-mark-start]");
117 }
118
119 if (!g1_policy->in_young_gc_mode()) {
120 // this ensures the flag is not set if we bail out of the marking
121 // cycle; normally the flag is cleared immediately after cleanup
122 g1->set_marking_complete();
123
124 if (g1_policy->adaptive_young_list_length()) {
125 double now = os::elapsedTime();
126 double init_prediction_ms = g1_policy->predict_init_time_ms();
127 jlong sleep_time_ms = mmu_tracker->when_ms(now, init_prediction_ms);
128 os::sleep(current_thread, sleep_time_ms, false);
129 }
130
131 // We don't have to skip here if we've been asked to restart, because
132 // in the worst case we just enqueue a new VM operation to start a
133 // marking. Note that the init operation resets has_aborted()
134 CMCheckpointRootsInitialClosure init_cl(_cm);
135 strcpy(verbose_str, "GC initial-mark");
136 VM_CGC_Operation op(&init_cl, verbose_str);
137 VMThread::execute(&op);
138 }
139
140 int iter = 0;
141 do {
142 iter++;
143 if (!cm()->has_aborted()) {
144 _cm->markFromRoots();
145 }
146
147 double mark_end_time = os::elapsedVTime();
148 double mark_end_sec = os::elapsedTime();
149 _vtime_mark_accum += (mark_end_time - cycle_start);
150 if (!cm()->has_aborted()) {
151 if (g1_policy->adaptive_young_list_length()) {
152 double now = os::elapsedTime();
153 double remark_prediction_ms = g1_policy->predict_remark_time_ms();
154 jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms);
155 os::sleep(current_thread, sleep_time_ms, false);
156 }
157
158 if (PrintGC) {
159 gclog_or_tty->date_stamp(PrintGCDateStamps);
160 gclog_or_tty->stamp(PrintGCTimeStamps);
161 gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf sec]",
162 mark_end_sec - mark_start_sec);
163 }
164
165 CMCheckpointRootsFinalClosure final_cl(_cm);
166 sprintf(verbose_str, "GC remark");
167 VM_CGC_Operation op(&final_cl, verbose_str);
168 VMThread::execute(&op);
169 }
170 if (cm()->restart_for_overflow() &&
171 G1TraceMarkStackOverflow) {
172 gclog_or_tty->print_cr("Restarting conc marking because of MS overflow "
173 "in remark (restart #%d).", iter);
174 }
175
176 if (cm()->restart_for_overflow()) {
177 if (PrintGC) {
178 gclog_or_tty->date_stamp(PrintGCDateStamps);
179 gclog_or_tty->stamp(PrintGCTimeStamps);
180 gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]");
181 }
182 }
183 } while (cm()->restart_for_overflow());
184 double counting_start_time = os::elapsedVTime();
185
186 // YSR: These look dubious (i.e. redundant) !!! FIX ME
187 slt()->manipulatePLL(SurrogateLockerThread::acquirePLL);
188 slt()->manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);
189
190 if (!cm()->has_aborted()) {
191 double count_start_sec = os::elapsedTime();
192 if (PrintGC) {
193 gclog_or_tty->date_stamp(PrintGCDateStamps);
194 gclog_or_tty->stamp(PrintGCTimeStamps);
195 gclog_or_tty->print_cr("[GC concurrent-count-start]");
196 }
197
198 _sts.join();
199 _cm->calcDesiredRegions();
200 _sts.leave();
201
202 if (!cm()->has_aborted()) {
203 double count_end_sec = os::elapsedTime();
204 if (PrintGC) {
205 gclog_or_tty->date_stamp(PrintGCDateStamps);
206 gclog_or_tty->stamp(PrintGCTimeStamps);
207 gclog_or_tty->print_cr("[GC concurrent-count-end, %1.7lf]",
208 count_end_sec - count_start_sec);
209 }
210 }
211 }
212 double end_time = os::elapsedVTime();
213 _vtime_count_accum += (end_time - counting_start_time);
214 // Update the total virtual time before doing this, since it will try
215 // to measure it to get the vtime for this marking. We purposely
216 // neglect the presumably-short "completeCleanup" phase here.
217 _vtime_accum = (end_time - _vtime_start);
218 if (!cm()->has_aborted()) {
219 if (g1_policy->adaptive_young_list_length()) {
220 double now = os::elapsedTime();
221 double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms();
222 jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms);
223 os::sleep(current_thread, sleep_time_ms, false);
224 }
225
226 CMCleanUp cl_cl(_cm);
227 sprintf(verbose_str, "GC cleanup");
228 VM_CGC_Operation op(&cl_cl, verbose_str);
229 VMThread::execute(&op);
230 } else {
231 G1CollectedHeap::heap()->set_marking_complete();
232 }
233
234 if (!cm()->has_aborted()) {
235 double cleanup_start_sec = os::elapsedTime();
236 if (PrintGC) {
237 gclog_or_tty->date_stamp(PrintGCDateStamps);
238 gclog_or_tty->stamp(PrintGCTimeStamps);
239 gclog_or_tty->print_cr("[GC concurrent-cleanup-start]");
240 }
241
242 // Now do the remainder of the cleanup operation.
243 _sts.join();
244 _cm->completeCleanup();
245 if (!cm()->has_aborted()) {
246 g1_policy->record_concurrent_mark_cleanup_completed();
247
248 double cleanup_end_sec = os::elapsedTime();
249 if (PrintGC) {
250 gclog_or_tty->date_stamp(PrintGCDateStamps);
251 gclog_or_tty->stamp(PrintGCTimeStamps);
252 gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf]",
253 cleanup_end_sec - cleanup_start_sec);
254 }
255 }
256 _sts.leave();
257 }
258 // We're done: no more unclean regions coming.
259 G1CollectedHeap::heap()->set_unclean_regions_coming(false);
260
261 if (cm()->has_aborted()) {
262 if (PrintGC) {
263 gclog_or_tty->date_stamp(PrintGCDateStamps);
264 gclog_or_tty->stamp(PrintGCTimeStamps);
265 gclog_or_tty->print_cr("[GC concurrent-mark-abort]");
266 }
267 }
268
269 // we now want to allow clearing of the marking bitmap to be
270 // suspended by a collection pause.
271 _sts.join();
272 _cm->clearNextBitmap();
273 _sts.leave();
274 }
275
276 // Update the number of full collections that have been
277 // completed. This will also notify the FullGCCount_lock in case a
278 // Java thread is waiting for a full GC to happen (e.g., it
279 // called System.gc() with +ExplicitGCInvokesConcurrent).
280 g1->increment_full_collections_completed(true /* outer */);
281 }
282 assert(_should_terminate, "just checking");
283
284 terminate();
285 }
286
287
288 void ConcurrentMarkThread::yield() {
289 _sts.yield("Concurrent Mark");
290 }
291
292 void ConcurrentMarkThread::stop() {
293 // it is ok to take late safepoints here, if needed
294 MutexLockerEx mu(Terminator_lock);
295 _should_terminate = true;
296 while (!_has_terminated) {
297 Terminator_lock->wait();
298 }
299 }
300
301 void ConcurrentMarkThread::print() const {
302 print_on(tty);
303 }
304
305 void ConcurrentMarkThread::print_on(outputStream* st) const {
306 st->print("\"G1 Main Concurrent Mark GC Thread\" ");
307 Thread::print_on(st);
308 st->cr();
309 }
310
311 void ConcurrentMarkThread::sleepBeforeNextCycle() {
312 // We join here because we don't want to do the "shouldConcurrentMark()"
313 // below while the world is otherwise stopped.
314 assert(!in_progress(), "should have been cleared");
315
316 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
317 while (!started()) {
318 CGC_lock->wait(Mutex::_no_safepoint_check_flag);
319 }
320 set_in_progress();
321 clear_started();
322 }
323
324 // Note: this method, although exported by the ConcurrentMarkSweepThread,
325 // which is a non-JavaThread, can only be called by a JavaThread.
326 // Currently this is done at vm creation time (post-vm-init) by the
327 // main/Primordial (Java)Thread.
328 // XXX Consider changing this in the future to allow the CMS thread
329 // itself to create this thread?
330 void ConcurrentMarkThread::makeSurrogateLockerThread(TRAPS) {
331 assert(_slt == NULL, "SLT already created");
332 _slt = SurrogateLockerThread::make(THREAD);
333 }