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