Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp @ 20211:82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
Summary: The test incorrectly assumed that it had been started with no other previous compilation activity. Fix this by allowing multiple code root free chunk lists, and use one separate from the global one to perform the test.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Wed, 16 Apr 2014 10:14:50 +0200 |
| parents | 581e70386ec9 |
| children | 7df07d855c8e |
| rev | line source |
|---|---|
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
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" | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
32 #include "gc_implementation/shared/gcTrace.hpp" |
| 1972 | 33 #include "memory/resourceArea.hpp" |
| 34 #include "runtime/vmThread.hpp" | |
| 342 | 35 |
| 36 // ======= Concurrent Mark Thread ======== | |
| 37 | |
| 38 // The CM thread is created when the G1 garbage collector is used | |
| 39 | |
| 40 SurrogateLockerThread* | |
| 41 ConcurrentMarkThread::_slt = NULL; | |
| 42 | |
| 43 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) : | |
| 44 ConcurrentGCThread(), | |
| 45 _cm(cm), | |
| 46 _started(false), | |
| 47 _in_progress(false), | |
| 48 _vtime_accum(0.0), | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4096
diff
changeset
|
49 _vtime_mark_accum(0.0) { |
| 342 | 50 create_and_start(); |
| 51 } | |
| 52 | |
| 53 class CMCheckpointRootsFinalClosure: public VoidClosure { | |
| 54 | |
| 55 ConcurrentMark* _cm; | |
| 56 public: | |
| 57 | |
| 58 CMCheckpointRootsFinalClosure(ConcurrentMark* cm) : | |
| 59 _cm(cm) {} | |
| 60 | |
| 61 void do_void(){ | |
| 62 _cm->checkpointRootsFinal(false); // !clear_all_soft_refs | |
| 63 } | |
| 64 }; | |
| 65 | |
| 66 class CMCleanUp: public VoidClosure { | |
| 67 ConcurrentMark* _cm; | |
| 68 public: | |
| 69 | |
| 70 CMCleanUp(ConcurrentMark* cm) : | |
| 71 _cm(cm) {} | |
| 72 | |
| 73 void do_void(){ | |
| 74 _cm->cleanup(); | |
| 75 } | |
| 76 }; | |
| 77 | |
| 78 | |
| 79 | |
| 80 void ConcurrentMarkThread::run() { | |
| 81 initialize_in_thread(); | |
| 82 _vtime_start = os::elapsedVTime(); | |
| 83 wait_for_universe_init(); | |
| 84 | |
| 2152 | 85 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
| 86 G1CollectorPolicy* g1_policy = g1h->g1_policy(); | |
| 342 | 87 G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker(); |
| 88 Thread *current_thread = Thread::current(); | |
| 89 | |
| 90 while (!_should_terminate) { | |
| 91 // wait until started is set. | |
| 92 sleepBeforeNextCycle(); | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
93 if (_should_terminate) { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
94 break; |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
95 } |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
96 |
| 342 | 97 { |
| 98 ResourceMark rm; | |
| 99 HandleMark hm; | |
| 100 double cycle_start = os::elapsedVTime(); | |
| 101 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
102 // 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
|
103 // 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
|
104 // 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
|
105 // 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
|
106 // 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
|
107 // 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
|
108 // correctness issue. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
109 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
110 double scan_start = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
111 if (!cm()->has_aborted()) { |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
112 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
113 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
114 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
|
115 } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
116 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
117 _cm->scanRootRegions(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
118 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
119 double scan_end = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
120 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
121 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
|
8109
96c885895d22
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
7450
diff
changeset
|
122 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
|
123 scan_end - scan_start); |
|
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 } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
126 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
127 double mark_start_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
128 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
129 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
|
619
7ea5ca260b28
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
342
diff
changeset
|
130 gclog_or_tty->print_cr("[GC concurrent-mark-start]"); |
| 342 | 131 } |
| 132 | |
| 133 int iter = 0; | |
| 134 do { | |
| 135 iter++; | |
| 136 if (!cm()->has_aborted()) { | |
| 137 _cm->markFromRoots(); | |
| 138 } | |
| 139 | |
| 140 double mark_end_time = os::elapsedVTime(); | |
| 141 double mark_end_sec = os::elapsedTime(); | |
| 142 _vtime_mark_accum += (mark_end_time - cycle_start); | |
| 143 if (!cm()->has_aborted()) { | |
| 144 if (g1_policy->adaptive_young_list_length()) { | |
| 145 double now = os::elapsedTime(); | |
| 146 double remark_prediction_ms = g1_policy->predict_remark_time_ms(); | |
| 147 jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms); | |
| 148 os::sleep(current_thread, sleep_time_ms, false); | |
| 149 } | |
| 150 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
151 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
152 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
|
8109
96c885895d22
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
7450
diff
changeset
|
153 gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf secs]", |
| 342 | 154 mark_end_sec - mark_start_sec); |
| 155 } | |
| 156 | |
| 157 CMCheckpointRootsFinalClosure final_cl(_cm); | |
| 10405 | 158 VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */); |
| 342 | 159 VMThread::execute(&op); |
| 160 } | |
| 161 if (cm()->restart_for_overflow()) { | |
|
7450
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
6120
diff
changeset
|
162 if (G1TraceMarkStackOverflow) { |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
6120
diff
changeset
|
163 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
|
164 "in remark (restart #%d).", iter); |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
6120
diff
changeset
|
165 } |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
166 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
167 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
| 342 | 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. |
| 20192 | 193 SuspendibleThreadSetJoiner sts; |
| 2152 | 194 g1h->set_marking_complete(); |
| 342 | 195 } |
| 196 | |
| 2152 | 197 // Check if cleanup set the free_regions_coming flag. If it |
| 198 // hasn't, we can just skip the next step. | |
| 199 if (g1h->free_regions_coming()) { | |
| 200 // The following will finish freeing up any regions that we | |
| 201 // found to be empty during cleanup. We'll do this part | |
| 202 // without joining the suspendible set. If an evacuation pause | |
| 2361 | 203 // takes place, then we would carry on freeing regions in |
| 2152 | 204 // case they are needed by the pause. If a Full GC takes |
| 2361 | 205 // place, it would wait for us to process the regions |
| 2152 | 206 // reclaimed by cleanup. |
| 207 | |
| 342 | 208 double cleanup_start_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
209 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
210 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
| 342 | 211 gclog_or_tty->print_cr("[GC concurrent-cleanup-start]"); |
| 212 } | |
| 213 | |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
214 // Now do the concurrent cleanup operation. |
| 342 | 215 _cm->completeCleanup(); |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
216 |
| 2185 | 217 // 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
|
218 // 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
|
219 // (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
|
220 // interval between finishing the cleanup pause and clearing |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
221 // 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
|
222 // 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
|
223 // 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
|
224 // 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
|
225 // the GC workers finishing. |
| 2185 | 226 g1h->reset_free_regions_coming(); |
| 227 | |
| 2152 | 228 double cleanup_end_sec = os::elapsedTime(); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
229 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
230 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
|
8109
96c885895d22
8007221: G1: concurrent phase durations do not state the time units ("secs")
johnc
parents:
7450
diff
changeset
|
231 gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf secs]", |
| 2152 | 232 cleanup_end_sec - cleanup_start_sec); |
| 342 | 233 } |
| 234 } | |
| 2152 | 235 guarantee(cm()->cleanup_list_is_empty(), |
| 236 "at this point there should be no regions on the cleanup list"); | |
| 342 | 237 |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
238 // 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
|
239 // 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
|
240 // 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
|
241 // abort() on concurrent mark after |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
242 // record_concurrent_mark_cleanup_completed(), since abort() is |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
243 // 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
|
244 // end up calling record_concurrent_mark_cleanup_completed() |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
245 // 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
|
246 // 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
|
247 // 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
|
248 // are two scenarios: |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
249 // |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
250 // 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
|
251 // 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
|
252 // 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
|
253 // will complete before abort() is called. |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
254 // |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
255 // 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
|
256 // 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
|
257 // 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
|
258 // true to prevent us from calling |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
259 // 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
|
260 // 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
|
261 // already reset). |
| 20192 | 262 { |
| 263 SuspendibleThreadSetJoiner sts; | |
| 264 if (!cm()->has_aborted()) { | |
| 265 g1_policy->record_concurrent_mark_cleanup_completed(); | |
| 266 } | |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
267 } |
|
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
268 |
| 342 | 269 if (cm()->has_aborted()) { |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
270 if (G1Log::fine()) { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17947
diff
changeset
|
271 gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id()); |
| 342 | 272 gclog_or_tty->print_cr("[GC concurrent-mark-abort]"); |
| 273 } | |
| 274 } | |
| 275 | |
|
4012
ec4b032a4977
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
3867
diff
changeset
|
276 // We now want to allow clearing of the marking bitmap to be |
| 342 | 277 // suspended by a collection pause. |
| 20192 | 278 { |
| 279 SuspendibleThreadSetJoiner sts; | |
| 280 _cm->clearNextBitmap(); | |
| 281 } | |
| 342 | 282 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
283 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
284 // Update the number of full collections that have been |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
285 // 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
|
286 // 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
|
287 // called System.gc() with +ExplicitGCInvokesConcurrent). |
| 20192 | 288 { |
| 289 SuspendibleThreadSetJoiner sts; | |
| 290 g1h->increment_old_marking_cycles_completed(true /* concurrent */); | |
| 291 g1h->register_concurrent_cycle_end(); | |
| 292 } | |
| 342 | 293 } |
| 294 assert(_should_terminate, "just checking"); | |
| 295 | |
| 296 terminate(); | |
| 297 } | |
| 298 | |
| 299 void ConcurrentMarkThread::stop() { | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
300 { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
301 MutexLockerEx ml(Terminator_lock); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
302 _should_terminate = true; |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
303 } |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
304 |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
305 { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
306 MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
307 CGC_lock->notify_all(); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
308 } |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
309 |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
310 { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
311 MutexLockerEx ml(Terminator_lock); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
312 while (!_has_terminated) { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
313 Terminator_lock->wait(); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
314 } |
| 342 | 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); |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
334 while (!started() && !_should_terminate) { |
| 342 | 335 CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
| 336 } | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
337 |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
338 if (started()) { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
339 set_in_progress(); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
340 clear_started(); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
10405
diff
changeset
|
341 } |
| 342 | 342 } |
| 343 | |
|
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
4012
diff
changeset
|
344 // 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
|
345 // 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
|
346 // 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
|
347 // 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
|
348 // XXX Consider changing this in the future to allow the CM thread |
| 342 | 349 // itself to create this thread? |
| 350 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
|
351 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
|
352 assert(THREAD->is_Java_thread(), "must be a Java thread"); |
| 342 | 353 assert(_slt == NULL, "SLT already created"); |
| 354 _slt = SurrogateLockerThread::make(THREAD); | |
| 355 } |