author | jprovino |
Sat, 27 Feb 2016 00:07:03 +0000 | |
changeset 36372 | b33937c0acdc |
parent 36084 | 9a3bf78e9a76 |
child 37081 | 7656f5356a5d |
permissions | -rw-r--r-- |
25350
6423a57e5451
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
24331
diff
changeset
|
1 |
/* |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
2 |
* Copyright (c) 2001, 2016, 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" |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
26 |
#include "classfile/classLoaderData.hpp" |
30764 | 27 |
#include "gc/g1/concurrentMarkThread.inline.hpp" |
28 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
|
29 |
#include "gc/g1/g1CollectorPolicy.hpp" |
|
30 |
#include "gc/g1/g1MMUTracker.hpp" |
|
30770
5ba2d9f2084d
8080585: concurrentGCThread.hpp should not include suspendibleThreadSet.hpp
pliden
parents:
30764
diff
changeset
|
31 |
#include "gc/g1/suspendibleThreadSet.hpp" |
30764 | 32 |
#include "gc/g1/vm_operations_g1.hpp" |
33107
77bf0d2069a3
8134953: Make the GC ID available in a central place
brutisso
parents:
33106
diff
changeset
|
33 |
#include "gc/shared/gcId.hpp" |
30764 | 34 |
#include "gc/shared/gcTrace.hpp" |
35061 | 35 |
#include "gc/shared/gcTraceTime.inline.hpp" |
36 |
#include "logging/log.hpp" |
|
7397 | 37 |
#include "memory/resourceArea.hpp" |
38 |
#include "runtime/vmThread.hpp" |
|
1374 | 39 |
|
40 |
// ======= Concurrent Mark Thread ======== |
|
41 |
||
42 |
// The CM thread is created when the G1 garbage collector is used |
|
43 |
||
44 |
SurrogateLockerThread* |
|
45 |
ConcurrentMarkThread::_slt = NULL; |
|
46 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
47 |
ConcurrentMarkThread::ConcurrentMarkThread(G1ConcurrentMark* cm) : |
1374 | 48 |
ConcurrentGCThread(), |
49 |
_cm(cm), |
|
31597
f63dde8cc8f7
8129626: G1: set_in_progress() and clear_started() needs a barrier on non-TSO platforms
brutisso
parents:
31397
diff
changeset
|
50 |
_state(Idle), |
1374 | 51 |
_vtime_accum(0.0), |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
52 |
_vtime_mark_accum(0.0) { |
24331
c0bc7e5653fb
6885993: Named Thread: introduce print() and print_on(outputStream* st) methods
zgu
parents:
24094
diff
changeset
|
53 |
|
29464
02c245ad3ec9
8073545: Use shorter and more descriptive names for GC worker threads
david
parents:
27885
diff
changeset
|
54 |
set_name("G1 Main Marker"); |
1374 | 55 |
create_and_start(); |
56 |
} |
|
57 |
||
58 |
class CMCheckpointRootsFinalClosure: public VoidClosure { |
|
59 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
60 |
G1ConcurrentMark* _cm; |
1374 | 61 |
public: |
62 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
63 |
CMCheckpointRootsFinalClosure(G1ConcurrentMark* cm) : |
1374 | 64 |
_cm(cm) {} |
65 |
||
66 |
void do_void(){ |
|
67 |
_cm->checkpointRootsFinal(false); // !clear_all_soft_refs |
|
68 |
} |
|
69 |
}; |
|
70 |
||
71 |
class CMCleanUp: public VoidClosure { |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
72 |
G1ConcurrentMark* _cm; |
1374 | 73 |
public: |
74 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
75 |
CMCleanUp(G1ConcurrentMark* cm) : |
1374 | 76 |
_cm(cm) {} |
77 |
||
78 |
void do_void(){ |
|
79 |
_cm->cleanup(); |
|
80 |
} |
|
81 |
}; |
|
82 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
83 |
// Marking pauses can be scheduled flexibly, so we might delay marking to meet MMU. |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
84 |
void ConcurrentMarkThread::delay_to_keep_mmu(G1CollectorPolicy* g1_policy, bool remark) { |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
85 |
if (g1_policy->adaptive_young_list_length()) { |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
86 |
double now = os::elapsedTime(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
87 |
double prediction_ms = remark ? g1_policy->predict_remark_time_ms() |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
88 |
: g1_policy->predict_cleanup_time_ms(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
89 |
G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
90 |
jlong sleep_time_ms = mmu_tracker->when_ms(now, prediction_ms); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
91 |
os::sleep(this, sleep_time_ms, false); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
92 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
93 |
} |
35204 | 94 |
|
95 |
class GCConcPhaseTimer : StackObj { |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
96 |
G1ConcurrentMark* _cm; |
35204 | 97 |
|
98 |
public: |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
99 |
GCConcPhaseTimer(G1ConcurrentMark* cm, const char* title) : _cm(cm) { |
35204 | 100 |
_cm->register_concurrent_phase_start(title); |
101 |
} |
|
102 |
||
103 |
~GCConcPhaseTimer() { |
|
104 |
_cm->register_concurrent_phase_end(); |
|
105 |
} |
|
106 |
}; |
|
107 |
||
1374 | 108 |
void ConcurrentMarkThread::run() { |
109 |
initialize_in_thread(); |
|
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
110 |
wait_for_universe_init(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
111 |
|
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
112 |
run_service(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
113 |
|
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
114 |
terminate(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
115 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
116 |
|
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
117 |
void ConcurrentMarkThread::run_service() { |
1374 | 118 |
_vtime_start = os::elapsedVTime(); |
119 |
||
7923 | 120 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
121 |
G1CollectorPolicy* g1_policy = g1h->g1_policy(); |
|
1374 | 122 |
|
123 |
while (!_should_terminate) { |
|
124 |
// wait until started is set. |
|
125 |
sleepBeforeNextCycle(); |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
126 |
if (_should_terminate) { |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
127 |
_cm->root_regions()->cancel_scan(); |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
128 |
break; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
129 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
130 |
|
33152
6ad7fe735042
8139293: TestGCEventMixedWithG1ConcurrentMark.java fails after JDK-8134953
brutisso
parents:
33107
diff
changeset
|
131 |
assert(GCId::current() != GCId::undefined(), "GC id should have been set up by the initial mark GC."); |
1374 | 132 |
{ |
133 |
ResourceMark rm; |
|
134 |
HandleMark hm; |
|
135 |
double cycle_start = os::elapsedVTime(); |
|
136 |
||
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
137 |
{ |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
138 |
GCConcPhaseTimer(_cm, "Concurrent Clearing of Claimed Marks"); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
139 |
ClassLoaderDataGraph::clear_claimed_marks(); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
140 |
} |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
141 |
|
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
142 |
// 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
|
143 |
// 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
|
144 |
// 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
|
145 |
// 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
|
146 |
// 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
|
147 |
// 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
|
148 |
// correctness issue. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
149 |
|
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
150 |
{ |
35204 | 151 |
GCConcPhaseTimer(_cm, "Concurrent Root Region Scanning"); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
152 |
_cm->scanRootRegions(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
153 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
154 |
|
35061 | 155 |
// It would be nice to use the GCTraceConcTime class here but |
156 |
// the "end" logging is inside the loop and not at the end of |
|
157 |
// a scope. Mimicking the same log output as GCTraceConcTime instead. |
|
158 |
jlong mark_start = os::elapsed_counter(); |
|
159 |
log_info(gc)("Concurrent Mark (%.3fs)", TimeHelper::counter_to_seconds(mark_start)); |
|
1374 | 160 |
|
161 |
int iter = 0; |
|
162 |
do { |
|
163 |
iter++; |
|
164 |
if (!cm()->has_aborted()) { |
|
35204 | 165 |
GCConcPhaseTimer(_cm, "Concurrent Mark"); |
1374 | 166 |
_cm->markFromRoots(); |
167 |
} |
|
168 |
||
169 |
double mark_end_time = os::elapsedVTime(); |
|
35061 | 170 |
jlong mark_end = os::elapsed_counter(); |
1374 | 171 |
_vtime_mark_accum += (mark_end_time - cycle_start); |
172 |
if (!cm()->has_aborted()) { |
|
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
173 |
delay_to_keep_mmu(g1_policy, true /* remark */); |
35061 | 174 |
log_info(gc)("Concurrent Mark (%.3fs, %.3fs) %.3fms", |
175 |
TimeHelper::counter_to_seconds(mark_start), |
|
176 |
TimeHelper::counter_to_seconds(mark_end), |
|
177 |
TimeHelper::counter_to_millis(mark_end - mark_start)); |
|
1374 | 178 |
|
179 |
CMCheckpointRootsFinalClosure final_cl(_cm); |
|
35061 | 180 |
VM_CGC_Operation op(&final_cl, "Pause Remark", true /* needs_pll */); |
1374 | 181 |
VMThread::execute(&op); |
182 |
} |
|
183 |
if (cm()->restart_for_overflow()) { |
|
35061 | 184 |
log_debug(gc)("Restarting conc marking because of MS overflow in remark (restart #%d).", iter); |
185 |
log_info(gc)("Concurrent Mark restart for overflow"); |
|
1374 | 186 |
} |
187 |
} 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
|
188 |
|
1374 | 189 |
double end_time = os::elapsedVTime(); |
190 |
// Update the total virtual time before doing this, since it will try |
|
191 |
// to measure it to get the vtime for this marking. We purposely |
|
192 |
// neglect the presumably-short "completeCleanup" phase here. |
|
193 |
_vtime_accum = (end_time - _vtime_start); |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
194 |
|
1374 | 195 |
if (!cm()->has_aborted()) { |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
196 |
delay_to_keep_mmu(g1_policy, false /* cleanup */); |
1374 | 197 |
|
198 |
CMCleanUp cl_cl(_cm); |
|
35061 | 199 |
VM_CGC_Operation op(&cl_cl, "Pause Cleanup", false /* needs_pll */); |
1374 | 200 |
VMThread::execute(&op); |
201 |
} else { |
|
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
202 |
// 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
|
203 |
// is already underway. |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
204 |
SuspendibleThreadSetJoiner sts_join; |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30770
diff
changeset
|
205 |
g1h->collector_state()->set_mark_in_progress(false); |
1374 | 206 |
} |
207 |
||
7923 | 208 |
// Check if cleanup set the free_regions_coming flag. If it |
209 |
// hasn't, we can just skip the next step. |
|
210 |
if (g1h->free_regions_coming()) { |
|
211 |
// The following will finish freeing up any regions that we |
|
212 |
// found to be empty during cleanup. We'll do this part |
|
213 |
// without joining the suspendible set. If an evacuation pause |
|
8680 | 214 |
// takes place, then we would carry on freeing regions in |
7923 | 215 |
// case they are needed by the pause. If a Full GC takes |
8680 | 216 |
// place, it would wait for us to process the regions |
7923 | 217 |
// reclaimed by cleanup. |
218 |
||
35061 | 219 |
GCTraceConcTime(Info, gc) tt("Concurrent Cleanup"); |
35204 | 220 |
GCConcPhaseTimer(_cm, "Concurrent Cleanup"); |
1374 | 221 |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
222 |
// Now do the concurrent cleanup operation. |
1374 | 223 |
_cm->completeCleanup(); |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
224 |
|
8100 | 225 |
// 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
|
226 |
// 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
|
227 |
// (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
|
228 |
// interval between finishing the cleanup pause and clearing |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
229 |
// 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
|
230 |
// 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
|
231 |
// 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
|
232 |
// 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
|
233 |
// the GC workers finishing. |
8100 | 234 |
g1h->reset_free_regions_coming(); |
1374 | 235 |
} |
7923 | 236 |
guarantee(cm()->cleanup_list_is_empty(), |
237 |
"at this point there should be no regions on the cleanup list"); |
|
1374 | 238 |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
239 |
// 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
|
240 |
// 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
|
241 |
// 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
|
242 |
// abort() on concurrent mark after |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
243 |
// record_concurrent_mark_cleanup_completed(), since abort() is |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
244 |
// 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
|
245 |
// end up calling record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
246 |
// 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
|
247 |
// 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
|
248 |
// 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
|
249 |
// are two scenarios: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
250 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
251 |
// 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
|
252 |
// 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
|
253 |
// 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
|
254 |
// will complete before abort() is called. |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
255 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
256 |
// 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
|
257 |
// 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
|
258 |
// 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
|
259 |
// true to prevent us from calling |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
260 |
// 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
|
261 |
// 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
|
262 |
// already reset). |
24094 | 263 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
264 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 265 |
if (!cm()->has_aborted()) { |
266 |
g1_policy->record_concurrent_mark_cleanup_completed(); |
|
31397
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31331
diff
changeset
|
267 |
} else { |
35061 | 268 |
log_info(gc)("Concurrent Mark abort"); |
1374 | 269 |
} |
270 |
} |
|
271 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
272 |
// We now want to allow clearing of the marking bitmap to be |
1374 | 273 |
// 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
|
274 |
// 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
|
275 |
// 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
|
276 |
if (!cm()->has_aborted()) { |
35204 | 277 |
GCConcPhaseTimer(_cm, "Concurrent Bitmap Clearing"); |
24094 | 278 |
_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
|
279 |
} else { |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
280 |
assert(!G1VerifyBitmaps || _cm->nextMarkBitmapIsClear(), "Next mark bitmap must be clear"); |
24094 | 281 |
} |
1374 | 282 |
} |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
283 |
|
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
284 |
// Update the number of full collections that have been |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
285 |
// 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
|
286 |
// 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
|
287 |
// called System.gc() with +ExplicitGCInvokesConcurrent). |
24094 | 288 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
289 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 290 |
g1h->increment_old_marking_cycles_completed(true /* concurrent */); |
291 |
g1h->register_concurrent_cycle_end(); |
|
292 |
} |
|
1374 | 293 |
} |
294 |
} |
|
295 |
||
296 |
void ConcurrentMarkThread::stop() { |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
297 |
{ |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
298 |
MutexLockerEx ml(Terminator_lock); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
299 |
_should_terminate = true; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
300 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
301 |
|
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
302 |
stop_service(); |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
303 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
304 |
{ |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
305 |
MutexLockerEx ml(Terminator_lock); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
306 |
while (!_has_terminated) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
307 |
Terminator_lock->wait(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
308 |
} |
1374 | 309 |
} |
310 |
} |
|
311 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
312 |
void ConcurrentMarkThread::stop_service() { |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
313 |
MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
314 |
CGC_lock->notify_all(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
315 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
316 |
|
1374 | 317 |
void ConcurrentMarkThread::sleepBeforeNextCycle() { |
318 |
// We join here because we don't want to do the "shouldConcurrentMark()" |
|
319 |
// below while the world is otherwise stopped. |
|
6766
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
320 |
assert(!in_progress(), "should have been cleared"); |
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
321 |
|
1374 | 322 |
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
323 |
while (!started() && !_should_terminate) { |
1374 | 324 |
CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
325 |
} |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
326 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
327 |
if (started()) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
328 |
set_in_progress(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
329 |
} |
1374 | 330 |
} |
331 |
||
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
332 |
// 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
|
333 |
// 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
|
334 |
// 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
|
335 |
// 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
|
336 |
// XXX Consider changing this in the future to allow the CM thread |
1374 | 337 |
// itself to create this thread? |
338 |
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
|
339 |
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
|
340 |
assert(THREAD->is_Java_thread(), "must be a Java thread"); |
1374 | 341 |
assert(_slt == NULL, "SLT already created"); |
342 |
_slt = SurrogateLockerThread::make(THREAD); |
|
343 |
} |