author | drwhite |
Thu, 02 Apr 2015 16:42:24 -0400 | |
changeset 30157 | e36165b16dde |
parent 29464 | 02c245ad3ec9 |
child 30613 | a7815bb05ae2 |
permissions | -rw-r--r-- |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
1 |
/* |
29464
02c245ad3ec9
8073545: Use shorter and more descriptive names for GC worker threads
david
parents:
27885
diff
changeset
|
2 |
* Copyright (c) 2001, 2015, 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" |
|
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
32 |
#include "gc_implementation/shared/gcTrace.hpp" |
7397 | 33 |
#include "memory/resourceArea.hpp" |
34 |
#include "runtime/vmThread.hpp" |
|
1374 | 35 |
|
36 |
// ======= Concurrent Mark Thread ======== |
|
37 |
||
38 |
// The CM thread is created when the G1 garbage collector is used |
|
39 |
||
40 |
SurrogateLockerThread* |
|
41 |
ConcurrentMarkThread::_slt = NULL; |
|
42 |
||
43 |
ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) : |
|
44 |
ConcurrentGCThread(), |
|
45 |
_cm(cm), |
|
46 |
_started(false), |
|
47 |
_in_progress(false), |
|
48 |
_vtime_accum(0.0), |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
49 |
_vtime_mark_accum(0.0) { |
24331
c0bc7e5653fb
6885993: Named Thread: introduce print() and print_on(outputStream* st) methods
zgu
parents:
24094
diff
changeset
|
50 |
|
29464
02c245ad3ec9
8073545: Use shorter and more descriptive names for GC worker threads
david
parents:
27885
diff
changeset
|
51 |
set_name("G1 Main Marker"); |
1374 | 52 |
create_and_start(); |
53 |
} |
|
54 |
||
55 |
class CMCheckpointRootsFinalClosure: public VoidClosure { |
|
56 |
||
57 |
ConcurrentMark* _cm; |
|
58 |
public: |
|
59 |
||
60 |
CMCheckpointRootsFinalClosure(ConcurrentMark* cm) : |
|
61 |
_cm(cm) {} |
|
62 |
||
63 |
void do_void(){ |
|
64 |
_cm->checkpointRootsFinal(false); // !clear_all_soft_refs |
|
65 |
} |
|
66 |
}; |
|
67 |
||
68 |
class CMCleanUp: public VoidClosure { |
|
69 |
ConcurrentMark* _cm; |
|
70 |
public: |
|
71 |
||
72 |
CMCleanUp(ConcurrentMark* cm) : |
|
73 |
_cm(cm) {} |
|
74 |
||
75 |
void do_void(){ |
|
76 |
_cm->cleanup(); |
|
77 |
} |
|
78 |
}; |
|
79 |
||
80 |
||
81 |
||
82 |
void ConcurrentMarkThread::run() { |
|
83 |
initialize_in_thread(); |
|
84 |
_vtime_start = os::elapsedVTime(); |
|
85 |
wait_for_universe_init(); |
|
86 |
||
7923 | 87 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
88 |
G1CollectorPolicy* g1_policy = g1h->g1_policy(); |
|
1374 | 89 |
G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker(); |
90 |
Thread *current_thread = Thread::current(); |
|
91 |
||
92 |
while (!_should_terminate) { |
|
93 |
// wait until started is set. |
|
94 |
sleepBeforeNextCycle(); |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
95 |
if (_should_terminate) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
96 |
break; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
97 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
98 |
|
1374 | 99 |
{ |
100 |
ResourceMark rm; |
|
101 |
HandleMark hm; |
|
102 |
double cycle_start = os::elapsedVTime(); |
|
103 |
||
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
104 |
// 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
|
105 |
// 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
|
106 |
// 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
|
107 |
// 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
|
108 |
// 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
|
109 |
// 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
|
110 |
// correctness issue. |
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 |
double scan_start = os::elapsedTime(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
113 |
if (!cm()->has_aborted()) { |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
114 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
115 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
116 |
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
|
117 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
118 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
119 |
_cm->scanRootRegions(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
120 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
121 |
double scan_end = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
122 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
123 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
124 |
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
|
125 |
scan_end - scan_start); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
126 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
127 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
128 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
129 |
double mark_start_sec = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
130 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
131 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
2145
da1dfec15623
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
1374
diff
changeset
|
132 |
gclog_or_tty->print_cr("[GC concurrent-mark-start]"); |
1374 | 133 |
} |
134 |
||
135 |
int iter = 0; |
|
136 |
do { |
|
137 |
iter++; |
|
138 |
if (!cm()->has_aborted()) { |
|
139 |
_cm->markFromRoots(); |
|
140 |
} |
|
141 |
||
142 |
double mark_end_time = os::elapsedVTime(); |
|
143 |
double mark_end_sec = os::elapsedTime(); |
|
144 |
_vtime_mark_accum += (mark_end_time - cycle_start); |
|
145 |
if (!cm()->has_aborted()) { |
|
146 |
if (g1_policy->adaptive_young_list_length()) { |
|
147 |
double now = os::elapsedTime(); |
|
148 |
double remark_prediction_ms = g1_policy->predict_remark_time_ms(); |
|
149 |
jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms); |
|
150 |
os::sleep(current_thread, sleep_time_ms, false); |
|
151 |
} |
|
152 |
||
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
153 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
154 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
155 |
gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf secs]", |
1374 | 156 |
mark_end_sec - mark_start_sec); |
157 |
} |
|
158 |
||
159 |
CMCheckpointRootsFinalClosure final_cl(_cm); |
|
18025 | 160 |
VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */); |
1374 | 161 |
VMThread::execute(&op); |
162 |
} |
|
163 |
if (cm()->restart_for_overflow()) { |
|
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
164 |
if (G1TraceMarkStackOverflow) { |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
165 |
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
|
166 |
"in remark (restart #%d).", iter); |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
12934
diff
changeset
|
167 |
} |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
168 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
169 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
1374 | 170 |
gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]"); |
171 |
} |
|
172 |
} |
|
173 |
} 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
|
174 |
|
1374 | 175 |
double end_time = os::elapsedVTime(); |
176 |
// Update the total virtual time before doing this, since it will try |
|
177 |
// to measure it to get the vtime for this marking. We purposely |
|
178 |
// neglect the presumably-short "completeCleanup" phase here. |
|
179 |
_vtime_accum = (end_time - _vtime_start); |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
180 |
|
1374 | 181 |
if (!cm()->has_aborted()) { |
182 |
if (g1_policy->adaptive_young_list_length()) { |
|
183 |
double now = os::elapsedTime(); |
|
184 |
double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms(); |
|
185 |
jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms); |
|
186 |
os::sleep(current_thread, sleep_time_ms, false); |
|
187 |
} |
|
188 |
||
189 |
CMCleanUp cl_cl(_cm); |
|
18025 | 190 |
VM_CGC_Operation op(&cl_cl, "GC cleanup", false /* needs_pll */); |
1374 | 191 |
VMThread::execute(&op); |
192 |
} else { |
|
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
193 |
// 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
|
194 |
// is already underway. |
24094 | 195 |
SuspendibleThreadSetJoiner sts; |
7923 | 196 |
g1h->set_marking_complete(); |
1374 | 197 |
} |
198 |
||
7923 | 199 |
// Check if cleanup set the free_regions_coming flag. If it |
200 |
// hasn't, we can just skip the next step. |
|
201 |
if (g1h->free_regions_coming()) { |
|
202 |
// The following will finish freeing up any regions that we |
|
203 |
// found to be empty during cleanup. We'll do this part |
|
204 |
// without joining the suspendible set. If an evacuation pause |
|
8680 | 205 |
// takes place, then we would carry on freeing regions in |
7923 | 206 |
// case they are needed by the pause. If a Full GC takes |
8680 | 207 |
// place, it would wait for us to process the regions |
7923 | 208 |
// reclaimed by cleanup. |
209 |
||
1374 | 210 |
double cleanup_start_sec = os::elapsedTime(); |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12227
diff
changeset
|
211 |
if (G1Log::fine()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
212 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
1374 | 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()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
232 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
15804
95a2110b2dbb
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
15090
diff
changeset
|
233 |
gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf secs]", |
7923 | 234 |
cleanup_end_sec - cleanup_start_sec); |
1374 | 235 |
} |
236 |
} |
|
7923 | 237 |
guarantee(cm()->cleanup_list_is_empty(), |
238 |
"at this point there should be no regions on the cleanup list"); |
|
1374 | 239 |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
240 |
// 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
|
241 |
// 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
|
242 |
// 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
|
243 |
// abort() on concurrent mark after |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
244 |
// record_concurrent_mark_cleanup_completed(), since abort() is |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
245 |
// 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
|
246 |
// end up calling record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
247 |
// 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
|
248 |
// 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
|
249 |
// 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
|
250 |
// are two scenarios: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
251 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
252 |
// 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
|
253 |
// 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
|
254 |
// 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
|
255 |
// will complete before abort() is called. |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
256 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
257 |
// 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
|
258 |
// 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
|
259 |
// 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
|
260 |
// true to prevent us from calling |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
261 |
// 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
|
262 |
// 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
|
263 |
// already reset). |
24094 | 264 |
{ |
265 |
SuspendibleThreadSetJoiner sts; |
|
266 |
if (!cm()->has_aborted()) { |
|
267 |
g1_policy->record_concurrent_mark_cleanup_completed(); |
|
268 |
} |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
269 |
} |
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()) { |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
273 |
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
1374 | 274 |
gclog_or_tty->print_cr("[GC concurrent-mark-abort]"); |
275 |
} |
|
276 |
} |
|
277 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
278 |
// We now want to allow clearing of the marking bitmap to be |
1374 | 279 |
// suspended by a collection pause. |
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
280 |
// We may have aborted just before the remark. Do not bother clearing the |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
281 |
// bitmap then, as it has been done during mark abort. |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
282 |
if (!cm()->has_aborted()) { |
24094 | 283 |
_cm->clearNextBitmap(); |
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
284 |
} else { |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
285 |
assert(!G1VerifyBitmaps || _cm->nextMarkBitmapIsClear(), "Next mark bitmap must be clear"); |
24094 | 286 |
} |
1374 | 287 |
} |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
288 |
|
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
289 |
// Update the number of full collections that have been |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
290 |
// 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
|
291 |
// 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
|
292 |
// called System.gc() with +ExplicitGCInvokesConcurrent). |
24094 | 293 |
{ |
294 |
SuspendibleThreadSetJoiner sts; |
|
295 |
g1h->increment_old_marking_cycles_completed(true /* concurrent */); |
|
296 |
g1h->register_concurrent_cycle_end(); |
|
297 |
} |
|
1374 | 298 |
} |
299 |
assert(_should_terminate, "just checking"); |
|
300 |
||
301 |
terminate(); |
|
302 |
} |
|
303 |
||
304 |
void ConcurrentMarkThread::stop() { |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
305 |
{ |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
306 |
MutexLockerEx ml(Terminator_lock); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
307 |
_should_terminate = true; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
308 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
309 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
310 |
{ |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
311 |
MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
312 |
CGC_lock->notify_all(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
313 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
314 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
315 |
{ |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
316 |
MutexLockerEx ml(Terminator_lock); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
317 |
while (!_has_terminated) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
318 |
Terminator_lock->wait(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
319 |
} |
1374 | 320 |
} |
321 |
} |
|
322 |
||
323 |
void ConcurrentMarkThread::sleepBeforeNextCycle() { |
|
324 |
// We join here because we don't want to do the "shouldConcurrentMark()" |
|
325 |
// below while the world is otherwise stopped. |
|
6766
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
326 |
assert(!in_progress(), "should have been cleared"); |
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
327 |
|
1374 | 328 |
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
329 |
while (!started() && !_should_terminate) { |
1374 | 330 |
CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
331 |
} |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
332 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
333 |
if (started()) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
334 |
set_in_progress(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
335 |
clear_started(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
336 |
} |
1374 | 337 |
} |
338 |
||
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
339 |
// 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
|
340 |
// 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
|
341 |
// 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
|
342 |
// 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
|
343 |
// XXX Consider changing this in the future to allow the CM thread |
1374 | 344 |
// itself to create this thread? |
345 |
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
|
346 |
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
|
347 |
assert(THREAD->is_Java_thread(), "must be a Java thread"); |
1374 | 348 |
assert(_slt == NULL, "SLT already created"); |
349 |
_slt = SurrogateLockerThread::make(THREAD); |
|
350 |
} |