author | kbarrett |
Tue, 30 Aug 2016 23:48:16 -0400 | |
changeset 40892 | 330a02d935ad |
parent 37985 | 539c597ee0fa |
child 42570 | 5a4f3339b5d9 |
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" |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37129
diff
changeset
|
28 |
#include "gc/g1/g1Analytics.hpp" |
30764 | 29 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
30 |
#include "gc/g1/g1ConcurrentMark.inline.hpp" |
30764 | 31 |
#include "gc/g1/g1MMUTracker.hpp" |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
32 |
#include "gc/g1/g1Policy.hpp" |
30770
5ba2d9f2084d
8080585: concurrentGCThread.hpp should not include suspendibleThreadSet.hpp
pliden
parents:
30764
diff
changeset
|
33 |
#include "gc/g1/suspendibleThreadSet.hpp" |
30764 | 34 |
#include "gc/g1/vm_operations_g1.hpp" |
33107
77bf0d2069a3
8134953: Make the GC ID available in a central place
brutisso
parents:
33106
diff
changeset
|
35 |
#include "gc/shared/gcId.hpp" |
30764 | 36 |
#include "gc/shared/gcTrace.hpp" |
35061 | 37 |
#include "gc/shared/gcTraceTime.inline.hpp" |
38 |
#include "logging/log.hpp" |
|
7397 | 39 |
#include "memory/resourceArea.hpp" |
40 |
#include "runtime/vmThread.hpp" |
|
1374 | 41 |
|
42 |
// ======= Concurrent Mark Thread ======== |
|
43 |
||
44 |
// The CM thread is created when the G1 garbage collector is used |
|
45 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
46 |
ConcurrentMarkThread::ConcurrentMarkThread(G1ConcurrentMark* cm) : |
1374 | 47 |
ConcurrentGCThread(), |
48 |
_cm(cm), |
|
31597
f63dde8cc8f7
8129626: G1: set_in_progress() and clear_started() needs a barrier on non-TSO platforms
brutisso
parents:
31397
diff
changeset
|
49 |
_state(Idle), |
1374 | 50 |
_vtime_accum(0.0), |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
51 |
_vtime_mark_accum(0.0) { |
24331
c0bc7e5653fb
6885993: Named Thread: introduce print() and print_on(outputStream* st) methods
zgu
parents:
24094
diff
changeset
|
52 |
|
29464
02c245ad3ec9
8073545: Use shorter and more descriptive names for GC worker threads
david
parents:
27885
diff
changeset
|
53 |
set_name("G1 Main Marker"); |
1374 | 54 |
create_and_start(); |
55 |
} |
|
56 |
||
57 |
class CMCheckpointRootsFinalClosure: public VoidClosure { |
|
58 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
59 |
G1ConcurrentMark* _cm; |
1374 | 60 |
public: |
61 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
62 |
CMCheckpointRootsFinalClosure(G1ConcurrentMark* cm) : |
1374 | 63 |
_cm(cm) {} |
64 |
||
65 |
void do_void(){ |
|
66 |
_cm->checkpointRootsFinal(false); // !clear_all_soft_refs |
|
67 |
} |
|
68 |
}; |
|
69 |
||
70 |
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
|
71 |
G1ConcurrentMark* _cm; |
1374 | 72 |
public: |
73 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
74 |
CMCleanUp(G1ConcurrentMark* cm) : |
1374 | 75 |
_cm(cm) {} |
76 |
||
77 |
void do_void(){ |
|
78 |
_cm->cleanup(); |
|
79 |
} |
|
80 |
}; |
|
81 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
82 |
// Marking pauses can be scheduled flexibly, so we might delay marking to meet MMU. |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
83 |
void ConcurrentMarkThread::delay_to_keep_mmu(G1Policy* g1_policy, bool remark) { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37129
diff
changeset
|
84 |
const G1Analytics* analytics = g1_policy->analytics(); |
33608
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(); |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37129
diff
changeset
|
87 |
double prediction_ms = remark ? analytics->predict_remark_time_ms() |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37129
diff
changeset
|
88 |
: analytics->predict_cleanup_time_ms(); |
33608
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 |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
95 |
class G1ConcPhaseTimer : public GCTraceConcTimeImpl<LogLevel::Info, LOG_TAGS(gc, marking)> { |
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: |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
99 |
G1ConcPhaseTimer(G1ConcurrentMark* cm, const char* title) : |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
100 |
GCTraceConcTimeImpl<LogLevel::Info, LogTag::_gc, LogTag::_marking>(title), |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
101 |
_cm(cm) { |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
102 |
_cm->gc_timer_cm()->register_gc_concurrent_start(title); |
35204 | 103 |
} |
104 |
||
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
105 |
~G1ConcPhaseTimer() { |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
106 |
_cm->gc_timer_cm()->register_gc_concurrent_end(); |
35204 | 107 |
} |
108 |
}; |
|
109 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
110 |
void ConcurrentMarkThread::run_service() { |
1374 | 111 |
_vtime_start = os::elapsedVTime(); |
112 |
||
7923 | 113 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
114 |
G1Policy* g1_policy = g1h->g1_policy(); |
1374 | 115 |
|
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
116 |
while (!should_terminate()) { |
1374 | 117 |
// wait until started is set. |
118 |
sleepBeforeNextCycle(); |
|
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
119 |
if (should_terminate()) { |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
120 |
break; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
121 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
122 |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
123 |
GCIdMark gc_id_mark; |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
124 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
125 |
cm()->concurrent_cycle_start(); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
126 |
|
33152
6ad7fe735042
8139293: TestGCEventMixedWithG1ConcurrentMark.java fails after JDK-8134953
brutisso
parents:
33107
diff
changeset
|
127 |
assert(GCId::current() != GCId::undefined(), "GC id should have been set up by the initial mark GC."); |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
128 |
|
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
129 |
GCTraceConcTime(Info, gc) tt("Concurrent Cycle"); |
1374 | 130 |
{ |
131 |
ResourceMark rm; |
|
132 |
HandleMark hm; |
|
133 |
double cycle_start = os::elapsedVTime(); |
|
134 |
||
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
135 |
{ |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
136 |
G1ConcPhaseTimer t(_cm, "Concurrent Clear Claimed Marks"); |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
137 |
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
|
138 |
} |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
139 |
|
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
140 |
// 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
|
141 |
// 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
|
142 |
// 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
|
143 |
// 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
|
144 |
// 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
|
145 |
// 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
|
146 |
// correctness issue. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
147 |
|
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
148 |
{ |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
149 |
G1ConcPhaseTimer t(_cm, "Concurrent Scan Root Regions"); |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
150 |
_cm->scan_root_regions(); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
151 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
152 |
|
35061 | 153 |
// It would be nice to use the GCTraceConcTime class here but |
154 |
// the "end" logging is inside the loop and not at the end of |
|
155 |
// a scope. Mimicking the same log output as GCTraceConcTime instead. |
|
156 |
jlong mark_start = os::elapsed_counter(); |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
157 |
log_info(gc, marking)("Concurrent Mark (%.3fs)", TimeHelper::counter_to_seconds(mark_start)); |
1374 | 158 |
|
159 |
int iter = 0; |
|
160 |
do { |
|
161 |
iter++; |
|
162 |
if (!cm()->has_aborted()) { |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
163 |
G1ConcPhaseTimer t(_cm, "Concurrent Mark From Roots"); |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
164 |
_cm->mark_from_roots(); |
1374 | 165 |
} |
166 |
||
167 |
double mark_end_time = os::elapsedVTime(); |
|
35061 | 168 |
jlong mark_end = os::elapsed_counter(); |
1374 | 169 |
_vtime_mark_accum += (mark_end_time - cycle_start); |
170 |
if (!cm()->has_aborted()) { |
|
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
171 |
delay_to_keep_mmu(g1_policy, true /* remark */); |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
172 |
log_info(gc, marking)("Concurrent Mark (%.3fs, %.3fs) %.3fms", |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
173 |
TimeHelper::counter_to_seconds(mark_start), |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
174 |
TimeHelper::counter_to_seconds(mark_end), |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
175 |
TimeHelper::counter_to_millis(mark_end - mark_start)); |
1374 | 176 |
|
177 |
CMCheckpointRootsFinalClosure final_cl(_cm); |
|
40892
330a02d935ad
8156500: Move Reference pending list into VM to prevent deadlocks
kbarrett
parents:
37985
diff
changeset
|
178 |
VM_CGC_Operation op(&final_cl, "Pause Remark"); |
1374 | 179 |
VMThread::execute(&op); |
180 |
} |
|
181 |
if (cm()->restart_for_overflow()) { |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
182 |
log_debug(gc, marking)("Restarting Concurrent Marking because of Mark Stack Overflow in Remark (Iteration #%d).", iter); |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
183 |
log_info(gc, marking)("Concurrent Mark Restart due to overflow"); |
1374 | 184 |
} |
185 |
} 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
|
186 |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
187 |
if (!cm()->has_aborted()) { |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
188 |
G1ConcPhaseTimer t(_cm, "Concurrent Create Live Data"); |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
189 |
cm()->create_live_data(); |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
190 |
} |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
191 |
|
1374 | 192 |
double end_time = os::elapsedVTime(); |
193 |
// Update the total virtual time before doing this, since it will try |
|
194 |
// to measure it to get the vtime for this marking. We purposely |
|
195 |
// neglect the presumably-short "completeCleanup" phase here. |
|
196 |
_vtime_accum = (end_time - _vtime_start); |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
197 |
|
1374 | 198 |
if (!cm()->has_aborted()) { |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
199 |
delay_to_keep_mmu(g1_policy, false /* cleanup */); |
1374 | 200 |
|
201 |
CMCleanUp cl_cl(_cm); |
|
40892
330a02d935ad
8156500: Move Reference pending list into VM to prevent deadlocks
kbarrett
parents:
37985
diff
changeset
|
202 |
VM_CGC_Operation op(&cl_cl, "Pause Cleanup"); |
1374 | 203 |
VMThread::execute(&op); |
204 |
} else { |
|
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
205 |
// 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
|
206 |
// is already underway. |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
207 |
SuspendibleThreadSetJoiner sts_join; |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30770
diff
changeset
|
208 |
g1h->collector_state()->set_mark_in_progress(false); |
1374 | 209 |
} |
210 |
||
7923 | 211 |
// Check if cleanup set the free_regions_coming flag. If it |
212 |
// hasn't, we can just skip the next step. |
|
213 |
if (g1h->free_regions_coming()) { |
|
214 |
// The following will finish freeing up any regions that we |
|
215 |
// found to be empty during cleanup. We'll do this part |
|
216 |
// without joining the suspendible set. If an evacuation pause |
|
8680 | 217 |
// takes place, then we would carry on freeing regions in |
7923 | 218 |
// case they are needed by the pause. If a Full GC takes |
8680 | 219 |
// place, it would wait for us to process the regions |
7923 | 220 |
// reclaimed by cleanup. |
221 |
||
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
222 |
G1ConcPhaseTimer t(_cm, "Concurrent Complete Cleanup"); |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
223 |
// Now do the concurrent cleanup operation. |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
224 |
_cm->complete_cleanup(); |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
225 |
|
8100 | 226 |
// 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
|
227 |
// 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
|
228 |
// (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
|
229 |
// interval between finishing the cleanup pause and clearing |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
230 |
// 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
|
231 |
// 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
|
232 |
// 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
|
233 |
// 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
|
234 |
// the GC workers finishing. |
8100 | 235 |
g1h->reset_free_regions_coming(); |
1374 | 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 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
265 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 266 |
if (!cm()->has_aborted()) { |
267 |
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
|
268 |
} else { |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
269 |
log_info(gc, marking)("Concurrent Mark Abort"); |
1374 | 270 |
} |
271 |
} |
|
272 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
273 |
// We now want to allow clearing of the marking bitmap to be |
1374 | 274 |
// 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
|
275 |
// 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
|
276 |
// 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
|
277 |
if (!cm()->has_aborted()) { |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
278 |
G1ConcPhaseTimer t(_cm, "Concurrent Cleanup for Next Mark"); |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37081
diff
changeset
|
279 |
_cm->cleanup_for_next_mark(); |
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
280 |
} else { |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
281 |
assert(!G1VerifyBitmaps || _cm->nextMarkBitmapIsClear(), "Next mark bitmap must be clear"); |
24094 | 282 |
} |
1374 | 283 |
} |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
284 |
|
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
285 |
// Update the number of full collections that have been |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
286 |
// 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
|
287 |
// 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
|
288 |
// called System.gc() with +ExplicitGCInvokesConcurrent). |
24094 | 289 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
290 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 291 |
g1h->increment_old_marking_cycles_completed(true /* concurrent */); |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
292 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
293 |
cm()->concurrent_cycle_end(); |
24094 | 294 |
} |
1374 | 295 |
} |
37120
7f2e805b6b77
8151336: Root region scanning should be cancelled and disabled when the ConcurrentMarkThread::run_service() exits
brutisso
parents:
37081
diff
changeset
|
296 |
_cm->root_regions()->cancel_scan(); |
1374 | 297 |
} |
298 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
299 |
void ConcurrentMarkThread::stop_service() { |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
300 |
MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
301 |
CGC_lock->notify_all(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
302 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
303 |
|
1374 | 304 |
void ConcurrentMarkThread::sleepBeforeNextCycle() { |
305 |
// We join here because we don't want to do the "shouldConcurrentMark()" |
|
306 |
// below while the world is otherwise stopped. |
|
6766
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
307 |
assert(!in_progress(), "should have been cleared"); |
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
308 |
|
1374 | 309 |
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
310 |
while (!started() && !should_terminate()) { |
1374 | 311 |
CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
312 |
} |
|
24093
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 |
if (started()) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
315 |
set_in_progress(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
316 |
} |
1374 | 317 |
} |