Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | fd2b426c30db |
| children | adedfbbf0360 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
2 * Copyright (c) 2001, 2011, 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:
1547
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1547
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:
1547
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "code/icBuffer.hpp" | |
| 27 #include "gc_implementation/g1/bufferingOopClosure.hpp" | |
| 28 #include "gc_implementation/g1/concurrentG1Refine.hpp" | |
| 29 #include "gc_implementation/g1/concurrentG1RefineThread.hpp" | |
| 30 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
31 #include "gc_implementation/g1/g1AllocRegion.inline.hpp" |
| 1972 | 32 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
| 33 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
34 #include "gc_implementation/g1/g1ErgoVerbose.hpp" |
| 1972 | 35 #include "gc_implementation/g1/g1MarkSweep.hpp" |
| 36 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
| 37 #include "gc_implementation/g1/g1RemSet.inline.hpp" | |
| 38 #include "gc_implementation/g1/heapRegionRemSet.hpp" | |
| 39 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 40 #include "gc_implementation/g1/vm_operations_g1.hpp" | |
| 41 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 42 #include "memory/gcLocker.inline.hpp" | |
| 43 #include "memory/genOopClosures.inline.hpp" | |
| 44 #include "memory/generationSpec.hpp" | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
45 #include "memory/referenceProcessor.hpp" |
| 1972 | 46 #include "oops/oop.inline.hpp" |
| 47 #include "oops/oop.pcgc.inline.hpp" | |
| 48 #include "runtime/aprofiler.hpp" | |
| 49 #include "runtime/vmThread.hpp" | |
| 342 | 50 |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
51 size_t G1CollectedHeap::_humongous_object_threshold_in_words = 0; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
52 |
| 342 | 53 // turn it on so that the contents of the young list (scan-only / |
| 54 // to-be-collected) are printed at "strategic" points before / during | |
| 55 // / after the collection --- this is useful for debugging | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
56 #define YOUNG_LIST_VERBOSE 0 |
| 342 | 57 // CURRENT STATUS |
| 58 // This file is under construction. Search for "FIXME". | |
| 59 | |
| 60 // INVARIANTS/NOTES | |
| 61 // | |
| 62 // All allocation activity covered by the G1CollectedHeap interface is | |
| 1973 | 63 // serialized by acquiring the HeapLock. This happens in mem_allocate |
| 64 // and allocate_new_tlab, which are the "entry" points to the | |
| 65 // allocation code from the rest of the JVM. (Note that this does not | |
| 66 // apply to TLAB allocation, which is not part of this interface: it | |
| 67 // is done by clients of this interface.) | |
| 342 | 68 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
69 // Notes on implementation of parallelism in different tasks. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
70 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
71 // G1ParVerifyTask uses heap_region_par_iterate_chunked() for parallelism. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
72 // The number of GC workers is passed to heap_region_par_iterate_chunked(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
73 // It does use run_task() which sets _n_workers in the task. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
74 // G1ParTask executes g1_process_strong_roots() -> |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
75 // SharedHeap::process_strong_roots() which calls eventuall to |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
76 // CardTableModRefBS::par_non_clean_card_iterate_work() which uses |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
77 // SequentialSubTasksDone. SharedHeap::process_strong_roots() also |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
78 // directly uses SubTasksDone (_process_strong_tasks field in SharedHeap). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
79 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
80 |
| 342 | 81 // Local to this file. |
| 82 | |
| 83 class RefineCardTableEntryClosure: public CardTableEntryClosure { | |
| 84 SuspendibleThreadSet* _sts; | |
| 85 G1RemSet* _g1rs; | |
| 86 ConcurrentG1Refine* _cg1r; | |
| 87 bool _concurrent; | |
| 88 public: | |
| 89 RefineCardTableEntryClosure(SuspendibleThreadSet* sts, | |
| 90 G1RemSet* g1rs, | |
| 91 ConcurrentG1Refine* cg1r) : | |
| 92 _sts(sts), _g1rs(g1rs), _cg1r(cg1r), _concurrent(true) | |
| 93 {} | |
| 94 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 1705 | 95 bool oops_into_cset = _g1rs->concurrentRefineOneCard(card_ptr, worker_i, false); |
| 96 // This path is executed by the concurrent refine or mutator threads, | |
| 97 // concurrently, and so we do not care if card_ptr contains references | |
| 98 // that point into the collection set. | |
| 99 assert(!oops_into_cset, "should be"); | |
| 100 | |
| 342 | 101 if (_concurrent && _sts->should_yield()) { |
| 102 // Caller will actually yield. | |
| 103 return false; | |
| 104 } | |
| 105 // Otherwise, we finished successfully; return true. | |
| 106 return true; | |
| 107 } | |
| 108 void set_concurrent(bool b) { _concurrent = b; } | |
| 109 }; | |
| 110 | |
| 111 | |
| 112 class ClearLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 113 int _calls; | |
| 114 G1CollectedHeap* _g1h; | |
| 115 CardTableModRefBS* _ctbs; | |
| 116 int _histo[256]; | |
| 117 public: | |
| 118 ClearLoggedCardTableEntryClosure() : | |
| 119 _calls(0) | |
| 120 { | |
| 121 _g1h = G1CollectedHeap::heap(); | |
| 122 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 123 for (int i = 0; i < 256; i++) _histo[i] = 0; | |
| 124 } | |
| 125 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 126 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 127 _calls++; | |
| 128 unsigned char* ujb = (unsigned char*)card_ptr; | |
| 129 int ind = (int)(*ujb); | |
| 130 _histo[ind]++; | |
| 131 *card_ptr = -1; | |
| 132 } | |
| 133 return true; | |
| 134 } | |
| 135 int calls() { return _calls; } | |
| 136 void print_histo() { | |
| 137 gclog_or_tty->print_cr("Card table value histogram:"); | |
| 138 for (int i = 0; i < 256; i++) { | |
| 139 if (_histo[i] != 0) { | |
| 140 gclog_or_tty->print_cr(" %d: %d", i, _histo[i]); | |
| 141 } | |
| 142 } | |
| 143 } | |
| 144 }; | |
| 145 | |
| 146 class RedirtyLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 147 int _calls; | |
| 148 G1CollectedHeap* _g1h; | |
| 149 CardTableModRefBS* _ctbs; | |
| 150 public: | |
| 151 RedirtyLoggedCardTableEntryClosure() : | |
| 152 _calls(0) | |
| 153 { | |
| 154 _g1h = G1CollectedHeap::heap(); | |
| 155 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 156 } | |
| 157 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 158 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 159 _calls++; | |
| 160 *card_ptr = 0; | |
| 161 } | |
| 162 return true; | |
| 163 } | |
| 164 int calls() { return _calls; } | |
| 165 }; | |
| 166 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
167 class RedirtyLoggedCardTableEntryFastClosure : public CardTableEntryClosure { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
168 public: |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
169 bool do_card_ptr(jbyte* card_ptr, int worker_i) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
170 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
171 return true; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
172 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
173 }; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
174 |
| 342 | 175 YoungList::YoungList(G1CollectedHeap* g1h) |
| 176 : _g1h(g1h), _head(NULL), | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
177 _length(0), |
| 342 | 178 _last_sampled_rs_lengths(0), |
| 545 | 179 _survivor_head(NULL), _survivor_tail(NULL), _survivor_length(0) |
| 342 | 180 { |
| 181 guarantee( check_list_empty(false), "just making sure..." ); | |
| 182 } | |
| 183 | |
| 184 void YoungList::push_region(HeapRegion *hr) { | |
| 185 assert(!hr->is_young(), "should not already be young"); | |
| 186 assert(hr->get_next_young_region() == NULL, "cause it should!"); | |
| 187 | |
| 188 hr->set_next_young_region(_head); | |
| 189 _head = hr; | |
| 190 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
191 _g1h->g1_policy()->set_region_eden(hr, (int) _length); |
| 342 | 192 ++_length; |
| 193 } | |
| 194 | |
| 195 void YoungList::add_survivor_region(HeapRegion* hr) { | |
| 545 | 196 assert(hr->is_survivor(), "should be flagged as survivor region"); |
| 342 | 197 assert(hr->get_next_young_region() == NULL, "cause it should!"); |
| 198 | |
| 199 hr->set_next_young_region(_survivor_head); | |
| 200 if (_survivor_head == NULL) { | |
| 545 | 201 _survivor_tail = hr; |
| 342 | 202 } |
| 203 _survivor_head = hr; | |
| 204 ++_survivor_length; | |
| 205 } | |
| 206 | |
| 207 void YoungList::empty_list(HeapRegion* list) { | |
| 208 while (list != NULL) { | |
| 209 HeapRegion* next = list->get_next_young_region(); | |
| 210 list->set_next_young_region(NULL); | |
| 211 list->uninstall_surv_rate_group(); | |
| 212 list->set_not_young(); | |
| 213 list = next; | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 void YoungList::empty_list() { | |
| 218 assert(check_list_well_formed(), "young list should be well formed"); | |
| 219 | |
| 220 empty_list(_head); | |
| 221 _head = NULL; | |
| 222 _length = 0; | |
| 223 | |
| 224 empty_list(_survivor_head); | |
| 225 _survivor_head = NULL; | |
| 545 | 226 _survivor_tail = NULL; |
| 342 | 227 _survivor_length = 0; |
| 228 | |
| 229 _last_sampled_rs_lengths = 0; | |
| 230 | |
| 231 assert(check_list_empty(false), "just making sure..."); | |
| 232 } | |
| 233 | |
| 234 bool YoungList::check_list_well_formed() { | |
| 235 bool ret = true; | |
| 236 | |
| 237 size_t length = 0; | |
| 238 HeapRegion* curr = _head; | |
| 239 HeapRegion* last = NULL; | |
| 240 while (curr != NULL) { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
241 if (!curr->is_young()) { |
| 342 | 242 gclog_or_tty->print_cr("### YOUNG REGION "PTR_FORMAT"-"PTR_FORMAT" " |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
243 "incorrectly tagged (y: %d, surv: %d)", |
| 342 | 244 curr->bottom(), curr->end(), |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
245 curr->is_young(), curr->is_survivor()); |
| 342 | 246 ret = false; |
| 247 } | |
| 248 ++length; | |
| 249 last = curr; | |
| 250 curr = curr->get_next_young_region(); | |
| 251 } | |
| 252 ret = ret && (length == _length); | |
| 253 | |
| 254 if (!ret) { | |
| 255 gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!"); | |
| 256 gclog_or_tty->print_cr("### list has %d entries, _length is %d", | |
| 257 length, _length); | |
| 258 } | |
| 259 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
260 return ret; |
| 342 | 261 } |
| 262 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
263 bool YoungList::check_list_empty(bool check_sample) { |
| 342 | 264 bool ret = true; |
| 265 | |
| 266 if (_length != 0) { | |
| 267 gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %d", | |
| 268 _length); | |
| 269 ret = false; | |
| 270 } | |
| 271 if (check_sample && _last_sampled_rs_lengths != 0) { | |
| 272 gclog_or_tty->print_cr("### YOUNG LIST has non-zero last sampled RS lengths"); | |
| 273 ret = false; | |
| 274 } | |
| 275 if (_head != NULL) { | |
| 276 gclog_or_tty->print_cr("### YOUNG LIST does not have a NULL head"); | |
| 277 ret = false; | |
| 278 } | |
| 279 if (!ret) { | |
| 280 gclog_or_tty->print_cr("### YOUNG LIST does not seem empty"); | |
| 281 } | |
| 282 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
283 return ret; |
| 342 | 284 } |
| 285 | |
| 286 void | |
| 287 YoungList::rs_length_sampling_init() { | |
| 288 _sampled_rs_lengths = 0; | |
| 289 _curr = _head; | |
| 290 } | |
| 291 | |
| 292 bool | |
| 293 YoungList::rs_length_sampling_more() { | |
| 294 return _curr != NULL; | |
| 295 } | |
| 296 | |
| 297 void | |
| 298 YoungList::rs_length_sampling_next() { | |
| 299 assert( _curr != NULL, "invariant" ); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
300 size_t rs_length = _curr->rem_set()->occupied(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
301 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
302 _sampled_rs_lengths += rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
303 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
304 // The current region may not yet have been added to the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
305 // incremental collection set (it gets added when it is |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
306 // retired as the current allocation region). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
307 if (_curr->in_collection_set()) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
308 // Update the collection set policy information for this region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
309 _g1h->g1_policy()->update_incremental_cset_info(_curr, rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
310 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
311 |
| 342 | 312 _curr = _curr->get_next_young_region(); |
| 313 if (_curr == NULL) { | |
| 314 _last_sampled_rs_lengths = _sampled_rs_lengths; | |
| 315 // gclog_or_tty->print_cr("last sampled RS lengths = %d", _last_sampled_rs_lengths); | |
| 316 } | |
| 317 } | |
| 318 | |
| 319 void | |
| 320 YoungList::reset_auxilary_lists() { | |
| 321 guarantee( is_empty(), "young list should be empty" ); | |
| 322 assert(check_list_well_formed(), "young list should be well formed"); | |
| 323 | |
| 324 // Add survivor regions to SurvRateGroup. | |
| 325 _g1h->g1_policy()->note_start_adding_survivor_regions(); | |
| 545 | 326 _g1h->g1_policy()->finished_recalculating_age_indexes(true /* is_survivors */); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
327 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
328 int young_index_in_cset = 0; |
| 342 | 329 for (HeapRegion* curr = _survivor_head; |
| 330 curr != NULL; | |
| 331 curr = curr->get_next_young_region()) { | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
332 _g1h->g1_policy()->set_region_survivor(curr, young_index_in_cset); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
333 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
334 // The region is a non-empty survivor so let's add it to |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
335 // the incremental collection set for the next evacuation |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
336 // pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
337 _g1h->g1_policy()->add_region_to_incremental_cset_rhs(curr); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
338 young_index_in_cset += 1; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
339 } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
340 assert((size_t) young_index_in_cset == _survivor_length, |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
341 "post-condition"); |
| 342 | 342 _g1h->g1_policy()->note_stop_adding_survivor_regions(); |
| 343 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
344 _head = _survivor_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
345 _length = _survivor_length; |
| 342 | 346 if (_survivor_head != NULL) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
347 assert(_survivor_tail != NULL, "cause it shouldn't be"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
348 assert(_survivor_length > 0, "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
349 _survivor_tail->set_next_young_region(NULL); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
350 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
351 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
352 // Don't clear the survivor list handles until the start of |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
353 // the next evacuation pause - we need it in order to re-tag |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
354 // the survivor regions from this evacuation pause as 'young' |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
355 // at the start of the next. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
356 |
| 545 | 357 _g1h->g1_policy()->finished_recalculating_age_indexes(false /* is_survivors */); |
| 342 | 358 |
| 359 assert(check_list_well_formed(), "young list should be well formed"); | |
| 360 } | |
| 361 | |
| 362 void YoungList::print() { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
363 HeapRegion* lists[] = {_head, _survivor_head}; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
364 const char* names[] = {"YOUNG", "SURVIVOR"}; |
| 342 | 365 |
| 366 for (unsigned int list = 0; list < ARRAY_SIZE(lists); ++list) { | |
| 367 gclog_or_tty->print_cr("%s LIST CONTENTS", names[list]); | |
| 368 HeapRegion *curr = lists[list]; | |
| 369 if (curr == NULL) | |
| 370 gclog_or_tty->print_cr(" empty"); | |
| 371 while (curr != NULL) { | |
| 372 gclog_or_tty->print_cr(" [%08x-%08x], t: %08x, P: %08x, N: %08x, C: %08x, " | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
373 "age: %4d, y: %d, surv: %d", |
| 342 | 374 curr->bottom(), curr->end(), |
| 375 curr->top(), | |
| 376 curr->prev_top_at_mark_start(), | |
| 377 curr->next_top_at_mark_start(), | |
| 378 curr->top_at_conc_mark_count(), | |
| 379 curr->age_in_surv_rate_group_cond(), | |
| 380 curr->is_young(), | |
| 381 curr->is_survivor()); | |
| 382 curr = curr->get_next_young_region(); | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 gclog_or_tty->print_cr(""); | |
| 387 } | |
| 388 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
389 void G1CollectedHeap::push_dirty_cards_region(HeapRegion* hr) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
390 { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
391 // Claim the right to put the region on the dirty cards region list |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
392 // by installing a self pointer. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
393 HeapRegion* next = hr->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
394 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
395 HeapRegion* res = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
396 Atomic::cmpxchg_ptr(hr, hr->next_dirty_cards_region_addr(), |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
397 NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
398 if (res == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
399 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
400 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
401 // Put the region to the dirty cards region list. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
402 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
403 next = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
404 Atomic::cmpxchg_ptr(hr, &_dirty_cards_region_list, head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
405 if (next == head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
406 assert(hr->get_next_dirty_cards_region() == hr, |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
407 "hr->get_next_dirty_cards_region() != hr"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
408 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
409 // The last region in the list points to itself. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
410 hr->set_next_dirty_cards_region(hr); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
411 } else { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
412 hr->set_next_dirty_cards_region(next); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
413 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
414 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
415 } while (next != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
416 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
417 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
418 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
419 |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
420 HeapRegion* G1CollectedHeap::pop_dirty_cards_region() |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
421 { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
422 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
423 HeapRegion* hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
424 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
425 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
426 if (head == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
427 return NULL; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
428 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
429 HeapRegion* new_head = head->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
430 if (head == new_head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
431 // The last region. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
432 new_head = NULL; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
433 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
434 hr = (HeapRegion*)Atomic::cmpxchg_ptr(new_head, &_dirty_cards_region_list, |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
435 head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
436 } while (hr != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
437 assert(hr != NULL, "invariant"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
438 hr->set_next_dirty_cards_region(NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
439 return hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
440 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
441 |
| 342 | 442 void G1CollectedHeap::stop_conc_gc_threads() { |
| 794 | 443 _cg1r->stop(); |
| 342 | 444 _cmThread->stop(); |
| 445 } | |
| 446 | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
447 #ifdef ASSERT |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
448 // A region is added to the collection set as it is retired |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
449 // so an address p can point to a region which will be in the |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
450 // collection set but has not yet been retired. This method |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
451 // therefore is only accurate during a GC pause after all |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
452 // regions have been retired. It is used for debugging |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
453 // to check if an nmethod has references to objects that can |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
454 // be move during a partial collection. Though it can be |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
455 // inaccurate, it is sufficient for G1 because the conservative |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
456 // implementation of is_scavengable() for G1 will indicate that |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
457 // all nmethods must be scanned during a partial collection. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
458 bool G1CollectedHeap::is_in_partial_collection(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
459 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
460 return hr != NULL && hr->in_collection_set(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
461 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
462 #endif |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
463 |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
464 // Returns true if the reference points to an object that |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
465 // can move in an incremental collecction. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
466 bool G1CollectedHeap::is_scavengable(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
467 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
468 G1CollectorPolicy* g1p = g1h->g1_policy(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
469 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
470 if (hr == NULL) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
471 // perm gen (or null) |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
472 return false; |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
473 } else { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
474 return !hr->isHumongous(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
475 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
476 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
477 |
| 342 | 478 void G1CollectedHeap::check_ct_logs_at_safepoint() { |
| 479 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 480 CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set(); | |
| 481 | |
| 482 // Count the dirty cards at the start. | |
| 483 CountNonCleanMemRegionClosure count1(this); | |
| 484 ct_bs->mod_card_iterate(&count1); | |
| 485 int orig_count = count1.n(); | |
| 486 | |
| 487 // First clear the logged cards. | |
| 488 ClearLoggedCardTableEntryClosure clear; | |
| 489 dcqs.set_closure(&clear); | |
| 490 dcqs.apply_closure_to_all_completed_buffers(); | |
| 491 dcqs.iterate_closure_all_threads(false); | |
| 492 clear.print_histo(); | |
| 493 | |
| 494 // Now ensure that there's no dirty cards. | |
| 495 CountNonCleanMemRegionClosure count2(this); | |
| 496 ct_bs->mod_card_iterate(&count2); | |
| 497 if (count2.n() != 0) { | |
| 498 gclog_or_tty->print_cr("Card table has %d entries; %d originally", | |
| 499 count2.n(), orig_count); | |
| 500 } | |
| 501 guarantee(count2.n() == 0, "Card table should be clean."); | |
| 502 | |
| 503 RedirtyLoggedCardTableEntryClosure redirty; | |
| 504 JavaThread::dirty_card_queue_set().set_closure(&redirty); | |
| 505 dcqs.apply_closure_to_all_completed_buffers(); | |
| 506 dcqs.iterate_closure_all_threads(false); | |
| 507 gclog_or_tty->print_cr("Log entries = %d, dirty cards = %d.", | |
| 508 clear.calls(), orig_count); | |
| 509 guarantee(redirty.calls() == clear.calls(), | |
| 510 "Or else mechanism is broken."); | |
| 511 | |
| 512 CountNonCleanMemRegionClosure count3(this); | |
| 513 ct_bs->mod_card_iterate(&count3); | |
| 514 if (count3.n() != orig_count) { | |
| 515 gclog_or_tty->print_cr("Should have restored them all: orig = %d, final = %d.", | |
| 516 orig_count, count3.n()); | |
| 517 guarantee(count3.n() >= orig_count, "Should have restored them all."); | |
| 518 } | |
| 519 | |
| 520 JavaThread::dirty_card_queue_set().set_closure(_refine_cte_cl); | |
| 521 } | |
| 522 | |
| 523 // Private class members. | |
| 524 | |
| 525 G1CollectedHeap* G1CollectedHeap::_g1h; | |
| 526 | |
| 527 // Private methods. | |
| 528 | |
| 2152 | 529 HeapRegion* |
| 2361 | 530 G1CollectedHeap::new_region_try_secondary_free_list() { |
| 2152 | 531 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 532 while (!_secondary_free_list.is_empty() || free_regions_coming()) { | |
| 533 if (!_secondary_free_list.is_empty()) { | |
| 534 if (G1ConcRegionFreeingVerbose) { | |
| 535 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 536 "secondary_free_list has "SIZE_FORMAT" entries", | |
| 537 _secondary_free_list.length()); | |
| 538 } | |
| 539 // It looks as if there are free regions available on the | |
| 540 // secondary_free_list. Let's move them to the free_list and try | |
| 541 // again to allocate from it. | |
| 542 append_secondary_free_list(); | |
| 543 | |
| 544 assert(!_free_list.is_empty(), "if the secondary_free_list was not " | |
| 545 "empty we should have moved at least one entry to the free_list"); | |
| 546 HeapRegion* res = _free_list.remove_head(); | |
| 547 if (G1ConcRegionFreeingVerbose) { | |
| 548 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 549 "allocated "HR_FORMAT" from secondary_free_list", | |
| 550 HR_FORMAT_PARAMS(res)); | |
| 551 } | |
| 552 return res; | |
| 553 } | |
| 554 | |
| 555 // Wait here until we get notifed either when (a) there are no | |
| 556 // more free regions coming or (b) some regions have been moved on | |
| 557 // the secondary_free_list. | |
| 558 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 559 } | |
| 560 | |
| 561 if (G1ConcRegionFreeingVerbose) { | |
| 562 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 563 "could not allocate from secondary_free_list"); | |
| 564 } | |
| 565 return NULL; | |
| 566 } | |
| 567 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
568 HeapRegion* G1CollectedHeap::new_region(size_t word_size, bool do_expand) { |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
569 assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords, |
| 2152 | 570 "the only time we use this to allocate a humongous region is " |
| 571 "when we are allocating a single humongous region"); | |
| 572 | |
| 573 HeapRegion* res; | |
| 574 if (G1StressConcRegionFreeing) { | |
| 575 if (!_secondary_free_list.is_empty()) { | |
| 576 if (G1ConcRegionFreeingVerbose) { | |
| 577 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 578 "forced to look at the secondary_free_list"); | |
| 579 } | |
| 2361 | 580 res = new_region_try_secondary_free_list(); |
| 2152 | 581 if (res != NULL) { |
| 582 return res; | |
| 583 } | |
| 584 } | |
| 585 } | |
| 586 res = _free_list.remove_head_or_null(); | |
| 587 if (res == NULL) { | |
| 588 if (G1ConcRegionFreeingVerbose) { | |
| 589 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 590 "res == NULL, trying the secondary_free_list"); | |
| 591 } | |
| 2361 | 592 res = new_region_try_secondary_free_list(); |
| 2152 | 593 } |
| 342 | 594 if (res == NULL && do_expand) { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
595 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
596 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
597 ergo_format_reason("region allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
598 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
599 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
600 if (expand(word_size * HeapWordSize)) { |
| 3766 | 601 // Even though the heap was expanded, it might not have reached |
| 602 // the desired size. So, we cannot assume that the allocation | |
| 603 // will succeed. | |
| 604 res = _free_list.remove_head_or_null(); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
605 } |
| 342 | 606 } |
| 607 return res; | |
| 608 } | |
| 609 | |
| 3766 | 610 size_t G1CollectedHeap::humongous_obj_allocate_find_first(size_t num_regions, |
| 611 size_t word_size) { | |
| 2361 | 612 assert(isHumongous(word_size), "word_size should be humongous"); |
| 613 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 614 | |
| 3766 | 615 size_t first = G1_NULL_HRS_INDEX; |
| 2152 | 616 if (num_regions == 1) { |
| 617 // Only one region to allocate, no need to go through the slower | |
| 618 // path. The caller will attempt the expasion if this fails, so | |
| 619 // let's not try to expand here too. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
620 HeapRegion* hr = new_region(word_size, false /* do_expand */); |
| 2152 | 621 if (hr != NULL) { |
| 622 first = hr->hrs_index(); | |
| 623 } else { | |
| 3766 | 624 first = G1_NULL_HRS_INDEX; |
| 2152 | 625 } |
| 626 } else { | |
| 627 // We can't allocate humongous regions while cleanupComplete() is | |
| 628 // running, since some of the regions we find to be empty might not | |
| 629 // yet be added to the free list and it is not straightforward to | |
| 630 // know which list they are on so that we can remove them. Note | |
| 631 // that we only need to do this if we need to allocate more than | |
| 632 // one region to satisfy the current humongous allocation | |
| 633 // request. If we are only allocating one region we use the common | |
| 634 // region allocation code (see above). | |
| 635 wait_while_free_regions_coming(); | |
| 2361 | 636 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 637 |
| 638 if (free_regions() >= num_regions) { | |
| 3766 | 639 first = _hrs.find_contiguous(num_regions); |
| 640 if (first != G1_NULL_HRS_INDEX) { | |
| 641 for (size_t i = first; i < first + num_regions; ++i) { | |
| 642 HeapRegion* hr = region_at(i); | |
| 2152 | 643 assert(hr->is_empty(), "sanity"); |
| 2361 | 644 assert(is_on_master_free_list(hr), "sanity"); |
| 2152 | 645 hr->set_pending_removal(true); |
| 646 } | |
| 647 _free_list.remove_all_pending(num_regions); | |
| 648 } | |
| 649 } | |
| 650 } | |
| 651 return first; | |
| 652 } | |
| 653 | |
| 2361 | 654 HeapWord* |
| 3766 | 655 G1CollectedHeap::humongous_obj_allocate_initialize_regions(size_t first, |
| 2361 | 656 size_t num_regions, |
| 657 size_t word_size) { | |
| 3766 | 658 assert(first != G1_NULL_HRS_INDEX, "pre-condition"); |
| 2361 | 659 assert(isHumongous(word_size), "word_size should be humongous"); |
| 660 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 661 | |
| 662 // Index of last region in the series + 1. | |
| 3766 | 663 size_t last = first + num_regions; |
| 2361 | 664 |
| 665 // We need to initialize the region(s) we just discovered. This is | |
| 666 // a bit tricky given that it can happen concurrently with | |
| 667 // refinement threads refining cards on these regions and | |
| 668 // potentially wanting to refine the BOT as they are scanning | |
| 669 // those cards (this can happen shortly after a cleanup; see CR | |
| 670 // 6991377). So we have to set up the region(s) carefully and in | |
| 671 // a specific order. | |
| 672 | |
| 673 // The word size sum of all the regions we will allocate. | |
| 674 size_t word_size_sum = num_regions * HeapRegion::GrainWords; | |
| 675 assert(word_size <= word_size_sum, "sanity"); | |
| 676 | |
| 677 // This will be the "starts humongous" region. | |
| 3766 | 678 HeapRegion* first_hr = region_at(first); |
| 2361 | 679 // The header of the new object will be placed at the bottom of |
| 680 // the first region. | |
| 681 HeapWord* new_obj = first_hr->bottom(); | |
| 682 // This will be the new end of the first region in the series that | |
| 683 // should also match the end of the last region in the seriers. | |
| 684 HeapWord* new_end = new_obj + word_size_sum; | |
| 685 // This will be the new top of the first region that will reflect | |
| 686 // this allocation. | |
| 687 HeapWord* new_top = new_obj + word_size; | |
| 688 | |
| 689 // First, we need to zero the header of the space that we will be | |
| 690 // allocating. When we update top further down, some refinement | |
| 691 // threads might try to scan the region. By zeroing the header we | |
| 692 // ensure that any thread that will try to scan the region will | |
| 693 // come across the zero klass word and bail out. | |
| 694 // | |
| 695 // NOTE: It would not have been correct to have used | |
| 696 // CollectedHeap::fill_with_object() and make the space look like | |
| 697 // an int array. The thread that is doing the allocation will | |
| 698 // later update the object header to a potentially different array | |
| 699 // type and, for a very short period of time, the klass and length | |
| 700 // fields will be inconsistent. This could cause a refinement | |
| 701 // thread to calculate the object size incorrectly. | |
| 702 Copy::fill_to_words(new_obj, oopDesc::header_size(), 0); | |
| 703 | |
| 704 // We will set up the first region as "starts humongous". This | |
| 705 // will also update the BOT covering all the regions to reflect | |
| 706 // that there is a single object that starts at the bottom of the | |
| 707 // first region. | |
| 708 first_hr->set_startsHumongous(new_top, new_end); | |
| 709 | |
| 710 // Then, if there are any, we will set up the "continues | |
| 711 // humongous" regions. | |
| 712 HeapRegion* hr = NULL; | |
| 3766 | 713 for (size_t i = first + 1; i < last; ++i) { |
| 714 hr = region_at(i); | |
| 2361 | 715 hr->set_continuesHumongous(first_hr); |
| 716 } | |
| 717 // If we have "continues humongous" regions (hr != NULL), then the | |
| 718 // end of the last one should match new_end. | |
| 719 assert(hr == NULL || hr->end() == new_end, "sanity"); | |
| 720 | |
| 721 // Up to this point no concurrent thread would have been able to | |
| 722 // do any scanning on any region in this series. All the top | |
| 723 // fields still point to bottom, so the intersection between | |
| 724 // [bottom,top] and [card_start,card_end] will be empty. Before we | |
| 725 // update the top fields, we'll do a storestore to make sure that | |
| 726 // no thread sees the update to top before the zeroing of the | |
| 727 // object header and the BOT initialization. | |
| 728 OrderAccess::storestore(); | |
| 729 | |
| 730 // Now that the BOT and the object header have been initialized, | |
| 731 // we can update top of the "starts humongous" region. | |
| 732 assert(first_hr->bottom() < new_top && new_top <= first_hr->end(), | |
| 733 "new_top should be in this region"); | |
| 734 first_hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
735 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
736 HeapWord* bottom = first_hr->bottom(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
737 HeapWord* end = first_hr->orig_end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
738 if ((first + 1) == last) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
739 // the series has a single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
740 _hr_printer.alloc(G1HRPrinter::SingleHumongous, first_hr, new_top); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
741 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
742 // the series has more than one humongous regions |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
743 _hr_printer.alloc(G1HRPrinter::StartsHumongous, first_hr, end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
744 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
745 } |
| 2361 | 746 |
| 747 // Now, we will update the top fields of the "continues humongous" | |
| 748 // regions. The reason we need to do this is that, otherwise, | |
| 749 // these regions would look empty and this will confuse parts of | |
| 750 // G1. For example, the code that looks for a consecutive number | |
| 751 // of empty regions will consider them empty and try to | |
| 752 // re-allocate them. We can extend is_empty() to also include | |
| 753 // !continuesHumongous(), but it is easier to just update the top | |
| 754 // fields here. The way we set top for all regions (i.e., top == | |
| 755 // end for all regions but the last one, top == new_top for the | |
| 756 // last one) is actually used when we will free up the humongous | |
| 757 // region in free_humongous_region(). | |
| 758 hr = NULL; | |
| 3766 | 759 for (size_t i = first + 1; i < last; ++i) { |
| 760 hr = region_at(i); | |
| 2361 | 761 if ((i + 1) == last) { |
| 762 // last continues humongous region | |
| 763 assert(hr->bottom() < new_top && new_top <= hr->end(), | |
| 764 "new_top should fall on this region"); | |
| 765 hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
766 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, new_top); |
| 2361 | 767 } else { |
| 768 // not last one | |
| 769 assert(new_top > hr->end(), "new_top should be above this region"); | |
| 770 hr->set_top(hr->end()); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
771 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, hr->end()); |
| 2361 | 772 } |
| 773 } | |
| 774 // If we have continues humongous regions (hr != NULL), then the | |
| 775 // end of the last one should match new_end and its top should | |
| 776 // match new_top. | |
| 777 assert(hr == NULL || | |
| 778 (hr->end() == new_end && hr->top() == new_top), "sanity"); | |
| 779 | |
| 780 assert(first_hr->used() == word_size * HeapWordSize, "invariant"); | |
| 781 _summary_bytes_used += first_hr->used(); | |
| 782 _humongous_set.add(first_hr); | |
| 783 | |
| 784 return new_obj; | |
| 785 } | |
| 786 | |
| 342 | 787 // If could fit into free regions w/o expansion, try. |
| 788 // Otherwise, if can expand, do so. | |
| 789 // Otherwise, if using ex regions might help, try with ex given back. | |
| 1973 | 790 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) { |
| 2152 | 791 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
| 792 | |
| 793 verify_region_sets_optional(); | |
| 342 | 794 |
| 795 size_t num_regions = | |
| 1973 | 796 round_to(word_size, HeapRegion::GrainWords) / HeapRegion::GrainWords; |
| 342 | 797 size_t x_size = expansion_regions(); |
| 3766 | 798 size_t fs = _hrs.free_suffix(); |
| 799 size_t first = humongous_obj_allocate_find_first(num_regions, word_size); | |
| 800 if (first == G1_NULL_HRS_INDEX) { | |
| 2152 | 801 // The only thing we can do now is attempt expansion. |
| 342 | 802 if (fs + x_size >= num_regions) { |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
803 // If the number of regions we're trying to allocate for this |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
804 // object is at most the number of regions in the free suffix, |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
805 // then the call to humongous_obj_allocate_find_first() above |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
806 // should have succeeded and we wouldn't be here. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
807 // |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
808 // We should only be trying to expand when the free suffix is |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
809 // not sufficient for the object _and_ we have some expansion |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
810 // room available. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
811 assert(num_regions > fs, "earlier allocation should have succeeded"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
812 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
813 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
814 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
815 ergo_format_reason("humongous allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
816 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
817 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
818 if (expand((num_regions - fs) * HeapRegion::GrainBytes)) { |
| 3766 | 819 // Even though the heap was expanded, it might not have |
| 820 // reached the desired size. So, we cannot assume that the | |
| 821 // allocation will succeed. | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
822 first = humongous_obj_allocate_find_first(num_regions, word_size); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
823 } |
| 2152 | 824 } |
| 825 } | |
| 826 | |
| 2361 | 827 HeapWord* result = NULL; |
| 3766 | 828 if (first != G1_NULL_HRS_INDEX) { |
| 2361 | 829 result = |
| 830 humongous_obj_allocate_initialize_regions(first, num_regions, word_size); | |
| 831 assert(result != NULL, "it should always return a valid result"); | |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
832 |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
833 // A successful humongous object allocation changes the used space |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
834 // information of the old generation so we need to recalculate the |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
835 // sizes and update the jstat counters here. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
836 g1mm()->update_sizes(); |
| 2152 | 837 } |
| 838 | |
| 839 verify_region_sets_optional(); | |
| 2361 | 840 |
| 841 return result; | |
| 342 | 842 } |
| 843 | |
| 1973 | 844 HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) { |
| 845 assert_heap_not_locked_and_not_at_safepoint(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
846 assert(!isHumongous(word_size), "we do not allow humongous TLABs"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
847 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
848 unsigned int dummy_gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
849 return attempt_allocation(word_size, &dummy_gc_count_before); |
| 342 | 850 } |
| 851 | |
| 852 HeapWord* | |
| 853 G1CollectedHeap::mem_allocate(size_t word_size, | |
| 1973 | 854 bool* gc_overhead_limit_was_exceeded) { |
| 855 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 856 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
857 // Loop until the allocation is satisified, or unsatisfied after GC. |
| 1973 | 858 for (int try_count = 1; /* we'll return */; try_count += 1) { |
| 859 unsigned int gc_count_before; | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
860 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
861 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
862 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
863 result = attempt_allocation(word_size, &gc_count_before); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
864 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
865 result = attempt_allocation_humongous(word_size, &gc_count_before); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
866 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
867 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
868 return result; |
| 342 | 869 } |
| 870 | |
| 871 // Create the garbage collection operation... | |
| 1973 | 872 VM_G1CollectForAllocation op(gc_count_before, word_size); |
| 342 | 873 // ...and get the VM thread to execute it. |
| 874 VMThread::execute(&op); | |
| 1973 | 875 |
| 876 if (op.prologue_succeeded() && op.pause_succeeded()) { | |
| 877 // If the operation was successful we'll return the result even | |
| 878 // if it is NULL. If the allocation attempt failed immediately | |
| 879 // after a Full GC, it's unlikely we'll be able to allocate now. | |
| 880 HeapWord* result = op.result(); | |
| 881 if (result != NULL && !isHumongous(word_size)) { | |
| 882 // Allocations that take place on VM operations do not do any | |
| 883 // card dirtying and we have to do it here. We only have to do | |
| 884 // this for non-humongous allocations, though. | |
| 885 dirty_young_block(result, word_size); | |
| 886 } | |
| 342 | 887 return result; |
| 1973 | 888 } else { |
| 889 assert(op.result() == NULL, | |
| 890 "the result should be NULL if the VM op did not succeed"); | |
| 342 | 891 } |
| 892 | |
| 893 // Give a warning if we seem to be looping forever. | |
| 894 if ((QueuedAllocationWarningCount > 0) && | |
| 895 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 1973 | 896 warning("G1CollectedHeap::mem_allocate retries %d times", try_count); |
| 342 | 897 } |
| 898 } | |
| 1973 | 899 |
| 900 ShouldNotReachHere(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
901 return NULL; |
| 342 | 902 } |
| 903 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
904 HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
905 unsigned int *gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
906 // Make sure you read the note in attempt_allocation_humongous(). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
907 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
908 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
909 assert(!isHumongous(word_size), "attempt_allocation_slow() should not " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
910 "be called for humongous allocation requests"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
911 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
912 // We should only get here after the first-level allocation attempt |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
913 // (attempt_allocation()) failed to allocate. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
914 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
915 // We will loop until a) we manage to successfully perform the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
916 // allocation or b) we successfully schedule a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
917 // fails to perform the allocation. b) is the only case when we'll |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
918 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
919 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
920 for (int try_count = 1; /* we'll return */; try_count += 1) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
921 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
922 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
923 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
924 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
925 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
926 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
927 result = _mutator_alloc_region.attempt_allocation_locked(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
928 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
929 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
930 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
931 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
932 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
933 // If we reach here, attempt_allocation_locked() above failed to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
934 // allocate a new region. So the mutator alloc region should be NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
935 assert(_mutator_alloc_region.get() == NULL, "only way to get here"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
936 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
937 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
938 if (g1_policy()->can_expand_young_list()) { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
939 // No need for an ergo verbose message here, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
940 // can_expand_young_list() does this when it returns true. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
941 result = _mutator_alloc_region.attempt_allocation_force(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
942 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
943 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
944 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
945 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
946 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
947 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
948 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
949 // Read the GC count while still holding the Heap_lock. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
950 gc_count_before = SharedHeap::heap()->total_collections(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
951 should_try_gc = true; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
952 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
953 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
954 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
955 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
956 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
957 result = do_collection_pause(word_size, gc_count_before, &succeeded); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
958 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
959 assert(succeeded, "only way to get back a non-NULL result"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
960 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
961 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
962 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
963 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
964 // If we get here we successfully scheduled a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
965 // failed to allocate. No point in trying to allocate |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
966 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
967 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
968 *gc_count_before_ret = SharedHeap::heap()->total_collections(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
969 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
970 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
971 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
972 GC_locker::stall_until_clear(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
973 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
974 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
975 // We can reach here if we were unsuccessul in scheduling a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
976 // collection (because another thread beat us to it) or if we were |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
977 // stalled due to the GC locker. In either can we should retry the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
978 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
979 // performed a collection and reclaimed enough space. We do the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
980 // first attempt (without holding the Heap_lock) here and the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
981 // follow-on attempt will be at the start of the next loop |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
982 // iteration (after taking the Heap_lock). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
983 result = _mutator_alloc_region.attempt_allocation(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
984 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
985 if (result != NULL ){ |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
986 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
987 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
988 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
989 // Give a warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
990 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
991 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
992 warning("G1CollectedHeap::attempt_allocation_slow() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
993 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
994 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
995 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
996 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
997 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
998 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
999 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1000 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1001 HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1002 unsigned int * gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1003 // The structure of this method has a lot of similarities to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1004 // attempt_allocation_slow(). The reason these two were not merged |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1005 // into a single one is that such a method would require several "if |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1006 // allocation is not humongous do this, otherwise do that" |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1007 // conditional paths which would obscure its flow. In fact, an early |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1008 // version of this code did use a unified method which was harder to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1009 // follow and, as a result, it had subtle bugs that were hard to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1010 // track down. So keeping these two methods separate allows each to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1011 // be more readable. It will be good to keep these two in sync as |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1012 // much as possible. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1013 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1014 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1015 assert(isHumongous(word_size), "attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1016 "should only be called for humongous allocations"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1017 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1018 // We will loop until a) we manage to successfully perform the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1019 // allocation or b) we successfully schedule a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1020 // fails to perform the allocation. b) is the only case when we'll |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1021 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1022 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1023 for (int try_count = 1; /* we'll return */; try_count += 1) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1024 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1025 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1026 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1027 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1028 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1029 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1030 // Given that humongous objects are not allocated in young |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1031 // regions, we'll first try to do the allocation without doing a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1032 // collection hoping that there's enough space in the heap. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1033 result = humongous_obj_allocate(word_size); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1034 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1035 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1036 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1037 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1038 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1039 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1040 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1041 // Read the GC count while still holding the Heap_lock. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1042 gc_count_before = SharedHeap::heap()->total_collections(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1043 should_try_gc = true; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1044 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1045 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1046 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1047 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1048 // If we failed to allocate the humongous object, we should try to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1049 // do a collection pause (if we're allowed) in case it reclaims |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1050 // enough space for the allocation to succeed after the pause. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1051 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1052 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1053 result = do_collection_pause(word_size, gc_count_before, &succeeded); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1054 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1055 assert(succeeded, "only way to get back a non-NULL result"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1056 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1057 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1058 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1059 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1060 // If we get here we successfully scheduled a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1061 // failed to allocate. No point in trying to allocate |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1062 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1063 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1064 *gc_count_before_ret = SharedHeap::heap()->total_collections(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1065 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1066 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1067 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1068 GC_locker::stall_until_clear(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1069 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1070 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1071 // We can reach here if we were unsuccessul in scheduling a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1072 // collection (because another thread beat us to it) or if we were |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1073 // stalled due to the GC locker. In either can we should retry the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1074 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1075 // performed a collection and reclaimed enough space. Give a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1076 // warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1077 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1078 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1079 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1080 warning("G1CollectedHeap::attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1081 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1082 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1083 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1084 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1085 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1086 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1087 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1088 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1089 HeapWord* G1CollectedHeap::attempt_allocation_at_safepoint(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1090 bool expect_null_mutator_alloc_region) { |
| 2152 | 1091 assert_at_safepoint(true /* should_be_vm_thread */); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1092 assert(_mutator_alloc_region.get() == NULL || |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1093 !expect_null_mutator_alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1094 "the current alloc region was unexpectedly found to be non-NULL"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1095 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1096 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1097 return _mutator_alloc_region.attempt_allocation_locked(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1098 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1099 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1100 return humongous_obj_allocate(word_size); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1101 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1102 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1103 ShouldNotReachHere(); |
| 342 | 1104 } |
| 1105 | |
| 1106 class PostMCRemSetClearClosure: public HeapRegionClosure { | |
| 1107 ModRefBarrierSet* _mr_bs; | |
| 1108 public: | |
| 1109 PostMCRemSetClearClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {} | |
| 1110 bool doHeapRegion(HeapRegion* r) { | |
| 1111 r->reset_gc_time_stamp(); | |
| 1112 if (r->continuesHumongous()) | |
| 1113 return false; | |
| 1114 HeapRegionRemSet* hrrs = r->rem_set(); | |
| 1115 if (hrrs != NULL) hrrs->clear(); | |
| 1116 // You might think here that we could clear just the cards | |
| 1117 // corresponding to the used region. But no: if we leave a dirty card | |
| 1118 // in a region we might allocate into, then it would prevent that card | |
| 1119 // from being enqueued, and cause it to be missed. | |
| 1120 // Re: the performance cost: we shouldn't be doing full GC anyway! | |
| 1121 _mr_bs->clear(MemRegion(r->bottom(), r->end())); | |
| 1122 return false; | |
| 1123 } | |
| 1124 }; | |
| 1125 | |
| 1126 | |
| 1127 class PostMCRemSetInvalidateClosure: public HeapRegionClosure { | |
| 1128 ModRefBarrierSet* _mr_bs; | |
| 1129 public: | |
| 1130 PostMCRemSetInvalidateClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {} | |
| 1131 bool doHeapRegion(HeapRegion* r) { | |
| 1132 if (r->continuesHumongous()) return false; | |
| 1133 if (r->used_region().word_size() != 0) { | |
| 1134 _mr_bs->invalidate(r->used_region(), true /*whole heap*/); | |
| 1135 } | |
| 1136 return false; | |
| 1137 } | |
| 1138 }; | |
| 1139 | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1140 class RebuildRSOutOfRegionClosure: public HeapRegionClosure { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1141 G1CollectedHeap* _g1h; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1142 UpdateRSOopClosure _cl; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1143 int _worker_i; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1144 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1145 RebuildRSOutOfRegionClosure(G1CollectedHeap* g1, int worker_i = 0) : |
| 1861 | 1146 _cl(g1->g1_rem_set(), worker_i), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1147 _worker_i(worker_i), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1148 _g1h(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1149 { } |
|
1960
878b57474103
6978187: G1: assert(ParallelGCThreads> 1 || n_yielded() == _hrrs->occupied()) strikes again
johnc
parents:
1883
diff
changeset
|
1150 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1151 bool doHeapRegion(HeapRegion* r) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1152 if (!r->continuesHumongous()) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1153 _cl.set_from(r); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1154 r->oop_iterate(&_cl); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1155 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1156 return false; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1157 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1158 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1159 |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1160 class ParRebuildRSTask: public AbstractGangTask { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1161 G1CollectedHeap* _g1; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1162 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1163 ParRebuildRSTask(G1CollectedHeap* g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1164 : AbstractGangTask("ParRebuildRSTask"), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1165 _g1(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1166 { } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1167 |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1168 void work(int i) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1169 RebuildRSOutOfRegionClosure rebuild_rs(_g1, i); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1170 _g1->heap_region_par_iterate_chunked(&rebuild_rs, i, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1171 _g1->workers()->active_workers(), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1172 HeapRegion::RebuildRSClaimValue); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1173 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1174 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1175 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1176 class PostCompactionPrinterClosure: public HeapRegionClosure { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1177 private: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1178 G1HRPrinter* _hr_printer; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1179 public: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1180 bool doHeapRegion(HeapRegion* hr) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1181 assert(!hr->is_young(), "not expecting to find young regions"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1182 // We only generate output for non-empty regions. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1183 if (!hr->is_empty()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1184 if (!hr->isHumongous()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1185 _hr_printer->post_compaction(hr, G1HRPrinter::Old); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1186 } else if (hr->startsHumongous()) { |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
1187 if (hr->capacity() == HeapRegion::GrainBytes) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1188 // single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1189 _hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1190 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1191 _hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1192 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1193 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1194 assert(hr->continuesHumongous(), "only way to get here"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1195 _hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1196 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1197 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1198 return false; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1199 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1200 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1201 PostCompactionPrinterClosure(G1HRPrinter* hr_printer) |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1202 : _hr_printer(hr_printer) { } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1203 }; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1204 |
| 1973 | 1205 bool G1CollectedHeap::do_collection(bool explicit_gc, |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1206 bool clear_all_soft_refs, |
| 342 | 1207 size_t word_size) { |
| 2152 | 1208 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1209 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1210 if (GC_locker::check_active_before_gc()) { |
| 1973 | 1211 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1212 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1213 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
1214 SvcGCMarker sgcm(SvcGCMarker::FULL); |
| 342 | 1215 ResourceMark rm; |
| 1216 | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1217 if (PrintHeapAtGC) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1218 Universe::print_heap_before_gc(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1219 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1220 |
| 4072 | 1221 HRSPhaseSetter x(HRSPhaseFullGC); |
| 2152 | 1222 verify_region_sets_optional(); |
| 342 | 1223 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1224 const bool do_clear_all_soft_refs = clear_all_soft_refs || |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1225 collector_policy()->should_clear_all_soft_refs(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1226 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1227 ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy()); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1228 |
| 342 | 1229 { |
| 1230 IsGCActiveMark x; | |
| 1231 | |
| 1232 // Timing | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1233 bool system_gc = (gc_cause() == GCCause::_java_lang_system_gc); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1234 assert(!system_gc || explicit_gc, "invariant"); |
| 342 | 1235 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); |
| 1236 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1237 TraceTime t(system_gc ? "Full GC (System.gc())" : "Full GC", |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1238 PrintGC, true, gclog_or_tty); |
| 342 | 1239 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
1240 TraceCollectorStats tcs(g1mm()->full_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
1241 TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1242 |
| 342 | 1243 double start = os::elapsedTime(); |
| 1244 g1_policy()->record_full_collection_start(); | |
| 1245 | |
| 2152 | 1246 wait_while_free_regions_coming(); |
| 2361 | 1247 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 1248 |
| 342 | 1249 gc_prologue(true); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1250 increment_total_collections(true /* full gc */); |
| 342 | 1251 |
| 1252 size_t g1h_prev_used = used(); | |
| 1253 assert(used() == recalculate_used(), "Should be equal"); | |
| 1254 | |
| 1255 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { | |
| 1256 HandleMark hm; // Discard invalid handles created during verification | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1257 gclog_or_tty->print(" VerifyBeforeGC:"); |
| 342 | 1258 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1259 Universe::verify(/* allow dirty */ true, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1260 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1261 /* option */ VerifyOption_G1UsePrevMarking); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1262 |
| 342 | 1263 } |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1264 pre_full_gc_dump(); |
| 342 | 1265 |
| 1266 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
| 1267 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1268 // Disable discovery and empty the discovered lists |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1269 // for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1270 ref_processor_cm()->disable_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1271 ref_processor_cm()->abandon_partial_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1272 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1273 |
| 1274 // Abandon current iterations of concurrent marking and concurrent | |
| 1275 // refinement, if any are in progress. | |
| 1276 concurrent_mark()->abort(); | |
| 1277 | |
| 1278 // Make sure we'll choose a new allocation region afterwards. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1279 release_mutator_alloc_region(); |
| 636 | 1280 abandon_gc_alloc_regions(); |
| 1861 | 1281 g1_rem_set()->cleanupHRRS(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1282 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1283 // We should call this after we retire any currently active alloc |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1284 // regions so that all the ALLOC / RETIRE events are generated |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1285 // before the start GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1286 _hr_printer.start_gc(true /* full */, (size_t) total_collections()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1287 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1288 // We may have added regions to the current incremental collection |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1289 // set between the last GC or pause and now. We need to clear the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1290 // incremental collection set and then start rebuilding it afresh |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1291 // after this full GC. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1292 abandon_collection_set(g1_policy()->inc_cset_head()); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1293 g1_policy()->clear_incremental_cset(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1294 g1_policy()->stop_incremental_cset_building(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1295 |
| 4072 | 1296 tear_down_region_sets(false /* free_list_only */); |
| 4710 | 1297 g1_policy()->set_gcs_are_young(true); |
| 342 | 1298 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1299 // See the comments in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1300 // G1CollectedHeap::ref_processing_init() about |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1301 // how reference processing currently works in G1. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1302 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1303 // Temporarily make discovery by the STW ref processor single threaded (non-MT). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1304 ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1305 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1306 // Temporarily clear the STW ref processor's _is_alive_non_header field. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1307 ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1308 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1309 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1310 ref_processor_stw()->setup_policy(do_clear_all_soft_refs); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1311 |
| 342 | 1312 // Do collection work |
| 1313 { | |
| 1314 HandleMark hm; // Discard invalid handles created during gc | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1315 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs); |
| 342 | 1316 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1317 |
| 2152 | 1318 assert(free_regions() == 0, "we should not have added any free regions"); |
| 4072 | 1319 rebuild_region_sets(false /* free_list_only */); |
| 342 | 1320 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1321 // Enqueue any discovered reference objects that have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1322 // not been removed from the discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1323 ref_processor_stw()->enqueue_discovered_references(); |
| 342 | 1324 |
| 1325 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
| 1326 | |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1327 MemoryService::track_memory_usage(); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1328 |
| 342 | 1329 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { |
| 1330 HandleMark hm; // Discard invalid handles created during verification | |
| 1331 gclog_or_tty->print(" VerifyAfterGC:"); | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
1332 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1333 Universe::verify(/* allow dirty */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1334 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1335 /* option */ VerifyOption_G1UsePrevMarking); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1336 |
| 342 | 1337 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1338 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1339 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1340 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1341 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1342 // Note: since we've just done a full GC, concurrent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1343 // marking is no longer active. Therefore we need not |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1344 // re-enable reference discovery for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1345 // That will be done at the start of the next marking cycle. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1346 assert(!ref_processor_cm()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1347 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1348 |
| 1349 reset_gc_time_stamp(); | |
| 1350 // Since everything potentially moved, we will clear all remembered | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1351 // sets, and clear all cards. Later we will rebuild remebered |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1352 // sets. We will also reset the GC time stamps of the regions. |
| 342 | 1353 PostMCRemSetClearClosure rs_clear(mr_bs()); |
| 1354 heap_region_iterate(&rs_clear); | |
| 1355 | |
| 1356 // Resize the heap if necessary. | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1357 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size); |
| 342 | 1358 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1359 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1360 // We should do this after we potentially resize the heap so |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1361 // that all the COMMIT / UNCOMMIT events are generated before |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1362 // the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1363 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1364 PostCompactionPrinterClosure cl(hr_printer()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1365 heap_region_iterate(&cl); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1366 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1367 _hr_printer.end_gc(true /* full */, (size_t) total_collections()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1368 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1369 |
| 342 | 1370 if (_cg1r->use_cache()) { |
| 1371 _cg1r->clear_and_record_card_counts(); | |
| 1372 _cg1r->clear_hot_cache(); | |
| 1373 } | |
| 1374 | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1375 // Rebuild remembered sets of all regions. |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
1376 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1377 int n_workers = |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1378 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1379 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1380 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1381 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1382 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1383 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1384 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1385 // Set parallel threads in the heap (_n_par_threads) only |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1386 // before a parallel phase and always reset it to 0 after |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1387 // the phase so that the number of parallel threads does |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1388 // no get carried forward to a serial phase where there |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1389 // may be code that is "possibly_parallel". |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1390 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1391 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1392 ParRebuildRSTask rebuild_rs_task(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1393 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1394 HeapRegion::InitialClaimValue), "sanity check"); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1395 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1396 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1397 "Unless dynamic should use total workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1398 // Use the most recent number of active workers |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1399 assert(workers()->active_workers() > 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1400 "Active workers not properly set"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1401 set_par_threads(workers()->active_workers()); |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1402 workers()->run_task(&rebuild_rs_task); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1403 set_par_threads(0); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1404 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1405 HeapRegion::RebuildRSClaimValue), "sanity check"); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1406 reset_heap_region_claim_values(); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1407 } else { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1408 RebuildRSOutOfRegionClosure rebuild_rs(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1409 heap_region_iterate(&rebuild_rs); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1410 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1411 |
| 342 | 1412 if (PrintGC) { |
| 1413 print_size_transition(gclog_or_tty, g1h_prev_used, used(), capacity()); | |
| 1414 } | |
| 1415 | |
| 1416 if (true) { // FIXME | |
| 1417 // Ask the permanent generation to adjust size for full collections | |
| 1418 perm()->compute_new_size(); | |
| 1419 } | |
| 1420 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1421 // Start a new incremental collection set for the next pause |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1422 assert(g1_policy()->collection_set() == NULL, "must be"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1423 g1_policy()->start_incremental_cset_building(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1424 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1425 // Clear the _cset_fast_test bitmap in anticipation of adding |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1426 // regions to the incremental collection set for the next |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1427 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1428 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1429 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1430 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1431 |
| 342 | 1432 double end = os::elapsedTime(); |
| 1433 g1_policy()->record_full_collection_end(); | |
| 1434 | |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1435 #ifdef TRACESPINNING |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1436 ParallelTaskTerminator::print_termination_counts(); |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1437 #endif |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1438 |
| 342 | 1439 gc_epilogue(true); |
| 1440 | |
| 794 | 1441 // Discard all rset updates |
| 1442 JavaThread::dirty_card_queue_set().abandon_logs(); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1443 assert(!G1DeferredRSUpdate |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1444 || (G1DeferredRSUpdate && (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any"); |
| 342 | 1445 } |
| 1446 | |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1447 _young_list->reset_sampled_info(); |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1448 // At this point there should be no regions in the |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1449 // entire heap tagged as young. |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1450 assert( check_young_list_empty(true /* check_heap */), |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1451 "young list should be empty at this point"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1452 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1453 // Update the number of full collections that have been completed. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
1454 increment_full_collections_completed(false /* concurrent */); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1455 |
| 3766 | 1456 _hrs.verify_optional(); |
| 2152 | 1457 verify_region_sets_optional(); |
| 1458 | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1459 if (PrintHeapAtGC) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1460 Universe::print_heap_after_gc(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1461 } |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1462 g1mm()->update_sizes(); |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1463 post_full_gc_dump(); |
| 1973 | 1464 |
| 1465 return true; | |
| 342 | 1466 } |
| 1467 | |
| 1468 void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) { | |
| 1973 | 1469 // do_collection() will return whether it succeeded in performing |
| 1470 // the GC. Currently, there is no facility on the | |
| 1471 // do_full_collection() API to notify the caller than the collection | |
| 1472 // did not succeed (e.g., because it was locked out by the GC | |
| 1473 // locker). So, right now, we'll ignore the return value. | |
| 1474 bool dummy = do_collection(true, /* explicit_gc */ | |
| 1475 clear_all_soft_refs, | |
| 1476 0 /* word_size */); | |
| 342 | 1477 } |
| 1478 | |
| 1479 // This code is mostly copied from TenuredGeneration. | |
| 1480 void | |
| 1481 G1CollectedHeap:: | |
| 1482 resize_if_necessary_after_full_collection(size_t word_size) { | |
| 1483 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, "sanity check"); | |
| 1484 | |
| 1485 // Include the current allocation, if any, and bytes that will be | |
| 1486 // pre-allocated to support collections, as "used". | |
| 1487 const size_t used_after_gc = used(); | |
| 1488 const size_t capacity_after_gc = capacity(); | |
| 1489 const size_t free_after_gc = capacity_after_gc - used_after_gc; | |
| 1490 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1491 // This is enforced in arguments.cpp. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1492 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1493 "otherwise the code below doesn't make sense"); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1494 |
| 342 | 1495 // We don't have floating point command-line arguments |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1496 const double minimum_free_percentage = (double) MinHeapFreeRatio / 100.0; |
| 342 | 1497 const double maximum_used_percentage = 1.0 - minimum_free_percentage; |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1498 const double maximum_free_percentage = (double) MaxHeapFreeRatio / 100.0; |
| 342 | 1499 const double minimum_used_percentage = 1.0 - maximum_free_percentage; |
| 1500 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1501 const size_t min_heap_size = collector_policy()->min_heap_byte_size(); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1502 const size_t max_heap_size = collector_policy()->max_heap_byte_size(); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1503 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1504 // We have to be careful here as these two calculations can overflow |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1505 // 32-bit size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1506 double used_after_gc_d = (double) used_after_gc; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1507 double minimum_desired_capacity_d = used_after_gc_d / maximum_used_percentage; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1508 double maximum_desired_capacity_d = used_after_gc_d / minimum_used_percentage; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1509 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1510 // Let's make sure that they are both under the max heap size, which |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1511 // by default will make them fit into a size_t. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1512 double desired_capacity_upper_bound = (double) max_heap_size; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1513 minimum_desired_capacity_d = MIN2(minimum_desired_capacity_d, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1514 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1515 maximum_desired_capacity_d = MIN2(maximum_desired_capacity_d, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1516 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1517 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1518 // We can now safely turn them into size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1519 size_t minimum_desired_capacity = (size_t) minimum_desired_capacity_d; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1520 size_t maximum_desired_capacity = (size_t) maximum_desired_capacity_d; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1521 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1522 // This assert only makes sense here, before we adjust them |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1523 // with respect to the min and max heap size. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1524 assert(minimum_desired_capacity <= maximum_desired_capacity, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1525 err_msg("minimum_desired_capacity = "SIZE_FORMAT", " |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1526 "maximum_desired_capacity = "SIZE_FORMAT, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1527 minimum_desired_capacity, maximum_desired_capacity)); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1528 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1529 // Should not be greater than the heap max size. No need to adjust |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1530 // it with respect to the heap min size as it's a lower bound (i.e., |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1531 // we'll try to make the capacity larger than it, not smaller). |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1532 minimum_desired_capacity = MIN2(minimum_desired_capacity, max_heap_size); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1533 // Should not be less than the heap min size. No need to adjust it |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1534 // with respect to the heap max size as it's an upper bound (i.e., |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1535 // we'll try to make the capacity smaller than it, not greater). |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1536 maximum_desired_capacity = MAX2(maximum_desired_capacity, min_heap_size); |
| 342 | 1537 |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1538 if (capacity_after_gc < minimum_desired_capacity) { |
| 342 | 1539 // Don't expand unless it's significant |
| 1540 size_t expand_bytes = minimum_desired_capacity - capacity_after_gc; | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1541 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1542 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1543 ergo_format_reason("capacity lower than " |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1544 "min desired capacity after Full GC") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1545 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1546 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1547 ergo_format_byte_perc("min desired capacity"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1548 capacity_after_gc, used_after_gc, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1549 minimum_desired_capacity, (double) MinHeapFreeRatio); |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1550 expand(expand_bytes); |
| 342 | 1551 |
| 1552 // No expansion, now see if we want to shrink | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1553 } else if (capacity_after_gc > maximum_desired_capacity) { |
| 342 | 1554 // Capacity too large, compute shrinking size |
| 1555 size_t shrink_bytes = capacity_after_gc - maximum_desired_capacity; | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1556 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1557 "attempt heap shrinking", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1558 ergo_format_reason("capacity higher than " |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1559 "max desired capacity after Full GC") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1560 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1561 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1562 ergo_format_byte_perc("max desired capacity"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1563 capacity_after_gc, used_after_gc, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1564 maximum_desired_capacity, (double) MaxHeapFreeRatio); |
| 342 | 1565 shrink(shrink_bytes); |
| 1566 } | |
| 1567 } | |
| 1568 | |
| 1569 | |
| 1570 HeapWord* | |
| 1973 | 1571 G1CollectedHeap::satisfy_failed_allocation(size_t word_size, |
| 1572 bool* succeeded) { | |
| 2152 | 1573 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1973 | 1574 |
| 1575 *succeeded = true; | |
| 1576 // Let's attempt the allocation first. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1577 HeapWord* result = |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1578 attempt_allocation_at_safepoint(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1579 false /* expect_null_mutator_alloc_region */); |
| 1973 | 1580 if (result != NULL) { |
| 1581 assert(*succeeded, "sanity"); | |
| 1582 return result; | |
| 1583 } | |
| 342 | 1584 |
| 1585 // In a G1 heap, we're supposed to keep allocation from failing by | |
| 1586 // incremental pauses. Therefore, at least for now, we'll favor | |
| 1587 // expansion over collection. (This might change in the future if we can | |
| 1588 // do something smarter than full collection to satisfy a failed alloc.) | |
| 1589 result = expand_and_allocate(word_size); | |
| 1590 if (result != NULL) { | |
| 1973 | 1591 assert(*succeeded, "sanity"); |
| 342 | 1592 return result; |
| 1593 } | |
| 1594 | |
| 1973 | 1595 // Expansion didn't work, we'll try to do a Full GC. |
| 1596 bool gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1597 false, /* clear_all_soft_refs */ | |
| 1598 word_size); | |
| 1599 if (!gc_succeeded) { | |
| 1600 *succeeded = false; | |
| 1601 return NULL; | |
| 1602 } | |
| 1603 | |
| 1604 // Retry the allocation | |
| 1605 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1606 true /* expect_null_mutator_alloc_region */); |
| 342 | 1607 if (result != NULL) { |
| 1973 | 1608 assert(*succeeded, "sanity"); |
| 342 | 1609 return result; |
| 1610 } | |
| 1611 | |
| 1973 | 1612 // Then, try a Full GC that will collect all soft references. |
| 1613 gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1614 true, /* clear_all_soft_refs */ | |
| 1615 word_size); | |
| 1616 if (!gc_succeeded) { | |
| 1617 *succeeded = false; | |
| 1618 return NULL; | |
| 1619 } | |
| 1620 | |
| 1621 // Retry the allocation once more | |
| 1622 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1623 true /* expect_null_mutator_alloc_region */); |
| 342 | 1624 if (result != NULL) { |
| 1973 | 1625 assert(*succeeded, "sanity"); |
| 342 | 1626 return result; |
| 1627 } | |
| 1628 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1629 assert(!collector_policy()->should_clear_all_soft_refs(), |
| 1973 | 1630 "Flag should have been handled and cleared prior to this point"); |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1631 |
| 342 | 1632 // What else? We might try synchronous finalization later. If the total |
| 1633 // space available is large enough for the allocation, then a more | |
| 1634 // complete compaction phase than we've tried so far might be | |
| 1635 // appropriate. | |
| 1973 | 1636 assert(*succeeded, "sanity"); |
| 342 | 1637 return NULL; |
| 1638 } | |
| 1639 | |
| 1640 // Attempting to expand the heap sufficiently | |
| 1641 // to support an allocation of the given "word_size". If | |
| 1642 // successful, perform the allocation and return the address of the | |
| 1643 // allocated block, or else "NULL". | |
| 1644 | |
| 1645 HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) { | |
| 2152 | 1646 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1647 | |
| 1648 verify_region_sets_optional(); | |
| 1973 | 1649 |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1650 size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes); |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1651 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1652 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1653 ergo_format_reason("allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1654 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1655 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1656 if (expand(expand_bytes)) { |
| 3766 | 1657 _hrs.verify_optional(); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1658 verify_region_sets_optional(); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1659 return attempt_allocation_at_safepoint(word_size, |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1660 false /* expect_null_mutator_alloc_region */); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1661 } |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1662 return NULL; |
| 342 | 1663 } |
| 1664 | |
| 3766 | 1665 void G1CollectedHeap::update_committed_space(HeapWord* old_end, |
| 1666 HeapWord* new_end) { | |
| 1667 assert(old_end != new_end, "don't call this otherwise"); | |
| 1668 assert((HeapWord*) _g1_storage.high() == new_end, "invariant"); | |
| 1669 | |
| 1670 // Update the committed mem region. | |
| 1671 _g1_committed.set_end(new_end); | |
| 1672 // Tell the card table about the update. | |
| 1673 Universe::heap()->barrier_set()->resize_covered_region(_g1_committed); | |
| 1674 // Tell the BOT about the update. | |
| 1675 _bot_shared->resize(_g1_committed.word_size()); | |
| 1676 } | |
| 1677 | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1678 bool G1CollectedHeap::expand(size_t expand_bytes) { |
| 342 | 1679 size_t old_mem_size = _g1_storage.committed_size(); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1680 size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes); |
| 342 | 1681 aligned_expand_bytes = align_size_up(aligned_expand_bytes, |
| 1682 HeapRegion::GrainBytes); | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1683 ergo_verbose2(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1684 "expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1685 ergo_format_byte("requested expansion amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1686 ergo_format_byte("attempted expansion amount"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1687 expand_bytes, aligned_expand_bytes); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1688 |
| 3766 | 1689 // First commit the memory. |
| 1690 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1691 bool successful = _g1_storage.expand_by(aligned_expand_bytes); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1692 if (successful) { |
| 3766 | 1693 // Then propagate this update to the necessary data structures. |
| 1694 HeapWord* new_end = (HeapWord*) _g1_storage.high(); | |
| 1695 update_committed_space(old_end, new_end); | |
| 1696 | |
| 1697 FreeRegionList expansion_list("Local Expansion List"); | |
| 1698 MemRegion mr = _hrs.expand_by(old_end, new_end, &expansion_list); | |
| 1699 assert(mr.start() == old_end, "post-condition"); | |
| 1700 // mr might be a smaller region than what was requested if | |
| 1701 // expand_by() was unable to allocate the HeapRegion instances | |
| 1702 assert(mr.end() <= new_end, "post-condition"); | |
| 1703 | |
| 1704 size_t actual_expand_bytes = mr.byte_size(); | |
| 1705 assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition"); | |
| 1706 assert(actual_expand_bytes == expansion_list.total_capacity_bytes(), | |
| 1707 "post-condition"); | |
| 1708 if (actual_expand_bytes < aligned_expand_bytes) { | |
| 1709 // We could not expand _hrs to the desired size. In this case we | |
| 1710 // need to shrink the committed space accordingly. | |
| 1711 assert(mr.end() < new_end, "invariant"); | |
| 1712 | |
| 1713 size_t diff_bytes = aligned_expand_bytes - actual_expand_bytes; | |
| 1714 // First uncommit the memory. | |
| 1715 _g1_storage.shrink_by(diff_bytes); | |
| 1716 // Then propagate this update to the necessary data structures. | |
| 1717 update_committed_space(new_end, mr.end()); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1718 } |
| 3766 | 1719 _free_list.add_as_tail(&expansion_list); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1720 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1721 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1722 HeapWord* curr = mr.start(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1723 while (curr < mr.end()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1724 HeapWord* curr_end = curr + HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1725 _hr_printer.commit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1726 curr = curr_end; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1727 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1728 assert(curr == mr.end(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1729 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1730 g1_policy()->record_new_heap_size(n_regions()); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1731 } else { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1732 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1733 "did not expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1734 ergo_format_reason("heap expansion operation failed")); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1735 // The expansion of the virtual storage space was unsuccessful. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1736 // Let's see if it was because we ran out of swap. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1737 if (G1ExitOnExpansionFailure && |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1738 _g1_storage.uncommitted_size() >= aligned_expand_bytes) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1739 // We had head room... |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1740 vm_exit_out_of_memory(aligned_expand_bytes, "G1 heap expansion"); |
| 342 | 1741 } |
| 1742 } | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1743 return successful; |
| 342 | 1744 } |
| 1745 | |
| 3766 | 1746 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) { |
| 342 | 1747 size_t old_mem_size = _g1_storage.committed_size(); |
| 1748 size_t aligned_shrink_bytes = | |
| 1749 ReservedSpace::page_align_size_down(shrink_bytes); | |
| 1750 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes, | |
| 1751 HeapRegion::GrainBytes); | |
| 1752 size_t num_regions_deleted = 0; | |
| 3766 | 1753 MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted); |
| 1754 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
| 1755 assert(mr.end() == old_end, "post-condition"); | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1756 |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1757 ergo_verbose3(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1758 "shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1759 ergo_format_byte("requested shrinking amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1760 ergo_format_byte("aligned shrinking amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1761 ergo_format_byte("attempted shrinking amount"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1762 shrink_bytes, aligned_shrink_bytes, mr.byte_size()); |
| 3766 | 1763 if (mr.byte_size() > 0) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1764 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1765 HeapWord* curr = mr.end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1766 while (curr > mr.start()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1767 HeapWord* curr_end = curr; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1768 curr -= HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1769 _hr_printer.uncommit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1770 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1771 assert(curr == mr.start(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1772 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1773 |
| 342 | 1774 _g1_storage.shrink_by(mr.byte_size()); |
| 3766 | 1775 HeapWord* new_end = (HeapWord*) _g1_storage.high(); |
| 1776 assert(mr.start() == new_end, "post-condition"); | |
| 1777 | |
| 1778 _expansion_regions += num_regions_deleted; | |
| 1779 update_committed_space(old_end, new_end); | |
| 1780 HeapRegionRemSet::shrink_heap(n_regions()); | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1781 g1_policy()->record_new_heap_size(n_regions()); |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1782 } else { |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1783 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1784 "did not shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1785 ergo_format_reason("heap shrinking operation failed")); |
| 342 | 1786 } |
| 1787 } | |
| 1788 | |
| 1789 void G1CollectedHeap::shrink(size_t shrink_bytes) { | |
| 2152 | 1790 verify_region_sets_optional(); |
| 1791 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1792 // We should only reach here at the end of a Full GC which means we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1793 // should not not be holding to any GC alloc regions. The method |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1794 // below will make sure of that and do any remaining clean up. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1795 abandon_gc_alloc_regions(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1796 |
| 2152 | 1797 // Instead of tearing down / rebuilding the free lists here, we |
| 1798 // could instead use the remove_all_pending() method on free_list to | |
| 1799 // remove only the ones that we need to remove. | |
| 4072 | 1800 tear_down_region_sets(true /* free_list_only */); |
| 342 | 1801 shrink_helper(shrink_bytes); |
| 4072 | 1802 rebuild_region_sets(true /* free_list_only */); |
| 2152 | 1803 |
| 3766 | 1804 _hrs.verify_optional(); |
| 2152 | 1805 verify_region_sets_optional(); |
| 342 | 1806 } |
| 1807 | |
| 1808 // Public methods. | |
| 1809 | |
| 1810 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away | |
| 1811 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 1812 #endif // _MSC_VER | |
| 1813 | |
| 1814 | |
| 1815 G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) : | |
| 1816 SharedHeap(policy_), | |
| 1817 _g1_policy(policy_), | |
| 1111 | 1818 _dirty_card_queue_set(false), |
| 1705 | 1819 _into_cset_dirty_card_queue_set(false), |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1820 _is_alive_closure_cm(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1821 _is_alive_closure_stw(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1822 _ref_processor_cm(NULL), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1823 _ref_processor_stw(NULL), |
| 342 | 1824 _process_strong_tasks(new SubTasksDone(G1H_PS_NumElements)), |
| 1825 _bot_shared(NULL), | |
| 1826 _objs_with_preserved_marks(NULL), _preserved_marks_of_objs(NULL), | |
| 1827 _evac_failure_scan_stack(NULL) , | |
| 1828 _mark_in_progress(false), | |
| 2152 | 1829 _cg1r(NULL), _summary_bytes_used(0), |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1830 _g1mm(NULL), |
| 342 | 1831 _refine_cte_cl(NULL), |
| 1832 _full_collection(false), | |
| 2152 | 1833 _free_list("Master Free List"), |
| 1834 _secondary_free_list("Secondary Free List"), | |
| 4072 | 1835 _old_set("Old Set"), |
| 2152 | 1836 _humongous_set("Master Humongous Set"), |
| 1837 _free_regions_coming(false), | |
| 342 | 1838 _young_list(new YoungList(this)), |
| 1839 _gc_time_stamp(0), | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1840 _retained_old_gc_alloc_region(NULL), |
| 526 | 1841 _surviving_young_words(NULL), |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1842 _full_collections_completed(0), |
| 526 | 1843 _in_cset_fast_test(NULL), |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
1844 _in_cset_fast_test_base(NULL), |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1845 _dirty_cards_region_list(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1846 _worker_cset_start_region(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1847 _worker_cset_start_region_time_stamp(NULL) { |
| 342 | 1848 _g1h = this; // To catch bugs. |
| 1849 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { | |
| 1850 vm_exit_during_initialization("Failed necessary allocation."); | |
| 1851 } | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1852 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1853 _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1854 |
| 342 | 1855 int n_queues = MAX2((int)ParallelGCThreads, 1); |
| 1856 _task_queues = new RefToScanQueueSet(n_queues); | |
| 1857 | |
| 1858 int n_rem_sets = HeapRegionRemSet::num_par_rem_sets(); | |
| 1859 assert(n_rem_sets > 0, "Invariant."); | |
| 1860 | |
| 1861 HeapRegionRemSetIterator** iter_arr = | |
| 1862 NEW_C_HEAP_ARRAY(HeapRegionRemSetIterator*, n_queues); | |
| 1863 for (int i = 0; i < n_queues; i++) { | |
| 1864 iter_arr[i] = new HeapRegionRemSetIterator(); | |
| 1865 } | |
| 1866 _rem_set_iterator = iter_arr; | |
| 1867 | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1868 _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1869 _worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1870 |
| 342 | 1871 for (int i = 0; i < n_queues; i++) { |
| 1872 RefToScanQueue* q = new RefToScanQueue(); | |
| 1873 q->initialize(); | |
| 1874 _task_queues->register_queue(i, q); | |
| 1875 } | |
| 1876 | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1877 clear_cset_start_regions(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1878 |
| 342 | 1879 guarantee(_task_queues != NULL, "task_queues allocation failure."); |
| 1880 } | |
| 1881 | |
| 1882 jint G1CollectedHeap::initialize() { | |
| 1166 | 1883 CollectedHeap::pre_initialize(); |
| 342 | 1884 os::enable_vtime(); |
| 1885 | |
| 1886 // Necessary to satisfy locking discipline assertions. | |
| 1887 | |
| 1888 MutexLocker x(Heap_lock); | |
| 1889 | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1890 // We have to initialize the printer before committing the heap, as |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1891 // it will be used then. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1892 _hr_printer.set_active(G1PrintHeapRegions); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1893 |
| 342 | 1894 // While there are no constraints in the GC code that HeapWordSize |
| 1895 // be any particular value, there are multiple other areas in the | |
| 1896 // system which believe this to be true (e.g. oop->object_size in some | |
| 1897 // cases incorrectly returns the size in wordSize units rather than | |
| 1898 // HeapWordSize). | |
| 1899 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); | |
| 1900 | |
| 1901 size_t init_byte_size = collector_policy()->initial_heap_byte_size(); | |
| 1902 size_t max_byte_size = collector_policy()->max_heap_byte_size(); | |
| 1903 | |
| 1904 // Ensure that the sizes are properly aligned. | |
| 1905 Universe::check_alignment(init_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1906 Universe::check_alignment(max_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1907 | |
| 1908 _cg1r = new ConcurrentG1Refine(); | |
| 1909 | |
| 1910 // Reserve the maximum. | |
| 1911 PermanentGenerationSpec* pgs = collector_policy()->permanent_generation(); | |
| 1912 // Includes the perm-gen. | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1913 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1914 // When compressed oops are enabled, the preferred heap base |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1915 // is calculated by subtracting the requested size from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1916 // 32Gb boundary and using the result as the base address for |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1917 // heap reservation. If the requested size is not aligned to |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1918 // HeapRegion::GrainBytes (i.e. the alignment that is passed |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1919 // into the ReservedHeapSpace constructor) then the actual |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1920 // base of the reserved heap may end up differing from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1921 // address that was requested (i.e. the preferred heap base). |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1922 // If this happens then we could end up using a non-optimal |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1923 // compressed oops mode. |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1924 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1925 // Since max_byte_size is aligned to the size of a heap region (checked |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1926 // above), we also need to align the perm gen size as it might not be. |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1927 const size_t total_reserved = max_byte_size + |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1928 align_size_up(pgs->max_size(), HeapRegion::GrainBytes); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1929 Universe::check_alignment(total_reserved, HeapRegion::GrainBytes, "g1 heap and perm"); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1930 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1931 char* addr = Universe::preferred_heap_base(total_reserved, Universe::UnscaledNarrowOop); |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1932 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1933 ReservedHeapSpace heap_rs(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1934 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1935 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1936 if (UseCompressedOops) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1937 if (addr != NULL && !heap_rs.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1938 // Failed to reserve at specified address - the requested memory |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1939 // region is taken already, for example, by 'java' launcher. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1940 // Try again to reserver heap higher. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1941 addr = Universe::preferred_heap_base(total_reserved, Universe::ZeroBasedNarrowOop); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1942 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1943 ReservedHeapSpace heap_rs0(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1944 UseLargePages, addr); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1945 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1946 if (addr != NULL && !heap_rs0.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1947 // Failed to reserve at specified address again - give up. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1948 addr = Universe::preferred_heap_base(total_reserved, Universe::HeapBasedNarrowOop); |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1949 assert(addr == NULL, ""); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1950 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1951 ReservedHeapSpace heap_rs1(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1952 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1953 heap_rs = heap_rs1; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1954 } else { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1955 heap_rs = heap_rs0; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1956 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1957 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1958 } |
| 342 | 1959 |
| 1960 if (!heap_rs.is_reserved()) { | |
| 1961 vm_exit_during_initialization("Could not reserve enough space for object heap"); | |
| 1962 return JNI_ENOMEM; | |
| 1963 } | |
| 1964 | |
| 1965 // It is important to do this in a way such that concurrent readers can't | |
| 1966 // temporarily think somethings in the heap. (I've actually seen this | |
| 1967 // happen in asserts: DLD.) | |
| 1968 _reserved.set_word_size(0); | |
| 1969 _reserved.set_start((HeapWord*)heap_rs.base()); | |
| 1970 _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size())); | |
| 1971 | |
| 1972 _expansion_regions = max_byte_size/HeapRegion::GrainBytes; | |
| 1973 | |
| 1974 // Create the gen rem set (and barrier set) for the entire reserved region. | |
| 1975 _rem_set = collector_policy()->create_rem_set(_reserved, 2); | |
| 1976 set_barrier_set(rem_set()->bs()); | |
| 1977 if (barrier_set()->is_a(BarrierSet::ModRef)) { | |
| 1978 _mr_bs = (ModRefBarrierSet*)_barrier_set; | |
| 1979 } else { | |
| 1980 vm_exit_during_initialization("G1 requires a mod ref bs."); | |
| 1981 return JNI_ENOMEM; | |
| 1982 } | |
| 1983 | |
| 1984 // Also create a G1 rem set. | |
| 1861 | 1985 if (mr_bs()->is_a(BarrierSet::CardTableModRef)) { |
| 1986 _g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs()); | |
| 342 | 1987 } else { |
| 1861 | 1988 vm_exit_during_initialization("G1 requires a cardtable mod ref bs."); |
| 1989 return JNI_ENOMEM; | |
| 342 | 1990 } |
| 1991 | |
| 1992 // Carve out the G1 part of the heap. | |
| 1993 | |
| 1994 ReservedSpace g1_rs = heap_rs.first_part(max_byte_size); | |
| 1995 _g1_reserved = MemRegion((HeapWord*)g1_rs.base(), | |
| 1996 g1_rs.size()/HeapWordSize); | |
| 1997 ReservedSpace perm_gen_rs = heap_rs.last_part(max_byte_size); | |
| 1998 | |
| 1999 _perm_gen = pgs->init(perm_gen_rs, pgs->init_size(), rem_set()); | |
| 2000 | |
| 2001 _g1_storage.initialize(g1_rs, 0); | |
| 2002 _g1_committed = MemRegion((HeapWord*)_g1_storage.low(), (size_t) 0); | |
| 3766 | 2003 _hrs.initialize((HeapWord*) _g1_reserved.start(), |
| 2004 (HeapWord*) _g1_reserved.end(), | |
| 2005 _expansion_regions); | |
| 342 | 2006 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2007 // 6843694 - ensure that the maximum region index can fit |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2008 // in the remembered set structures. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2009 const size_t max_region_idx = ((size_t)1 << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2010 guarantee((max_regions() - 1) <= max_region_idx, "too many regions"); |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2011 |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2012 size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1; |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2013 guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized"); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
2014 guarantee(HeapRegion::CardsPerRegion < max_cards_per_region, |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2015 "too many cards per region"); |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2016 |
| 2152 | 2017 HeapRegionSet::set_unrealistically_long_length(max_regions() + 1); |
| 2018 | |
| 342 | 2019 _bot_shared = new G1BlockOffsetSharedArray(_reserved, |
| 2020 heap_word_size(init_byte_size)); | |
| 2021 | |
| 2022 _g1h = this; | |
| 2023 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2024 _in_cset_fast_test_length = max_regions(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2025 _in_cset_fast_test_base = NEW_C_HEAP_ARRAY(bool, _in_cset_fast_test_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2026 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2027 // We're biasing _in_cset_fast_test to avoid subtracting the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2028 // beginning of the heap every time we want to index; basically |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2029 // it's the same with what we do with the card table. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2030 _in_cset_fast_test = _in_cset_fast_test_base - |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2031 ((size_t) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2032 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2033 // Clear the _cset_fast_test bitmap in anticipation of adding |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2034 // regions to the incremental collection set for the first |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2035 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2036 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2037 |
| 342 | 2038 // Create the ConcurrentMark data structure and thread. |
| 2039 // (Must do this late, so that "max_regions" is defined.) | |
| 2040 _cm = new ConcurrentMark(heap_rs, (int) max_regions()); | |
| 2041 _cmThread = _cm->cmThread(); | |
| 2042 | |
| 2043 // Initialize the from_card cache structure of HeapRegionRemSet. | |
| 2044 HeapRegionRemSet::init_heap(max_regions()); | |
| 2045 | |
| 677 | 2046 // Now expand into the initial heap size. |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2047 if (!expand(init_byte_size)) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2048 vm_exit_during_initialization("Failed to allocate initial heap."); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2049 return JNI_ENOMEM; |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2050 } |
| 342 | 2051 |
| 2052 // Perform any initialization actions delegated to the policy. | |
| 2053 g1_policy()->init(); | |
| 2054 | |
| 2055 _refine_cte_cl = | |
| 2056 new RefineCardTableEntryClosure(ConcurrentG1RefineThread::sts(), | |
| 2057 g1_rem_set(), | |
| 2058 concurrent_g1_refine()); | |
| 2059 JavaThread::dirty_card_queue_set().set_closure(_refine_cte_cl); | |
| 2060 | |
| 2061 JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon, | |
| 2062 SATB_Q_FL_lock, | |
| 1111 | 2063 G1SATBProcessCompletedThreshold, |
| 342 | 2064 Shared_SATB_Q_lock); |
| 794 | 2065 |
| 2066 JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, | |
| 2067 DirtyCardQ_FL_lock, | |
| 1111 | 2068 concurrent_g1_refine()->yellow_zone(), |
| 2069 concurrent_g1_refine()->red_zone(), | |
| 794 | 2070 Shared_DirtyCardQ_lock); |
| 2071 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2072 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2073 dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2074 DirtyCardQ_FL_lock, |
| 1111 | 2075 -1, // never trigger processing |
| 2076 -1, // no limit on length | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2077 Shared_DirtyCardQ_lock, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2078 &JavaThread::dirty_card_queue_set()); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2079 } |
| 1705 | 2080 |
| 2081 // Initialize the card queue set used to hold cards containing | |
| 2082 // references into the collection set. | |
| 2083 _into_cset_dirty_card_queue_set.initialize(DirtyCardQ_CBL_mon, | |
| 2084 DirtyCardQ_FL_lock, | |
| 2085 -1, // never trigger processing | |
| 2086 -1, // no limit on length | |
| 2087 Shared_DirtyCardQ_lock, | |
| 2088 &JavaThread::dirty_card_queue_set()); | |
| 2089 | |
| 342 | 2090 // In case we're keeping closure specialization stats, initialize those |
| 2091 // counts and that mechanism. | |
| 2092 SpecializationStats::clear(); | |
| 2093 | |
| 2094 // Do later initialization work for concurrent refinement. | |
| 2095 _cg1r->init(); | |
| 2096 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2097 // Here we allocate the dummy full region that is required by the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2098 // G1AllocRegion class. If we don't pass an address in the reserved |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2099 // space here, lots of asserts fire. |
| 3766 | 2100 |
| 2101 HeapRegion* dummy_region = new_heap_region(0 /* index of bottom region */, | |
| 2102 _g1_reserved.start()); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2103 // We'll re-use the same region whether the alloc region will |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2104 // require BOT updates or not and, if it doesn't, then a non-young |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2105 // region will complain that it cannot support allocations without |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2106 // BOT updates. So we'll tag the dummy region as young to avoid that. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2107 dummy_region->set_young(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2108 // Make sure it's full. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2109 dummy_region->set_top(dummy_region->end()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2110 G1AllocRegion::setup(this, dummy_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2111 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2112 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2113 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2114 // Do create of the monitoring and management support so that |
|
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2115 // values in the heap have been properly initialized. |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
2116 _g1mm = new G1MonitoringSupport(this); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2117 |
| 342 | 2118 return JNI_OK; |
| 2119 } | |
| 2120 | |
| 2121 void G1CollectedHeap::ref_processing_init() { | |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2122 // Reference processing in G1 currently works as follows: |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2123 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2124 // * There are two reference processor instances. One is |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2125 // used to record and process discovered references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2126 // during concurrent marking; the other is used to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2127 // record and process references during STW pauses |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2128 // (both full and incremental). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2129 // * Both ref processors need to 'span' the entire heap as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2130 // the regions in the collection set may be dotted around. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2131 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2132 // * For the concurrent marking ref processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2133 // * Reference discovery is enabled at initial marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2134 // * Reference discovery is disabled and the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2135 // references processed etc during remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2136 // * Reference discovery is MT (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2137 // * Reference discovery requires a barrier (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2138 // * Reference processing may or may not be MT |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2139 // (depending on the value of ParallelRefProcEnabled |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2140 // and ParallelGCThreads). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2141 // * A full GC disables reference discovery by the CM |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2142 // ref processor and abandons any entries on it's |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2143 // discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2144 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2145 // * For the STW processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2146 // * Non MT discovery is enabled at the start of a full GC. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2147 // * Processing and enqueueing during a full GC is non-MT. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2148 // * During a full GC, references are processed after marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2149 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2150 // * Discovery (may or may not be MT) is enabled at the start |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2151 // of an incremental evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2152 // * References are processed near the end of a STW evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2153 // * For both types of GC: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2154 // * Discovery is atomic - i.e. not concurrent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2155 // * Reference discovery will not need a barrier. |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2156 |
| 342 | 2157 SharedHeap::ref_processing_init(); |
| 2158 MemRegion mr = reserved_region(); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2159 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2160 // Concurrent Mark ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2161 _ref_processor_cm = |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2361
diff
changeset
|
2162 new ReferenceProcessor(mr, // span |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2163 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2164 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2165 (int) ParallelGCThreads, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2166 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2167 (ParallelGCThreads > 1) || (ConcGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2168 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2169 (int) MAX2(ParallelGCThreads, ConcGCThreads), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2170 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2171 false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2172 // Reference discovery is not atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2173 &_is_alive_closure_cm, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2174 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2175 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2176 true); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2177 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2178 // lists requires a barrier. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2179 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2180 // STW ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2181 _ref_processor_stw = |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2182 new ReferenceProcessor(mr, // span |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2183 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2184 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2185 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2186 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2187 (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2188 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2189 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2190 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2191 true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2192 // Reference discovery is atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2193 &_is_alive_closure_stw, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2194 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2195 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2196 false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2197 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2198 // lists requires a barrier. |
| 342 | 2199 } |
| 2200 | |
| 2201 size_t G1CollectedHeap::capacity() const { | |
| 2202 return _g1_committed.byte_size(); | |
| 2203 } | |
| 2204 | |
| 1705 | 2205 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, |
| 2206 DirtyCardQueue* into_cset_dcq, | |
| 2207 bool concurrent, | |
| 342 | 2208 int worker_i) { |
| 889 | 2209 // Clean cards in the hot card cache |
| 1705 | 2210 concurrent_g1_refine()->clean_up_cache(worker_i, g1_rem_set(), into_cset_dcq); |
| 889 | 2211 |
| 342 | 2212 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
| 2213 int n_completed_buffers = 0; | |
| 1705 | 2214 while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) { |
| 342 | 2215 n_completed_buffers++; |
| 2216 } | |
| 2217 g1_policy()->record_update_rs_processed_buffers(worker_i, | |
| 2218 (double) n_completed_buffers); | |
| 2219 dcqs.clear_n_completed_buffers(); | |
| 2220 assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!"); | |
| 2221 } | |
| 2222 | |
| 2223 | |
| 2224 // Computes the sum of the storage used by the various regions. | |
| 2225 | |
| 2226 size_t G1CollectedHeap::used() const { | |
|
862
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2227 assert(Heap_lock->owner() != NULL, |
|
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2228 "Should be owned on this thread's behalf."); |
| 342 | 2229 size_t result = _summary_bytes_used; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2230 // Read only once in case it is set to NULL concurrently |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2231 HeapRegion* hr = _mutator_alloc_region.get(); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2232 if (hr != NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2233 result += hr->used(); |
| 342 | 2234 return result; |
| 2235 } | |
| 2236 | |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2237 size_t G1CollectedHeap::used_unlocked() const { |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2238 size_t result = _summary_bytes_used; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2239 return result; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2240 } |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2241 |
| 342 | 2242 class SumUsedClosure: public HeapRegionClosure { |
| 2243 size_t _used; | |
| 2244 public: | |
| 2245 SumUsedClosure() : _used(0) {} | |
| 2246 bool doHeapRegion(HeapRegion* r) { | |
| 2247 if (!r->continuesHumongous()) { | |
| 2248 _used += r->used(); | |
| 2249 } | |
| 2250 return false; | |
| 2251 } | |
| 2252 size_t result() { return _used; } | |
| 2253 }; | |
| 2254 | |
| 2255 size_t G1CollectedHeap::recalculate_used() const { | |
| 2256 SumUsedClosure blk; | |
| 3766 | 2257 heap_region_iterate(&blk); |
| 342 | 2258 return blk.result(); |
| 2259 } | |
| 2260 | |
| 2261 size_t G1CollectedHeap::unsafe_max_alloc() { | |
| 2152 | 2262 if (free_regions() > 0) return HeapRegion::GrainBytes; |
| 342 | 2263 // otherwise, is there space in the current allocation region? |
| 2264 | |
| 2265 // We need to store the current allocation region in a local variable | |
| 2266 // here. The problem is that this method doesn't take any locks and | |
| 2267 // there may be other threads which overwrite the current allocation | |
| 2268 // region field. attempt_allocation(), for example, sets it to NULL | |
| 2269 // and this can happen *after* the NULL check here but before the call | |
| 2270 // to free(), resulting in a SIGSEGV. Note that this doesn't appear | |
| 2271 // to be a problem in the optimized build, since the two loads of the | |
| 2272 // current allocation region field are optimized away. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2273 HeapRegion* hr = _mutator_alloc_region.get(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2274 if (hr == NULL) { |
| 342 | 2275 return 0; |
| 2276 } | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2277 return hr->free(); |
| 342 | 2278 } |
| 2279 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2280 bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2281 return |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2282 ((cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) || |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2283 (cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2284 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2285 |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2286 #ifndef PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2287 void G1CollectedHeap::allocate_dummy_regions() { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2288 // Let's fill up most of the region |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2289 size_t word_size = HeapRegion::GrainWords - 1024; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2290 // And as a result the region we'll allocate will be humongous. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2291 guarantee(isHumongous(word_size), "sanity"); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2292 |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2293 for (uintx i = 0; i < G1DummyRegionsPerGC; ++i) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2294 // Let's use the existing mechanism for the allocation |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2295 HeapWord* dummy_obj = humongous_obj_allocate(word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2296 if (dummy_obj != NULL) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2297 MemRegion mr(dummy_obj, word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2298 CollectedHeap::fill_with_object(mr); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2299 } else { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2300 // If we can't allocate once, we probably cannot allocate |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2301 // again. Let's get out of the loop. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2302 break; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2303 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2304 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2305 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2306 #endif // !PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2307 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2308 void G1CollectedHeap::increment_full_collections_completed(bool concurrent) { |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2309 MonitorLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2310 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2311 // We assume that if concurrent == true, then the caller is a |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2312 // concurrent thread that was joined the Suspendible Thread |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2313 // Set. If there's ever a cheap way to check this, we should add an |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2314 // assert here. |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2315 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2316 // We have already incremented _total_full_collections at the start |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2317 // of the GC, so total_full_collections() represents how many full |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2318 // collections have been started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2319 unsigned int full_collections_started = total_full_collections(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2320 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2321 // Given that this method is called at the end of a Full GC or of a |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2322 // concurrent cycle, and those can be nested (i.e., a Full GC can |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2323 // interrupt a concurrent cycle), the number of full collections |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2324 // completed should be either one (in the case where there was no |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2325 // nesting) or two (when a Full GC interrupted a concurrent cycle) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2326 // behind the number of full collections started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2327 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2328 // This is the case for the inner caller, i.e. a Full GC. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2329 assert(concurrent || |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2330 (full_collections_started == _full_collections_completed + 1) || |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2331 (full_collections_started == _full_collections_completed + 2), |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2332 err_msg("for inner caller (Full GC): full_collections_started = %u " |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2333 "is inconsistent with _full_collections_completed = %u", |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2334 full_collections_started, _full_collections_completed)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2335 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2336 // This is the case for the outer caller, i.e. the concurrent cycle. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2337 assert(!concurrent || |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2338 (full_collections_started == _full_collections_completed + 1), |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2339 err_msg("for outer caller (concurrent cycle): " |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2340 "full_collections_started = %u " |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2341 "is inconsistent with _full_collections_completed = %u", |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2342 full_collections_started, _full_collections_completed)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2343 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2344 _full_collections_completed += 1; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2345 |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2346 // We need to clear the "in_progress" flag in the CM thread before |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2347 // we wake up any waiters (especially when ExplicitInvokesConcurrent |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2348 // is set) so that if a waiter requests another System.gc() it doesn't |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2349 // incorrectly see that a marking cyle is still in progress. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2350 if (concurrent) { |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2351 _cmThread->clear_in_progress(); |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2352 } |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2353 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2354 // This notify_all() will ensure that a thread that called |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2355 // System.gc() with (with ExplicitGCInvokesConcurrent set or not) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2356 // and it's waiting for a full GC to finish will be woken up. It is |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2357 // waiting in VM_G1IncCollectionPause::doit_epilogue(). |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2358 FullGCCount_lock->notify_all(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2359 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2360 |
| 342 | 2361 void G1CollectedHeap::collect_as_vm_thread(GCCause::Cause cause) { |
| 2152 | 2362 assert_at_safepoint(true /* should_be_vm_thread */); |
| 342 | 2363 GCCauseSetter gcs(this, cause); |
| 2364 switch (cause) { | |
| 2365 case GCCause::_heap_inspection: | |
| 2366 case GCCause::_heap_dump: { | |
| 2367 HandleMark hm; | |
| 2368 do_full_collection(false); // don't clear all soft refs | |
| 2369 break; | |
| 2370 } | |
| 2371 default: // XXX FIX ME | |
| 2372 ShouldNotReachHere(); // Unexpected use of this function | |
| 2373 } | |
| 2374 } | |
| 2375 | |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2376 void G1CollectedHeap::collect(GCCause::Cause cause) { |
|
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2377 // The caller doesn't have the Heap_lock |
|
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2378 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock"); |
|
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2379 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2380 unsigned int gc_count_before; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2381 unsigned int full_gc_count_before; |
| 342 | 2382 { |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2383 MutexLocker ml(Heap_lock); |
| 1973 | 2384 |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2385 // Read the GC count while holding the Heap_lock |
|
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2386 gc_count_before = SharedHeap::heap()->total_collections(); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2387 full_gc_count_before = SharedHeap::heap()->total_full_collections(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2388 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2389 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2390 if (should_do_concurrent_full_gc(cause)) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2391 // Schedule an initial-mark evacuation pause that will start a |
| 1973 | 2392 // concurrent cycle. We're setting word_size to 0 which means that |
| 2393 // we are not requesting a post-GC allocation. | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2394 VM_G1IncCollectionPause op(gc_count_before, |
| 1973 | 2395 0, /* word_size */ |
| 2396 true, /* should_initiate_conc_mark */ | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2397 g1_policy()->max_pause_time_ms(), |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2398 cause); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2399 VMThread::execute(&op); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2400 } else { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2401 if (cause == GCCause::_gc_locker |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2402 DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2403 |
| 1973 | 2404 // Schedule a standard evacuation pause. We're setting word_size |
| 2405 // to 0 which means that we are not requesting a post-GC allocation. | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2406 VM_G1IncCollectionPause op(gc_count_before, |
| 1973 | 2407 0, /* word_size */ |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2408 false, /* should_initiate_conc_mark */ |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2409 g1_policy()->max_pause_time_ms(), |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2410 cause); |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2411 VMThread::execute(&op); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2412 } else { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2413 // Schedule a Full GC. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2414 VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause); |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2415 VMThread::execute(&op); |
|
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2416 } |
| 342 | 2417 } |
| 2418 } | |
| 2419 | |
| 2420 bool G1CollectedHeap::is_in(const void* p) const { | |
| 4708 | 2421 if (_g1_committed.contains(p)) { |
| 2422 // Given that we know that p is in the committed space, | |
| 2423 // heap_region_containing_raw() should successfully | |
| 2424 // return the containing region. | |
| 2425 HeapRegion* hr = heap_region_containing_raw(p); | |
| 342 | 2426 return hr->is_in(p); |
| 2427 } else { | |
| 2428 return _perm_gen->as_gen()->is_in(p); | |
| 2429 } | |
| 2430 } | |
| 2431 | |
| 2432 // Iteration functions. | |
| 2433 | |
| 2434 // Iterates an OopClosure over all ref-containing fields of objects | |
| 2435 // within a HeapRegion. | |
| 2436 | |
| 2437 class IterateOopClosureRegionClosure: public HeapRegionClosure { | |
| 2438 MemRegion _mr; | |
| 2439 OopClosure* _cl; | |
| 2440 public: | |
| 2441 IterateOopClosureRegionClosure(MemRegion mr, OopClosure* cl) | |
| 2442 : _mr(mr), _cl(cl) {} | |
| 2443 bool doHeapRegion(HeapRegion* r) { | |
| 2444 if (! r->continuesHumongous()) { | |
| 2445 r->oop_iterate(_cl); | |
| 2446 } | |
| 2447 return false; | |
| 2448 } | |
| 2449 }; | |
| 2450 | |
| 678 | 2451 void G1CollectedHeap::oop_iterate(OopClosure* cl, bool do_perm) { |
| 342 | 2452 IterateOopClosureRegionClosure blk(_g1_committed, cl); |
| 3766 | 2453 heap_region_iterate(&blk); |
| 678 | 2454 if (do_perm) { |
| 2455 perm_gen()->oop_iterate(cl); | |
| 2456 } | |
| 342 | 2457 } |
| 2458 | |
| 678 | 2459 void G1CollectedHeap::oop_iterate(MemRegion mr, OopClosure* cl, bool do_perm) { |
| 342 | 2460 IterateOopClosureRegionClosure blk(mr, cl); |
| 3766 | 2461 heap_region_iterate(&blk); |
| 678 | 2462 if (do_perm) { |
| 2463 perm_gen()->oop_iterate(cl); | |
| 2464 } | |
| 342 | 2465 } |
| 2466 | |
| 2467 // Iterates an ObjectClosure over all objects within a HeapRegion. | |
| 2468 | |
| 2469 class IterateObjectClosureRegionClosure: public HeapRegionClosure { | |
| 2470 ObjectClosure* _cl; | |
| 2471 public: | |
| 2472 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {} | |
| 2473 bool doHeapRegion(HeapRegion* r) { | |
| 2474 if (! r->continuesHumongous()) { | |
| 2475 r->object_iterate(_cl); | |
| 2476 } | |
| 2477 return false; | |
| 2478 } | |
| 2479 }; | |
| 2480 | |
| 678 | 2481 void G1CollectedHeap::object_iterate(ObjectClosure* cl, bool do_perm) { |
| 342 | 2482 IterateObjectClosureRegionClosure blk(cl); |
| 3766 | 2483 heap_region_iterate(&blk); |
| 678 | 2484 if (do_perm) { |
| 2485 perm_gen()->object_iterate(cl); | |
| 2486 } | |
| 342 | 2487 } |
| 2488 | |
| 2489 void G1CollectedHeap::object_iterate_since_last_GC(ObjectClosure* cl) { | |
| 2490 // FIXME: is this right? | |
| 2491 guarantee(false, "object_iterate_since_last_GC not supported by G1 heap"); | |
| 2492 } | |
| 2493 | |
| 2494 // Calls a SpaceClosure on a HeapRegion. | |
| 2495 | |
| 2496 class SpaceClosureRegionClosure: public HeapRegionClosure { | |
| 2497 SpaceClosure* _cl; | |
| 2498 public: | |
| 2499 SpaceClosureRegionClosure(SpaceClosure* cl) : _cl(cl) {} | |
| 2500 bool doHeapRegion(HeapRegion* r) { | |
| 2501 _cl->do_space(r); | |
| 2502 return false; | |
| 2503 } | |
| 2504 }; | |
| 2505 | |
| 2506 void G1CollectedHeap::space_iterate(SpaceClosure* cl) { | |
| 2507 SpaceClosureRegionClosure blk(cl); | |
| 3766 | 2508 heap_region_iterate(&blk); |
| 342 | 2509 } |
| 2510 | |
| 3766 | 2511 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const { |
| 2512 _hrs.iterate(cl); | |
| 342 | 2513 } |
| 2514 | |
| 2515 void G1CollectedHeap::heap_region_iterate_from(HeapRegion* r, | |
| 3766 | 2516 HeapRegionClosure* cl) const { |
| 2517 _hrs.iterate_from(r, cl); | |
| 342 | 2518 } |
| 2519 | |
| 2520 void | |
| 2521 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl, | |
| 2522 int worker, | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2523 int no_of_par_workers, |
| 342 | 2524 jint claim_value) { |
| 355 | 2525 const size_t regions = n_regions(); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2526 const size_t max_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2527 no_of_par_workers : |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2528 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2529 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2530 no_of_par_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2531 "Non dynamic should use fixed number of workers"); |
| 355 | 2532 // try to spread out the starting points of the workers |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2533 const size_t start_index = regions / max_workers * (size_t) worker; |
| 355 | 2534 |
| 2535 // each worker will actually look at all regions | |
| 2536 for (size_t count = 0; count < regions; ++count) { | |
| 2537 const size_t index = (start_index + count) % regions; | |
| 2538 assert(0 <= index && index < regions, "sanity"); | |
| 2539 HeapRegion* r = region_at(index); | |
| 2540 // we'll ignore "continues humongous" regions (we'll process them | |
| 2541 // when we come across their corresponding "start humongous" | |
| 2542 // region) and regions already claimed | |
| 2543 if (r->claim_value() == claim_value || r->continuesHumongous()) { | |
| 2544 continue; | |
| 2545 } | |
| 2546 // OK, try to claim it | |
| 342 | 2547 if (r->claimHeapRegion(claim_value)) { |
| 355 | 2548 // success! |
| 2549 assert(!r->continuesHumongous(), "sanity"); | |
| 2550 if (r->startsHumongous()) { | |
| 2551 // If the region is "starts humongous" we'll iterate over its | |
| 2552 // "continues humongous" first; in fact we'll do them | |
| 2553 // first. The order is important. In on case, calling the | |
| 2554 // closure on the "starts humongous" region might de-allocate | |
| 2555 // and clear all its "continues humongous" regions and, as a | |
| 2556 // result, we might end up processing them twice. So, we'll do | |
| 2557 // them first (notice: most closures will ignore them anyway) and | |
| 2558 // then we'll do the "starts humongous" region. | |
| 2559 for (size_t ch_index = index + 1; ch_index < regions; ++ch_index) { | |
| 2560 HeapRegion* chr = region_at(ch_index); | |
| 2561 | |
| 2562 // if the region has already been claimed or it's not | |
| 2563 // "continues humongous" we're done | |
| 2564 if (chr->claim_value() == claim_value || | |
| 2565 !chr->continuesHumongous()) { | |
| 2566 break; | |
| 2567 } | |
| 2568 | |
| 2569 // Noone should have claimed it directly. We can given | |
| 2570 // that we claimed its "starts humongous" region. | |
| 2571 assert(chr->claim_value() != claim_value, "sanity"); | |
| 2572 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2573 | |
| 2574 if (chr->claimHeapRegion(claim_value)) { | |
| 2575 // we should always be able to claim it; noone else should | |
| 2576 // be trying to claim this region | |
| 2577 | |
| 2578 bool res2 = cl->doHeapRegion(chr); | |
| 2579 assert(!res2, "Should not abort"); | |
| 2580 | |
| 2581 // Right now, this holds (i.e., no closure that actually | |
| 2582 // does something with "continues humongous" regions | |
| 2583 // clears them). We might have to weaken it in the future, | |
| 2584 // but let's leave these two asserts here for extra safety. | |
| 2585 assert(chr->continuesHumongous(), "should still be the case"); | |
| 2586 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2587 } else { | |
| 2588 guarantee(false, "we should not reach here"); | |
| 2589 } | |
| 2590 } | |
| 2591 } | |
| 2592 | |
| 2593 assert(!r->continuesHumongous(), "sanity"); | |
| 2594 bool res = cl->doHeapRegion(r); | |
| 2595 assert(!res, "Should not abort"); | |
| 2596 } | |
| 2597 } | |
| 2598 } | |
| 2599 | |
| 390 | 2600 class ResetClaimValuesClosure: public HeapRegionClosure { |
| 2601 public: | |
| 2602 bool doHeapRegion(HeapRegion* r) { | |
| 2603 r->set_claim_value(HeapRegion::InitialClaimValue); | |
| 2604 return false; | |
| 2605 } | |
| 2606 }; | |
| 2607 | |
| 2608 void | |
| 2609 G1CollectedHeap::reset_heap_region_claim_values() { | |
| 2610 ResetClaimValuesClosure blk; | |
| 2611 heap_region_iterate(&blk); | |
| 2612 } | |
| 2613 | |
| 355 | 2614 #ifdef ASSERT |
| 2615 // This checks whether all regions in the heap have the correct claim | |
| 2616 // value. I also piggy-backed on this a check to ensure that the | |
| 2617 // humongous_start_region() information on "continues humongous" | |
| 2618 // regions is correct. | |
| 2619 | |
| 2620 class CheckClaimValuesClosure : public HeapRegionClosure { | |
| 2621 private: | |
| 2622 jint _claim_value; | |
| 2623 size_t _failures; | |
| 2624 HeapRegion* _sh_region; | |
| 2625 public: | |
| 2626 CheckClaimValuesClosure(jint claim_value) : | |
| 2627 _claim_value(claim_value), _failures(0), _sh_region(NULL) { } | |
| 2628 bool doHeapRegion(HeapRegion* r) { | |
| 2629 if (r->claim_value() != _claim_value) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2630 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2631 "claim value = %d, should be %d", |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2632 HR_FORMAT_PARAMS(r), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2633 r->claim_value(), _claim_value); |
| 355 | 2634 ++_failures; |
| 2635 } | |
| 2636 if (!r->isHumongous()) { | |
| 2637 _sh_region = NULL; | |
| 2638 } else if (r->startsHumongous()) { | |
| 2639 _sh_region = r; | |
| 2640 } else if (r->continuesHumongous()) { | |
| 2641 if (r->humongous_start_region() != _sh_region) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2642 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2643 "HS = "PTR_FORMAT", should be "PTR_FORMAT, |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2644 HR_FORMAT_PARAMS(r), |
| 355 | 2645 r->humongous_start_region(), |
| 2646 _sh_region); | |
| 2647 ++_failures; | |
| 342 | 2648 } |
| 2649 } | |
| 355 | 2650 return false; |
| 2651 } | |
| 2652 size_t failures() { | |
| 2653 return _failures; | |
| 2654 } | |
| 2655 }; | |
| 2656 | |
| 2657 bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) { | |
| 2658 CheckClaimValuesClosure cl(claim_value); | |
| 2659 heap_region_iterate(&cl); | |
| 2660 return cl.failures() == 0; | |
| 2661 } | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2662 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2663 class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2664 jint _claim_value; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2665 size_t _failures; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2666 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2667 public: |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2668 CheckClaimValuesInCSetHRClosure(jint claim_value) : |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2669 _claim_value(claim_value), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2670 _failures(0) { } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2671 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2672 size_t failures() { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2673 return _failures; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2674 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2675 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2676 bool doHeapRegion(HeapRegion* hr) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2677 assert(hr->in_collection_set(), "how?"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2678 assert(!hr->isHumongous(), "H-region in CSet"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2679 if (hr->claim_value() != _claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2680 gclog_or_tty->print_cr("CSet Region " HR_FORMAT ", " |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2681 "claim value = %d, should be %d", |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2682 HR_FORMAT_PARAMS(hr), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2683 hr->claim_value(), _claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2684 _failures += 1; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2685 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2686 return false; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2687 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2688 }; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2689 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2690 bool G1CollectedHeap::check_cset_heap_region_claim_values(jint claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2691 CheckClaimValuesInCSetHRClosure cl(claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2692 collection_set_iterate(&cl); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2693 return cl.failures() == 0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2694 } |
| 355 | 2695 #endif // ASSERT |
| 342 | 2696 |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2697 // Clear the cached CSet starting regions and (more importantly) |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2698 // the time stamps. Called when we reset the GC time stamp. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2699 void G1CollectedHeap::clear_cset_start_regions() { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2700 assert(_worker_cset_start_region != NULL, "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2701 assert(_worker_cset_start_region_time_stamp != NULL, "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2702 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2703 int n_queues = MAX2((int)ParallelGCThreads, 1); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2704 for (int i = 0; i < n_queues; i++) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2705 _worker_cset_start_region[i] = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2706 _worker_cset_start_region_time_stamp[i] = 0; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2707 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2708 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2709 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2710 // Given the id of a worker, obtain or calculate a suitable |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2711 // starting region for iterating over the current collection set. |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2712 HeapRegion* G1CollectedHeap::start_cset_region_for_worker(int worker_i) { |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2713 assert(get_gc_time_stamp() > 0, "should have been updated by now"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2714 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2715 HeapRegion* result = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2716 unsigned gc_time_stamp = get_gc_time_stamp(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2717 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2718 if (_worker_cset_start_region_time_stamp[worker_i] == gc_time_stamp) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2719 // Cached starting region for current worker was set |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2720 // during the current pause - so it's valid. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2721 // Note: the cached starting heap region may be NULL |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2722 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2723 result = _worker_cset_start_region[worker_i]; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2724 assert(result == NULL || result->in_collection_set(), "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2725 return result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2726 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2727 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2728 // The cached entry was not valid so let's calculate |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2729 // a suitable starting heap region for this worker. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2730 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2731 // We want the parallel threads to start their collection |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2732 // set iteration at different collection set regions to |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2733 // avoid contention. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2734 // If we have: |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2735 // n collection set regions |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2736 // p threads |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2737 // Then thread t will start at region floor ((t * n) / p) |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2738 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2739 result = g1_policy()->collection_set(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2740 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2741 size_t cs_size = g1_policy()->cset_region_length(); |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2742 int active_workers = workers()->active_workers(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2743 assert(UseDynamicNumberOfGCThreads || |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2744 active_workers == workers()->total_workers(), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2745 "Unless dynamic should use total workers"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2746 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2747 size_t end_ind = (cs_size * worker_i) / active_workers; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2748 size_t start_ind = 0; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2749 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2750 if (worker_i > 0 && |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2751 _worker_cset_start_region_time_stamp[worker_i - 1] == gc_time_stamp) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2752 // Previous workers starting region is valid |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2753 // so let's iterate from there |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2754 start_ind = (cs_size * (worker_i - 1)) / active_workers; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2755 result = _worker_cset_start_region[worker_i - 1]; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2756 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2757 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2758 for (size_t i = start_ind; i < end_ind; i++) { |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2759 result = result->next_in_collection_set(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2760 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2761 } |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2762 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2763 // Note: the calculated starting heap region may be NULL |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2764 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2765 assert(result == NULL || result->in_collection_set(), "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2766 assert(_worker_cset_start_region_time_stamp[worker_i] != gc_time_stamp, |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2767 "should be updated only once per pause"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2768 _worker_cset_start_region[worker_i] = result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2769 OrderAccess::storestore(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2770 _worker_cset_start_region_time_stamp[worker_i] = gc_time_stamp; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2771 return result; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2772 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2773 |
| 342 | 2774 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) { |
| 2775 HeapRegion* r = g1_policy()->collection_set(); | |
| 2776 while (r != NULL) { | |
| 2777 HeapRegion* next = r->next_in_collection_set(); | |
| 2778 if (cl->doHeapRegion(r)) { | |
| 2779 cl->incomplete(); | |
| 2780 return; | |
| 2781 } | |
| 2782 r = next; | |
| 2783 } | |
| 2784 } | |
| 2785 | |
| 2786 void G1CollectedHeap::collection_set_iterate_from(HeapRegion* r, | |
| 2787 HeapRegionClosure *cl) { | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2788 if (r == NULL) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2789 // The CSet is empty so there's nothing to do. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2790 return; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2791 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2792 |
| 342 | 2793 assert(r->in_collection_set(), |
| 2794 "Start region must be a member of the collection set."); | |
| 2795 HeapRegion* cur = r; | |
| 2796 while (cur != NULL) { | |
| 2797 HeapRegion* next = cur->next_in_collection_set(); | |
| 2798 if (cl->doHeapRegion(cur) && false) { | |
| 2799 cl->incomplete(); | |
| 2800 return; | |
| 2801 } | |
| 2802 cur = next; | |
| 2803 } | |
| 2804 cur = g1_policy()->collection_set(); | |
| 2805 while (cur != r) { | |
| 2806 HeapRegion* next = cur->next_in_collection_set(); | |
| 2807 if (cl->doHeapRegion(cur) && false) { | |
| 2808 cl->incomplete(); | |
| 2809 return; | |
| 2810 } | |
| 2811 cur = next; | |
| 2812 } | |
| 2813 } | |
| 2814 | |
| 2815 CompactibleSpace* G1CollectedHeap::first_compactible_space() { | |
| 3766 | 2816 return n_regions() > 0 ? region_at(0) : NULL; |
| 342 | 2817 } |
| 2818 | |
| 2819 | |
| 2820 Space* G1CollectedHeap::space_containing(const void* addr) const { | |
| 2821 Space* res = heap_region_containing(addr); | |
| 2822 if (res == NULL) | |
| 2823 res = perm_gen()->space_containing(addr); | |
| 2824 return res; | |
| 2825 } | |
| 2826 | |
| 2827 HeapWord* G1CollectedHeap::block_start(const void* addr) const { | |
| 2828 Space* sp = space_containing(addr); | |
| 2829 if (sp != NULL) { | |
| 2830 return sp->block_start(addr); | |
| 2831 } | |
| 2832 return NULL; | |
| 2833 } | |
| 2834 | |
| 2835 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { | |
| 2836 Space* sp = space_containing(addr); | |
| 2837 assert(sp != NULL, "block_size of address outside of heap"); | |
| 2838 return sp->block_size(addr); | |
| 2839 } | |
| 2840 | |
| 2841 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { | |
| 2842 Space* sp = space_containing(addr); | |
| 2843 return sp->block_is_obj(addr); | |
| 2844 } | |
| 2845 | |
| 2846 bool G1CollectedHeap::supports_tlab_allocation() const { | |
| 2847 return true; | |
| 2848 } | |
| 2849 | |
| 2850 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const { | |
| 2851 return HeapRegion::GrainBytes; | |
| 2852 } | |
| 2853 | |
| 2854 size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const { | |
| 2855 // Return the remaining space in the cur alloc region, but not less than | |
| 2856 // the min TLAB size. | |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2857 |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2858 // Also, this value can be at most the humongous object threshold, |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2859 // since we can't allow tlabs to grow big enough to accomodate |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2860 // humongous objects. |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2861 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2862 HeapRegion* hr = _mutator_alloc_region.get(); |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2863 size_t max_tlab_size = _humongous_object_threshold_in_words * wordSize; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2864 if (hr == NULL) { |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2865 return max_tlab_size; |
| 342 | 2866 } else { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2867 return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab_size); |
| 342 | 2868 } |
| 2869 } | |
| 2870 | |
| 2871 size_t G1CollectedHeap::max_capacity() const { | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2872 return _g1_reserved.byte_size(); |
| 342 | 2873 } |
| 2874 | |
| 2875 jlong G1CollectedHeap::millis_since_last_gc() { | |
| 2876 // assert(false, "NYI"); | |
| 2877 return 0; | |
| 2878 } | |
| 2879 | |
| 2880 void G1CollectedHeap::prepare_for_verify() { | |
| 2881 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { | |
| 2882 ensure_parsability(false); | |
| 2883 } | |
| 2884 g1_rem_set()->prepare_for_verify(); | |
| 2885 } | |
| 2886 | |
| 2887 class VerifyLivenessOopClosure: public OopClosure { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2888 G1CollectedHeap* _g1h; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2889 VerifyOption _vo; |
| 342 | 2890 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2891 VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo): |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2892 _g1h(g1h), _vo(vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2893 { } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2894 void do_oop(narrowOop *p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2895 void do_oop( oop *p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2896 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2897 template <class T> void do_oop_work(T *p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2898 oop obj = oopDesc::load_decode_heap_oop(p); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2899 guarantee(obj == NULL || !_g1h->is_obj_dead_cond(obj, _vo), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2900 "Dead object referenced by a not dead object"); |
| 342 | 2901 } |
| 2902 }; | |
| 2903 | |
| 2904 class VerifyObjsInRegionClosure: public ObjectClosure { | |
| 811 | 2905 private: |
| 342 | 2906 G1CollectedHeap* _g1h; |
| 2907 size_t _live_bytes; | |
| 2908 HeapRegion *_hr; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2909 VerifyOption _vo; |
| 342 | 2910 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2911 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2912 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2913 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2914 VerifyObjsInRegionClosure(HeapRegion *hr, VerifyOption vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2915 : _live_bytes(0), _hr(hr), _vo(vo) { |
| 342 | 2916 _g1h = G1CollectedHeap::heap(); |
| 2917 } | |
| 2918 void do_object(oop o) { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2919 VerifyLivenessOopClosure isLive(_g1h, _vo); |
| 342 | 2920 assert(o != NULL, "Huh?"); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2921 if (!_g1h->is_obj_dead_cond(o, _vo)) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2922 // If the object is alive according to the mark word, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2923 // then verify that the marking information agrees. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2924 // Note we can't verify the contra-positive of the |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2925 // above: if the object is dead (according to the mark |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2926 // word), it may not be marked, or may have been marked |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2927 // but has since became dead, or may have been allocated |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2928 // since the last marking. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2929 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2930 guarantee(!_g1h->is_obj_dead(o), "mark word and concurrent mark mismatch"); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2931 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2932 |
| 342 | 2933 o->oop_iterate(&isLive); |
|
1389
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
2934 if (!_hr->obj_allocated_since_prev_marking(o)) { |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
2935 size_t obj_size = o->size(); // Make sure we don't overflow |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
2936 _live_bytes += (obj_size * HeapWordSize); |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
2937 } |
| 342 | 2938 } |
| 2939 } | |
| 2940 size_t live_bytes() { return _live_bytes; } | |
| 2941 }; | |
| 2942 | |
| 2943 class PrintObjsInRegionClosure : public ObjectClosure { | |
| 2944 HeapRegion *_hr; | |
| 2945 G1CollectedHeap *_g1; | |
| 2946 public: | |
| 2947 PrintObjsInRegionClosure(HeapRegion *hr) : _hr(hr) { | |
| 2948 _g1 = G1CollectedHeap::heap(); | |
| 2949 }; | |
| 2950 | |
| 2951 void do_object(oop o) { | |
| 2952 if (o != NULL) { | |
| 2953 HeapWord *start = (HeapWord *) o; | |
| 2954 size_t word_sz = o->size(); | |
| 2955 gclog_or_tty->print("\nPrinting obj "PTR_FORMAT" of size " SIZE_FORMAT | |
| 2956 " isMarkedPrev %d isMarkedNext %d isAllocSince %d\n", | |
| 2957 (void*) o, word_sz, | |
| 2958 _g1->isMarkedPrev(o), | |
| 2959 _g1->isMarkedNext(o), | |
| 2960 _hr->obj_allocated_since_prev_marking(o)); | |
| 2961 HeapWord *end = start + word_sz; | |
| 2962 HeapWord *cur; | |
| 2963 int *val; | |
| 2964 for (cur = start; cur < end; cur++) { | |
| 2965 val = (int *) cur; | |
| 2966 gclog_or_tty->print("\t "PTR_FORMAT":"PTR_FORMAT"\n", val, *val); | |
| 2967 } | |
| 2968 } | |
| 2969 } | |
| 2970 }; | |
| 2971 | |
| 2972 class VerifyRegionClosure: public HeapRegionClosure { | |
| 811 | 2973 private: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2974 bool _allow_dirty; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2975 bool _par; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2976 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2977 bool _failures; |
| 811 | 2978 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2979 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2980 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2981 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2982 VerifyRegionClosure(bool allow_dirty, bool par, VerifyOption vo) |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2983 : _allow_dirty(allow_dirty), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2984 _par(par), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2985 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2986 _failures(false) {} |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2987 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2988 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2989 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2990 } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2991 |
| 342 | 2992 bool doHeapRegion(HeapRegion* r) { |
| 390 | 2993 guarantee(_par || r->claim_value() == HeapRegion::InitialClaimValue, |
| 2994 "Should be unclaimed at verify points."); | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
2995 if (!r->continuesHumongous()) { |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2996 bool failures = false; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2997 r->verify(_allow_dirty, _vo, &failures); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2998 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
2999 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3000 } else { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3001 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3002 r->object_iterate(¬_dead_yet_cl); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3003 if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3004 gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] " |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3005 "max_live_bytes "SIZE_FORMAT" " |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3006 "< calculated "SIZE_FORMAT, |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3007 r->bottom(), r->end(), |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3008 r->max_live_bytes(), |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3009 not_dead_yet_cl.live_bytes()); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3010 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3011 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3012 } |
| 342 | 3013 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3014 return false; // stop the region iteration if we hit a failure |
| 342 | 3015 } |
| 3016 }; | |
| 3017 | |
| 3018 class VerifyRootsClosure: public OopsInGenClosure { | |
| 3019 private: | |
| 3020 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3021 VerifyOption _vo; |
| 342 | 3022 bool _failures; |
| 3023 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3024 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3025 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3026 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3027 VerifyRootsClosure(VerifyOption vo) : |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3028 _g1h(G1CollectedHeap::heap()), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3029 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3030 _failures(false) { } |
| 342 | 3031 |
| 3032 bool failures() { return _failures; } | |
| 3033 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3034 template <class T> void do_oop_nv(T* p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3035 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3036 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3037 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3038 if (_g1h->is_obj_dead_cond(obj, _vo)) { |
| 342 | 3039 gclog_or_tty->print_cr("Root location "PTR_FORMAT" " |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3040 "points to dead obj "PTR_FORMAT, p, (void*) obj); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3041 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3042 gclog_or_tty->print_cr(" Mark word: "PTR_FORMAT, (void*)(obj->mark())); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3043 } |
| 342 | 3044 obj->print_on(gclog_or_tty); |
| 3045 _failures = true; | |
| 3046 } | |
| 3047 } | |
| 3048 } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3049 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3050 void do_oop(oop* p) { do_oop_nv(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3051 void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 3052 }; |
| 3053 | |
| 390 | 3054 // This is the task used for parallel heap verification. |
| 3055 | |
| 3056 class G1ParVerifyTask: public AbstractGangTask { | |
| 3057 private: | |
| 3058 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3059 bool _allow_dirty; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3060 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3061 bool _failures; |
| 390 | 3062 |
| 3063 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3064 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3065 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3066 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3067 G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty, VerifyOption vo) : |
| 390 | 3068 AbstractGangTask("Parallel verify task"), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3069 _g1h(g1h), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3070 _allow_dirty(allow_dirty), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3071 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3072 _failures(false) { } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3073 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3074 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3075 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3076 } |
| 390 | 3077 |
| 3078 void work(int worker_i) { | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3079 HandleMark hm; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3080 VerifyRegionClosure blk(_allow_dirty, true, _vo); |
| 390 | 3081 _g1h->heap_region_par_iterate_chunked(&blk, worker_i, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3082 _g1h->workers()->active_workers(), |
| 390 | 3083 HeapRegion::ParVerifyClaimValue); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3084 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3085 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3086 } |
| 390 | 3087 } |
| 3088 }; | |
| 3089 | |
| 342 | 3090 void G1CollectedHeap::verify(bool allow_dirty, bool silent) { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3091 verify(allow_dirty, silent, VerifyOption_G1UsePrevMarking); |
| 811 | 3092 } |
| 3093 | |
| 3094 void G1CollectedHeap::verify(bool allow_dirty, | |
| 3095 bool silent, | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3096 VerifyOption vo) { |
| 342 | 3097 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3098 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); } |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3099 VerifyRootsClosure rootsCl(vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3100 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3101 assert(Thread::current()->is_VM_thread(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3102 "Expected to be executed serially by the VM thread at this point"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3103 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3104 CodeBlobToOopClosure blobsCl(&rootsCl, /*do_marking=*/ false); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3105 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3106 // We apply the relevant closures to all the oops in the |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3107 // system dictionary, the string table and the code cache. |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3108 const int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3109 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3110 process_strong_roots(true, // activate StrongRootsScope |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3111 true, // we set "collecting perm gen" to true, |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3112 // so we don't reset the dirty cards in the perm gen. |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3113 SharedHeap::ScanningOption(so), // roots scanning options |
| 342 | 3114 &rootsCl, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3115 &blobsCl, |
| 342 | 3116 &rootsCl); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3117 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3118 // If we're verifying after the marking phase of a Full GC then we can't |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3119 // treat the perm gen as roots into the G1 heap. Some of the objects in |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3120 // the perm gen may be dead and hence not marked. If one of these dead |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3121 // objects is considered to be a root then we may end up with a false |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3122 // "Root location <x> points to dead ob <y>" failure. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3123 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3124 // Since we used "collecting_perm_gen" == true above, we will not have |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3125 // checked the refs from perm into the G1-collected heap. We check those |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3126 // references explicitly below. Whether the relevant cards are dirty |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3127 // is checked further below in the rem set verification. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3128 if (!silent) { gclog_or_tty->print("Permgen roots "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3129 perm_gen()->oop_iterate(&rootsCl); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3130 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3131 bool failures = rootsCl.failures(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3132 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3133 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3134 // If we're verifying during a full GC then the region sets |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3135 // will have been torn down at the start of the GC. Therefore |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3136 // verifying the region sets will fail. So we only verify |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3137 // the region sets when not in a full GC. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3138 if (!silent) { gclog_or_tty->print("HeapRegionSets "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3139 verify_region_sets(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3140 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3141 |
| 2152 | 3142 if (!silent) { gclog_or_tty->print("HeapRegions "); } |
| 390 | 3143 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { |
| 3144 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3145 "sanity check"); | |
| 3146 | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3147 G1ParVerifyTask task(this, allow_dirty, vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3148 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3149 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3150 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3151 int n_workers = workers()->active_workers(); |
| 390 | 3152 set_par_threads(n_workers); |
| 3153 workers()->run_task(&task); | |
| 3154 set_par_threads(0); | |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3155 if (task.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3156 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3157 } |
| 390 | 3158 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3159 // Checks that the expected amount of parallel work was done. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3160 // The implication is that n_workers is > 0. |
| 390 | 3161 assert(check_heap_region_claim_values(HeapRegion::ParVerifyClaimValue), |
| 3162 "sanity check"); | |
| 3163 | |
| 3164 reset_heap_region_claim_values(); | |
| 3165 | |
| 3166 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3167 "sanity check"); | |
| 3168 } else { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3169 VerifyRegionClosure blk(allow_dirty, false, vo); |
| 3766 | 3170 heap_region_iterate(&blk); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3171 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3172 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3173 } |
| 390 | 3174 } |
| 2152 | 3175 if (!silent) gclog_or_tty->print("RemSet "); |
| 342 | 3176 rem_set()->verify(); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3177 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3178 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3179 gclog_or_tty->print_cr("Heap:"); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3180 // It helps to have the per-region information in the output to |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3181 // help us track down what went wrong. This is why we call |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3182 // print_extended_on() instead of print_on(). |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3183 print_extended_on(gclog_or_tty); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3184 gclog_or_tty->print_cr(""); |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3185 #ifndef PRODUCT |
| 1044 | 3186 if (VerifyDuringGC && G1VerifyDuringGCPrintReachable) { |
| 1388 | 3187 concurrent_mark()->print_reachable("at-verification-failure", |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3188 vo, false /* all */); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3189 } |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3190 #endif |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3191 gclog_or_tty->flush(); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3192 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3193 guarantee(!failures, "there should not have been any failures"); |
| 342 | 3194 } else { |
| 3195 if (!silent) gclog_or_tty->print("(SKIPPING roots, heapRegions, remset) "); | |
| 3196 } | |
| 3197 } | |
| 3198 | |
| 3199 class PrintRegionClosure: public HeapRegionClosure { | |
| 3200 outputStream* _st; | |
| 3201 public: | |
| 3202 PrintRegionClosure(outputStream* st) : _st(st) {} | |
| 3203 bool doHeapRegion(HeapRegion* r) { | |
| 3204 r->print_on(_st); | |
| 3205 return false; | |
| 3206 } | |
| 3207 }; | |
| 3208 | |
| 3209 void G1CollectedHeap::print_on(outputStream* st) const { | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3210 st->print(" %-20s", "garbage-first heap"); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3211 st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
3212 capacity()/K, used_unlocked()/K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3213 st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3214 _g1_storage.low_boundary(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3215 _g1_storage.high(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3216 _g1_storage.high_boundary()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3217 st->cr(); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
3218 st->print(" region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3219 size_t young_regions = _young_list->length(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3220 st->print(SIZE_FORMAT " young (" SIZE_FORMAT "K), ", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3221 young_regions, young_regions * HeapRegion::GrainBytes / K); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3222 size_t survivor_regions = g1_policy()->recorded_survivor_regions(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3223 st->print(SIZE_FORMAT " survivors (" SIZE_FORMAT "K)", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3224 survivor_regions, survivor_regions * HeapRegion::GrainBytes / K); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3225 st->cr(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3226 perm()->as_gen()->print_on(st); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3227 } |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3228 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3229 void G1CollectedHeap::print_extended_on(outputStream* st) const { |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3230 print_on(st); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3231 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3232 // Print the per-region information. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3233 st->cr(); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3234 st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), HS=humongous(starts), HC=humongous(continues), CS=collection set, F=free, TS=gc time stamp, PTAMS=previous top-at-mark-start, NTAMS=next top-at-mark-start)"); |
| 342 | 3235 PrintRegionClosure blk(st); |
| 3766 | 3236 heap_region_iterate(&blk); |
| 342 | 3237 } |
| 3238 | |
| 3239 void G1CollectedHeap::print_gc_threads_on(outputStream* st) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3240 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 1019 | 3241 workers()->print_worker_threads_on(st); |
| 3242 } | |
| 3243 _cmThread->print_on(st); | |
| 342 | 3244 st->cr(); |
| 1019 | 3245 _cm->print_worker_threads_on(st); |
| 3246 _cg1r->print_worker_threads_on(st); | |
| 342 | 3247 st->cr(); |
| 3248 } | |
| 3249 | |
| 3250 void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3251 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 3252 workers()->threads_do(tc); |
| 3253 } | |
| 3254 tc->do_thread(_cmThread); | |
| 794 | 3255 _cg1r->threads_do(tc); |
| 342 | 3256 } |
| 3257 | |
| 3258 void G1CollectedHeap::print_tracing_info() const { | |
| 3259 // We'll overload this to mean "trace GC pause statistics." | |
| 3260 if (TraceGen0Time || TraceGen1Time) { | |
| 3261 // The "G1CollectorPolicy" is keeping track of these stats, so delegate | |
| 3262 // to that. | |
| 3263 g1_policy()->print_tracing_info(); | |
| 3264 } | |
| 751 | 3265 if (G1SummarizeRSetStats) { |
| 342 | 3266 g1_rem_set()->print_summary_info(); |
| 3267 } | |
| 1282 | 3268 if (G1SummarizeConcMark) { |
| 342 | 3269 concurrent_mark()->print_summary_info(); |
| 3270 } | |
| 3271 g1_policy()->print_yg_surv_rate_info(); | |
| 3272 SpecializationStats::print(); | |
| 3273 } | |
| 3274 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3275 #ifndef PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3276 // Helpful for debugging RSet issues. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3277 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3278 class PrintRSetsClosure : public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3279 private: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3280 const char* _msg; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3281 size_t _occupied_sum; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3282 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3283 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3284 bool doHeapRegion(HeapRegion* r) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3285 HeapRegionRemSet* hrrs = r->rem_set(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3286 size_t occupied = hrrs->occupied(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3287 _occupied_sum += occupied; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3288 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3289 gclog_or_tty->print_cr("Printing RSet for region "HR_FORMAT, |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3290 HR_FORMAT_PARAMS(r)); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3291 if (occupied == 0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3292 gclog_or_tty->print_cr(" RSet is empty"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3293 } else { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3294 hrrs->print(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3295 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3296 gclog_or_tty->print_cr("----------"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3297 return false; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3298 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3299 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3300 PrintRSetsClosure(const char* msg) : _msg(msg), _occupied_sum(0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3301 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3302 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3303 gclog_or_tty->print_cr(msg); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3304 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3305 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3306 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3307 ~PrintRSetsClosure() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3308 gclog_or_tty->print_cr("Occupied Sum: "SIZE_FORMAT, _occupied_sum); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3309 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3310 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3311 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3312 }; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3313 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3314 void G1CollectedHeap::print_cset_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3315 PrintRSetsClosure cl("Printing CSet RSets"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3316 collection_set_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3317 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3318 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3319 void G1CollectedHeap::print_all_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3320 PrintRSetsClosure cl("Printing All RSets");; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3321 heap_region_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3322 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3323 #endif // PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3324 |
| 342 | 3325 G1CollectedHeap* G1CollectedHeap::heap() { |
| 3326 assert(_sh->kind() == CollectedHeap::G1CollectedHeap, | |
| 3327 "not a garbage-first heap"); | |
| 3328 return _g1h; | |
| 3329 } | |
| 3330 | |
| 3331 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) { | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3332 // always_do_update_barrier = false; |
| 342 | 3333 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); |
| 3334 // Call allocation profiler | |
| 3335 AllocationProfiler::iterate_since_last_gc(); | |
| 3336 // Fill TLAB's and such | |
| 3337 ensure_parsability(true); | |
| 3338 } | |
| 3339 | |
| 3340 void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) { | |
| 3341 // FIXME: what is this about? | |
| 3342 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled" | |
| 3343 // is set. | |
| 3344 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), | |
| 3345 "derived pointer present")); | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3346 // always_do_update_barrier = true; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3347 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3348 // We have just completed a GC. Update the soft reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3349 // policy with the new heap occupancy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3350 Universe::update_heap_info_at_gc(); |
| 342 | 3351 } |
| 3352 | |
| 1973 | 3353 HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size, |
| 3354 unsigned int gc_count_before, | |
| 3355 bool* succeeded) { | |
| 3356 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 3357 g1_policy()->record_stop_world_start(); |
| 1973 | 3358 VM_G1IncCollectionPause op(gc_count_before, |
| 3359 word_size, | |
| 3360 false, /* should_initiate_conc_mark */ | |
| 3361 g1_policy()->max_pause_time_ms(), | |
| 3362 GCCause::_g1_inc_collection_pause); | |
| 3363 VMThread::execute(&op); | |
| 3364 | |
| 3365 HeapWord* result = op.result(); | |
| 3366 bool ret_succeeded = op.prologue_succeeded() && op.pause_succeeded(); | |
| 3367 assert(result == NULL || ret_succeeded, | |
| 3368 "the result should be NULL if the VM did not succeed"); | |
| 3369 *succeeded = ret_succeeded; | |
| 3370 | |
| 3371 assert_heap_not_locked(); | |
| 3372 return result; | |
| 342 | 3373 } |
| 3374 | |
| 3375 void | |
| 3376 G1CollectedHeap::doConcurrentMark() { | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3377 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3378 if (!_cmThread->in_progress()) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3379 _cmThread->set_started(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3380 CGC_lock->notify(); |
| 342 | 3381 } |
| 3382 } | |
| 3383 | |
| 3384 double G1CollectedHeap::predict_region_elapsed_time_ms(HeapRegion *hr, | |
| 3385 bool young) { | |
| 3386 return _g1_policy->predict_region_elapsed_time_ms(hr, young); | |
| 3387 } | |
| 3388 | |
| 3389 void G1CollectedHeap::check_if_region_is_too_expensive(double | |
| 3390 predicted_time_ms) { | |
| 3391 _g1_policy->check_if_region_is_too_expensive(predicted_time_ms); | |
| 3392 } | |
| 3393 | |
| 3394 size_t G1CollectedHeap::pending_card_num() { | |
| 3395 size_t extra_cards = 0; | |
| 3396 JavaThread *curr = Threads::first(); | |
| 3397 while (curr != NULL) { | |
| 3398 DirtyCardQueue& dcq = curr->dirty_card_queue(); | |
| 3399 extra_cards += dcq.size(); | |
| 3400 curr = curr->next(); | |
| 3401 } | |
| 3402 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3403 size_t buffer_size = dcqs.buffer_size(); | |
| 3404 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 3405 return buffer_size * buffer_num + extra_cards; | |
| 3406 } | |
| 3407 | |
| 3408 size_t G1CollectedHeap::max_pending_card_num() { | |
| 3409 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3410 size_t buffer_size = dcqs.buffer_size(); | |
| 3411 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 3412 int thread_num = Threads::number_of_threads(); | |
| 3413 return (buffer_num + thread_num) * buffer_size; | |
| 3414 } | |
| 3415 | |
| 3416 size_t G1CollectedHeap::cards_scanned() { | |
| 1861 | 3417 return g1_rem_set()->cardsScanned(); |
| 342 | 3418 } |
| 3419 | |
| 3420 void | |
| 3421 G1CollectedHeap::setup_surviving_young_words() { | |
| 3422 guarantee( _surviving_young_words == NULL, "pre-condition" ); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
3423 size_t array_length = g1_policy()->young_cset_region_length(); |
| 342 | 3424 _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, array_length); |
| 3425 if (_surviving_young_words == NULL) { | |
| 3426 vm_exit_out_of_memory(sizeof(size_t) * array_length, | |
| 3427 "Not enough space for young surv words summary."); | |
| 3428 } | |
| 3429 memset(_surviving_young_words, 0, array_length * sizeof(size_t)); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3430 #ifdef ASSERT |
| 342 | 3431 for (size_t i = 0; i < array_length; ++i) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3432 assert( _surviving_young_words[i] == 0, "memset above" ); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3433 } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3434 #endif // !ASSERT |
| 342 | 3435 } |
| 3436 | |
| 3437 void | |
| 3438 G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { | |
| 3439 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
3440 size_t array_length = g1_policy()->young_cset_region_length(); |
| 342 | 3441 for (size_t i = 0; i < array_length; ++i) |
| 3442 _surviving_young_words[i] += surv_young_words[i]; | |
| 3443 } | |
| 3444 | |
| 3445 void | |
| 3446 G1CollectedHeap::cleanup_surviving_young_words() { | |
| 3447 guarantee( _surviving_young_words != NULL, "pre-condition" ); | |
| 3448 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words); | |
| 3449 _surviving_young_words = NULL; | |
| 3450 } | |
| 3451 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3452 #ifdef ASSERT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3453 class VerifyCSetClosure: public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3454 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3455 bool doHeapRegion(HeapRegion* hr) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3456 // Here we check that the CSet region's RSet is ready for parallel |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3457 // iteration. The fields that we'll verify are only manipulated |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3458 // when the region is part of a CSet and is collected. Afterwards, |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3459 // we reset these fields when we clear the region's RSet (when the |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3460 // region is freed) so they are ready when the region is |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3461 // re-allocated. The only exception to this is if there's an |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3462 // evacuation failure and instead of freeing the region we leave |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3463 // it in the heap. In that case, we reset these fields during |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3464 // evacuation failure handling. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3465 guarantee(hr->rem_set()->verify_ready_for_par_iteration(), "verification"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3466 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3467 // Here's a good place to add any other checks we'd like to |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3468 // perform on CSet regions. |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3469 return false; |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3470 } |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3471 }; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3472 #endif // ASSERT |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3473 |
| 1709 | 3474 #if TASKQUEUE_STATS |
| 3475 void G1CollectedHeap::print_taskqueue_stats_hdr(outputStream* const st) { | |
| 3476 st->print_raw_cr("GC Task Stats"); | |
| 3477 st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr(); | |
| 3478 st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); | |
| 3479 } | |
| 3480 | |
| 3481 void G1CollectedHeap::print_taskqueue_stats(outputStream* const st) const { | |
| 3482 print_taskqueue_stats_hdr(st); | |
| 3483 | |
| 3484 TaskQueueStats totals; | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3485 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3486 for (int i = 0; i < n; ++i) { |
| 3487 st->print("%3d ", i); task_queue(i)->stats.print(st); st->cr(); | |
| 3488 totals += task_queue(i)->stats; | |
| 3489 } | |
| 3490 st->print_raw("tot "); totals.print(st); st->cr(); | |
| 3491 | |
| 3492 DEBUG_ONLY(totals.verify()); | |
| 3493 } | |
| 3494 | |
| 3495 void G1CollectedHeap::reset_taskqueue_stats() { | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3496 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3497 for (int i = 0; i < n; ++i) { |
| 3498 task_queue(i)->stats.reset(); | |
| 3499 } | |
| 3500 } | |
| 3501 #endif // TASKQUEUE_STATS | |
| 3502 | |
| 1973 | 3503 bool |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3504 G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { |
| 2152 | 3505 assert_at_safepoint(true /* should_be_vm_thread */); |
| 3506 guarantee(!is_gc_active(), "collection is not reentrant"); | |
| 3507 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3508 if (GC_locker::check_active_before_gc()) { |
| 1973 | 3509 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3510 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3511 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
3512 SvcGCMarker sgcm(SvcGCMarker::MINOR); |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3513 ResourceMark rm; |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3514 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3515 if (PrintHeapAtGC) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3516 Universe::print_heap_before_gc(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3517 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3518 |
| 4072 | 3519 HRSPhaseSetter x(HRSPhaseEvacuation); |
| 2152 | 3520 verify_region_sets_optional(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3521 verify_dirty_young_regions(); |
| 2152 | 3522 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3523 { |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3524 // This call will decide whether this pause is an initial-mark |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3525 // pause. If it is, during_initial_mark_pause() will return true |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3526 // for the duration of this pause. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3527 g1_policy()->decide_on_conc_mark_initiation(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3528 |
| 4710 | 3529 // We do not allow initial-mark to be piggy-backed on a mixed GC. |
|
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3980
diff
changeset
|
3530 assert(!g1_policy()->during_initial_mark_pause() || |
| 4710 | 3531 g1_policy()->gcs_are_young(), "sanity"); |
| 3532 | |
| 3533 // We also do not allow mixed GCs during marking. | |
| 3534 assert(!mark_in_progress() || g1_policy()->gcs_are_young(), "sanity"); | |
|
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3980
diff
changeset
|
3535 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3536 char verbose_str[128]; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3537 sprintf(verbose_str, "GC pause "); |
| 4710 | 3538 if (g1_policy()->gcs_are_young()) { |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3539 strcat(verbose_str, "(young)"); |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3540 } else { |
| 4710 | 3541 strcat(verbose_str, "(mixed)"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3542 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3543 if (g1_policy()->during_initial_mark_pause()) { |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3544 strcat(verbose_str, " (initial-mark)"); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3545 // We are about to start a marking cycle, so we increment the |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3546 // full collection counter. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3547 increment_total_full_collections(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3548 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3549 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3550 // if PrintGCDetails is on, we'll print long statistics information |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3551 // in the collector policy code, so let's not print this as the output |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3552 // is messy if we do. |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3553 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3554 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3555 TraceTime t(verbose_str, PrintGC && !PrintGCDetails, true, gclog_or_tty); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3556 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3557 TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
3558 TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
3559 |
| 2361 | 3560 // If the secondary_free_list is not empty, append it to the |
| 3561 // free_list. No need to wait for the cleanup operation to finish; | |
| 3562 // the region allocation code will check the secondary_free_list | |
| 3563 // and wait if necessary. If the G1StressConcRegionFreeing flag is | |
| 3564 // set, skip this step so that the region allocation code has to | |
| 3565 // get entries from the secondary_free_list. | |
| 2152 | 3566 if (!G1StressConcRegionFreeing) { |
| 2361 | 3567 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 3568 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3569 |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3570 assert(check_young_list_well_formed(), |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3571 "young list should be well formed"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3572 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3573 // Don't dynamically change the number of GC threads this early. A value of |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3574 // 0 is used to indicate serial work. When parallel work is done, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3575 // it will be set. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3576 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3577 { // Call to jvmpi::post_class_unload_events must occur outside of active GC |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3578 IsGCActiveMark x; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3579 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3580 gc_prologue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3581 increment_total_collections(false /* full gc */); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3582 increment_gc_time_stamp(); |
| 342 | 3583 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3584 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3585 HandleMark hm; // Discard invalid handles created during verification |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3586 gclog_or_tty->print(" VerifyBeforeGC:"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3587 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3588 Universe::verify(/* allow dirty */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3589 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3590 /* option */ VerifyOption_G1UsePrevMarking); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3591 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3592 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3593 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3594 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3595 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3596 // Please see comment in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3597 // G1CollectedHeap::ref_processing_init() to see how |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3598 // reference processing currently works in G1. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3599 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3600 // Enable discovery in the STW reference processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3601 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3602 true /*verify_no_refs*/); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3603 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3604 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3605 // We want to temporarily turn off discovery by the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3606 // CM ref processor, if necessary, and turn it back on |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3607 // on again later if we do. Using a scoped |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3608 // NoRefDiscovery object will do this. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3609 NoRefDiscovery no_cm_discovery(ref_processor_cm()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3610 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3611 // Forget the current alloc region (we might even choose it to be part |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3612 // of the collection set!). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3613 release_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3614 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3615 // We should call this after we retire the mutator alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3616 // region(s) so that all the ALLOC / RETIRE events are generated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3617 // before the start GC event. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3618 _hr_printer.start_gc(false /* full */, (size_t) total_collections()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3619 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3620 // The elapsed time induced by the start time below deliberately elides |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3621 // the possible verification above. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3622 double start_time_sec = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3623 size_t start_used_bytes = used(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3624 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3625 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3626 gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3627 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3628 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3629 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3630 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3631 g1_policy()->record_collection_pause_start(start_time_sec, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3632 start_used_bytes); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3633 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3634 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3635 gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3636 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3637 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3638 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3639 if (g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3640 concurrent_mark()->checkpointRootsInitialPre(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3641 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3642 perm_gen()->save_marks(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3643 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3644 // We must do this before any possible evacuation that should propagate |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3645 // marks. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3646 if (mark_in_progress()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3647 double start_time_sec = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3648 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3649 _cm->drainAllSATBBuffers(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3650 double finish_mark_ms = (os::elapsedTime() - start_time_sec) * 1000.0; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3651 g1_policy()->record_satb_drain_time(finish_mark_ms); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3652 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3653 // Record the number of elements currently on the mark stack, so we |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3654 // only iterate over these. (Since evacuation may add to the mark |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3655 // stack, doing more exposes race conditions.) If no mark is in |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3656 // progress, this will be zero. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3657 _cm->set_oops_do_bound(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3658 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3659 if (mark_in_progress()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3660 concurrent_mark()->newCSet(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3661 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3662 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3663 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3664 gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3665 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3666 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3667 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3668 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3669 g1_policy()->choose_collection_set(target_pause_time_ms); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3670 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3671 if (_hr_printer.is_active()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3672 HeapRegion* hr = g1_policy()->collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3673 while (hr != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3674 G1HRPrinter::RegionType type; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3675 if (!hr->is_young()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3676 type = G1HRPrinter::Old; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3677 } else if (hr->is_survivor()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3678 type = G1HRPrinter::Survivor; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3679 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3680 type = G1HRPrinter::Eden; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3681 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3682 _hr_printer.cset(hr); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3683 hr = hr->next_in_collection_set(); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3684 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3685 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3686 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3687 // We have chosen the complete collection set. If marking is |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3688 // active then, we clear the region fields of any of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3689 // concurrent marking tasks whose region fields point into |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3690 // the collection set as these values will become stale. This |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3691 // will cause the owning marking threads to claim a new region |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3692 // when marking restarts. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3693 if (mark_in_progress()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3694 concurrent_mark()->reset_active_task_region_fields_in_cset(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3695 } |
|
3378
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3377
diff
changeset
|
3696 |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3697 #ifdef ASSERT |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3698 VerifyCSetClosure cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3699 collection_set_iterate(&cl); |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3700 #endif // ASSERT |
| 1707 | 3701 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3702 setup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3703 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3704 // Initialize the GC alloc regions. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3705 init_gc_alloc_regions(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3706 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3707 // Actually do the work... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3708 evacuate_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3709 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3710 free_collection_set(g1_policy()->collection_set()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3711 g1_policy()->clear_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3712 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3713 cleanup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3714 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3715 // Start a new incremental collection set for the next pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3716 g1_policy()->start_incremental_cset_building(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3717 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3718 // Clear the _cset_fast_test bitmap in anticipation of adding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3719 // regions to the incremental collection set for the next |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3720 // evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3721 clear_cset_fast_test(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3722 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3723 _young_list->reset_sampled_info(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3724 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3725 // Don't check the whole heap at this point as the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3726 // GC alloc regions from this pause have been tagged |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3727 // as survivors and moved on to the survivor list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3728 // Survivor regions will fail the !is_young() check. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3729 assert(check_young_list_empty(false /* check_heap */), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3730 "young list should be empty"); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3731 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3732 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3733 gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3734 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3735 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3736 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3737 g1_policy()->record_survivor_regions(_young_list->survivor_length(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3738 _young_list->first_survivor_region(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3739 _young_list->last_survivor_region()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3740 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3741 _young_list->reset_auxilary_lists(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3742 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3743 if (evacuation_failed()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3744 _summary_bytes_used = recalculate_used(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3745 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3746 // The "used" of the the collection set have already been subtracted |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3747 // when they were freed. Add in the bytes evacuated. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3748 _summary_bytes_used += g1_policy()->bytes_copied_during_gc(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3749 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3750 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3751 if (g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3752 concurrent_mark()->checkpointRootsInitialPost(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3753 set_marking_started(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3754 // CAUTION: after the doConcurrentMark() call below, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3755 // the concurrent marking thread(s) could be running |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3756 // concurrently with us. Make sure that anything after |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3757 // this point does not assume that we are the only GC thread |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3758 // running. Note: of course, the actual marking work will |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3759 // not start until the safepoint itself is released in |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3760 // ConcurrentGCThread::safepoint_desynchronize(). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3761 doConcurrentMark(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3762 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3763 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3764 allocate_dummy_regions(); |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
3765 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3766 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3767 gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3768 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3769 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3770 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3771 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3772 init_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3773 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3774 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3775 size_t expand_bytes = g1_policy()->expansion_amount(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3776 if (expand_bytes > 0) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3777 size_t bytes_before = capacity(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3778 if (!expand(expand_bytes)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3779 // We failed to expand the heap so let's verify that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3780 // committed/uncommitted amount match the backing store |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3781 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3782 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3783 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3784 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3785 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3786 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3787 double end_time_sec = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3788 double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3789 g1_policy()->record_pause_time_ms(pause_time_ms); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3790 int active_gc_threads = workers()->active_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3791 g1_policy()->record_collection_pause_end(active_gc_threads); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3792 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3793 MemoryService::track_memory_usage(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3794 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3795 // In prepare_for_verify() below we'll need to scan the deferred |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3796 // update buffers to bring the RSets up-to-date if |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3797 // G1HRRSFlushLogBuffersOnVerify has been set. While scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3798 // the update buffers we'll probably need to scan cards on the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3799 // regions we just allocated to (i.e., the GC alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3800 // regions). However, during the last GC we called |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3801 // set_saved_mark() on all the GC alloc regions, so card |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3802 // scanning might skip the [saved_mark_word()...top()] area of |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3803 // those regions (i.e., the area we allocated objects into |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3804 // during the last GC). But it shouldn't. Given that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3805 // saved_mark_word() is conditional on whether the GC time stamp |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3806 // on the region is current or not, by incrementing the GC time |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3807 // stamp here we invalidate all the GC time stamps on all the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3808 // regions and saved_mark_word() will simply return top() for |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3809 // all the regions. This is a nicer way of ensuring this rather |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3810 // than iterating over the regions and fixing them. In fact, the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3811 // GC time stamp increment here also ensures that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3812 // saved_mark_word() will return top() between pauses, i.e., |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3813 // during concurrent refinement. So we don't need the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3814 // is_gc_active() check to decided which top to use when |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3815 // scanning cards (see CR 7039627). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3816 increment_gc_time_stamp(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3817 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3818 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3819 HandleMark hm; // Discard invalid handles created during verification |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3820 gclog_or_tty->print(" VerifyAfterGC:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3821 prepare_for_verify(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3822 Universe::verify(/* allow dirty */ true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3823 /* silent */ false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3824 /* option */ VerifyOption_G1UsePrevMarking); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3825 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3826 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3827 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3828 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3829 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3830 // CM reference discovery will be re-enabled if necessary. |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3831 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3832 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3833 { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3834 size_t expand_bytes = g1_policy()->expansion_amount(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3835 if (expand_bytes > 0) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3836 size_t bytes_before = capacity(); |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
3837 // No need for an ergo verbose message here, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
3838 // expansion_amount() does this when it returns a value > 0. |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3839 if (!expand(expand_bytes)) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3840 // We failed to expand the heap so let's verify that |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3841 // committed/uncommitted amount match the backing store |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3842 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3843 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3844 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3845 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3846 } |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3847 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3848 // We should do this after we potentially expand the heap so |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3849 // that all the COMMIT events are generated before the end GC |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3850 // event, and after we retire the GC alloc regions so that all |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3851 // RETIRE events are generated before the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3852 _hr_printer.end_gc(false /* full */, (size_t) total_collections()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3853 |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
3378
diff
changeset
|
3854 // We have to do this after we decide whether to expand the heap or not. |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
3378
diff
changeset
|
3855 g1_policy()->print_heap_transition(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3856 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3857 if (mark_in_progress()) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3858 concurrent_mark()->update_g1_committed(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3859 } |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3860 |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3861 #ifdef TRACESPINNING |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3862 ParallelTaskTerminator::print_termination_counts(); |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3863 #endif |
| 342 | 3864 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3865 gc_epilogue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3866 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3867 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3868 if (ExitAfterGCNum > 0 && total_collections() == ExitAfterGCNum) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3869 gclog_or_tty->print_cr("Stopping after GC #%d", ExitAfterGCNum); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3870 print_tracing_info(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3871 vm_exit(-1); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3872 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3873 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3874 |
| 3766 | 3875 _hrs.verify_optional(); |
| 2152 | 3876 verify_region_sets_optional(); |
| 3877 | |
| 1709 | 3878 TASKQUEUE_STATS_ONLY(if (ParallelGCVerbose) print_taskqueue_stats()); |
| 3879 TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); | |
| 3880 | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3881 if (PrintHeapAtGC) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3882 Universe::print_heap_after_gc(); |
| 342 | 3883 } |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
3884 g1mm()->update_sizes(); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3885 |
|
884
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3886 if (G1SummarizeRSetStats && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3887 (G1SummarizeRSetStatsPeriod > 0) && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3888 (total_collections() % G1SummarizeRSetStatsPeriod == 0)) { |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3889 g1_rem_set()->print_summary_info(); |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3890 } |
| 1973 | 3891 |
| 3892 return true; | |
| 342 | 3893 } |
| 3894 | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3895 size_t G1CollectedHeap::desired_plab_sz(GCAllocPurpose purpose) |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3896 { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3897 size_t gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3898 switch (purpose) { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3899 case GCAllocForSurvived: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3900 gclab_word_size = YoungPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3901 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3902 case GCAllocForTenured: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3903 gclab_word_size = OldPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3904 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3905 default: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3906 assert(false, "unknown GCAllocPurpose"); |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3907 gclab_word_size = OldPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3908 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3909 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3910 return gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3911 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3912 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3913 void G1CollectedHeap::init_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3914 assert(_mutator_alloc_region.get() == NULL, "pre-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3915 _mutator_alloc_region.init(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3916 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3917 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3918 void G1CollectedHeap::release_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3919 _mutator_alloc_region.release(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3920 assert(_mutator_alloc_region.get() == NULL, "post-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3921 } |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3922 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3923 void G1CollectedHeap::init_gc_alloc_regions() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3924 assert_at_safepoint(true /* should_be_vm_thread */); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3925 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3926 _survivor_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3927 _old_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3928 HeapRegion* retained_region = _retained_old_gc_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3929 _retained_old_gc_alloc_region = NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3930 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3931 // We will discard the current GC alloc region if: |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3932 // a) it's in the collection set (it can happen!), |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3933 // b) it's already full (no point in using it), |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3934 // c) it's empty (this means that it was emptied during |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3935 // a cleanup and it should be on the free list now), or |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3936 // d) it's humongous (this means that it was emptied |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3937 // during a cleanup and was added to the free list, but |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3938 // has been subseqently used to allocate a humongous |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3939 // object that may be less than the region size). |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3940 if (retained_region != NULL && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3941 !retained_region->in_collection_set() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3942 !(retained_region->top() == retained_region->end()) && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3943 !retained_region->is_empty() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3944 !retained_region->isHumongous()) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3945 retained_region->set_saved_mark(); |
| 4072 | 3946 // The retained region was added to the old region set when it was |
| 3947 // retired. We have to remove it now, since we don't allow regions | |
| 3948 // we allocate to in the region sets. We'll re-add it later, when | |
| 3949 // it's retired again. | |
| 3950 _old_set.remove(retained_region); | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3951 _old_gc_alloc_region.set(retained_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3952 _hr_printer.reuse(retained_region); |
| 342 | 3953 } |
| 3954 } | |
| 3955 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3956 void G1CollectedHeap::release_gc_alloc_regions() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3957 _survivor_gc_alloc_region.release(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3958 // If we have an old GC alloc region to release, we'll save it in |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3959 // _retained_old_gc_alloc_region. If we don't |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3960 // _retained_old_gc_alloc_region will become NULL. This is what we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3961 // want either way so no reason to check explicitly for either |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3962 // condition. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3963 _retained_old_gc_alloc_region = _old_gc_alloc_region.release(); |
| 342 | 3964 } |
| 3965 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3966 void G1CollectedHeap::abandon_gc_alloc_regions() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3967 assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3968 assert(_old_gc_alloc_region.get() == NULL, "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
3969 _retained_old_gc_alloc_region = NULL; |
| 342 | 3970 } |
| 3971 | |
| 3972 void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) { | |
| 3973 _drain_in_progress = false; | |
| 3974 set_evac_failure_closure(cl); | |
| 3975 _evac_failure_scan_stack = new (ResourceObj::C_HEAP) GrowableArray<oop>(40, true); | |
| 3976 } | |
| 3977 | |
| 3978 void G1CollectedHeap::finalize_for_evac_failure() { | |
| 3979 assert(_evac_failure_scan_stack != NULL && | |
| 3980 _evac_failure_scan_stack->length() == 0, | |
| 3981 "Postcondition"); | |
| 3982 assert(!_drain_in_progress, "Postcondition"); | |
| 1045 | 3983 delete _evac_failure_scan_stack; |
| 342 | 3984 _evac_failure_scan_stack = NULL; |
| 3985 } | |
| 3986 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3987 class UpdateRSetDeferred : public OopsInHeapRegionClosure { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3988 private: |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3989 G1CollectedHeap* _g1; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3990 DirtyCardQueue *_dcq; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3991 CardTableModRefBS* _ct_bs; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3992 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3993 public: |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3994 UpdateRSetDeferred(G1CollectedHeap* g1, DirtyCardQueue* dcq) : |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3995 _g1(g1), _ct_bs((CardTableModRefBS*)_g1->barrier_set()), _dcq(dcq) {} |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
3996 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3997 virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3998 virtual void do_oop( oop* p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3999 template <class T> void do_oop_work(T* p) { |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4000 assert(_from->is_in_reserved(p), "paranoia"); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4001 if (!_from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4002 !_from->is_survivor()) { |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4003 size_t card_index = _ct_bs->index_for(p); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4004 if (_ct_bs->mark_card_deferred(card_index)) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4005 _dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index)); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4006 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4007 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4008 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4009 }; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4010 |
| 342 | 4011 class RemoveSelfPointerClosure: public ObjectClosure { |
| 4012 private: | |
| 4013 G1CollectedHeap* _g1; | |
| 4014 ConcurrentMark* _cm; | |
| 4015 HeapRegion* _hr; | |
| 4016 size_t _prev_marked_bytes; | |
| 4017 size_t _next_marked_bytes; | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4018 OopsInHeapRegionClosure *_cl; |
| 342 | 4019 public: |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4020 RemoveSelfPointerClosure(G1CollectedHeap* g1, HeapRegion* hr, |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4021 OopsInHeapRegionClosure* cl) : |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4022 _g1(g1), _hr(hr), _cm(_g1->concurrent_mark()), _prev_marked_bytes(0), |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4023 _next_marked_bytes(0), _cl(cl) {} |
| 342 | 4024 |
| 4025 size_t prev_marked_bytes() { return _prev_marked_bytes; } | |
| 4026 size_t next_marked_bytes() { return _next_marked_bytes; } | |
| 4027 | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4028 // <original comment> |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4029 // The original idea here was to coalesce evacuated and dead objects. |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4030 // However that caused complications with the block offset table (BOT). |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4031 // In particular if there were two TLABs, one of them partially refined. |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4032 // |----- TLAB_1--------|----TLAB_2-~~~(partially refined part)~~~| |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4033 // The BOT entries of the unrefined part of TLAB_2 point to the start |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4034 // of TLAB_2. If the last object of the TLAB_1 and the first object |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4035 // of TLAB_2 are coalesced, then the cards of the unrefined part |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4036 // would point into middle of the filler object. |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4037 // The current approach is to not coalesce and leave the BOT contents intact. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4038 // </original comment> |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4039 // |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4040 // We now reset the BOT when we start the object iteration over the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4041 // region and refine its entries for every object we come across. So |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4042 // the above comment is not really relevant and we should be able |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4043 // to coalesce dead objects if we want to. |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4044 void do_object(oop obj) { |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4045 HeapWord* obj_addr = (HeapWord*) obj; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4046 assert(_hr->is_in(obj_addr), "sanity"); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4047 size_t obj_size = obj->size(); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4048 _hr->update_bot_for_object(obj_addr, obj_size); |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4049 if (obj->is_forwarded() && obj->forwardee() == obj) { |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4050 // The object failed to move. |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4051 assert(!_g1->is_obj_dead(obj), "We should not be preserving dead objs."); |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4052 _cm->markPrev(obj); |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4053 assert(_cm->isPrevMarked(obj), "Should be marked!"); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4054 _prev_marked_bytes += (obj_size * HeapWordSize); |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4055 if (_g1->mark_in_progress() && !_g1->is_obj_ill(obj)) { |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4056 _cm->markAndGrayObjectIfNecessary(obj); |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4057 } |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4058 obj->set_mark(markOopDesc::prototype()); |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4059 // While we were processing RSet buffers during the |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4060 // collection, we actually didn't scan any cards on the |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4061 // collection set, since we didn't want to update remebered |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4062 // sets with entries that point into the collection set, given |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4063 // that live objects fromthe collection set are about to move |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4064 // and such entries will be stale very soon. This change also |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4065 // dealt with a reliability issue which involved scanning a |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4066 // card in the collection set and coming across an array that |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4067 // was being chunked and looking malformed. The problem is |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4068 // that, if evacuation fails, we might have remembered set |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4069 // entries missing given that we skipped cards on the |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4070 // collection set. So, we'll recreate such entries now. |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4071 obj->oop_iterate(_cl); |
|
352
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4072 assert(_cm->isPrevMarked(obj), "Should be marked!"); |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4073 } else { |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4074 // The object has been either evacuated or is dead. Fill it with a |
|
e0c09f7ec5c4
6702387: G1: assertion failure: assert(p == current_top || oop(p)->is_oop(),"p is not a block start")
iveresov
parents:
342
diff
changeset
|
4075 // dummy object. |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4076 MemRegion mr((HeapWord*)obj, obj_size); |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
457
diff
changeset
|
4077 CollectedHeap::fill_with_object(mr); |
| 342 | 4078 _cm->clearRangeBothMaps(mr); |
| 4079 } | |
| 4080 } | |
| 4081 }; | |
| 4082 | |
| 4083 void G1CollectedHeap::remove_self_forwarding_pointers() { | |
| 1705 | 4084 UpdateRSetImmediate immediate_update(_g1h->g1_rem_set()); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4085 DirtyCardQueue dcq(&_g1h->dirty_card_queue_set()); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4086 UpdateRSetDeferred deferred_update(_g1h, &dcq); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4087 OopsInHeapRegionClosure *cl; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4088 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4089 cl = &deferred_update; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4090 } else { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4091 cl = &immediate_update; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4092 } |
| 342 | 4093 HeapRegion* cur = g1_policy()->collection_set(); |
| 4094 while (cur != NULL) { | |
| 4095 assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4096 assert(!cur->isHumongous(), "sanity"); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4097 |
| 342 | 4098 if (cur->evacuation_failed()) { |
| 4099 assert(cur->in_collection_set(), "bad CS"); | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4100 RemoveSelfPointerClosure rspc(_g1h, cur, cl); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4101 |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4102 // In the common case we make sure that this is done when the |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4103 // region is freed so that it is "ready-to-go" when it's |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4104 // re-allocated. However, when evacuation failure happens, a |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4105 // region will remain in the heap and might ultimately be added |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4106 // to a CSet in the future. So we have to be careful here and |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4107 // make sure the region's RSet is ready for parallel iteration |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4108 // whenever this might be required in the future. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4109 cur->rem_set()->reset_for_par_iteration(); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
2039
diff
changeset
|
4110 cur->reset_bot(); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4111 cl->set_region(cur); |
| 342 | 4112 cur->object_iterate(&rspc); |
| 4113 | |
| 4114 // A number of manipulations to make the TAMS be the current top, | |
| 4115 // and the marked bytes be the ones observed in the iteration. | |
| 4116 if (_g1h->concurrent_mark()->at_least_one_mark_complete()) { | |
| 4117 // The comments below are the postconditions achieved by the | |
| 4118 // calls. Note especially the last such condition, which says that | |
| 4119 // the count of marked bytes has been properly restored. | |
| 4120 cur->note_start_of_marking(false); | |
| 4121 // _next_top_at_mark_start == top, _next_marked_bytes == 0 | |
| 4122 cur->add_to_marked_bytes(rspc.prev_marked_bytes()); | |
| 4123 // _next_marked_bytes == prev_marked_bytes. | |
| 4124 cur->note_end_of_marking(); | |
| 4125 // _prev_top_at_mark_start == top(), | |
| 4126 // _prev_marked_bytes == prev_marked_bytes | |
| 4127 } | |
| 4128 // If there is no mark in progress, we modified the _next variables | |
| 4129 // above needlessly, but harmlessly. | |
| 4130 if (_g1h->mark_in_progress()) { | |
| 4131 cur->note_start_of_marking(false); | |
| 4132 // _next_top_at_mark_start == top, _next_marked_bytes == 0 | |
| 4133 // _next_marked_bytes == next_marked_bytes. | |
| 4134 } | |
| 4135 } | |
| 4136 cur = cur->next_in_collection_set(); | |
| 4137 } | |
| 4138 assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); | |
| 4139 | |
| 4140 // Now restore saved marks, if any. | |
| 4141 if (_objs_with_preserved_marks != NULL) { | |
| 4142 assert(_preserved_marks_of_objs != NULL, "Both or none."); | |
| 4143 guarantee(_objs_with_preserved_marks->length() == | |
| 4144 _preserved_marks_of_objs->length(), "Both or none."); | |
| 4145 for (int i = 0; i < _objs_with_preserved_marks->length(); i++) { | |
| 4146 oop obj = _objs_with_preserved_marks->at(i); | |
| 4147 markOop m = _preserved_marks_of_objs->at(i); | |
| 4148 obj->set_mark(m); | |
| 4149 } | |
| 4150 // Delete the preserved marks growable arrays (allocated on the C heap). | |
| 4151 delete _objs_with_preserved_marks; | |
| 4152 delete _preserved_marks_of_objs; | |
| 4153 _objs_with_preserved_marks = NULL; | |
| 4154 _preserved_marks_of_objs = NULL; | |
| 4155 } | |
| 4156 } | |
| 4157 | |
| 4158 void G1CollectedHeap::push_on_evac_failure_scan_stack(oop obj) { | |
| 4159 _evac_failure_scan_stack->push(obj); | |
| 4160 } | |
| 4161 | |
| 4162 void G1CollectedHeap::drain_evac_failure_scan_stack() { | |
| 4163 assert(_evac_failure_scan_stack != NULL, "precondition"); | |
| 4164 | |
| 4165 while (_evac_failure_scan_stack->length() > 0) { | |
| 4166 oop obj = _evac_failure_scan_stack->pop(); | |
| 4167 _evac_failure_closure->set_region(heap_region_containing(obj)); | |
| 4168 obj->oop_iterate_backwards(_evac_failure_closure); | |
| 4169 } | |
| 4170 } | |
| 4171 | |
| 4172 oop | |
| 4173 G1CollectedHeap::handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, | |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4174 oop old, |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4175 bool should_mark_root) { |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4176 assert(obj_in_cs(old), |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4177 err_msg("obj: "PTR_FORMAT" should still be in the CSet", |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4178 (HeapWord*) old)); |
| 342 | 4179 markOop m = old->mark(); |
| 4180 oop forward_ptr = old->forward_to_atomic(old); | |
| 4181 if (forward_ptr == NULL) { | |
| 4182 // Forward-to-self succeeded. | |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4183 |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4184 // should_mark_root will be true when this routine is called |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4185 // from a root scanning closure during an initial mark pause. |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4186 // In this case the thread that succeeds in self-forwarding the |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4187 // object is also responsible for marking the object. |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4188 if (should_mark_root) { |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4189 assert(!oopDesc::is_null(old), "shouldn't be"); |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4190 _cm->grayRoot(old); |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4191 } |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4192 |
| 342 | 4193 if (_evac_failure_closure != cl) { |
| 4194 MutexLockerEx x(EvacFailureStack_lock, Mutex::_no_safepoint_check_flag); | |
| 4195 assert(!_drain_in_progress, | |
| 4196 "Should only be true while someone holds the lock."); | |
| 4197 // Set the global evac-failure closure to the current thread's. | |
| 4198 assert(_evac_failure_closure == NULL, "Or locking has failed."); | |
| 4199 set_evac_failure_closure(cl); | |
| 4200 // Now do the common part. | |
| 4201 handle_evacuation_failure_common(old, m); | |
| 4202 // Reset to NULL. | |
| 4203 set_evac_failure_closure(NULL); | |
| 4204 } else { | |
| 4205 // The lock is already held, and this is recursive. | |
| 4206 assert(_drain_in_progress, "This should only be the recursive case."); | |
| 4207 handle_evacuation_failure_common(old, m); | |
| 4208 } | |
| 4209 return old; | |
| 4210 } else { | |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4211 // Forward-to-self failed. Either someone else managed to allocate |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4212 // space for this object (old != forward_ptr) or they beat us in |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4213 // self-forwarding it (old == forward_ptr). |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4214 assert(old == forward_ptr || !obj_in_cs(forward_ptr), |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4215 err_msg("obj: "PTR_FORMAT" forwarded to: "PTR_FORMAT" " |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4216 "should not be in the CSet", |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4217 (HeapWord*) old, (HeapWord*) forward_ptr)); |
| 342 | 4218 return forward_ptr; |
| 4219 } | |
| 4220 } | |
| 4221 | |
| 4222 void G1CollectedHeap::handle_evacuation_failure_common(oop old, markOop m) { | |
| 4223 set_evacuation_failed(true); | |
| 4224 | |
| 4225 preserve_mark_if_necessary(old, m); | |
| 4226 | |
| 4227 HeapRegion* r = heap_region_containing(old); | |
| 4228 if (!r->evacuation_failed()) { | |
| 4229 r->set_evacuation_failed(true); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4230 _hr_printer.evac_failure(r); |
| 342 | 4231 } |
| 4232 | |
| 4233 push_on_evac_failure_scan_stack(old); | |
| 4234 | |
| 4235 if (!_drain_in_progress) { | |
| 4236 // prevent recursion in copy_to_survivor_space() | |
| 4237 _drain_in_progress = true; | |
| 4238 drain_evac_failure_scan_stack(); | |
| 4239 _drain_in_progress = false; | |
| 4240 } | |
| 4241 } | |
| 4242 | |
| 4243 void G1CollectedHeap::preserve_mark_if_necessary(oop obj, markOop m) { | |
|
2038
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4244 assert(evacuation_failed(), "Oversaving!"); |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4245 // We want to call the "for_promotion_failure" version only in the |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4246 // case of a promotion failure. |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4247 if (m->must_be_preserved_for_promotion_failure(obj)) { |
| 342 | 4248 if (_objs_with_preserved_marks == NULL) { |
| 4249 assert(_preserved_marks_of_objs == NULL, "Both or none."); | |
| 4250 _objs_with_preserved_marks = | |
| 4251 new (ResourceObj::C_HEAP) GrowableArray<oop>(40, true); | |
| 4252 _preserved_marks_of_objs = | |
| 4253 new (ResourceObj::C_HEAP) GrowableArray<markOop>(40, true); | |
| 4254 } | |
| 4255 _objs_with_preserved_marks->push(obj); | |
| 4256 _preserved_marks_of_objs->push(m); | |
| 4257 } | |
| 4258 } | |
| 4259 | |
| 4260 HeapWord* G1CollectedHeap::par_allocate_during_gc(GCAllocPurpose purpose, | |
| 4261 size_t word_size) { | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4262 if (purpose == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4263 HeapWord* result = survivor_attempt_allocation(word_size); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4264 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4265 return result; |
| 342 | 4266 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4267 // Let's try to allocate in the old gen in case we can fit the |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4268 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4269 return old_attempt_allocation(word_size); |
| 342 | 4270 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4271 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4272 assert(purpose == GCAllocForTenured, "sanity"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4273 HeapWord* result = old_attempt_allocation(word_size); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4274 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4275 return result; |
| 342 | 4276 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4277 // Let's try to allocate in the survivors in case we can fit the |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4278 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4279 return survivor_attempt_allocation(word_size); |
| 342 | 4280 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4281 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4282 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4283 ShouldNotReachHere(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4284 // Trying to keep some compilers happy. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4285 return NULL; |
| 342 | 4286 } |
| 4287 | |
| 4288 #ifndef PRODUCT | |
| 4289 bool GCLabBitMapClosure::do_bit(size_t offset) { | |
| 4290 HeapWord* addr = _bitmap->offsetToHeapWord(offset); | |
| 4291 guarantee(_cm->isMarked(oop(addr)), "it should be!"); | |
| 4292 return true; | |
| 4293 } | |
| 4294 #endif // PRODUCT | |
| 4295 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4296 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4297 ParGCAllocBuffer(gclab_word_size), |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4298 _should_mark_objects(false), |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4299 _bitmap(G1CollectedHeap::heap()->reserved_region().start(), gclab_word_size), |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4300 _retired(false) |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4301 { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4302 //_should_mark_objects is set to true when G1ParCopyHelper needs to |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4303 // mark the forwarded location of an evacuated object. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4304 // We set _should_mark_objects to true if marking is active, i.e. when we |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4305 // need to propagate a mark, or during an initial mark pause, i.e. when we |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4306 // need to mark objects immediately reachable by the roots. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4307 if (G1CollectedHeap::heap()->mark_in_progress() || |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4308 G1CollectedHeap::heap()->g1_policy()->during_initial_mark_pause()) { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4309 _should_mark_objects = true; |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4310 } |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4311 } |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4312 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4313 G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, int queue_num) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4314 : _g1h(g1h), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4315 _refs(g1h->task_queue(queue_num)), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4316 _dcq(&g1h->dirty_card_queue_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4317 _ct_bs((CardTableModRefBS*)_g1h->barrier_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4318 _g1_rem(g1h->g1_rem_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4319 _hash_seed(17), _queue_num(queue_num), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4320 _term_attempts(0), |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4321 _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)), |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4322 _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4323 _age_table(false), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4324 _strong_roots_time(0), _term_time(0), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4325 _alloc_buffer_waste(0), _undo_waste(0) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4326 { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4327 // we allocate G1YoungSurvRateNumRegions plus one entries, since |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4328 // we "sacrifice" entry 0 to keep track of surviving bytes for |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4329 // non-young regions (where the age is -1) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4330 // We also add a few elements at the beginning and at the end in |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4331 // an attempt to eliminate cache contention |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
4332 size_t real_length = 1 + _g1h->g1_policy()->young_cset_region_length(); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4333 size_t array_length = PADDING_ELEM_NUM + |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4334 real_length + |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4335 PADDING_ELEM_NUM; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4336 _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4337 if (_surviving_young_words_base == NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4338 vm_exit_out_of_memory(array_length * sizeof(size_t), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4339 "Not enough space for young surv histo."); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4340 _surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4341 memset(_surviving_young_words, 0, real_length * sizeof(size_t)); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4342 |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4343 _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4344 _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4345 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4346 _start = os::elapsedTime(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4347 } |
| 342 | 4348 |
| 1709 | 4349 void |
| 4350 G1ParScanThreadState::print_termination_stats_hdr(outputStream* const st) | |
| 4351 { | |
| 4352 st->print_raw_cr("GC Termination Stats"); | |
| 4353 st->print_raw_cr(" elapsed --strong roots-- -------termination-------" | |
| 4354 " ------waste (KiB)------"); | |
| 4355 st->print_raw_cr("thr ms ms % ms % attempts" | |
| 4356 " total alloc undo"); | |
| 4357 st->print_raw_cr("--- --------- --------- ------ --------- ------ --------" | |
| 4358 " ------- ------- -------"); | |
| 4359 } | |
| 4360 | |
| 4361 void | |
| 4362 G1ParScanThreadState::print_termination_stats(int i, | |
| 4363 outputStream* const st) const | |
| 4364 { | |
| 4365 const double elapsed_ms = elapsed_time() * 1000.0; | |
| 4366 const double s_roots_ms = strong_roots_time() * 1000.0; | |
| 4367 const double term_ms = term_time() * 1000.0; | |
| 4368 st->print_cr("%3d %9.2f %9.2f %6.2f " | |
| 4369 "%9.2f %6.2f " SIZE_FORMAT_W(8) " " | |
| 4370 SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), | |
| 4371 i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms, | |
| 4372 term_ms, term_ms * 100 / elapsed_ms, term_attempts(), | |
| 4373 (alloc_buffer_waste() + undo_waste()) * HeapWordSize / K, | |
| 4374 alloc_buffer_waste() * HeapWordSize / K, | |
| 4375 undo_waste() * HeapWordSize / K); | |
| 4376 } | |
| 4377 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4378 #ifdef ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4379 bool G1ParScanThreadState::verify_ref(narrowOop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4380 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4381 assert(UseCompressedOops, "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4382 assert(!has_partial_array_mask(ref), err_msg("ref=" PTR_FORMAT, ref)); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4383 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4384 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4385 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4386 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4387 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4388 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4389 bool G1ParScanThreadState::verify_ref(oop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4390 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4391 if (has_partial_array_mask(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4392 // Must be in the collection set--it's already been copied. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4393 oop p = clear_partial_array_mask(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4394 assert(_g1h->obj_in_cs(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4395 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4396 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4397 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4398 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4399 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4400 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4401 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4402 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4403 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4404 bool G1ParScanThreadState::verify_task(StarTask ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4405 if (ref.is_narrow()) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4406 return verify_ref((narrowOop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4407 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4408 return verify_ref((oop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4409 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4410 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4411 #endif // ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4412 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4413 void G1ParScanThreadState::trim_queue() { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4414 assert(_evac_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4415 assert(_evac_failure_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4416 assert(_partial_scan_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4417 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4418 StarTask ref; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4419 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4420 // Drain the overflow stack first, so other threads can steal. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4421 while (refs()->pop_overflow(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4422 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4423 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4424 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4425 while (refs()->pop_local(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4426 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4427 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4428 } while (!refs()->is_empty()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4429 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4430 |
| 342 | 4431 G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
| 4432 _g1(g1), _g1_rem(_g1->g1_rem_set()), _cm(_g1->concurrent_mark()), | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4433 _par_scan_state(par_scan_state), |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4434 _during_initial_mark(_g1->g1_policy()->during_initial_mark_pause()), |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4435 _mark_in_progress(_g1->mark_in_progress()) { } |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4436 |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4437 template <class T> void G1ParCopyHelper::mark_object(T* p) { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4438 // This is called from do_oop_work for objects that are not |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4439 // in the collection set. Objects in the collection set |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4440 // are marked after they have been evacuated. |
| 342 | 4441 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4442 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4443 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4444 oop obj = oopDesc::decode_heap_oop(heap_oop); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4445 HeapWord* addr = (HeapWord*)obj; |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4446 if (_g1->is_in_g1_reserved(addr)) { |
| 342 | 4447 _cm->grayRoot(oop(addr)); |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4448 } |
| 342 | 4449 } |
| 4450 } | |
| 4451 | |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4452 oop G1ParCopyHelper::copy_to_survivor_space(oop old, bool should_mark_root, |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4453 bool should_mark_copy) { |
| 342 | 4454 size_t word_sz = old->size(); |
| 4455 HeapRegion* from_region = _g1->heap_region_containing_raw(old); | |
| 4456 // +1 to make the -1 indexes valid... | |
| 4457 int young_index = from_region->young_index_in_cset()+1; | |
| 4458 assert( (from_region->is_young() && young_index > 0) || | |
| 4459 (!from_region->is_young() && young_index == 0), "invariant" ); | |
| 4460 G1CollectorPolicy* g1p = _g1->g1_policy(); | |
| 4461 markOop m = old->mark(); | |
| 545 | 4462 int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age() |
| 4463 : m->age(); | |
| 4464 GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age, | |
| 342 | 4465 word_sz); |
| 4466 HeapWord* obj_ptr = _par_scan_state->allocate(alloc_purpose, word_sz); | |
| 4467 oop obj = oop(obj_ptr); | |
| 4468 | |
| 4469 if (obj_ptr == NULL) { | |
| 4470 // This will either forward-to-self, or detect that someone else has | |
| 4471 // installed a forwarding pointer. | |
| 4472 OopsInHeapRegionClosure* cl = _par_scan_state->evac_failure_closure(); | |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4473 return _g1->handle_evacuation_failure_par(cl, old, should_mark_root); |
| 342 | 4474 } |
| 4475 | |
| 526 | 4476 // We're going to allocate linearly, so might as well prefetch ahead. |
| 4477 Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes); | |
| 4478 | |
| 342 | 4479 oop forward_ptr = old->forward_to_atomic(obj); |
| 4480 if (forward_ptr == NULL) { | |
| 4481 Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz); | |
| 526 | 4482 if (g1p->track_object_age(alloc_purpose)) { |
| 4483 // We could simply do obj->incr_age(). However, this causes a | |
| 4484 // performance issue. obj->incr_age() will first check whether | |
| 4485 // the object has a displaced mark by checking its mark word; | |
| 4486 // getting the mark word from the new location of the object | |
| 4487 // stalls. So, given that we already have the mark word and we | |
| 4488 // are about to install it anyway, it's better to increase the | |
| 4489 // age on the mark word, when the object does not have a | |
| 4490 // displaced mark word. We're not expecting many objects to have | |
| 4491 // a displaced marked word, so that case is not optimized | |
| 4492 // further (it could be...) and we simply call obj->incr_age(). | |
| 4493 | |
| 4494 if (m->has_displaced_mark_helper()) { | |
| 4495 // in this case, we have to install the mark word first, | |
| 4496 // otherwise obj looks to be forwarded (the old mark word, | |
| 4497 // which contains the forward pointer, was copied) | |
| 4498 obj->set_mark(m); | |
| 4499 obj->incr_age(); | |
| 4500 } else { | |
| 4501 m = m->incr_age(); | |
| 545 | 4502 obj->set_mark(m); |
| 526 | 4503 } |
| 545 | 4504 _par_scan_state->age_table()->add(obj, word_sz); |
| 4505 } else { | |
| 4506 obj->set_mark(m); | |
| 526 | 4507 } |
| 4508 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4509 // Mark the evacuated object or propagate "next" mark bit |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4510 if (should_mark_copy) { |
| 342 | 4511 if (!use_local_bitmaps || |
| 4512 !_par_scan_state->alloc_buffer(alloc_purpose)->mark(obj_ptr)) { | |
| 4513 // if we couldn't mark it on the local bitmap (this happens when | |
| 4514 // the object was not allocated in the GCLab), we have to bite | |
| 4515 // the bullet and do the standard parallel mark | |
| 4516 _cm->markAndGrayObjectIfNecessary(obj); | |
| 4517 } | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4518 |
| 342 | 4519 if (_g1->isMarkedNext(old)) { |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4520 // Unmark the object's old location so that marking |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4521 // doesn't think the old object is alive. |
| 342 | 4522 _cm->nextMarkBitMap()->parClear((HeapWord*)old); |
| 4523 } | |
| 4524 } | |
| 4525 | |
| 4526 size_t* surv_young_words = _par_scan_state->surviving_young_words(); | |
| 4527 surv_young_words[young_index] += word_sz; | |
| 4528 | |
| 4529 if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) { | |
| 4530 arrayOop(old)->set_length(0); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4531 oop* old_p = set_partial_array_mask(old); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4532 _par_scan_state->push_on_queue(old_p); |
| 342 | 4533 } else { |
| 526 | 4534 // No point in using the slower heap_region_containing() method, |
| 4535 // given that we know obj is in the heap. | |
| 4536 _scanner->set_region(_g1->heap_region_containing_raw(obj)); | |
| 342 | 4537 obj->oop_iterate_backwards(_scanner); |
| 4538 } | |
| 4539 } else { | |
| 4540 _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); | |
| 4541 obj = forward_ptr; | |
| 4542 } | |
| 4543 return obj; | |
| 4544 } | |
| 4545 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4546 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4547 template <class T> |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4548 void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4549 ::do_oop_work(T* p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4550 oop obj = oopDesc::load_decode_heap_oop(p); |
| 342 | 4551 assert(barrier != G1BarrierRS || obj != NULL, |
| 4552 "Precondition: G1BarrierRS implies obj is nonNull"); | |
| 4553 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4554 // Marking: |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4555 // If the object is in the collection set, then the thread |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4556 // that copies the object should mark, or propagate the |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4557 // mark to, the evacuated object. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4558 // If the object is not in the collection set then we |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4559 // should call the mark_object() method depending on the |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4560 // value of the template parameter do_mark_object (which will |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4561 // be true for root scanning closures during an initial mark |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4562 // pause). |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4563 // The mark_object() method first checks whether the object |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4564 // is marked and, if not, attempts to mark the object. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4565 |
| 526 | 4566 // here the null check is implicit in the cset_fast_test() test |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4567 if (_g1->in_cset_fast_test(obj)) { |
| 526 | 4568 if (obj->is_forwarded()) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4569 oopDesc::encode_store_heap_oop(p, obj->forwardee()); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4570 // If we are a root scanning closure during an initial |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4571 // mark pause (i.e. do_mark_object will be true) then |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4572 // we also need to handle marking of roots in the |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4573 // event of an evacuation failure. In the event of an |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4574 // evacuation failure, the object is forwarded to itself |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4575 // and not copied. For root-scanning closures, the |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4576 // object would be marked after a successful self-forward |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4577 // but an object could be pointed to by both a root and non |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4578 // root location and be self-forwarded by a non-root-scanning |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4579 // closure. Therefore we also have to attempt to mark the |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4580 // self-forwarded root object here. |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4581 if (do_mark_object && obj->forwardee() == obj) { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4582 mark_object(p); |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4583 } |
| 526 | 4584 } else { |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4585 // During an initial mark pause, objects that are pointed to |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4586 // by the roots need to be marked - even in the event of an |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4587 // evacuation failure. We pass the template parameter |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4588 // do_mark_object (which is true for root scanning closures |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4589 // during an initial mark pause) to copy_to_survivor_space |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4590 // which will pass it on to the evacuation failure handling |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4591 // code. The thread that successfully self-forwards a root |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4592 // object to itself is responsible for marking the object. |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4593 bool should_mark_root = do_mark_object; |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4594 |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4595 // We need to mark the copied object if we're a root scanning |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4596 // closure during an initial mark pause (i.e. do_mark_object |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4597 // will be true), or the object is already marked and we need |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4598 // to propagate the mark to the evacuated copy. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4599 bool should_mark_copy = do_mark_object || |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4600 _during_initial_mark || |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4601 (_mark_in_progress && !_g1->is_obj_ill(obj)); |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4602 |
|
3973
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4603 oop copy_oop = copy_to_survivor_space(obj, should_mark_root, |
|
663cb89032b1
7092412: G1: Some roots not marked during an initial mark that gets an evacuation failure
johnc
parents:
3920
diff
changeset
|
4604 should_mark_copy); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4605 oopDesc::encode_store_heap_oop(p, copy_oop); |
| 342 | 4606 } |
| 526 | 4607 // When scanning the RS, we only care about objs in CS. |
| 4608 if (barrier == G1BarrierRS) { | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4609 _par_scan_state->update_rs(_from, p, _par_scan_state->queue_num()); |
| 342 | 4610 } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4611 } else { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4612 // The object is not in collection set. If we're a root scanning |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4613 // closure during an initial mark pause (i.e. do_mark_object will |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4614 // be true) then attempt to mark the object. |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4615 if (do_mark_object) { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4616 mark_object(p); |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4617 } |
| 526 | 4618 } |
| 4619 | |
| 4620 if (barrier == G1BarrierEvac && obj != NULL) { | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4621 _par_scan_state->update_rs(_from, p, _par_scan_state->queue_num()); |
| 526 | 4622 } |
| 4623 | |
| 4624 if (do_gen_barrier && obj != NULL) { | |
| 4625 par_do_barrier(p); | |
| 4626 } | |
| 4627 } | |
| 4628 | |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4629 template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(oop* p); |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4630 template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(narrowOop* p); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4631 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4632 template <class T> void G1ParScanPartialArrayClosure::do_oop_nv(T* p) { |
| 526 | 4633 assert(has_partial_array_mask(p), "invariant"); |
| 4634 oop old = clear_partial_array_mask(p); | |
| 342 | 4635 assert(old->is_objArray(), "must be obj array"); |
| 4636 assert(old->is_forwarded(), "must be forwarded"); | |
| 4637 assert(Universe::heap()->is_in_reserved(old), "must be in heap."); | |
| 4638 | |
| 4639 objArrayOop obj = objArrayOop(old->forwardee()); | |
| 4640 assert((void*)old != (void*)old->forwardee(), "self forwarding here?"); | |
| 4641 // Process ParGCArrayScanChunk elements now | |
| 4642 // and push the remainder back onto queue | |
| 4643 int start = arrayOop(old)->length(); | |
| 4644 int end = obj->length(); | |
| 4645 int remainder = end - start; | |
| 4646 assert(start <= end, "just checking"); | |
| 4647 if (remainder > 2 * ParGCArrayScanChunk) { | |
| 4648 // Test above combines last partial chunk with a full chunk | |
| 4649 end = start + ParGCArrayScanChunk; | |
| 4650 arrayOop(old)->set_length(end); | |
| 4651 // Push remainder. | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4652 oop* old_p = set_partial_array_mask(old); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4653 assert(arrayOop(old)->length() < obj->length(), "Empty push?"); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4654 _par_scan_state->push_on_queue(old_p); |
| 342 | 4655 } else { |
| 4656 // Restore length so that the heap remains parsable in | |
| 4657 // case of evacuation failure. | |
| 4658 arrayOop(old)->set_length(end); | |
| 4659 } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4660 _scanner.set_region(_g1->heap_region_containing_raw(obj)); |
| 342 | 4661 // process our set of indices (include header in first chunk) |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4662 obj->oop_iterate_range(&_scanner, start, end); |
| 342 | 4663 } |
| 4664 | |
| 4665 class G1ParEvacuateFollowersClosure : public VoidClosure { | |
| 4666 protected: | |
| 4667 G1CollectedHeap* _g1h; | |
| 4668 G1ParScanThreadState* _par_scan_state; | |
| 4669 RefToScanQueueSet* _queues; | |
| 4670 ParallelTaskTerminator* _terminator; | |
| 4671 | |
| 4672 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } | |
| 4673 RefToScanQueueSet* queues() { return _queues; } | |
| 4674 ParallelTaskTerminator* terminator() { return _terminator; } | |
| 4675 | |
| 4676 public: | |
| 4677 G1ParEvacuateFollowersClosure(G1CollectedHeap* g1h, | |
| 4678 G1ParScanThreadState* par_scan_state, | |
| 4679 RefToScanQueueSet* queues, | |
| 4680 ParallelTaskTerminator* terminator) | |
| 4681 : _g1h(g1h), _par_scan_state(par_scan_state), | |
| 4682 _queues(queues), _terminator(terminator) {} | |
| 4683 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4684 void do_void(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4685 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4686 private: |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4687 inline bool offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4688 }; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4689 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4690 bool G1ParEvacuateFollowersClosure::offer_termination() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4691 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4692 pss->start_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4693 const bool res = terminator()->offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4694 pss->end_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4695 return res; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4696 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4697 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4698 void G1ParEvacuateFollowersClosure::do_void() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4699 StarTask stolen_task; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4700 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4701 pss->trim_queue(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4702 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4703 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4704 while (queues()->steal(pss->queue_num(), pss->hash_seed(), stolen_task)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4705 assert(pss->verify_task(stolen_task), "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4706 if (stolen_task.is_narrow()) { |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4707 pss->deal_with_reference((narrowOop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4708 } else { |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4709 pss->deal_with_reference((oop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4710 } |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4711 |
|
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4712 // We've just processed a reference and we might have made |
|
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4713 // available new entries on the queues. So we have to make sure |
|
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4714 // we drain the queues as necessary. |
| 342 | 4715 pss->trim_queue(); |
| 4716 } | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4717 } while (!offer_termination()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4718 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4719 pss->retire_alloc_buffers(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4720 } |
| 342 | 4721 |
| 4722 class G1ParTask : public AbstractGangTask { | |
| 4723 protected: | |
| 4724 G1CollectedHeap* _g1h; | |
| 4725 RefToScanQueueSet *_queues; | |
| 4726 ParallelTaskTerminator _terminator; | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4727 int _n_workers; |
| 342 | 4728 |
| 4729 Mutex _stats_lock; | |
| 4730 Mutex* stats_lock() { return &_stats_lock; } | |
| 4731 | |
| 4732 size_t getNCards() { | |
| 4733 return (_g1h->capacity() + G1BlockOffsetSharedArray::N_bytes - 1) | |
| 4734 / G1BlockOffsetSharedArray::N_bytes; | |
| 4735 } | |
| 4736 | |
| 4737 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4738 G1ParTask(G1CollectedHeap* g1h, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4739 RefToScanQueueSet *task_queues) |
| 342 | 4740 : AbstractGangTask("G1 collection"), |
| 4741 _g1h(g1h), | |
| 4742 _queues(task_queues), | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4743 _terminator(0, _queues), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4744 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true) |
| 342 | 4745 {} |
| 4746 | |
| 4747 RefToScanQueueSet* queues() { return _queues; } | |
| 4748 | |
| 4749 RefToScanQueue *work_queue(int i) { | |
| 4750 return queues()->queue(i); | |
| 4751 } | |
| 4752 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4753 ParallelTaskTerminator* terminator() { return &_terminator; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4754 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4755 virtual void set_for_termination(int active_workers) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4756 // This task calls set_n_termination() in par_non_clean_card_iterate_work() |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4757 // in the young space (_par_seq_tasks) in the G1 heap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4758 // for SequentialSubTasksDone. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4759 // This task also uses SubTasksDone in SharedHeap and G1CollectedHeap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4760 // both of which need setting by set_n_termination(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4761 _g1h->SharedHeap::set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4762 _g1h->set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4763 terminator()->reset_for_reuse(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4764 _n_workers = active_workers; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4765 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4766 |
| 342 | 4767 void work(int i) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4768 if (i >= _n_workers) return; // no work needed this round |
| 1611 | 4769 |
| 4770 double start_time_ms = os::elapsedTime() * 1000.0; | |
| 4771 _g1h->g1_policy()->record_gc_worker_start_time(i, start_time_ms); | |
| 4772 | |
| 342 | 4773 ResourceMark rm; |
| 4774 HandleMark hm; | |
| 4775 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4776 ReferenceProcessor* rp = _g1h->ref_processor_stw(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4777 |
| 526 | 4778 G1ParScanThreadState pss(_g1h, i); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4779 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4780 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4781 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); |
| 342 | 4782 |
| 4783 pss.set_evac_closure(&scan_evac_cl); | |
| 4784 pss.set_evac_failure_closure(&evac_failure_cl); | |
| 4785 pss.set_partial_scan_closure(&partial_scan_cl); | |
| 4786 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4787 G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4788 G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4789 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4790 G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4791 G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss, rp); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4792 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4793 OopClosure* scan_root_cl = &only_scan_root_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4794 OopsInHeapRegionClosure* scan_perm_cl = &only_scan_perm_cl; |
| 342 | 4795 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
4796 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4797 // We also need to mark copied objects. |
| 342 | 4798 scan_root_cl = &scan_mark_root_cl; |
| 4799 scan_perm_cl = &scan_mark_perm_cl; | |
| 4800 } | |
| 4801 | |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3982
diff
changeset
|
4802 G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4803 |
| 342 | 4804 pss.start_strong_roots(); |
| 4805 _g1h->g1_process_strong_roots(/* not collecting perm */ false, | |
| 4806 SharedHeap::SO_AllClasses, | |
| 4807 scan_root_cl, | |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4808 &push_heap_rs_cl, |
| 342 | 4809 scan_perm_cl, |
| 4810 i); | |
| 4811 pss.end_strong_roots(); | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4812 |
| 342 | 4813 { |
| 4814 double start = os::elapsedTime(); | |
| 4815 G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); | |
| 4816 evac.do_void(); | |
| 4817 double elapsed_ms = (os::elapsedTime()-start)*1000.0; | |
| 4818 double term_ms = pss.term_time()*1000.0; | |
| 4819 _g1h->g1_policy()->record_obj_copy_time(i, elapsed_ms-term_ms); | |
| 1611 | 4820 _g1h->g1_policy()->record_termination(i, term_ms, pss.term_attempts()); |
| 342 | 4821 } |
| 1282 | 4822 _g1h->g1_policy()->record_thread_age_table(pss.age_table()); |
| 342 | 4823 _g1h->update_surviving_young_words(pss.surviving_young_words()+1); |
| 4824 | |
| 4825 // Clean up any par-expanded rem sets. | |
| 4826 HeapRegionRemSet::par_cleanup(); | |
| 4827 | |
| 4828 if (ParallelGCVerbose) { | |
| 1709 | 4829 MutexLocker x(stats_lock()); |
| 4830 pss.print_termination_stats(i); | |
| 342 | 4831 } |
| 4832 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4833 assert(pss.refs()->is_empty(), "should be empty"); |
| 1611 | 4834 double end_time_ms = os::elapsedTime() * 1000.0; |
| 4835 _g1h->g1_policy()->record_gc_worker_end_time(i, end_time_ms); | |
| 342 | 4836 } |
| 4837 }; | |
| 4838 | |
| 4839 // *** Common G1 Evacuation Stuff | |
| 4840 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4841 // This method is run in a GC worker. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4842 |
| 342 | 4843 void |
| 4844 G1CollectedHeap:: | |
| 4845 g1_process_strong_roots(bool collecting_perm_gen, | |
| 4846 SharedHeap::ScanningOption so, | |
| 4847 OopClosure* scan_non_heap_roots, | |
| 4848 OopsInHeapRegionClosure* scan_rs, | |
| 4849 OopsInGenClosure* scan_perm, | |
| 4850 int worker_i) { | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4851 |
| 342 | 4852 // First scan the strong roots, including the perm gen. |
| 4853 double ext_roots_start = os::elapsedTime(); | |
| 4854 double closure_app_time_sec = 0.0; | |
| 4855 | |
| 4856 BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); | |
| 4857 BufferingOopsInGenClosure buf_scan_perm(scan_perm); | |
| 4858 buf_scan_perm.set_generation(perm_gen()); | |
| 4859 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4860 // Walk the code cache w/o buffering, because StarTask cannot handle |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4861 // unaligned oop locations. |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4862 CodeBlobToOopClosure eager_scan_code_roots(scan_non_heap_roots, /*do_marking=*/ true); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4863 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4864 process_strong_roots(false, // no scoping; this is parallel code |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4865 collecting_perm_gen, so, |
| 342 | 4866 &buf_scan_non_heap_roots, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4867 &eager_scan_code_roots, |
| 342 | 4868 &buf_scan_perm); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4869 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4870 // Now the CM ref_processor roots. |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4871 if (!_process_strong_tasks->is_task_claimed(G1H_PS_refProcessor_oops_do)) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4872 // We need to treat the discovered reference lists of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4873 // concurrent mark ref processor as roots and keep entries |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4874 // (which are added by the marking threads) on them live |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4875 // until they can be processed at the end of marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4876 ref_processor_cm()->weak_oops_do(&buf_scan_non_heap_roots); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4877 } |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4878 |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4879 // Finish up any enqueued closure apps (attributed as object copy time). |
| 342 | 4880 buf_scan_non_heap_roots.done(); |
| 4881 buf_scan_perm.done(); | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4882 |
| 342 | 4883 double ext_roots_end = os::elapsedTime(); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4884 |
| 342 | 4885 g1_policy()->reset_obj_copy_time(worker_i); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4886 double obj_copy_time_sec = buf_scan_perm.closure_app_seconds() + |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4887 buf_scan_non_heap_roots.closure_app_seconds(); |
| 342 | 4888 g1_policy()->record_obj_copy_time(worker_i, obj_copy_time_sec * 1000.0); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4889 |
| 342 | 4890 double ext_root_time_ms = |
| 4891 ((ext_roots_end - ext_roots_start) - obj_copy_time_sec) * 1000.0; | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4892 |
| 342 | 4893 g1_policy()->record_ext_root_scan_time(worker_i, ext_root_time_ms); |
| 4894 | |
| 4895 // Scan strong roots in mark stack. | |
| 4896 if (!_process_strong_tasks->is_task_claimed(G1H_PS_mark_stack_oops_do)) { | |
| 4897 concurrent_mark()->oops_do(scan_non_heap_roots); | |
| 4898 } | |
| 4899 double mark_stack_scan_ms = (os::elapsedTime() - ext_roots_end) * 1000.0; | |
| 4900 g1_policy()->record_mark_stack_scan_time(worker_i, mark_stack_scan_ms); | |
| 4901 | |
| 4902 // Now scan the complement of the collection set. | |
| 4903 if (scan_rs != NULL) { | |
| 4904 g1_rem_set()->oops_into_collection_set_do(scan_rs, worker_i); | |
| 4905 } | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4906 |
| 342 | 4907 _process_strong_tasks->all_tasks_completed(); |
| 4908 } | |
| 4909 | |
| 4910 void | |
| 4911 G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure, | |
| 4912 OopClosure* non_root_closure) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4913 CodeBlobToOopClosure roots_in_blobs(root_closure, /*do_marking=*/ false); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4914 SharedHeap::process_weak_roots(root_closure, &roots_in_blobs, non_root_closure); |
| 342 | 4915 } |
| 4916 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4917 // Weak Reference Processing support |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4918 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4919 // An always "is_alive" closure that is used to preserve referents. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4920 // If the object is non-null then it's alive. Used in the preservation |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4921 // of referent objects that are pointed to by reference objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4922 // discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4923 class G1AlwaysAliveClosure: public BoolObjectClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4924 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4925 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4926 G1AlwaysAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4927 void do_object(oop p) { assert(false, "Do not call."); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4928 bool do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4929 if (p != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4930 return true; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4931 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4932 return false; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4933 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4934 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4935 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4936 bool G1STWIsAliveClosure::do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4937 // An object is reachable if it is outside the collection set, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4938 // or is inside and copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4939 return !_g1->obj_in_cs(p) || p->is_forwarded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4940 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4941 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4942 // Non Copying Keep Alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4943 class G1KeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4944 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4945 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4946 G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4947 void do_oop(narrowOop* p) { guarantee(false, "Not needed"); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4948 void do_oop( oop* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4949 oop obj = *p; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4950 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4951 if (_g1->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4952 assert( obj->is_forwarded(), "invariant" ); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4953 *p = obj->forwardee(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4954 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4955 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4956 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4957 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4958 // Copying Keep Alive closure - can be called from both |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4959 // serial and parallel code as long as different worker |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4960 // threads utilize different G1ParScanThreadState instances |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4961 // and different queues. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4962 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4963 class G1CopyingKeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4964 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4965 OopClosure* _copy_non_heap_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4966 OopsInHeapRegionClosure* _copy_perm_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4967 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4968 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4969 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4970 G1CopyingKeepAliveClosure(G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4971 OopClosure* non_heap_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4972 OopsInHeapRegionClosure* perm_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4973 G1ParScanThreadState* pss): |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4974 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4975 _copy_non_heap_obj_cl(non_heap_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4976 _copy_perm_obj_cl(perm_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4977 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4978 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4979 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4980 virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4981 virtual void do_oop( oop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4982 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4983 template <class T> void do_oop_work(T* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4984 oop obj = oopDesc::load_decode_heap_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4985 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4986 if (_g1h->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4987 // If the referent object has been forwarded (either copied |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4988 // to a new location or to itself in the event of an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4989 // evacuation failure) then we need to update the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4990 // field and, if both reference and referent are in the G1 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4991 // heap, update the RSet for the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4992 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4993 // If the referent has not been forwarded then we have to keep |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4994 // it alive by policy. Therefore we have copy the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4995 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4996 // If the reference field is in the G1 heap then we can push |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4997 // on the PSS queue. When the queue is drained (after each |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4998 // phase of reference processing) the object and it's followers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4999 // will be copied, the reference field set to point to the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5000 // new location, and the RSet updated. Otherwise we need to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5001 // use the the non-heap or perm closures directly to copy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5002 // the refernt object and update the pointer, while avoiding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5003 // updating the RSet. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5004 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5005 if (_g1h->is_in_g1_reserved(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5006 _par_scan_state->push_on_queue(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5007 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5008 // The reference field is not in the G1 heap. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5009 if (_g1h->perm_gen()->is_in(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5010 _copy_perm_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5011 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5012 _copy_non_heap_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5013 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5014 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5015 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5016 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5017 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5018 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5019 // Serial drain queue closure. Called as the 'complete_gc' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5020 // closure for each discovered list in some of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5021 // reference processing phases. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5022 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5023 class G1STWDrainQueueClosure: public VoidClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5024 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5025 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5026 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5027 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5028 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5029 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5030 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5031 G1STWDrainQueueClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5032 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5033 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5034 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5035 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5036 void do_void() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5037 G1ParScanThreadState* const pss = par_scan_state(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5038 pss->trim_queue(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5039 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5040 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5041 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5042 // Parallel Reference Processing closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5043 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5044 // Implementation of AbstractRefProcTaskExecutor for parallel reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5045 // processing during G1 evacuation pauses. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5046 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5047 class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5048 private: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5049 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5050 RefToScanQueueSet* _queues; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5051 FlexibleWorkGang* _workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5052 int _active_workers; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5053 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5054 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5055 G1STWRefProcTaskExecutor(G1CollectedHeap* g1h, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5056 FlexibleWorkGang* workers, |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5057 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5058 int n_workers) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5059 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5060 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5061 _workers(workers), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5062 _active_workers(n_workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5063 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5064 assert(n_workers > 0, "shouldn't call this otherwise"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5065 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5066 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5067 // Executes the given task using concurrent marking worker threads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5068 virtual void execute(ProcessTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5069 virtual void execute(EnqueueTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5070 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5071 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5072 // Gang task for possibly parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5073 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5074 class G1STWRefProcTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5075 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5076 ProcessTask& _proc_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5077 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5078 RefToScanQueueSet *_task_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5079 ParallelTaskTerminator* _terminator; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5080 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5081 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5082 G1STWRefProcTaskProxy(ProcessTask& proc_task, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5083 G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5084 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5085 ParallelTaskTerminator* terminator) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5086 AbstractGangTask("Process reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5087 _proc_task(proc_task), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5088 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5089 _task_queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5090 _terminator(terminator) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5091 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5092 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5093 virtual void work(int i) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5094 // The reference processing task executed by a single worker. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5095 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5096 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5097 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5098 G1STWIsAliveClosure is_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5099 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5100 G1ParScanThreadState pss(_g1h, i); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5101 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5102 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5103 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5104 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5105 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5106 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5107 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5108 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5109 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5110 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5111 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5112 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5113 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5114 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5115 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5116 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5117 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5118 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5119 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5120 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5121 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5122 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5123 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5124 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5125 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5126 G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, copy_perm_cl, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5127 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5128 // Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5129 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5130 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5131 // Call the reference processing task's work routine. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5132 _proc_task.work(i, is_alive, keep_alive, drain_queue); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5133 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5134 // Note we cannot assert that the refs array is empty here as not all |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5135 // of the processing tasks (specifically phase2 - pp2_work) execute |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5136 // the complete_gc closure (which ordinarily would drain the queue) so |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5137 // the queue may not be empty. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5138 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5139 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5140 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5141 // Driver routine for parallel reference processing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5142 // Creates an instance of the ref processing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5143 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5144 void G1STWRefProcTaskExecutor::execute(ProcessTask& proc_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5145 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5146 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5147 ParallelTaskTerminator terminator(_active_workers, _queues); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5148 G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5149 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5150 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5151 _workers->run_task(&proc_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5152 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5153 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5154 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5155 // Gang task for parallel reference enqueueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5156 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5157 class G1STWRefEnqueueTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5158 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5159 EnqueueTask& _enq_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5160 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5161 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5162 G1STWRefEnqueueTaskProxy(EnqueueTask& enq_task) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5163 AbstractGangTask("Enqueue reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5164 _enq_task(enq_task) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5165 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5166 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5167 virtual void work(int i) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5168 _enq_task.work(i); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5169 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5170 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5171 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5172 // Driver routine for parallel reference enqueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5173 // Creates an instance of the ref enqueueing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5174 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5175 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5176 void G1STWRefProcTaskExecutor::execute(EnqueueTask& enq_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5177 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5178 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5179 G1STWRefEnqueueTaskProxy enq_task_proxy(enq_task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5180 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5181 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5182 _workers->run_task(&enq_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5183 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5184 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5185 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5186 // End of weak reference support closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5187 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5188 // Abstract task used to preserve (i.e. copy) any referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5189 // that are in the collection set and are pointed to by reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5190 // objects discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5191 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5192 class G1ParPreserveCMReferentsTask: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5193 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5194 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5195 RefToScanQueueSet *_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5196 ParallelTaskTerminator _terminator; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5197 int _n_workers; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5198 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5199 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5200 G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5201 AbstractGangTask("ParPreserveCMReferents"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5202 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5203 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5204 _terminator(workers, _queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5205 _n_workers(workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5206 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5207 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5208 void work(int i) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5209 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5210 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5211 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5212 G1ParScanThreadState pss(_g1h, i); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5213 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5214 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5215 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5216 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5217 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5218 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5219 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5220 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5221 assert(pss.refs()->is_empty(), "both queue and overflow should be empty"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5222 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5223 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5224 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5225 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5226 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5227 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5228 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5229 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5230 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5231 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5232 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5233 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5234 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5235 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5236 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5237 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5238 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5239 // Is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5240 G1AlwaysAliveClosure always_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5241 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5242 // Copying keep alive closure. Applied to referent objects that need |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5243 // to be copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5244 G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, copy_perm_cl, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5245 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5246 ReferenceProcessor* rp = _g1h->ref_processor_cm(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5247 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5248 int limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5249 int stride = MIN2(MAX2(_n_workers, 1), limit); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5250 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5251 // limit is set using max_num_q() - which was set using ParallelGCThreads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5252 // So this must be true - but assert just in case someone decides to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5253 // change the worker ids. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5254 assert(0 <= i && i < limit, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5255 assert(!rp->discovery_is_atomic(), "check this code"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5256 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5257 // Select discovered lists [i, i+stride, i+2*stride,...,limit) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5258 for (int idx = i; idx < limit; idx += stride) { |
|
4014
bf2d2b8b1726
7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents:
4013
diff
changeset
|
5259 DiscoveredList& ref_list = rp->discovered_refs()[idx]; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5260 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5261 DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5262 while (iter.has_next()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5263 // Since discovery is not atomic for the CM ref processor, we |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5264 // can see some null referent objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5265 iter.load_ptrs(DEBUG_ONLY(true)); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5266 oop ref = iter.obj(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5267 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5268 // This will filter nulls. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5269 if (iter.is_referent_alive()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5270 iter.make_referent_alive(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5271 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5272 iter.move_to_next(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5273 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5274 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5275 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5276 // Drain the queue - which may cause stealing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5277 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5278 drain_queue.do_void(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5279 // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5280 assert(pss.refs()->is_empty(), "should be"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5281 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5282 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5283 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5284 // Weak Reference processing during an evacuation pause (part 1). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5285 void G1CollectedHeap::process_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5286 double ref_proc_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5287 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5288 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5289 assert(rp->discovery_enabled(), "should have been enabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5290 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5291 // Any reference objects, in the collection set, that were 'discovered' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5292 // by the CM ref processor should have already been copied (either by |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5293 // applying the external root copy closure to the discovered lists, or |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5294 // by following an RSet entry). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5295 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5296 // But some of the referents, that are in the collection set, that these |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5297 // reference objects point to may not have been copied: the STW ref |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5298 // processor would have seen that the reference object had already |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5299 // been 'discovered' and would have skipped discovering the reference, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5300 // but would not have treated the reference object as a regular oop. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5301 // As a reult the copy closure would not have been applied to the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5302 // referent object. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5303 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5304 // We need to explicitly copy these referent objects - the references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5305 // will be processed at the end of remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5306 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5307 // We also need to do this copying before we process the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5308 // objects discovered by the STW ref processor in case one of these |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5309 // referents points to another object which is also referenced by an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5310 // object discovered by the STW ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5311 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5312 int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5313 workers()->active_workers() : 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5314 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5315 assert(active_workers == workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5316 "Need to reset active_workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5317 set_par_threads(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5318 G1ParPreserveCMReferentsTask keep_cm_referents(this, active_workers, _task_queues); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5319 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5320 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5321 workers()->run_task(&keep_cm_referents); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5322 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5323 keep_cm_referents.work(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5324 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5325 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5326 set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5327 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5328 // Closure to test whether a referent is alive. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5329 G1STWIsAliveClosure is_alive(this); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5330 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5331 // Even when parallel reference processing is enabled, the processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5332 // of JNI refs is serial and performed serially by the current thread |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5333 // rather than by a worker. The following PSS will be used for processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5334 // JNI refs. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5335 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5336 // Use only a single queue for this PSS. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5337 G1ParScanThreadState pss(this, 0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5338 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5339 // We do not embed a reference processor in the copying/scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5340 // closures while we're actually processing the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5341 // reference objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5342 G1ParScanHeapEvacClosure scan_evac_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5343 G1ParScanHeapEvacFailureClosure evac_failure_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5344 G1ParScanPartialArrayClosure partial_scan_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5345 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5346 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5347 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5348 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5349 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5350 assert(pss.refs()->is_empty(), "pre-condition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5351 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5352 G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5353 G1ParScanPermClosure only_copy_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5354 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5355 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5356 G1ParScanAndMarkPermClosure copy_mark_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5357 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5358 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5359 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5360 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5361 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5362 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5363 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5364 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5365 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5366 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5367 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5368 G1CopyingKeepAliveClosure keep_alive(this, copy_non_heap_cl, copy_perm_cl, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5369 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5370 // Serial Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5371 G1STWDrainQueueClosure drain_queue(this, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5372 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5373 // Setup the soft refs policy... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5374 rp->setup_policy(false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5375 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5376 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5377 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5378 rp->process_discovered_references(&is_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5379 &keep_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5380 &drain_queue, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5381 NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5382 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5383 // Parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5384 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5385 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5386 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5387 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5388 rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, &par_task_executor); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5389 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5390 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5391 // We have completed copying any necessary live referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5392 // (that were not copied during the actual pause) so we can |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5393 // retire any active alloc buffers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5394 pss.retire_alloc_buffers(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5395 assert(pss.refs()->is_empty(), "both queue and overflow should be empty"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5396 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5397 double ref_proc_time = os::elapsedTime() - ref_proc_start; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5398 g1_policy()->record_ref_proc_time(ref_proc_time * 1000.0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5399 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5400 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5401 // Weak Reference processing during an evacuation pause (part 2). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5402 void G1CollectedHeap::enqueue_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5403 double ref_enq_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5404 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5405 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5406 assert(!rp->discovery_enabled(), "should have been disabled as part of processing"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5407 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5408 // Now enqueue any remaining on the discovered lists on to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5409 // the pending list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5410 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5411 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5412 rp->enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5413 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5414 // Parallel reference enqueuing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5415 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5416 int active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5417 assert(active_workers == workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5418 "Need to reset active_workers"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5419 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5420 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5421 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5422 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5423 rp->enqueue_discovered_references(&par_task_executor); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5424 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5425 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5426 rp->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5427 assert(!rp->discovery_enabled(), "should have been disabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5428 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5429 // FIXME |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5430 // CM's reference processing also cleans up the string and symbol tables. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5431 // Should we do that here also? We could, but it is a serial operation |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5432 // and could signicantly increase the pause time. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5433 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5434 double ref_enq_time = os::elapsedTime() - ref_enq_start; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5435 g1_policy()->record_ref_enq_time(ref_enq_time * 1000.0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5436 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5437 |
| 342 | 5438 void G1CollectedHeap::evacuate_collection_set() { |
| 5439 set_evacuation_failed(false); | |
| 5440 | |
| 5441 g1_rem_set()->prepare_for_oops_into_collection_set_do(); | |
| 5442 concurrent_g1_refine()->set_use_cache(false); | |
| 889 | 5443 concurrent_g1_refine()->clear_hot_cache_claimed_index(); |
| 5444 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5445 int n_workers; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5446 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5447 n_workers = |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5448 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5449 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5450 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5451 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5452 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5453 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5454 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5455 } else { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5456 assert(n_par_threads() == 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5457 "Should be the original non-parallel value"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5458 n_workers = 1; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5459 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5460 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5461 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5462 G1ParTask g1_par_task(this, _task_queues); |
| 342 | 5463 |
| 5464 init_for_evac_failure(NULL); | |
| 5465 | |
| 5466 rem_set()->prepare_for_younger_refs_iterate(true); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5467 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5468 assert(dirty_card_queue_set().completed_buffers_num() == 0, "Should be empty"); |
| 342 | 5469 double start_par = os::elapsedTime(); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5470 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
5471 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 5472 // The individual threads will set their evac-failure closures. |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5473 StrongRootsScope srs(this); |
| 1709 | 5474 if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5475 // These tasks use ShareHeap::_process_strong_tasks |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5476 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5477 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5478 "If not dynamic should be using all the workers"); |
| 342 | 5479 workers()->run_task(&g1_par_task); |
| 5480 } else { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5481 StrongRootsScope srs(this); |
| 342 | 5482 g1_par_task.work(0); |
| 5483 } | |
| 5484 | |
| 5485 double par_time = (os::elapsedTime() - start_par) * 1000.0; | |
| 5486 g1_policy()->record_par_time(par_time); | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5487 |
| 342 | 5488 set_par_threads(0); |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5489 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5490 // Process any discovered reference objects - we have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5491 // to do this _before_ we retire the GC alloc regions |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5492 // as we may have to copy some 'reachable' referent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5493 // objects (and their reachable sub-graphs) that were |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5494 // not copied during the pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5495 process_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5496 |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5497 // Weak root processing. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5498 // Note: when JSR 292 is enabled and code blobs can contain |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5499 // non-perm oops then we will need to process the code blobs |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5500 // here too. |
| 342 | 5501 { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5502 G1STWIsAliveClosure is_alive(this); |
| 342 | 5503 G1KeepAliveClosure keep_alive(this); |
| 5504 JNIHandles::weak_oops_do(&is_alive, &keep_alive); | |
| 5505 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5506 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5507 release_gc_alloc_regions(); |
| 342 | 5508 g1_rem_set()->cleanup_after_oops_into_collection_set_do(); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5509 |
| 889 | 5510 concurrent_g1_refine()->clear_hot_cache(); |
| 342 | 5511 concurrent_g1_refine()->set_use_cache(true); |
| 5512 | |
| 5513 finalize_for_evac_failure(); | |
| 5514 | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5515 // Must do this before clearing the per-region evac-failure flags |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5516 // (which is currently done when we free the collection set). |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5517 // We also only do this if marking is actually in progress and so |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5518 // have to do this before we set the mark_in_progress flag at the |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5519 // end of an initial mark pause. |
| 342 | 5520 concurrent_mark()->complete_marking_in_collection_set(); |
| 5521 | |
| 5522 if (evacuation_failed()) { | |
| 5523 remove_self_forwarding_pointers(); | |
| 5524 if (PrintGCDetails) { | |
|
1719
b63010841f78
6975964: G1: print out a more descriptive message for evacuation failure when +PrintGCDetails is set
tonyp
parents:
1718
diff
changeset
|
5525 gclog_or_tty->print(" (to-space overflow)"); |
| 342 | 5526 } else if (PrintGC) { |
| 5527 gclog_or_tty->print("--"); | |
| 5528 } | |
| 5529 } | |
| 5530 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5531 // Enqueue any remaining references remaining on the STW |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5532 // reference processor's discovered lists. We need to do |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5533 // this after the card table is cleaned (and verified) as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5534 // the act of enqueuing entries on to the pending list |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5535 // will log these updates (and dirty their associated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5536 // cards). We need these updates logged to update any |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5537 // RSets. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5538 enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5539 |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5540 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5541 RedirtyLoggedCardTableEntryFastClosure redirty; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5542 dirty_card_queue_set().set_closure(&redirty); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5543 dirty_card_queue_set().apply_closure_to_all_completed_buffers(); |
| 1111 | 5544 |
| 5545 DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set(); | |
| 5546 dcq.merge_bufferlists(&dirty_card_queue_set()); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5547 assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5548 } |
| 342 | 5549 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
| 5550 } | |
| 5551 | |
| 2173 | 5552 void G1CollectedHeap::free_region_if_empty(HeapRegion* hr, |
| 2152 | 5553 size_t* pre_used, |
| 5554 FreeRegionList* free_list, | |
| 4072 | 5555 OldRegionSet* old_proxy_set, |
| 2152 | 5556 HumongousRegionSet* humongous_proxy_set, |
| 2173 | 5557 HRRSCleanupTask* hrrs_cleanup_task, |
| 2152 | 5558 bool par) { |
| 5559 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) { | |
| 5560 if (hr->isHumongous()) { | |
| 5561 assert(hr->startsHumongous(), "we should only see starts humongous"); | |
| 5562 free_humongous_region(hr, pre_used, free_list, humongous_proxy_set, par); | |
| 5563 } else { | |
| 4072 | 5564 _old_set.remove_with_proxy(hr, old_proxy_set); |
| 2152 | 5565 free_region(hr, pre_used, free_list, par); |
| 342 | 5566 } |
| 2173 | 5567 } else { |
| 5568 hr->rem_set()->do_cleanup_work(hrrs_cleanup_task); | |
| 342 | 5569 } |
| 5570 } | |
| 5571 | |
| 2152 | 5572 void G1CollectedHeap::free_region(HeapRegion* hr, |
| 5573 size_t* pre_used, | |
| 5574 FreeRegionList* free_list, | |
| 5575 bool par) { | |
| 5576 assert(!hr->isHumongous(), "this is only for non-humongous regions"); | |
| 5577 assert(!hr->is_empty(), "the region should not be empty"); | |
| 5578 assert(free_list != NULL, "pre-condition"); | |
| 5579 | |
| 5580 *pre_used += hr->used(); | |
| 5581 hr->hr_clear(par, true /* clear_space */); | |
|
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2369
diff
changeset
|
5582 free_list->add_as_head(hr); |
| 2152 | 5583 } |
| 5584 | |
| 5585 void G1CollectedHeap::free_humongous_region(HeapRegion* hr, | |
| 5586 size_t* pre_used, | |
| 5587 FreeRegionList* free_list, | |
| 5588 HumongousRegionSet* humongous_proxy_set, | |
| 5589 bool par) { | |
| 5590 assert(hr->startsHumongous(), "this is only for starts humongous regions"); | |
| 5591 assert(free_list != NULL, "pre-condition"); | |
| 5592 assert(humongous_proxy_set != NULL, "pre-condition"); | |
| 5593 | |
| 5594 size_t hr_used = hr->used(); | |
| 5595 size_t hr_capacity = hr->capacity(); | |
| 5596 size_t hr_pre_used = 0; | |
| 5597 _humongous_set.remove_with_proxy(hr, humongous_proxy_set); | |
| 5598 hr->set_notHumongous(); | |
| 5599 free_region(hr, &hr_pre_used, free_list, par); | |
| 5600 | |
| 3766 | 5601 size_t i = hr->hrs_index() + 1; |
| 2152 | 5602 size_t num = 1; |
| 3766 | 5603 while (i < n_regions()) { |
| 5604 HeapRegion* curr_hr = region_at(i); | |
| 2152 | 5605 if (!curr_hr->continuesHumongous()) { |
| 5606 break; | |
| 5607 } | |
| 5608 curr_hr->set_notHumongous(); | |
| 5609 free_region(curr_hr, &hr_pre_used, free_list, par); | |
| 5610 num += 1; | |
| 5611 i += 1; | |
| 5612 } | |
| 5613 assert(hr_pre_used == hr_used, | |
| 5614 err_msg("hr_pre_used: "SIZE_FORMAT" and hr_used: "SIZE_FORMAT" " | |
| 5615 "should be the same", hr_pre_used, hr_used)); | |
| 5616 *pre_used += hr_pre_used; | |
| 5617 } | |
| 5618 | |
| 5619 void G1CollectedHeap::update_sets_after_freeing_regions(size_t pre_used, | |
| 5620 FreeRegionList* free_list, | |
| 4072 | 5621 OldRegionSet* old_proxy_set, |
| 2152 | 5622 HumongousRegionSet* humongous_proxy_set, |
| 5623 bool par) { | |
| 5624 if (pre_used > 0) { | |
| 5625 Mutex* lock = (par) ? ParGCRareEvent_lock : NULL; | |
| 342 | 5626 MutexLockerEx x(lock, Mutex::_no_safepoint_check_flag); |
| 2152 | 5627 assert(_summary_bytes_used >= pre_used, |
| 5628 err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" " | |
| 5629 "should be >= pre_used: "SIZE_FORMAT, | |
| 5630 _summary_bytes_used, pre_used)); | |
| 342 | 5631 _summary_bytes_used -= pre_used; |
| 2152 | 5632 } |
| 5633 if (free_list != NULL && !free_list->is_empty()) { | |
| 5634 MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag); | |
|
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2369
diff
changeset
|
5635 _free_list.add_as_head(free_list); |
| 2152 | 5636 } |
| 4072 | 5637 if (old_proxy_set != NULL && !old_proxy_set->is_empty()) { |
| 5638 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5639 _old_set.update_from_proxy(old_proxy_set); | |
| 5640 } | |
| 2152 | 5641 if (humongous_proxy_set != NULL && !humongous_proxy_set->is_empty()) { |
| 5642 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5643 _humongous_set.update_from_proxy(humongous_proxy_set); | |
| 342 | 5644 } |
| 5645 } | |
| 5646 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5647 class G1ParCleanupCTTask : public AbstractGangTask { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5648 CardTableModRefBS* _ct_bs; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5649 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5650 HeapRegion* volatile _su_head; |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5651 public: |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5652 G1ParCleanupCTTask(CardTableModRefBS* ct_bs, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5653 G1CollectedHeap* g1h) : |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5654 AbstractGangTask("G1 Par Cleanup CT Task"), |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5655 _ct_bs(ct_bs), _g1h(g1h) { } |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5656 |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5657 void work(int i) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5658 HeapRegion* r; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5659 while (r = _g1h->pop_dirty_cards_region()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5660 clear_cards(r); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5661 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5662 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5663 |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5664 void clear_cards(HeapRegion* r) { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5665 // Cards of the survivors should have already been dirtied. |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5666 if (!r->is_survivor()) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5667 _ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5668 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5669 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5670 }; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5671 |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5672 #ifndef PRODUCT |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5673 class G1VerifyCardTableCleanup: public HeapRegionClosure { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5674 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5675 CardTableModRefBS* _ct_bs; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5676 public: |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5677 G1VerifyCardTableCleanup(G1CollectedHeap* g1h, CardTableModRefBS* ct_bs) |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5678 : _g1h(g1h), _ct_bs(ct_bs) { } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5679 virtual bool doHeapRegion(HeapRegion* r) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5680 if (r->is_survivor()) { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5681 _g1h->verify_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5682 } else { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5683 _g1h->verify_not_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5684 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5685 return false; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5686 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5687 }; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5688 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5689 void G1CollectedHeap::verify_not_dirty_region(HeapRegion* hr) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5690 // All of the region should be clean. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5691 CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5692 MemRegion mr(hr->bottom(), hr->end()); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5693 ct_bs->verify_not_dirty_region(mr); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5694 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5695 |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5696 void G1CollectedHeap::verify_dirty_region(HeapRegion* hr) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5697 // We cannot guarantee that [bottom(),end()] is dirty. Threads |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5698 // dirty allocated blocks as they allocate them. The thread that |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5699 // retires each region and replaces it with a new one will do a |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5700 // maximal allocation to fill in [pre_dummy_top(),end()] but will |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5701 // not dirty that area (one less thing to have to do while holding |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5702 // a lock). So we can only verify that [bottom(),pre_dummy_top()] |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5703 // is dirty. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5704 CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5705 MemRegion mr(hr->bottom(), hr->pre_dummy_top()); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5706 ct_bs->verify_dirty_region(mr); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5707 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5708 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5709 void G1CollectedHeap::verify_dirty_young_list(HeapRegion* head) { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5710 CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5711 for (HeapRegion* hr = head; hr != NULL; hr = hr->get_next_young_region()) { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5712 verify_dirty_region(hr); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5713 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5714 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5715 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5716 void G1CollectedHeap::verify_dirty_young_regions() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5717 verify_dirty_young_list(_young_list->first_region()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5718 verify_dirty_young_list(_young_list->first_survivor_region()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5719 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5720 #endif |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5721 |
| 342 | 5722 void G1CollectedHeap::cleanUpCardTable() { |
| 5723 CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set()); | |
| 5724 double start = os::elapsedTime(); | |
| 5725 | |
| 4023 | 5726 { |
| 5727 // Iterate over the dirty cards region list. | |
| 5728 G1ParCleanupCTTask cleanup_task(ct_bs, this); | |
| 5729 | |
| 5730 if (ParallelGCThreads > 0) { | |
| 5731 set_par_threads(workers()->total_workers()); | |
| 5732 workers()->run_task(&cleanup_task); | |
| 5733 set_par_threads(0); | |
| 5734 } else { | |
| 5735 while (_dirty_cards_region_list) { | |
| 5736 HeapRegion* r = _dirty_cards_region_list; | |
| 5737 cleanup_task.clear_cards(r); | |
| 5738 _dirty_cards_region_list = r->get_next_dirty_cards_region(); | |
| 5739 if (_dirty_cards_region_list == r) { | |
| 5740 // The last region. | |
| 5741 _dirty_cards_region_list = NULL; | |
| 5742 } | |
| 5743 r->set_next_dirty_cards_region(NULL); | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5744 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5745 } |
| 4023 | 5746 #ifndef PRODUCT |
| 5747 if (G1VerifyCTCleanup || VerifyAfterGC) { | |
| 5748 G1VerifyCardTableCleanup cleanup_verifier(this, ct_bs); | |
| 5749 heap_region_iterate(&cleanup_verifier); | |
| 5750 } | |
| 5751 #endif | |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5752 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5753 |
| 342 | 5754 double elapsed = os::elapsedTime() - start; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5755 g1_policy()->record_clear_ct_time(elapsed * 1000.0); |
| 342 | 5756 } |
| 5757 | |
| 5758 void G1CollectedHeap::free_collection_set(HeapRegion* cs_head) { | |
| 2152 | 5759 size_t pre_used = 0; |
| 5760 FreeRegionList local_free_list("Local List for CSet Freeing"); | |
| 5761 | |
| 342 | 5762 double young_time_ms = 0.0; |
| 5763 double non_young_time_ms = 0.0; | |
| 5764 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5765 // Since the collection set is a superset of the the young list, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5766 // all we need to do to clear the young list is clear its |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5767 // head and length, and unlink any young regions in the code below |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5768 _young_list->clear(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5769 |
| 342 | 5770 G1CollectorPolicy* policy = g1_policy(); |
| 5771 | |
| 5772 double start_sec = os::elapsedTime(); | |
| 5773 bool non_young = true; | |
| 5774 | |
| 5775 HeapRegion* cur = cs_head; | |
| 5776 int age_bound = -1; | |
| 5777 size_t rs_lengths = 0; | |
| 5778 | |
| 5779 while (cur != NULL) { | |
| 2361 | 5780 assert(!is_on_master_free_list(cur), "sanity"); |
| 342 | 5781 if (non_young) { |
| 5782 if (cur->is_young()) { | |
| 5783 double end_sec = os::elapsedTime(); | |
| 5784 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
| 5785 non_young_time_ms += elapsed_ms; | |
| 5786 | |
| 5787 start_sec = os::elapsedTime(); | |
| 5788 non_young = false; | |
| 5789 } | |
| 5790 } else { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5791 if (!cur->is_young()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5792 double end_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5793 double elapsed_ms = (end_sec - start_sec) * 1000.0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5794 young_time_ms += elapsed_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5795 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5796 start_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5797 non_young = true; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5798 } |
| 342 | 5799 } |
| 5800 | |
| 5801 rs_lengths += cur->rem_set()->occupied(); | |
| 5802 | |
| 5803 HeapRegion* next = cur->next_in_collection_set(); | |
| 5804 assert(cur->in_collection_set(), "bad CS"); | |
| 5805 cur->set_next_in_collection_set(NULL); | |
| 5806 cur->set_in_collection_set(false); | |
| 5807 | |
| 5808 if (cur->is_young()) { | |
| 5809 int index = cur->young_index_in_cset(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5810 assert(index != -1, "invariant"); |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5811 assert((size_t) index < policy->young_cset_region_length(), "invariant"); |
| 342 | 5812 size_t words_survived = _surviving_young_words[index]; |
| 5813 cur->record_surv_words_in_group(words_survived); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5814 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5815 // At this point the we have 'popped' cur from the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5816 // (linked via next_in_collection_set()) but it is still in the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5817 // young list (linked via next_young_region()). Clear the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5818 // _next_young_region field. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5819 cur->set_next_young_region(NULL); |
| 342 | 5820 } else { |
| 5821 int index = cur->young_index_in_cset(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5822 assert(index == -1, "invariant"); |
| 342 | 5823 } |
| 5824 | |
| 5825 assert( (cur->is_young() && cur->young_index_in_cset() > -1) || | |
| 5826 (!cur->is_young() && cur->young_index_in_cset() == -1), | |
| 5827 "invariant" ); | |
| 5828 | |
| 5829 if (!cur->evacuation_failed()) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5830 MemRegion used_mr = cur->used_region(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5831 |
| 342 | 5832 // And the region is empty. |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5833 assert(!used_mr.is_empty(), "Should not have empty regions in a CS."); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5834 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5835 // If marking is in progress then clear any objects marked in |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5836 // the current region. Note mark_in_progress() returns false, |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5837 // even during an initial mark pause, until the set_marking_started() |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5838 // call which takes place later in the pause. |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5839 if (mark_in_progress()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5840 assert(!g1_policy()->during_initial_mark_pause(), "sanity"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5841 _cm->nextMarkBitMap()->clearRange(used_mr); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5842 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5843 |
| 2152 | 5844 free_region(cur, &pre_used, &local_free_list, false /* par */); |
| 342 | 5845 } else { |
| 5846 cur->uninstall_surv_rate_group(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5847 if (cur->is_young()) { |
| 342 | 5848 cur->set_young_index_in_cset(-1); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5849 } |
| 342 | 5850 cur->set_not_young(); |
| 5851 cur->set_evacuation_failed(false); | |
| 4072 | 5852 // The region is now considered to be old. |
| 5853 _old_set.add(cur); | |
| 342 | 5854 } |
| 5855 cur = next; | |
| 5856 } | |
| 5857 | |
| 5858 policy->record_max_rs_lengths(rs_lengths); | |
| 5859 policy->cset_regions_freed(); | |
| 5860 | |
| 5861 double end_sec = os::elapsedTime(); | |
| 5862 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5863 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5864 if (non_young) { |
| 342 | 5865 non_young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5866 } else { |
| 342 | 5867 young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5868 } |
| 342 | 5869 |
| 2152 | 5870 update_sets_after_freeing_regions(pre_used, &local_free_list, |
| 4072 | 5871 NULL /* old_proxy_set */, |
| 2152 | 5872 NULL /* humongous_proxy_set */, |
| 5873 false /* par */); | |
| 342 | 5874 policy->record_young_free_cset_time_ms(young_time_ms); |
| 5875 policy->record_non_young_free_cset_time_ms(non_young_time_ms); | |
| 5876 } | |
| 5877 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5878 // This routine is similar to the above but does not record |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5879 // any policy statistics or update free lists; we are abandoning |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5880 // the current incremental collection set in preparation of a |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5881 // full collection. After the full GC we will start to build up |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5882 // the incremental collection set again. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5883 // This is only called when we're doing a full collection |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5884 // and is immediately followed by the tearing down of the young list. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5885 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5886 void G1CollectedHeap::abandon_collection_set(HeapRegion* cs_head) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5887 HeapRegion* cur = cs_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5888 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5889 while (cur != NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5890 HeapRegion* next = cur->next_in_collection_set(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5891 assert(cur->in_collection_set(), "bad CS"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5892 cur->set_next_in_collection_set(NULL); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5893 cur->set_in_collection_set(false); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5894 cur->set_young_index_in_cset(-1); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5895 cur = next; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5896 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5897 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5898 |
| 2152 | 5899 void G1CollectedHeap::set_free_regions_coming() { |
| 5900 if (G1ConcRegionFreeingVerbose) { | |
| 5901 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 5902 "setting free regions coming"); | |
| 5903 } | |
| 5904 | |
| 5905 assert(!free_regions_coming(), "pre-condition"); | |
| 5906 _free_regions_coming = true; | |
| 342 | 5907 } |
| 5908 | |
| 2152 | 5909 void G1CollectedHeap::reset_free_regions_coming() { |
| 5910 { | |
| 5911 assert(free_regions_coming(), "pre-condition"); | |
| 5912 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 5913 _free_regions_coming = false; | |
| 5914 SecondaryFreeList_lock->notify_all(); | |
| 5915 } | |
| 5916 | |
| 5917 if (G1ConcRegionFreeingVerbose) { | |
| 5918 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 5919 "reset free regions coming"); | |
| 342 | 5920 } |
| 5921 } | |
| 5922 | |
| 2152 | 5923 void G1CollectedHeap::wait_while_free_regions_coming() { |
| 5924 // Most of the time we won't have to wait, so let's do a quick test | |
| 5925 // first before we take the lock. | |
| 5926 if (!free_regions_coming()) { | |
| 5927 return; | |
| 5928 } | |
| 5929 | |
| 5930 if (G1ConcRegionFreeingVerbose) { | |
| 5931 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 5932 "waiting for free regions"); | |
| 342 | 5933 } |
| 5934 | |
| 5935 { | |
| 2152 | 5936 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 5937 while (free_regions_coming()) { | |
| 5938 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 342 | 5939 } |
| 2152 | 5940 } |
| 5941 | |
| 5942 if (G1ConcRegionFreeingVerbose) { | |
| 5943 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 5944 "done waiting for free regions"); | |
| 5945 } | |
| 342 | 5946 } |
| 5947 | |
| 5948 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) { | |
| 5949 assert(heap_lock_held_for_gc(), | |
| 5950 "the heap lock should already be held by or for this thread"); | |
| 5951 _young_list->push_region(hr); | |
| 5952 } | |
| 5953 | |
| 5954 class NoYoungRegionsClosure: public HeapRegionClosure { | |
| 5955 private: | |
| 5956 bool _success; | |
| 5957 public: | |
| 5958 NoYoungRegionsClosure() : _success(true) { } | |
| 5959 bool doHeapRegion(HeapRegion* r) { | |
| 5960 if (r->is_young()) { | |
| 5961 gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", | |
| 5962 r->bottom(), r->end()); | |
| 5963 _success = false; | |
| 5964 } | |
| 5965 return false; | |
| 5966 } | |
| 5967 bool success() { return _success; } | |
| 5968 }; | |
| 5969 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5970 bool G1CollectedHeap::check_young_list_empty(bool check_heap, bool check_sample) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5971 bool ret = _young_list->check_list_empty(check_sample); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5972 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5973 if (check_heap) { |
| 342 | 5974 NoYoungRegionsClosure closure; |
| 5975 heap_region_iterate(&closure); | |
| 5976 ret = ret && closure.success(); | |
| 5977 } | |
| 5978 | |
| 5979 return ret; | |
| 5980 } | |
| 5981 | |
| 4072 | 5982 class TearDownRegionSetsClosure : public HeapRegionClosure { |
| 5983 private: | |
| 5984 OldRegionSet *_old_set; | |
| 2152 | 5985 |
| 342 | 5986 public: |
| 4072 | 5987 TearDownRegionSetsClosure(OldRegionSet* old_set) : _old_set(old_set) { } |
| 2152 | 5988 |
| 342 | 5989 bool doHeapRegion(HeapRegion* r) { |
| 4072 | 5990 if (r->is_empty()) { |
| 5991 // We ignore empty regions, we'll empty the free list afterwards | |
| 5992 } else if (r->is_young()) { | |
| 5993 // We ignore young regions, we'll empty the young list afterwards | |
| 5994 } else if (r->isHumongous()) { | |
| 5995 // We ignore humongous regions, we're not tearing down the | |
| 5996 // humongous region set | |
| 342 | 5997 } else { |
| 4072 | 5998 // The rest should be old |
| 5999 _old_set->remove(r); | |
| 342 | 6000 } |
| 6001 return false; | |
| 6002 } | |
| 6003 | |
| 4072 | 6004 ~TearDownRegionSetsClosure() { |
| 6005 assert(_old_set->is_empty(), "post-condition"); | |
| 2152 | 6006 } |
| 342 | 6007 }; |
| 6008 | |
| 4072 | 6009 void G1CollectedHeap::tear_down_region_sets(bool free_list_only) { |
| 6010 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6011 | |
| 6012 if (!free_list_only) { | |
| 6013 TearDownRegionSetsClosure cl(&_old_set); | |
| 6014 heap_region_iterate(&cl); | |
| 6015 | |
| 6016 // Need to do this after the heap iteration to be able to | |
| 6017 // recognize the young regions and ignore them during the iteration. | |
| 6018 _young_list->empty_list(); | |
| 6019 } | |
| 6020 _free_list.remove_all(); | |
| 6021 } | |
| 6022 | |
| 6023 class RebuildRegionSetsClosure : public HeapRegionClosure { | |
| 6024 private: | |
| 6025 bool _free_list_only; | |
| 6026 OldRegionSet* _old_set; | |
| 6027 FreeRegionList* _free_list; | |
| 6028 size_t _total_used; | |
| 6029 | |
| 6030 public: | |
| 6031 RebuildRegionSetsClosure(bool free_list_only, | |
| 6032 OldRegionSet* old_set, FreeRegionList* free_list) : | |
| 6033 _free_list_only(free_list_only), | |
| 6034 _old_set(old_set), _free_list(free_list), _total_used(0) { | |
| 6035 assert(_free_list->is_empty(), "pre-condition"); | |
| 6036 if (!free_list_only) { | |
| 6037 assert(_old_set->is_empty(), "pre-condition"); | |
| 6038 } | |
| 6039 } | |
| 6040 | |
| 6041 bool doHeapRegion(HeapRegion* r) { | |
| 6042 if (r->continuesHumongous()) { | |
| 6043 return false; | |
| 6044 } | |
| 6045 | |
| 6046 if (r->is_empty()) { | |
| 6047 // Add free regions to the free list | |
| 6048 _free_list->add_as_tail(r); | |
| 6049 } else if (!_free_list_only) { | |
| 6050 assert(!r->is_young(), "we should not come across young regions"); | |
| 6051 | |
| 6052 if (r->isHumongous()) { | |
| 6053 // We ignore humongous regions, we left the humongous set unchanged | |
| 6054 } else { | |
| 6055 // The rest should be old, add them to the old set | |
| 6056 _old_set->add(r); | |
| 6057 } | |
| 6058 _total_used += r->used(); | |
| 6059 } | |
| 6060 | |
| 6061 return false; | |
| 6062 } | |
| 6063 | |
| 6064 size_t total_used() { | |
| 6065 return _total_used; | |
| 6066 } | |
| 6067 }; | |
| 6068 | |
| 6069 void G1CollectedHeap::rebuild_region_sets(bool free_list_only) { | |
| 6070 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6071 | |
| 6072 RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list); | |
| 6073 heap_region_iterate(&cl); | |
| 6074 | |
| 6075 if (!free_list_only) { | |
| 6076 _summary_bytes_used = cl.total_used(); | |
| 6077 } | |
| 6078 assert(_summary_bytes_used == recalculate_used(), | |
| 6079 err_msg("inconsistent _summary_bytes_used, " | |
| 6080 "value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, | |
| 6081 _summary_bytes_used, recalculate_used())); | |
| 342 | 6082 } |
| 6083 | |
| 6084 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) { | |
| 6085 _refine_cte_cl->set_concurrent(concurrent); | |
| 6086 } | |
| 6087 | |
| 6088 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { | |
| 6089 HeapRegion* hr = heap_region_containing(p); | |
| 6090 if (hr == NULL) { | |
| 6091 return is_in_permanent(p); | |
| 6092 } else { | |
| 6093 return hr->is_in(p); | |
| 6094 } | |
| 6095 } | |
| 2152 | 6096 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6097 // Methods for the mutator alloc region |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6098 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6099 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6100 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6101 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6102 assert(!force || g1_policy()->can_expand_young_list(), |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6103 "if force is true we should be able to expand the young list"); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6104 bool young_list_full = g1_policy()->is_young_list_full(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6105 if (force || !young_list_full) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6106 HeapRegion* new_alloc_region = new_region(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6107 false /* do_expand */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6108 if (new_alloc_region != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6109 set_region_short_lived_locked(new_alloc_region); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6110 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6111 return new_alloc_region; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6112 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6113 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6114 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6115 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6116 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6117 void G1CollectedHeap::retire_mutator_alloc_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6118 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6119 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6120 assert(alloc_region->is_young(), "all mutator alloc regions should be young"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6121 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6122 g1_policy()->add_region_to_incremental_cset_lhs(alloc_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6123 _summary_bytes_used += allocated_bytes; |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6124 _hr_printer.retire(alloc_region); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6125 // We update the eden sizes here, when the region is retired, |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6126 // instead of when it's allocated, since this is the point that its |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6127 // used space has been recored in _summary_bytes_used. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6128 g1mm()->update_eden_size(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6129 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6130 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6131 HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6132 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6133 return _g1h->new_mutator_alloc_region(word_size, force); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6134 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6135 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6136 void G1CollectedHeap::set_par_threads() { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6137 // Don't change the number of workers. Use the value previously set |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6138 // in the workgroup. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6139 int n_workers = workers()->active_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6140 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6141 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6142 "Otherwise should be using the total number of workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6143 if (n_workers == 0) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6144 assert(false, "Should have been set in prior evacuation pause."); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6145 n_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6146 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6147 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6148 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6149 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6150 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6151 void MutatorAllocRegion::retire_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6152 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6153 _g1h->retire_mutator_alloc_region(alloc_region, allocated_bytes); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6154 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6155 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6156 // Methods for the GC alloc regions |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6157 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6158 HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6159 size_t count, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6160 GCAllocPurpose ap) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6161 assert(FreeList_lock->owned_by_self(), "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6162 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6163 if (count < g1_policy()->max_regions(ap)) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6164 HeapRegion* new_alloc_region = new_region(word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6165 true /* do_expand */); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6166 if (new_alloc_region != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6167 // We really only need to do this for old regions given that we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6168 // should never scan survivors. But it doesn't hurt to do it |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6169 // for survivors too. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6170 new_alloc_region->set_saved_mark(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6171 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6172 new_alloc_region->set_survivor(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6173 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Survivor); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6174 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6175 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Old); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6176 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6177 return new_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6178 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6179 g1_policy()->note_alloc_region_limit_reached(ap); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6180 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6181 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6182 return NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6183 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6184 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6185 void G1CollectedHeap::retire_gc_alloc_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6186 size_t allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6187 GCAllocPurpose ap) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6188 alloc_region->note_end_of_copying(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6189 g1_policy()->record_bytes_copied_during_gc(allocated_bytes); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6190 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6191 young_list()->add_survivor_region(alloc_region); |
| 4072 | 6192 } else { |
| 6193 _old_set.add(alloc_region); | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6194 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6195 _hr_printer.retire(alloc_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6196 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6197 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6198 HeapRegion* SurvivorGCAllocRegion::allocate_new_region(size_t word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6199 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6200 assert(!force, "not supported for GC alloc regions"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6201 return _g1h->new_gc_alloc_region(word_size, count(), GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6202 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6203 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6204 void SurvivorGCAllocRegion::retire_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6205 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6206 _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6207 GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6208 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6209 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6210 HeapRegion* OldGCAllocRegion::allocate_new_region(size_t word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6211 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6212 assert(!force, "not supported for GC alloc regions"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6213 return _g1h->new_gc_alloc_region(word_size, count(), GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6214 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6215 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6216 void OldGCAllocRegion::retire_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6217 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6218 _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6219 GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6220 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6221 // Heap region set verification |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6222 |
| 2152 | 6223 class VerifyRegionListsClosure : public HeapRegionClosure { |
| 6224 private: | |
| 4072 | 6225 FreeRegionList* _free_list; |
| 6226 OldRegionSet* _old_set; | |
| 2152 | 6227 HumongousRegionSet* _humongous_set; |
| 6228 size_t _region_count; | |
| 6229 | |
| 6230 public: | |
| 4072 | 6231 VerifyRegionListsClosure(OldRegionSet* old_set, |
| 6232 HumongousRegionSet* humongous_set, | |
| 2152 | 6233 FreeRegionList* free_list) : |
| 4072 | 6234 _old_set(old_set), _humongous_set(humongous_set), |
| 6235 _free_list(free_list), _region_count(0) { } | |
| 2152 | 6236 |
| 6237 size_t region_count() { return _region_count; } | |
| 6238 | |
| 6239 bool doHeapRegion(HeapRegion* hr) { | |
| 6240 _region_count += 1; | |
| 6241 | |
| 6242 if (hr->continuesHumongous()) { | |
| 6243 return false; | |
| 6244 } | |
| 6245 | |
| 6246 if (hr->is_young()) { | |
| 6247 // TODO | |
| 6248 } else if (hr->startsHumongous()) { | |
| 6249 _humongous_set->verify_next_region(hr); | |
| 6250 } else if (hr->is_empty()) { | |
| 6251 _free_list->verify_next_region(hr); | |
| 4072 | 6252 } else { |
| 6253 _old_set->verify_next_region(hr); | |
| 2152 | 6254 } |
| 6255 return false; | |
| 6256 } | |
| 6257 }; | |
| 6258 | |
| 3766 | 6259 HeapRegion* G1CollectedHeap::new_heap_region(size_t hrs_index, |
| 6260 HeapWord* bottom) { | |
| 6261 HeapWord* end = bottom + HeapRegion::GrainWords; | |
| 6262 MemRegion mr(bottom, end); | |
| 6263 assert(_g1_reserved.contains(mr), "invariant"); | |
| 6264 // This might return NULL if the allocation fails | |
| 6265 return new HeapRegion(hrs_index, _bot_shared, mr, true /* is_zeroed */); | |
| 6266 } | |
| 6267 | |
| 2152 | 6268 void G1CollectedHeap::verify_region_sets() { |
| 6269 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); | |
| 6270 | |
| 6271 // First, check the explicit lists. | |
| 6272 _free_list.verify(); | |
| 6273 { | |
| 6274 // Given that a concurrent operation might be adding regions to | |
| 6275 // the secondary free list we have to take the lock before | |
| 6276 // verifying it. | |
| 6277 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 6278 _secondary_free_list.verify(); | |
| 6279 } | |
| 4072 | 6280 _old_set.verify(); |
| 2152 | 6281 _humongous_set.verify(); |
| 6282 | |
| 6283 // If a concurrent region freeing operation is in progress it will | |
| 6284 // be difficult to correctly attributed any free regions we come | |
| 6285 // across to the correct free list given that they might belong to | |
| 6286 // one of several (free_list, secondary_free_list, any local lists, | |
| 6287 // etc.). So, if that's the case we will skip the rest of the | |
| 6288 // verification operation. Alternatively, waiting for the concurrent | |
| 6289 // operation to complete will have a non-trivial effect on the GC's | |
| 6290 // operation (no concurrent operation will last longer than the | |
| 6291 // interval between two calls to verification) and it might hide | |
| 6292 // any issues that we would like to catch during testing. | |
| 6293 if (free_regions_coming()) { | |
| 6294 return; | |
| 6295 } | |
| 6296 | |
| 2361 | 6297 // Make sure we append the secondary_free_list on the free_list so |
| 6298 // that all free regions we will come across can be safely | |
| 6299 // attributed to the free_list. | |
| 6300 append_secondary_free_list_if_not_empty_with_lock(); | |
| 2152 | 6301 |
| 6302 // Finally, make sure that the region accounting in the lists is | |
| 6303 // consistent with what we see in the heap. | |
| 4072 | 6304 _old_set.verify_start(); |
| 2152 | 6305 _humongous_set.verify_start(); |
| 6306 _free_list.verify_start(); | |
| 6307 | |
| 4072 | 6308 VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list); |
| 2152 | 6309 heap_region_iterate(&cl); |
| 6310 | |
| 4072 | 6311 _old_set.verify_end(); |
| 2152 | 6312 _humongous_set.verify_end(); |
| 6313 _free_list.verify_end(); | |
| 342 | 6314 } |