Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp @ 6007:5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
Summary: Added log levels "fine", "finer" and "finest". Let PrintGC map to "fine" and PrintGCDetails map to "finer". Separated out the per worker information in the G1 logging to the "finest" level.
Reviewed-by: stefank, jwilhelm, tonyp, johnc
| author | brutisso |
|---|---|
| date | Fri, 13 Apr 2012 01:59:38 +0200 |
| parents | 64bf7c8270cb |
| children | 37552638d24a |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4096
diff
changeset
|
2 * Copyright (c) 2001, 2012, 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 char verbose_str[128]; | |
| 97 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
98 // 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
|
99 // 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
|
100 // 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
|
101 // 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
|
102 // 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
|
103 // 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
|
104 // correctness issue. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
105 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
106 double scan_start = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
107 if (!cm()->has_aborted()) { |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
108 if (G1Log::fine()) { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
109 gclog_or_tty->date_stamp(PrintGCDateStamps); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
110 gclog_or_tty->stamp(PrintGCTimeStamps); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
111 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
|
112 } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
113 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
114 _cm->scanRootRegions(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
115 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
116 double scan_end = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
117 if (G1Log::fine()) { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
118 gclog_or_tty->date_stamp(PrintGCDateStamps); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
119 gclog_or_tty->stamp(PrintGCTimeStamps); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
120 gclog_or_tty->print_cr("[GC concurrent-root-region-scan-end, %1.7lf]", |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
121 scan_end - scan_start); |
|
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 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
125 double mark_start_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
126 if (G1Log::fine()) { |
| 342 | 127 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 128 gclog_or_tty->stamp(PrintGCTimeStamps); | |
|
619
7ea5ca260b28
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
342
diff
changeset
|
129 gclog_or_tty->print_cr("[GC concurrent-mark-start]"); |
| 342 | 130 } |
| 131 | |
| 132 int iter = 0; | |
| 133 do { | |
| 134 iter++; | |
| 135 if (!cm()->has_aborted()) { | |
| 136 _cm->markFromRoots(); | |
| 137 } | |
| 138 | |
| 139 double mark_end_time = os::elapsedVTime(); | |
| 140 double mark_end_sec = os::elapsedTime(); | |
| 141 _vtime_mark_accum += (mark_end_time - cycle_start); | |
| 142 if (!cm()->has_aborted()) { | |
| 143 if (g1_policy->adaptive_young_list_length()) { | |
| 144 double now = os::elapsedTime(); | |
| 145 double remark_prediction_ms = g1_policy->predict_remark_time_ms(); | |
| 146 jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms); | |
| 147 os::sleep(current_thread, sleep_time_ms, false); | |
| 148 } | |
| 149 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
150 if (G1Log::fine()) { |
| 342 | 151 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 152 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 153 gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf sec]", | |
| 154 mark_end_sec - mark_start_sec); | |
| 155 } | |
| 156 | |
| 157 CMCheckpointRootsFinalClosure final_cl(_cm); | |
| 158 sprintf(verbose_str, "GC remark"); | |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4837
diff
changeset
|
159 VM_CGC_Operation op(&final_cl, verbose_str, true /* needs_pll */); |
| 342 | 160 VMThread::execute(&op); |
| 161 } | |
| 162 if (cm()->restart_for_overflow() && | |
| 163 G1TraceMarkStackOverflow) { | |
| 164 gclog_or_tty->print_cr("Restarting conc marking because of MS overflow " | |
| 165 "in remark (restart #%d).", iter); | |
| 166 } | |
| 167 | |
| 168 if (cm()->restart_for_overflow()) { | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
169 if (G1Log::fine()) { |
| 342 | 170 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 171 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 172 gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]"); | |
| 173 } | |
| 174 } | |
| 175 } 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
|
176 |
| 342 | 177 double end_time = os::elapsedVTime(); |
| 178 // Update the total virtual time before doing this, since it will try | |
| 179 // to measure it to get the vtime for this marking. We purposely | |
| 180 // neglect the presumably-short "completeCleanup" phase here. | |
| 181 _vtime_accum = (end_time - _vtime_start); | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4096
diff
changeset
|
182 |
| 342 | 183 if (!cm()->has_aborted()) { |
| 184 if (g1_policy->adaptive_young_list_length()) { | |
| 185 double now = os::elapsedTime(); | |
| 186 double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms(); | |
| 187 jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms); | |
| 188 os::sleep(current_thread, sleep_time_ms, false); | |
| 189 } | |
| 190 | |
| 191 CMCleanUp cl_cl(_cm); | |
| 192 sprintf(verbose_str, "GC cleanup"); | |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4837
diff
changeset
|
193 VM_CGC_Operation op(&cl_cl, verbose_str, false /* needs_pll */); |
| 342 | 194 VMThread::execute(&op); |
| 195 } else { | |
|
4096
00dd86e542eb
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
4022
diff
changeset
|
196 // 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
|
197 // is already underway. |
|
00dd86e542eb
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
4022
diff
changeset
|
198 _sts.join(); |
| 2152 | 199 g1h->set_marking_complete(); |
|
4096
00dd86e542eb
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
4022
diff
changeset
|
200 _sts.leave(); |
| 342 | 201 } |
| 202 | |
| 2152 | 203 // Check if cleanup set the free_regions_coming flag. If it |
| 204 // hasn't, we can just skip the next step. | |
| 205 if (g1h->free_regions_coming()) { | |
| 206 // The following will finish freeing up any regions that we | |
| 207 // found to be empty during cleanup. We'll do this part | |
| 208 // without joining the suspendible set. If an evacuation pause | |
| 2361 | 209 // takes place, then we would carry on freeing regions in |
| 2152 | 210 // case they are needed by the pause. If a Full GC takes |
| 2361 | 211 // place, it would wait for us to process the regions |
| 2152 | 212 // reclaimed by cleanup. |
| 213 | |
| 342 | 214 double cleanup_start_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
215 if (G1Log::fine()) { |
| 342 | 216 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 217 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 218 gclog_or_tty->print_cr("[GC concurrent-cleanup-start]"); | |
| 219 } | |
| 220 | |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
221 // Now do the concurrent cleanup operation. |
| 342 | 222 _cm->completeCleanup(); |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
223 |
| 2185 | 224 // 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
|
225 // 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
|
226 // (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
|
227 // interval between finishing the cleanup pause and clearing |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
228 // 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
|
229 // 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
|
230 // 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
|
231 // 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
|
232 // the GC workers finishing. |
| 2185 | 233 g1h->reset_free_regions_coming(); |
| 234 | |
| 2152 | 235 double cleanup_end_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
236 if (G1Log::fine()) { |
| 2152 | 237 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 238 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 239 gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf]", | |
| 240 cleanup_end_sec - cleanup_start_sec); | |
| 342 | 241 } |
| 242 } | |
| 2152 | 243 guarantee(cm()->cleanup_list_is_empty(), |
| 244 "at this point there should be no regions on the cleanup list"); | |
| 342 | 245 |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
246 // 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
|
247 // 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
|
248 // 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
|
249 // abort() on concurrent mark after |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
250 // record_concurrent_mark_cleanup_completed(), since abort() is |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
251 // 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
|
252 // end up calling record_concurrent_mark_cleanup_completed() |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
253 // 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
|
254 // 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
|
255 // 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
|
256 // are two scenarios: |
|
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 // 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
|
259 // 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
|
260 // 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
|
261 // will complete before abort() is called. |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
262 // |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
263 // 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
|
264 // 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
|
265 // 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
|
266 // true to prevent us from calling |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
267 // 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
|
268 // 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
|
269 // already reset). |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
270 _sts.join(); |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
271 if (!cm()->has_aborted()) { |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
272 g1_policy->record_concurrent_mark_cleanup_completed(); |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
273 } |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
274 _sts.leave(); |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
275 |
| 342 | 276 if (cm()->has_aborted()) { |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
277 if (G1Log::fine()) { |
| 342 | 278 gclog_or_tty->date_stamp(PrintGCDateStamps); |
| 279 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 280 gclog_or_tty->print_cr("[GC concurrent-mark-abort]"); | |
| 281 } | |
| 282 } | |
| 283 | |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
284 // We now want to allow clearing of the marking bitmap to be |
| 342 | 285 // suspended by a collection pause. |
| 286 _sts.join(); | |
| 287 _cm->clearNextBitmap(); | |
| 288 _sts.leave(); | |
| 289 } | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
290 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
291 // Update the number of full collections that have been |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
292 // 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
|
293 // 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
|
294 // called System.gc() with +ExplicitGCInvokesConcurrent). |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1972
diff
changeset
|
295 _sts.join(); |
| 2152 | 296 g1h->increment_full_collections_completed(true /* concurrent */); |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1972
diff
changeset
|
297 _sts.leave(); |
| 342 | 298 } |
| 299 assert(_should_terminate, "just checking"); | |
| 300 | |
| 301 terminate(); | |
| 302 } | |
| 303 | |
| 304 | |
| 305 void ConcurrentMarkThread::yield() { | |
| 306 _sts.yield("Concurrent Mark"); | |
| 307 } | |
| 308 | |
| 309 void ConcurrentMarkThread::stop() { | |
| 310 // it is ok to take late safepoints here, if needed | |
| 311 MutexLockerEx mu(Terminator_lock); | |
| 312 _should_terminate = true; | |
| 313 while (!_has_terminated) { | |
| 314 Terminator_lock->wait(); | |
| 315 } | |
| 316 } | |
| 317 | |
| 1019 | 318 void ConcurrentMarkThread::print() const { |
| 319 print_on(tty); | |
| 320 } | |
| 321 | |
| 322 void ConcurrentMarkThread::print_on(outputStream* st) const { | |
| 323 st->print("\"G1 Main Concurrent Mark GC Thread\" "); | |
| 324 Thread::print_on(st); | |
| 325 st->cr(); | |
| 342 | 326 } |
| 327 | |
| 328 void ConcurrentMarkThread::sleepBeforeNextCycle() { | |
| 329 // We join here because we don't want to do the "shouldConcurrentMark()" | |
| 330 // below while the world is otherwise stopped. | |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1656
diff
changeset
|
331 assert(!in_progress(), "should have been cleared"); |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1656
diff
changeset
|
332 |
| 342 | 333 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
| 334 while (!started()) { | |
| 335 CGC_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 336 } | |
| 337 set_in_progress(); | |
| 338 clear_started(); | |
| 339 } | |
| 340 | |
|
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
4012
diff
changeset
|
341 // 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
|
342 // 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
|
343 // 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
|
344 // 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
|
345 // XXX Consider changing this in the future to allow the CM thread |
| 342 | 346 // itself to create this thread? |
| 347 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
|
348 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
|
349 assert(THREAD->is_Java_thread(), "must be a Java thread"); |
| 342 | 350 assert(_slt == NULL, "SLT already created"); |
| 351 _slt = SurrogateLockerThread::make(THREAD); | |
| 352 } |