author | jwilhelm |
Thu, 03 Oct 2013 21:36:29 +0200 | |
changeset 20398 | b206c580c45f |
parent 18025 | b7bcf7497f93 |
child 24093 | 095cc0a63ed9 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
2 |
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 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" |
|
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
29 |
#include "gc_implementation/g1/g1Log.hpp" |
7397 | 30 |
#include "gc_implementation/g1/g1MMUTracker.hpp" |
31 |
#include "gc_implementation/g1/vm_operations_g1.hpp" |
|
32 |
#include "memory/resourceArea.hpp" |
|
33 |
#include "runtime/vmThread.hpp" |
|
1374 | 34 |
|
35 |
// ======= Concurrent Mark Thread ======== |
|
36 |
||
37 |
// The CM thread is created when the G1 garbage collector is used |
|
38 |
||
39 |
SurrogateLockerThread* |
|
40 |
ConcurrentMarkThread::_slt = NULL; |
|
41 |
||
42 |
ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) : |
|
43 |
ConcurrentGCThread(), |
|
44 |
_cm(cm), |
|
45 |
_started(false), |
|
46 |
_in_progress(false), |
|
47 |
_vtime_accum(0.0), |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
48 |
_vtime_mark_accum(0.0) { |
1374 | 49 |
create_and_start(); |
50 |
} |
|
51 |
||
52 |
class CMCheckpointRootsFinalClosure: public VoidClosure { |
|
53 |
||
54 |
ConcurrentMark* _cm; |
|
55 |
public: |
|
56 |
||
57 |
CMCheckpointRootsFinalClosure(ConcurrentMark* cm) : |
|
58 |
_cm(cm) {} |
|
59 |
||
60 |
void do_void(){ |
|
61 |
_cm->checkpointRootsFinal(false); // !clear_all_soft_refs |
|
62 |
} |
|
63 |
}; |
|
64 |
||
65 |
class CMCleanUp: public VoidClosure { |
|
66 |
ConcurrentMark* _cm; |
|
67 |
public: |
|
68 |
||
69 |
CMCleanUp(ConcurrentMark* cm) : |
|
70 |
_cm(cm) {} |
|
71 |
||
72 |
void do_void(){ |
|
73 |
_cm->cleanup(); |
|
74 |
} |
|
75 |
}; |
|
76 |
||
77 |
||
78 |
||
79 |
void ConcurrentMarkThread::run() { |
|
80 |
initialize_in_thread(); |
|
81 |
_vtime_start = os::elapsedVTime(); |
|
82 |
wait_for_universe_init(); |
|
83 |
||
7923 | 84 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
85 |
G1CollectorPolicy* g1_policy = g1h->g1_policy(); |
|
1374 | 86 |
G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker(); |
87 |
Thread *current_thread = Thread::current(); |
|
88 |
||
89 |
while (!_should_terminate) { |
|
90 |
// wait until started is set. |
|
91 |
sleepBeforeNextCycle(); |
|
92 |
{ |
|
93 |
ResourceMark rm; |
|
94 |
HandleMark hm; |
|
95 |
double cycle_start = os::elapsedVTime(); |
|
96 |
||
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
97 |
// We have to ensure that we finish scanning the root regions |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
98 |
// before the next GC takes place. To ensure this we have to |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
99 |
// make sure that we do not join the STS until the root regions |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
100 |
// have been scanned. If we did then it's possible that a |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
101 |
// subsequent GC could block us from joining the STS and proceed |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
102 |
// without the root regions have been scanned which would be a |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
103 |
// correctness issue. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
104 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
105 |
double scan_start = os::elapsedTime(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
106 |
if (!cm()->has_aborted()) { |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
107 |
if (G1Log::fine()) { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
108 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
109 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
110 |
gclog_or_tty->print_cr("[GC concurrent-root-region-scan-start]"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
111 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
112 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
113 |
_cm->scanRootRegions(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
114 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
115 |
double scan_end = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
116 |
if (G1Log::fine()) { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
117 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
118 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
119 |
gclog_or_tty->print_cr("[GC concurrent-root-region-scan-end, %1.7lf secs]", |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
120 |
scan_end - scan_start); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
121 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
122 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
123 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
124 |
double mark_start_sec = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
125 |
if (G1Log::fine()) { |
1374 | 126 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
127 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
2145
da1dfec15623
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
1374
diff
changeset
|
128 |
gclog_or_tty->print_cr("[GC concurrent-mark-start]"); |
1374 | 129 |
} |
130 |
||
131 |
int iter = 0; |
|
132 |
do { |
|
133 |
iter++; |
|
134 |
if (!cm()->has_aborted()) { |
|
135 |
_cm->markFromRoots(); |
|
136 |
} |
|
137 |
||
138 |
double mark_end_time = os::elapsedVTime(); |
|
139 |
double mark_end_sec = os::elapsedTime(); |
|
140 |
_vtime_mark_accum += (mark_end_time - cycle_start); |
|
141 |
if (!cm()->has_aborted()) { |
|
142 |
if (g1_policy->adaptive_young_list_length()) { |
|
143 |
double now = os::elapsedTime(); |
|
144 |
double remark_prediction_ms = g1_policy->predict_remark_time_ms(); |
|
145 |
jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms); |
|
146 |
os::sleep(current_thread, sleep_time_ms, false); |
|
147 |
} |
|
148 |
||
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
149 |
if (G1Log::fine()) { |
1374 | 150 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
151 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
152 |
gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf secs]", |
1374 | 153 |
mark_end_sec - mark_start_sec); |
154 |
} |
|
155 |
||
156 |
CMCheckpointRootsFinalClosure final_cl(_cm); |
|
18025 | 157 |
VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */); |
1374 | 158 |
VMThread::execute(&op); |
159 |
} |
|
160 |
if (cm()->restart_for_overflow()) { |
|
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
161 |
if (G1TraceMarkStackOverflow) { |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
162 |
gclog_or_tty->print_cr("Restarting conc marking because of MS overflow " |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
163 |
"in remark (restart #%d).", iter); |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
164 |
} |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
165 |
if (G1Log::fine()) { |
1374 | 166 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
167 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
168 |
gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]"); |
|
169 |
} |
|
170 |
} |
|
171 |
} while (cm()->restart_for_overflow()); |
|
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
172 |
|
1374 | 173 |
double end_time = os::elapsedVTime(); |
174 |
// Update the total virtual time before doing this, since it will try |
|
175 |
// to measure it to get the vtime for this marking. We purposely |
|
176 |
// neglect the presumably-short "completeCleanup" phase here. |
|
177 |
_vtime_accum = (end_time - _vtime_start); |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
178 |
|
1374 | 179 |
if (!cm()->has_aborted()) { |
180 |
if (g1_policy->adaptive_young_list_length()) { |
|
181 |
double now = os::elapsedTime(); |
|
182 |
double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms(); |
|
183 |
jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms); |
|
184 |
os::sleep(current_thread, sleep_time_ms, false); |
|
185 |
} |
|
186 |
||
187 |
CMCleanUp cl_cl(_cm); |
|
18025 | 188 |
VM_CGC_Operation op(&cl_cl, "GC cleanup", false /* needs_pll */); |
1374 | 189 |
VMThread::execute(&op); |
190 |
} else { |
|
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
191 |
// We don't want to update the marking status if a GC pause |
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
192 |
// is already underway. |
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
193 |
_sts.join(); |
7923 | 194 |
g1h->set_marking_complete(); |
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
195 |
_sts.leave(); |
1374 | 196 |
} |
197 |
||
7923 | 198 |
// Check if cleanup set the free_regions_coming flag. If it |
199 |
// hasn't, we can just skip the next step. |
|
200 |
if (g1h->free_regions_coming()) { |
|
201 |
// The following will finish freeing up any regions that we |
|
202 |
// found to be empty during cleanup. We'll do this part |
|
203 |
// without joining the suspendible set. If an evacuation pause |
|
8680 | 204 |
// takes place, then we would carry on freeing regions in |
7923 | 205 |
// case they are needed by the pause. If a Full GC takes |
8680 | 206 |
// place, it would wait for us to process the regions |
7923 | 207 |
// reclaimed by cleanup. |
208 |
||
1374 | 209 |
double cleanup_start_sec = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
210 |
if (G1Log::fine()) { |
1374 | 211 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
212 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
213 |
gclog_or_tty->print_cr("[GC concurrent-cleanup-start]"); |
|
214 |
} |
|
215 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
216 |
// Now do the concurrent cleanup operation. |
1374 | 217 |
_cm->completeCleanup(); |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
218 |
|
8100 | 219 |
// Notify anyone who's waiting that there are no more free |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
220 |
// regions coming. We have to do this before we join the STS |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
221 |
// (in fact, we should not attempt to join the STS in the |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
222 |
// interval between finishing the cleanup pause and clearing |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
223 |
// the free_regions_coming flag) otherwise we might deadlock: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
224 |
// a GC worker could be blocked waiting for the notification |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
225 |
// whereas this thread will be blocked for the pause to finish |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
226 |
// while it's trying to join the STS, which is conditional on |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
227 |
// the GC workers finishing. |
8100 | 228 |
g1h->reset_free_regions_coming(); |
229 |
||
7923 | 230 |
double cleanup_end_sec = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
231 |
if (G1Log::fine()) { |
7923 | 232 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
233 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
234 |
gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf secs]", |
7923 | 235 |
cleanup_end_sec - cleanup_start_sec); |
1374 | 236 |
} |
237 |
} |
|
7923 | 238 |
guarantee(cm()->cleanup_list_is_empty(), |
239 |
"at this point there should be no regions on the cleanup list"); |
|
1374 | 240 |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
241 |
// There is a tricky race before recording that the concurrent |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
242 |
// cleanup has completed and a potential Full GC starting around |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
243 |
// the same time. We want to make sure that the Full GC calls |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
244 |
// abort() on concurrent mark after |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
245 |
// record_concurrent_mark_cleanup_completed(), since abort() is |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
246 |
// the method that will reset the concurrent mark state. If we |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
247 |
// end up calling record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
248 |
// after abort() then we might incorrectly undo some of the work |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
249 |
// abort() did. Checking the has_aborted() flag after joining |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
250 |
// the STS allows the correct ordering of the two methods. There |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
251 |
// are two scenarios: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
252 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
253 |
// a) If we reach here before the Full GC, the fact that we have |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
254 |
// joined the STS means that the Full GC cannot start until we |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
255 |
// leave the STS, so record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
256 |
// will complete before abort() is called. |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
257 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
258 |
// b) If we reach here during the Full GC, we'll be held up from |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
259 |
// joining the STS until the Full GC is done, which means that |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
260 |
// abort() will have completed and has_aborted() will return |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
261 |
// true to prevent us from calling |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
262 |
// record_concurrent_mark_cleanup_completed() (and, in fact, it's |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
263 |
// not needed any more as the concurrent mark state has been |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
264 |
// already reset). |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
265 |
_sts.join(); |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
266 |
if (!cm()->has_aborted()) { |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
267 |
g1_policy->record_concurrent_mark_cleanup_completed(); |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
268 |
} |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
269 |
_sts.leave(); |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
270 |
|
1374 | 271 |
if (cm()->has_aborted()) { |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
272 |
if (G1Log::fine()) { |
1374 | 273 |
gclog_or_tty->date_stamp(PrintGCDateStamps); |
274 |
gclog_or_tty->stamp(PrintGCTimeStamps); |
|
275 |
gclog_or_tty->print_cr("[GC concurrent-mark-abort]"); |
|
276 |
} |
|
277 |
} |
|
278 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
279 |
// We now want to allow clearing of the marking bitmap to be |
1374 | 280 |
// suspended by a collection pause. |
281 |
_sts.join(); |
|
282 |
_cm->clearNextBitmap(); |
|
283 |
_sts.leave(); |
|
284 |
} |
|
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
285 |
|
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
286 |
// Update the number of full collections that have been |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
287 |
// completed. This will also notify the FullGCCount_lock in case a |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
288 |
// Java thread is waiting for a full GC to happen (e.g., it |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
289 |
// called System.gc() with +ExplicitGCInvokesConcurrent). |
7455
22e19e8c0beb
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
7397
diff
changeset
|
290 |
_sts.join(); |
12934
f9bc0e664918
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
12378
diff
changeset
|
291 |
g1h->increment_old_marking_cycles_completed(true /* concurrent */); |
18025 | 292 |
g1h->register_concurrent_cycle_end(); |
7455
22e19e8c0beb
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
7397
diff
changeset
|
293 |
_sts.leave(); |
1374 | 294 |
} |
295 |
assert(_should_terminate, "just checking"); |
|
296 |
||
297 |
terminate(); |
|
298 |
} |
|
299 |
||
300 |
||
301 |
void ConcurrentMarkThread::yield() { |
|
302 |
_sts.yield("Concurrent Mark"); |
|
303 |
} |
|
304 |
||
305 |
void ConcurrentMarkThread::stop() { |
|
306 |
// it is ok to take late safepoints here, if needed |
|
307 |
MutexLockerEx mu(Terminator_lock); |
|
308 |
_should_terminate = true; |
|
309 |
while (!_has_terminated) { |
|
310 |
Terminator_lock->wait(); |
|
311 |
} |
|
312 |
} |
|
313 |
||
4022 | 314 |
void ConcurrentMarkThread::print() const { |
315 |
print_on(tty); |
|
316 |
} |
|
317 |
||
318 |
void ConcurrentMarkThread::print_on(outputStream* st) const { |
|
319 |
st->print("\"G1 Main Concurrent Mark GC Thread\" "); |
|
320 |
Thread::print_on(st); |
|
321 |
st->cr(); |
|
1374 | 322 |
} |
323 |
||
324 |
void ConcurrentMarkThread::sleepBeforeNextCycle() { |
|
325 |
// We join here because we don't want to do the "shouldConcurrentMark()" |
|
326 |
// below while the world is otherwise stopped. |
|
6766
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
327 |
assert(!in_progress(), "should have been cleared"); |
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
328 |
|
1374 | 329 |
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
330 |
while (!started()) { |
|
331 |
CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
|
332 |
} |
|
333 |
set_in_progress(); |
|
334 |
clear_started(); |
|
335 |
} |
|
336 |
||
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
337 |
// Note: As is the case with CMS - this method, although exported |
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
338 |
// by the ConcurrentMarkThread, which is a non-JavaThread, can only |
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
339 |
// be called by a JavaThread. Currently this is done at vm creation |
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
340 |
// time (post-vm-init) by the main/Primordial (Java)Thread. |
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
341 |
// XXX Consider changing this in the future to allow the CM thread |
1374 | 342 |
// itself to create this thread? |
343 |
void ConcurrentMarkThread::makeSurrogateLockerThread(TRAPS) { |
|
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
344 |
assert(UseG1GC, "SLT thread needed only for concurrent GC"); |
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
345 |
assert(THREAD->is_Java_thread(), "must be a Java thread"); |
1374 | 346 |
assert(_slt == NULL, "SLT already created"); |
347 |
_slt = SurrogateLockerThread::make(THREAD); |
|
348 |
} |