Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 6007:5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
Summary: Added log levels "fine", "finer" and "finest". Let PrintGC map to "fine" and PrintGCDetails map to "finer". Separated out the per worker information in the G1 logging to the "finest" level.
Reviewed-by: stefank, jwilhelm, tonyp, johnc
| author | brutisso |
|---|---|
| date | Fri, 13 Apr 2012 01:59:38 +0200 |
| parents | 748051fd24ce |
| children | b632e80fc9dc |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 342 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
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" |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
35 #include "gc_implementation/g1/g1EvacFailure.hpp" |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
36 #include "gc_implementation/g1/g1Log.hpp" |
| 1972 | 37 #include "gc_implementation/g1/g1MarkSweep.hpp" |
| 38 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
| 39 #include "gc_implementation/g1/g1RemSet.inline.hpp" | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
40 #include "gc_implementation/g1/heapRegion.inline.hpp" |
| 1972 | 41 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
| 42 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 43 #include "gc_implementation/g1/vm_operations_g1.hpp" | |
| 44 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 45 #include "memory/gcLocker.inline.hpp" | |
| 46 #include "memory/genOopClosures.inline.hpp" | |
| 47 #include "memory/generationSpec.hpp" | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
48 #include "memory/referenceProcessor.hpp" |
| 1972 | 49 #include "oops/oop.inline.hpp" |
| 50 #include "oops/oop.pcgc.inline.hpp" | |
| 51 #include "runtime/aprofiler.hpp" | |
| 52 #include "runtime/vmThread.hpp" | |
| 342 | 53 |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
54 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
|
55 |
| 342 | 56 // turn it on so that the contents of the young list (scan-only / |
| 57 // to-be-collected) are printed at "strategic" points before / during | |
| 58 // / 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
|
59 #define YOUNG_LIST_VERBOSE 0 |
| 342 | 60 // CURRENT STATUS |
| 61 // This file is under construction. Search for "FIXME". | |
| 62 | |
| 63 // INVARIANTS/NOTES | |
| 64 // | |
| 65 // All allocation activity covered by the G1CollectedHeap interface is | |
| 1973 | 66 // serialized by acquiring the HeapLock. This happens in mem_allocate |
| 67 // and allocate_new_tlab, which are the "entry" points to the | |
| 68 // allocation code from the rest of the JVM. (Note that this does not | |
| 69 // apply to TLAB allocation, which is not part of this interface: it | |
| 70 // is done by clients of this interface.) | |
| 342 | 71 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
72 // Notes on implementation of parallelism in different tasks. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
73 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
74 // G1ParVerifyTask uses heap_region_par_iterate_chunked() for parallelism. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
75 // 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
|
76 // 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
|
77 // G1ParTask executes g1_process_strong_roots() -> |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
78 // SharedHeap::process_strong_roots() which calls eventuall to |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
79 // CardTableModRefBS::par_non_clean_card_iterate_work() which uses |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
80 // SequentialSubTasksDone. SharedHeap::process_strong_roots() also |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
81 // directly uses SubTasksDone (_process_strong_tasks field in SharedHeap). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
82 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
83 |
| 342 | 84 // Local to this file. |
| 85 | |
| 86 class RefineCardTableEntryClosure: public CardTableEntryClosure { | |
| 87 SuspendibleThreadSet* _sts; | |
| 88 G1RemSet* _g1rs; | |
| 89 ConcurrentG1Refine* _cg1r; | |
| 90 bool _concurrent; | |
| 91 public: | |
| 92 RefineCardTableEntryClosure(SuspendibleThreadSet* sts, | |
| 93 G1RemSet* g1rs, | |
| 94 ConcurrentG1Refine* cg1r) : | |
| 95 _sts(sts), _g1rs(g1rs), _cg1r(cg1r), _concurrent(true) | |
| 96 {} | |
| 97 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 1705 | 98 bool oops_into_cset = _g1rs->concurrentRefineOneCard(card_ptr, worker_i, false); |
| 99 // This path is executed by the concurrent refine or mutator threads, | |
| 100 // concurrently, and so we do not care if card_ptr contains references | |
| 101 // that point into the collection set. | |
| 102 assert(!oops_into_cset, "should be"); | |
| 103 | |
| 342 | 104 if (_concurrent && _sts->should_yield()) { |
| 105 // Caller will actually yield. | |
| 106 return false; | |
| 107 } | |
| 108 // Otherwise, we finished successfully; return true. | |
| 109 return true; | |
| 110 } | |
| 111 void set_concurrent(bool b) { _concurrent = b; } | |
| 112 }; | |
| 113 | |
| 114 | |
| 115 class ClearLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 116 int _calls; | |
| 117 G1CollectedHeap* _g1h; | |
| 118 CardTableModRefBS* _ctbs; | |
| 119 int _histo[256]; | |
| 120 public: | |
| 121 ClearLoggedCardTableEntryClosure() : | |
| 122 _calls(0) | |
| 123 { | |
| 124 _g1h = G1CollectedHeap::heap(); | |
| 125 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 126 for (int i = 0; i < 256; i++) _histo[i] = 0; | |
| 127 } | |
| 128 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 129 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 130 _calls++; | |
| 131 unsigned char* ujb = (unsigned char*)card_ptr; | |
| 132 int ind = (int)(*ujb); | |
| 133 _histo[ind]++; | |
| 134 *card_ptr = -1; | |
| 135 } | |
| 136 return true; | |
| 137 } | |
| 138 int calls() { return _calls; } | |
| 139 void print_histo() { | |
| 140 gclog_or_tty->print_cr("Card table value histogram:"); | |
| 141 for (int i = 0; i < 256; i++) { | |
| 142 if (_histo[i] != 0) { | |
| 143 gclog_or_tty->print_cr(" %d: %d", i, _histo[i]); | |
| 144 } | |
| 145 } | |
| 146 } | |
| 147 }; | |
| 148 | |
| 149 class RedirtyLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 150 int _calls; | |
| 151 G1CollectedHeap* _g1h; | |
| 152 CardTableModRefBS* _ctbs; | |
| 153 public: | |
| 154 RedirtyLoggedCardTableEntryClosure() : | |
| 155 _calls(0) | |
| 156 { | |
| 157 _g1h = G1CollectedHeap::heap(); | |
| 158 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 159 } | |
| 160 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 161 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 162 _calls++; | |
| 163 *card_ptr = 0; | |
| 164 } | |
| 165 return true; | |
| 166 } | |
| 167 int calls() { return _calls; } | |
| 168 }; | |
| 169 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
170 class RedirtyLoggedCardTableEntryFastClosure : public CardTableEntryClosure { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
171 public: |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
172 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
|
173 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
174 return true; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
175 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
176 }; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
177 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
178 YoungList::YoungList(G1CollectedHeap* g1h) : |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
179 _g1h(g1h), _head(NULL), _length(0), _last_sampled_rs_lengths(0), |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
180 _survivor_head(NULL), _survivor_tail(NULL), _survivor_length(0) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
181 guarantee(check_list_empty(false), "just making sure..."); |
| 342 | 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 } |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
594 if (res == NULL && do_expand && _expand_heap_after_alloc_failure) { |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
595 // Currently, only attempts to allocate GC alloc regions set |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
596 // do_expand to true. So, we should only reach here during a |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
597 // safepoint. If this assumption changes we might have to |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
598 // reconsider the use of _expand_heap_after_alloc_failure. |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
599 assert(SafepointSynchronize::is_at_safepoint(), "invariant"); |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
600 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
601 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
602 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
603 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
|
604 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
605 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
606 if (expand(word_size * HeapWordSize)) { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
607 // Given that expand() succeeded in expanding the heap, and we |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
608 // always expand the heap by an amount aligned to the heap |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
609 // region size, the free list should in theory not be empty. So |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
610 // it would probably be OK to use remove_head(). But the extra |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
611 // check for NULL is unlikely to be a performance issue here (we |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
612 // just expanded the heap!) so let's just be conservative and |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
613 // use remove_head_or_null(). |
| 3766 | 614 res = _free_list.remove_head_or_null(); |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
615 } else { |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
616 _expand_heap_after_alloc_failure = false; |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
617 } |
| 342 | 618 } |
| 619 return res; | |
| 620 } | |
| 621 | |
| 3766 | 622 size_t G1CollectedHeap::humongous_obj_allocate_find_first(size_t num_regions, |
| 623 size_t word_size) { | |
| 2361 | 624 assert(isHumongous(word_size), "word_size should be humongous"); |
| 625 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 626 | |
| 3766 | 627 size_t first = G1_NULL_HRS_INDEX; |
| 2152 | 628 if (num_regions == 1) { |
| 629 // Only one region to allocate, no need to go through the slower | |
| 630 // path. The caller will attempt the expasion if this fails, so | |
| 631 // 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
|
632 HeapRegion* hr = new_region(word_size, false /* do_expand */); |
| 2152 | 633 if (hr != NULL) { |
| 634 first = hr->hrs_index(); | |
| 635 } else { | |
| 3766 | 636 first = G1_NULL_HRS_INDEX; |
| 2152 | 637 } |
| 638 } else { | |
| 639 // We can't allocate humongous regions while cleanupComplete() is | |
| 640 // running, since some of the regions we find to be empty might not | |
| 641 // yet be added to the free list and it is not straightforward to | |
| 642 // know which list they are on so that we can remove them. Note | |
| 643 // that we only need to do this if we need to allocate more than | |
| 644 // one region to satisfy the current humongous allocation | |
| 645 // request. If we are only allocating one region we use the common | |
| 646 // region allocation code (see above). | |
| 647 wait_while_free_regions_coming(); | |
| 2361 | 648 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 649 |
| 650 if (free_regions() >= num_regions) { | |
| 3766 | 651 first = _hrs.find_contiguous(num_regions); |
| 652 if (first != G1_NULL_HRS_INDEX) { | |
| 653 for (size_t i = first; i < first + num_regions; ++i) { | |
| 654 HeapRegion* hr = region_at(i); | |
| 2152 | 655 assert(hr->is_empty(), "sanity"); |
| 2361 | 656 assert(is_on_master_free_list(hr), "sanity"); |
| 2152 | 657 hr->set_pending_removal(true); |
| 658 } | |
| 659 _free_list.remove_all_pending(num_regions); | |
| 660 } | |
| 661 } | |
| 662 } | |
| 663 return first; | |
| 664 } | |
| 665 | |
| 2361 | 666 HeapWord* |
| 3766 | 667 G1CollectedHeap::humongous_obj_allocate_initialize_regions(size_t first, |
| 2361 | 668 size_t num_regions, |
| 669 size_t word_size) { | |
| 3766 | 670 assert(first != G1_NULL_HRS_INDEX, "pre-condition"); |
| 2361 | 671 assert(isHumongous(word_size), "word_size should be humongous"); |
| 672 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 673 | |
| 674 // Index of last region in the series + 1. | |
| 3766 | 675 size_t last = first + num_regions; |
| 2361 | 676 |
| 677 // We need to initialize the region(s) we just discovered. This is | |
| 678 // a bit tricky given that it can happen concurrently with | |
| 679 // refinement threads refining cards on these regions and | |
| 680 // potentially wanting to refine the BOT as they are scanning | |
| 681 // those cards (this can happen shortly after a cleanup; see CR | |
| 682 // 6991377). So we have to set up the region(s) carefully and in | |
| 683 // a specific order. | |
| 684 | |
| 685 // The word size sum of all the regions we will allocate. | |
| 686 size_t word_size_sum = num_regions * HeapRegion::GrainWords; | |
| 687 assert(word_size <= word_size_sum, "sanity"); | |
| 688 | |
| 689 // This will be the "starts humongous" region. | |
| 3766 | 690 HeapRegion* first_hr = region_at(first); |
| 2361 | 691 // The header of the new object will be placed at the bottom of |
| 692 // the first region. | |
| 693 HeapWord* new_obj = first_hr->bottom(); | |
| 694 // This will be the new end of the first region in the series that | |
| 695 // should also match the end of the last region in the seriers. | |
| 696 HeapWord* new_end = new_obj + word_size_sum; | |
| 697 // This will be the new top of the first region that will reflect | |
| 698 // this allocation. | |
| 699 HeapWord* new_top = new_obj + word_size; | |
| 700 | |
| 701 // First, we need to zero the header of the space that we will be | |
| 702 // allocating. When we update top further down, some refinement | |
| 703 // threads might try to scan the region. By zeroing the header we | |
| 704 // ensure that any thread that will try to scan the region will | |
| 705 // come across the zero klass word and bail out. | |
| 706 // | |
| 707 // NOTE: It would not have been correct to have used | |
| 708 // CollectedHeap::fill_with_object() and make the space look like | |
| 709 // an int array. The thread that is doing the allocation will | |
| 710 // later update the object header to a potentially different array | |
| 711 // type and, for a very short period of time, the klass and length | |
| 712 // fields will be inconsistent. This could cause a refinement | |
| 713 // thread to calculate the object size incorrectly. | |
| 714 Copy::fill_to_words(new_obj, oopDesc::header_size(), 0); | |
| 715 | |
| 716 // We will set up the first region as "starts humongous". This | |
| 717 // will also update the BOT covering all the regions to reflect | |
| 718 // that there is a single object that starts at the bottom of the | |
| 719 // first region. | |
| 720 first_hr->set_startsHumongous(new_top, new_end); | |
| 721 | |
| 722 // Then, if there are any, we will set up the "continues | |
| 723 // humongous" regions. | |
| 724 HeapRegion* hr = NULL; | |
| 3766 | 725 for (size_t i = first + 1; i < last; ++i) { |
| 726 hr = region_at(i); | |
| 2361 | 727 hr->set_continuesHumongous(first_hr); |
| 728 } | |
| 729 // If we have "continues humongous" regions (hr != NULL), then the | |
| 730 // end of the last one should match new_end. | |
| 731 assert(hr == NULL || hr->end() == new_end, "sanity"); | |
| 732 | |
| 733 // Up to this point no concurrent thread would have been able to | |
| 734 // do any scanning on any region in this series. All the top | |
| 735 // fields still point to bottom, so the intersection between | |
| 736 // [bottom,top] and [card_start,card_end] will be empty. Before we | |
| 737 // update the top fields, we'll do a storestore to make sure that | |
| 738 // no thread sees the update to top before the zeroing of the | |
| 739 // object header and the BOT initialization. | |
| 740 OrderAccess::storestore(); | |
| 741 | |
| 742 // Now that the BOT and the object header have been initialized, | |
| 743 // we can update top of the "starts humongous" region. | |
| 744 assert(first_hr->bottom() < new_top && new_top <= first_hr->end(), | |
| 745 "new_top should be in this region"); | |
| 746 first_hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
747 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
748 HeapWord* bottom = first_hr->bottom(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
749 HeapWord* end = first_hr->orig_end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
750 if ((first + 1) == last) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
751 // the series has a single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
752 _hr_printer.alloc(G1HRPrinter::SingleHumongous, first_hr, new_top); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
753 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
754 // the series has more than one humongous regions |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
755 _hr_printer.alloc(G1HRPrinter::StartsHumongous, first_hr, end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
756 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
757 } |
| 2361 | 758 |
| 759 // Now, we will update the top fields of the "continues humongous" | |
| 760 // regions. The reason we need to do this is that, otherwise, | |
| 761 // these regions would look empty and this will confuse parts of | |
| 762 // G1. For example, the code that looks for a consecutive number | |
| 763 // of empty regions will consider them empty and try to | |
| 764 // re-allocate them. We can extend is_empty() to also include | |
| 765 // !continuesHumongous(), but it is easier to just update the top | |
| 766 // fields here. The way we set top for all regions (i.e., top == | |
| 767 // end for all regions but the last one, top == new_top for the | |
| 768 // last one) is actually used when we will free up the humongous | |
| 769 // region in free_humongous_region(). | |
| 770 hr = NULL; | |
| 3766 | 771 for (size_t i = first + 1; i < last; ++i) { |
| 772 hr = region_at(i); | |
| 2361 | 773 if ((i + 1) == last) { |
| 774 // last continues humongous region | |
| 775 assert(hr->bottom() < new_top && new_top <= hr->end(), | |
| 776 "new_top should fall on this region"); | |
| 777 hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
778 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, new_top); |
| 2361 | 779 } else { |
| 780 // not last one | |
| 781 assert(new_top > hr->end(), "new_top should be above this region"); | |
| 782 hr->set_top(hr->end()); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
783 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, hr->end()); |
| 2361 | 784 } |
| 785 } | |
| 786 // If we have continues humongous regions (hr != NULL), then the | |
| 787 // end of the last one should match new_end and its top should | |
| 788 // match new_top. | |
| 789 assert(hr == NULL || | |
| 790 (hr->end() == new_end && hr->top() == new_top), "sanity"); | |
| 791 | |
| 792 assert(first_hr->used() == word_size * HeapWordSize, "invariant"); | |
| 793 _summary_bytes_used += first_hr->used(); | |
| 794 _humongous_set.add(first_hr); | |
| 795 | |
| 796 return new_obj; | |
| 797 } | |
| 798 | |
| 342 | 799 // If could fit into free regions w/o expansion, try. |
| 800 // Otherwise, if can expand, do so. | |
| 801 // Otherwise, if using ex regions might help, try with ex given back. | |
| 1973 | 802 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) { |
| 2152 | 803 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
| 804 | |
| 805 verify_region_sets_optional(); | |
| 342 | 806 |
| 807 size_t num_regions = | |
| 1973 | 808 round_to(word_size, HeapRegion::GrainWords) / HeapRegion::GrainWords; |
| 342 | 809 size_t x_size = expansion_regions(); |
| 3766 | 810 size_t fs = _hrs.free_suffix(); |
| 811 size_t first = humongous_obj_allocate_find_first(num_regions, word_size); | |
| 812 if (first == G1_NULL_HRS_INDEX) { | |
| 2152 | 813 // The only thing we can do now is attempt expansion. |
| 342 | 814 if (fs + x_size >= num_regions) { |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
815 // 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
|
816 // 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
|
817 // 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
|
818 // should have succeeded and we wouldn't be here. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
819 // |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
820 // 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
|
821 // 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
|
822 // room available. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
823 assert(num_regions > fs, "earlier allocation should have succeeded"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
824 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
825 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
826 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
827 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
|
828 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
829 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
830 if (expand((num_regions - fs) * HeapRegion::GrainBytes)) { |
| 3766 | 831 // Even though the heap was expanded, it might not have |
| 832 // reached the desired size. So, we cannot assume that the | |
| 833 // allocation will succeed. | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
834 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
|
835 } |
| 2152 | 836 } |
| 837 } | |
| 838 | |
| 2361 | 839 HeapWord* result = NULL; |
| 3766 | 840 if (first != G1_NULL_HRS_INDEX) { |
| 2361 | 841 result = |
| 842 humongous_obj_allocate_initialize_regions(first, num_regions, word_size); | |
| 843 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
|
844 |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
845 // A successful humongous object allocation changes the used space |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
846 // 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
|
847 // sizes and update the jstat counters here. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
848 g1mm()->update_sizes(); |
| 2152 | 849 } |
| 850 | |
| 851 verify_region_sets_optional(); | |
| 2361 | 852 |
| 853 return result; | |
| 342 | 854 } |
| 855 | |
| 1973 | 856 HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) { |
| 857 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
|
858 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
|
859 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
860 unsigned int dummy_gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
861 return attempt_allocation(word_size, &dummy_gc_count_before); |
| 342 | 862 } |
| 863 | |
| 864 HeapWord* | |
| 865 G1CollectedHeap::mem_allocate(size_t word_size, | |
| 1973 | 866 bool* gc_overhead_limit_was_exceeded) { |
| 867 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 868 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
869 // Loop until the allocation is satisified, or unsatisfied after GC. |
| 1973 | 870 for (int try_count = 1; /* we'll return */; try_count += 1) { |
| 871 unsigned int gc_count_before; | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
872 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
873 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
874 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
875 result = attempt_allocation(word_size, &gc_count_before); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
876 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
877 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
|
878 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
879 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
880 return result; |
| 342 | 881 } |
| 882 | |
| 883 // Create the garbage collection operation... | |
| 1973 | 884 VM_G1CollectForAllocation op(gc_count_before, word_size); |
| 342 | 885 // ...and get the VM thread to execute it. |
| 886 VMThread::execute(&op); | |
| 1973 | 887 |
| 888 if (op.prologue_succeeded() && op.pause_succeeded()) { | |
| 889 // If the operation was successful we'll return the result even | |
| 890 // if it is NULL. If the allocation attempt failed immediately | |
| 891 // after a Full GC, it's unlikely we'll be able to allocate now. | |
| 892 HeapWord* result = op.result(); | |
| 893 if (result != NULL && !isHumongous(word_size)) { | |
| 894 // Allocations that take place on VM operations do not do any | |
| 895 // card dirtying and we have to do it here. We only have to do | |
| 896 // this for non-humongous allocations, though. | |
| 897 dirty_young_block(result, word_size); | |
| 898 } | |
| 342 | 899 return result; |
| 1973 | 900 } else { |
| 901 assert(op.result() == NULL, | |
| 902 "the result should be NULL if the VM op did not succeed"); | |
| 342 | 903 } |
| 904 | |
| 905 // Give a warning if we seem to be looping forever. | |
| 906 if ((QueuedAllocationWarningCount > 0) && | |
| 907 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 1973 | 908 warning("G1CollectedHeap::mem_allocate retries %d times", try_count); |
| 342 | 909 } |
| 910 } | |
| 1973 | 911 |
| 912 ShouldNotReachHere(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
913 return NULL; |
| 342 | 914 } |
| 915 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
916 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
|
917 unsigned int *gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
918 // 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
|
919 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
920 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
921 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
|
922 "be called for humongous allocation requests"); |
|
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 // 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
|
925 // (attempt_allocation()) failed to allocate. |
|
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 // 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
|
928 // 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
|
929 // 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
|
930 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
931 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
932 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
|
933 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
934 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
935 |
|
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 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
938 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
939 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
|
940 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
941 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
942 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
943 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
944 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
945 // 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
|
946 // 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
|
947 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
|
948 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
949 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
950 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
|
951 // 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
|
952 // 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
|
953 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
|
954 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
955 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
956 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
957 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
958 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
959 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
960 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
961 // Read the GC count while still holding the Heap_lock. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
962 gc_count_before = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
963 should_try_gc = true; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
964 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
965 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
966 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
967 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
968 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
969 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
|
970 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
971 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
|
972 return result; |
|
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 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
976 // 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
|
977 // 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
|
978 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
979 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
980 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
981 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
982 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
983 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
984 GC_locker::stall_until_clear(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
985 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
986 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
987 // 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
|
988 // 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
|
989 // 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
|
990 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
991 // 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
|
992 // 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
|
993 // 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
|
994 // iteration (after taking the Heap_lock). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
995 result = _mutator_alloc_region.attempt_allocation(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
996 false /* bot_updates */); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
997 if (result != NULL) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
998 return result; |
|
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 // 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
|
1002 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1003 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1004 warning("G1CollectedHeap::attempt_allocation_slow() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1005 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1006 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1007 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1008 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1009 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1010 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1011 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1012 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1013 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
|
1014 unsigned int * gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1015 // 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
|
1016 // 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
|
1017 // 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
|
1018 // 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
|
1019 // 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
|
1020 // 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
|
1021 // 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
|
1022 // 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
|
1023 // 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
|
1024 // much as possible. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1025 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1026 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1027 assert(isHumongous(word_size), "attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1028 "should only be called for humongous allocations"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1029 |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1030 // Humongous objects can exhaust the heap quickly, so we should check if we |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1031 // need to start a marking cycle at each humongous object allocation. We do |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1032 // the check before we do the actual allocation. The reason for doing it |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1033 // before the allocation is that we avoid having to keep track of the newly |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1034 // allocated memory while we do a GC. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1035 if (g1_policy()->need_to_start_conc_mark("concurrent humongous allocation", |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1036 word_size)) { |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1037 collect(GCCause::_g1_humongous_allocation); |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1038 } |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1039 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1040 // 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
|
1041 // 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
|
1042 // 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
|
1043 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1044 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1045 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
|
1046 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1047 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1048 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1049 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1050 MutexLockerEx x(Heap_lock); |
|
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 // 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
|
1053 // 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
|
1054 // 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
|
1055 result = humongous_obj_allocate(word_size); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1056 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1057 return result; |
|
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 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1060 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1061 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1062 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1063 // Read the GC count while still holding the Heap_lock. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1064 gc_count_before = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1065 should_try_gc = true; |
|
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 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1068 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1069 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1070 // 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
|
1071 // 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
|
1072 // 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
|
1073 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1074 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1075 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
|
1076 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1077 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
|
1078 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1079 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1080 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1081 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1082 // 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
|
1083 // 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
|
1084 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1085 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1086 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1087 return NULL; |
|
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 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1090 GC_locker::stall_until_clear(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1091 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1092 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1093 // 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
|
1094 // 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
|
1095 // 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
|
1096 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1097 // 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
|
1098 // warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1099 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1100 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1101 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1102 warning("G1CollectedHeap::attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1103 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1104 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1105 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1106 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1107 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1108 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1109 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1110 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1111 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
|
1112 bool expect_null_mutator_alloc_region) { |
| 2152 | 1113 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
|
1114 assert(_mutator_alloc_region.get() == NULL || |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1115 !expect_null_mutator_alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1116 "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
|
1117 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1118 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1119 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
|
1120 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1121 } else { |
|
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1122 HeapWord* result = humongous_obj_allocate(word_size); |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1123 if (result != NULL && g1_policy()->need_to_start_conc_mark("STW humongous allocation")) { |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1124 g1_policy()->set_initiate_conc_mark_if_possible(); |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1125 } |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1126 return result; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1127 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1128 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1129 ShouldNotReachHere(); |
| 342 | 1130 } |
| 1131 | |
| 1132 class PostMCRemSetClearClosure: public HeapRegionClosure { | |
| 1133 ModRefBarrierSet* _mr_bs; | |
| 1134 public: | |
| 1135 PostMCRemSetClearClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {} | |
| 1136 bool doHeapRegion(HeapRegion* r) { | |
| 1137 r->reset_gc_time_stamp(); | |
| 1138 if (r->continuesHumongous()) | |
| 1139 return false; | |
| 1140 HeapRegionRemSet* hrrs = r->rem_set(); | |
| 1141 if (hrrs != NULL) hrrs->clear(); | |
| 1142 // You might think here that we could clear just the cards | |
| 1143 // corresponding to the used region. But no: if we leave a dirty card | |
| 1144 // in a region we might allocate into, then it would prevent that card | |
| 1145 // from being enqueued, and cause it to be missed. | |
| 1146 // Re: the performance cost: we shouldn't be doing full GC anyway! | |
| 1147 _mr_bs->clear(MemRegion(r->bottom(), r->end())); | |
| 1148 return false; | |
| 1149 } | |
| 1150 }; | |
| 1151 | |
| 1152 | |
| 1153 class PostMCRemSetInvalidateClosure: public HeapRegionClosure { | |
| 1154 ModRefBarrierSet* _mr_bs; | |
| 1155 public: | |
| 1156 PostMCRemSetInvalidateClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {} | |
| 1157 bool doHeapRegion(HeapRegion* r) { | |
| 1158 if (r->continuesHumongous()) return false; | |
| 1159 if (r->used_region().word_size() != 0) { | |
| 1160 _mr_bs->invalidate(r->used_region(), true /*whole heap*/); | |
| 1161 } | |
| 1162 return false; | |
| 1163 } | |
| 1164 }; | |
| 1165 | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1166 class RebuildRSOutOfRegionClosure: public HeapRegionClosure { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1167 G1CollectedHeap* _g1h; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1168 UpdateRSOopClosure _cl; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1169 int _worker_i; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1170 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1171 RebuildRSOutOfRegionClosure(G1CollectedHeap* g1, int worker_i = 0) : |
| 1861 | 1172 _cl(g1->g1_rem_set(), worker_i), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1173 _worker_i(worker_i), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1174 _g1h(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1175 { } |
|
1960
878b57474103
6978187: G1: assert(ParallelGCThreads> 1 || n_yielded() == _hrrs->occupied()) strikes again
johnc
parents:
1883
diff
changeset
|
1176 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1177 bool doHeapRegion(HeapRegion* r) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1178 if (!r->continuesHumongous()) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1179 _cl.set_from(r); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1180 r->oop_iterate(&_cl); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1181 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1182 return false; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1183 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1184 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1185 |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1186 class ParRebuildRSTask: public AbstractGangTask { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1187 G1CollectedHeap* _g1; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1188 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1189 ParRebuildRSTask(G1CollectedHeap* g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1190 : AbstractGangTask("ParRebuildRSTask"), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1191 _g1(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1192 { } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1193 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1194 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1195 RebuildRSOutOfRegionClosure rebuild_rs(_g1, worker_id); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1196 _g1->heap_region_par_iterate_chunked(&rebuild_rs, worker_id, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1197 _g1->workers()->active_workers(), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1198 HeapRegion::RebuildRSClaimValue); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1199 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1200 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1201 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1202 class PostCompactionPrinterClosure: public HeapRegionClosure { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1203 private: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1204 G1HRPrinter* _hr_printer; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1205 public: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1206 bool doHeapRegion(HeapRegion* hr) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1207 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
|
1208 // We only generate output for non-empty regions. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1209 if (!hr->is_empty()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1210 if (!hr->isHumongous()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1211 _hr_printer->post_compaction(hr, G1HRPrinter::Old); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1212 } else if (hr->startsHumongous()) { |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
1213 if (hr->capacity() == HeapRegion::GrainBytes) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1214 // single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1215 _hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1216 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1217 _hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1218 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1219 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1220 assert(hr->continuesHumongous(), "only way to get here"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1221 _hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1222 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1223 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1224 return false; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1225 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1226 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1227 PostCompactionPrinterClosure(G1HRPrinter* hr_printer) |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1228 : _hr_printer(hr_printer) { } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1229 }; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1230 |
| 1973 | 1231 bool G1CollectedHeap::do_collection(bool explicit_gc, |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1232 bool clear_all_soft_refs, |
| 342 | 1233 size_t word_size) { |
| 2152 | 1234 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1235 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1236 if (GC_locker::check_active_before_gc()) { |
| 1973 | 1237 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1238 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1239 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
1240 SvcGCMarker sgcm(SvcGCMarker::FULL); |
| 342 | 1241 ResourceMark rm; |
| 1242 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
1243 print_heap_before_gc(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1244 |
| 4072 | 1245 HRSPhaseSetter x(HRSPhaseFullGC); |
| 2152 | 1246 verify_region_sets_optional(); |
| 342 | 1247 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1248 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
|
1249 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
|
1250 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1251 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
|
1252 |
| 342 | 1253 { |
| 1254 IsGCActiveMark x; | |
| 1255 | |
| 1256 // Timing | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1257 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
|
1258 assert(!system_gc || explicit_gc, "invariant"); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1259 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1260 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1261 TraceTime t(system_gc ? "Full GC (System.gc())" : "Full GC", |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1262 G1Log::fine(), true, gclog_or_tty); |
| 342 | 1263 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
1264 TraceCollectorStats tcs(g1mm()->full_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
1265 TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1266 |
| 342 | 1267 double start = os::elapsedTime(); |
| 1268 g1_policy()->record_full_collection_start(); | |
| 1269 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1270 // Note: When we have a more flexible GC logging framework that |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1271 // allows us to add optional attributes to a GC log record we |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1272 // could consider timing and reporting how long we wait in the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1273 // following two methods. |
| 2152 | 1274 wait_while_free_regions_coming(); |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1275 // If we start the compaction before the CM threads finish |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1276 // scanning the root regions we might trip them over as we'll |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1277 // be moving objects / updating references. So let's wait until |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1278 // they are done. By telling them to abort, they should complete |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1279 // early. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1280 _cm->root_regions()->abort(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1281 _cm->root_regions()->wait_until_scan_finished(); |
| 2361 | 1282 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 1283 |
| 342 | 1284 gc_prologue(true); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1285 increment_total_collections(true /* full gc */); |
| 342 | 1286 |
| 1287 size_t g1h_prev_used = used(); | |
| 1288 assert(used() == recalculate_used(), "Should be equal"); | |
| 1289 | |
| 1290 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { | |
| 1291 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
|
1292 gclog_or_tty->print(" VerifyBeforeGC:"); |
| 342 | 1293 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1294 Universe::verify(/* allow dirty */ true, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1295 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1296 /* option */ VerifyOption_G1UsePrevMarking); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1297 |
| 342 | 1298 } |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1299 pre_full_gc_dump(); |
| 342 | 1300 |
| 1301 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
| 1302 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1303 // Disable discovery and empty the discovered lists |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1304 // for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1305 ref_processor_cm()->disable_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1306 ref_processor_cm()->abandon_partial_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1307 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1308 |
| 1309 // Abandon current iterations of concurrent marking and concurrent | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1310 // refinement, if any are in progress. We have to do this before |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1311 // wait_until_scan_finished() below. |
| 342 | 1312 concurrent_mark()->abort(); |
| 1313 | |
| 1314 // 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
|
1315 release_mutator_alloc_region(); |
| 636 | 1316 abandon_gc_alloc_regions(); |
| 1861 | 1317 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
|
1318 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1319 // 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
|
1320 // 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
|
1321 // before the start GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1322 _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
|
1323 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1324 // 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
|
1325 // 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
|
1326 // 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
|
1327 // after this full GC. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1328 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
|
1329 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
|
1330 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
|
1331 |
| 4072 | 1332 tear_down_region_sets(false /* free_list_only */); |
| 4710 | 1333 g1_policy()->set_gcs_are_young(true); |
| 342 | 1334 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1335 // See the comments in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1336 // G1CollectedHeap::ref_processing_init() about |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1337 // how reference processing currently works in G1. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1338 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1339 // 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
|
1340 ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false); |
|
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 // 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
|
1343 ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1344 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1345 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
|
1346 ref_processor_stw()->setup_policy(do_clear_all_soft_refs); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1347 |
| 342 | 1348 // Do collection work |
| 1349 { | |
| 1350 HandleMark hm; // Discard invalid handles created during gc | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1351 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs); |
| 342 | 1352 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1353 |
| 2152 | 1354 assert(free_regions() == 0, "we should not have added any free regions"); |
| 4072 | 1355 rebuild_region_sets(false /* free_list_only */); |
| 342 | 1356 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1357 // Enqueue any discovered reference objects that have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1358 // not been removed from the discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1359 ref_processor_stw()->enqueue_discovered_references(); |
| 342 | 1360 |
| 1361 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
| 1362 | |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1363 MemoryService::track_memory_usage(); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1364 |
| 342 | 1365 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { |
| 1366 HandleMark hm; // Discard invalid handles created during verification | |
| 1367 gclog_or_tty->print(" VerifyAfterGC:"); | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
1368 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1369 Universe::verify(/* allow dirty */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1370 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1371 /* option */ VerifyOption_G1UsePrevMarking); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
1372 |
| 342 | 1373 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1374 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1375 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1376 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1377 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1378 // Note: since we've just done a full GC, concurrent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1379 // marking is no longer active. Therefore we need not |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1380 // re-enable reference discovery for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1381 // 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
|
1382 assert(!ref_processor_cm()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1383 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1384 |
| 1385 reset_gc_time_stamp(); | |
| 1386 // Since everything potentially moved, we will clear all remembered | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1387 // sets, and clear all cards. Later we will rebuild remebered |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1388 // sets. We will also reset the GC time stamps of the regions. |
| 342 | 1389 PostMCRemSetClearClosure rs_clear(mr_bs()); |
| 1390 heap_region_iterate(&rs_clear); | |
| 1391 | |
| 1392 // Resize the heap if necessary. | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1393 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size); |
| 342 | 1394 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1395 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1396 // 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
|
1397 // that all the COMMIT / UNCOMMIT events are generated before |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1398 // the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1399 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1400 PostCompactionPrinterClosure cl(hr_printer()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1401 heap_region_iterate(&cl); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1402 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1403 _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
|
1404 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1405 |
| 342 | 1406 if (_cg1r->use_cache()) { |
| 1407 _cg1r->clear_and_record_card_counts(); | |
| 1408 _cg1r->clear_hot_cache(); | |
| 1409 } | |
| 1410 | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1411 // Rebuild remembered sets of all regions. |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
1412 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1413 uint n_workers = |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1414 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1415 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1416 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1417 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1418 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1419 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1420 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1421 // 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
|
1422 // 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
|
1423 // 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
|
1424 // 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
|
1425 // may be code that is "possibly_parallel". |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1426 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1427 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1428 ParRebuildRSTask rebuild_rs_task(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1429 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1430 HeapRegion::InitialClaimValue), "sanity check"); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1431 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1432 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1433 "Unless dynamic should use total workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1434 // Use the most recent number of active workers |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1435 assert(workers()->active_workers() > 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1436 "Active workers not properly set"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1437 set_par_threads(workers()->active_workers()); |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1438 workers()->run_task(&rebuild_rs_task); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1439 set_par_threads(0); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1440 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1441 HeapRegion::RebuildRSClaimValue), "sanity check"); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1442 reset_heap_region_claim_values(); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1443 } else { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1444 RebuildRSOutOfRegionClosure rebuild_rs(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1445 heap_region_iterate(&rebuild_rs); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1446 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1447 |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1448 if (G1Log::fine()) { |
| 342 | 1449 print_size_transition(gclog_or_tty, g1h_prev_used, used(), capacity()); |
| 1450 } | |
| 1451 | |
| 1452 if (true) { // FIXME | |
| 1453 // Ask the permanent generation to adjust size for full collections | |
| 1454 perm()->compute_new_size(); | |
| 1455 } | |
| 1456 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1457 // 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
|
1458 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
|
1459 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
|
1460 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1461 // 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
|
1462 // 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
|
1463 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1464 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1465 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1466 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1467 |
| 342 | 1468 double end = os::elapsedTime(); |
| 1469 g1_policy()->record_full_collection_end(); | |
| 1470 | |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1471 #ifdef TRACESPINNING |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1472 ParallelTaskTerminator::print_termination_counts(); |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1473 #endif |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1474 |
| 342 | 1475 gc_epilogue(true); |
| 1476 | |
| 794 | 1477 // Discard all rset updates |
| 1478 JavaThread::dirty_card_queue_set().abandon_logs(); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1479 assert(!G1DeferredRSUpdate |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1480 || (G1DeferredRSUpdate && (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any"); |
| 342 | 1481 } |
| 1482 | |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1483 _young_list->reset_sampled_info(); |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1484 // 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
|
1485 // entire heap tagged as young. |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1486 assert( check_young_list_empty(true /* check_heap */), |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1487 "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
|
1488 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1489 // 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
|
1490 increment_full_collections_completed(false /* concurrent */); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1491 |
| 3766 | 1492 _hrs.verify_optional(); |
| 2152 | 1493 verify_region_sets_optional(); |
| 1494 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
1495 print_heap_after_gc(); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1496 g1mm()->update_sizes(); |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1497 post_full_gc_dump(); |
| 1973 | 1498 |
| 1499 return true; | |
| 342 | 1500 } |
| 1501 | |
| 1502 void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) { | |
| 1973 | 1503 // do_collection() will return whether it succeeded in performing |
| 1504 // the GC. Currently, there is no facility on the | |
| 1505 // do_full_collection() API to notify the caller than the collection | |
| 1506 // did not succeed (e.g., because it was locked out by the GC | |
| 1507 // locker). So, right now, we'll ignore the return value. | |
| 1508 bool dummy = do_collection(true, /* explicit_gc */ | |
| 1509 clear_all_soft_refs, | |
| 1510 0 /* word_size */); | |
| 342 | 1511 } |
| 1512 | |
| 1513 // This code is mostly copied from TenuredGeneration. | |
| 1514 void | |
| 1515 G1CollectedHeap:: | |
| 1516 resize_if_necessary_after_full_collection(size_t word_size) { | |
| 1517 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, "sanity check"); | |
| 1518 | |
| 1519 // Include the current allocation, if any, and bytes that will be | |
| 1520 // pre-allocated to support collections, as "used". | |
| 1521 const size_t used_after_gc = used(); | |
| 1522 const size_t capacity_after_gc = capacity(); | |
| 1523 const size_t free_after_gc = capacity_after_gc - used_after_gc; | |
| 1524 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1525 // This is enforced in arguments.cpp. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1526 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1527 "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
|
1528 |
| 342 | 1529 // 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
|
1530 const double minimum_free_percentage = (double) MinHeapFreeRatio / 100.0; |
| 342 | 1531 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
|
1532 const double maximum_free_percentage = (double) MaxHeapFreeRatio / 100.0; |
| 342 | 1533 const double minimum_used_percentage = 1.0 - maximum_free_percentage; |
| 1534 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1535 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
|
1536 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
|
1537 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1538 // 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
|
1539 // 32-bit size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1540 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
|
1541 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
|
1542 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
|
1543 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1544 // 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
|
1545 // 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
|
1546 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
|
1547 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
|
1548 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1549 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
|
1550 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1551 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1552 // 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
|
1553 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
|
1554 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
|
1555 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1556 // 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
|
1557 // 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
|
1558 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
|
1559 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
|
1560 "maximum_desired_capacity = "SIZE_FORMAT, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1561 minimum_desired_capacity, maximum_desired_capacity)); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1562 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1563 // 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
|
1564 // 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
|
1565 // 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
|
1566 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
|
1567 // 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
|
1568 // 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
|
1569 // 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
|
1570 maximum_desired_capacity = MAX2(maximum_desired_capacity, min_heap_size); |
| 342 | 1571 |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1572 if (capacity_after_gc < minimum_desired_capacity) { |
| 342 | 1573 // Don't expand unless it's significant |
| 1574 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
|
1575 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1576 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1577 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
|
1578 "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
|
1579 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1580 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1581 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
|
1582 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
|
1583 minimum_desired_capacity, (double) MinHeapFreeRatio); |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1584 expand(expand_bytes); |
| 342 | 1585 |
| 1586 // 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
|
1587 } else if (capacity_after_gc > maximum_desired_capacity) { |
| 342 | 1588 // Capacity too large, compute shrinking size |
| 1589 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
|
1590 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1591 "attempt heap shrinking", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1592 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
|
1593 "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
|
1594 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1595 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1596 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
|
1597 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
|
1598 maximum_desired_capacity, (double) MaxHeapFreeRatio); |
| 342 | 1599 shrink(shrink_bytes); |
| 1600 } | |
| 1601 } | |
| 1602 | |
| 1603 | |
| 1604 HeapWord* | |
| 1973 | 1605 G1CollectedHeap::satisfy_failed_allocation(size_t word_size, |
| 1606 bool* succeeded) { | |
| 2152 | 1607 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1973 | 1608 |
| 1609 *succeeded = true; | |
| 1610 // Let's attempt the allocation first. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1611 HeapWord* result = |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1612 attempt_allocation_at_safepoint(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1613 false /* expect_null_mutator_alloc_region */); |
| 1973 | 1614 if (result != NULL) { |
| 1615 assert(*succeeded, "sanity"); | |
| 1616 return result; | |
| 1617 } | |
| 342 | 1618 |
| 1619 // In a G1 heap, we're supposed to keep allocation from failing by | |
| 1620 // incremental pauses. Therefore, at least for now, we'll favor | |
| 1621 // expansion over collection. (This might change in the future if we can | |
| 1622 // do something smarter than full collection to satisfy a failed alloc.) | |
| 1623 result = expand_and_allocate(word_size); | |
| 1624 if (result != NULL) { | |
| 1973 | 1625 assert(*succeeded, "sanity"); |
| 342 | 1626 return result; |
| 1627 } | |
| 1628 | |
| 1973 | 1629 // Expansion didn't work, we'll try to do a Full GC. |
| 1630 bool gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1631 false, /* clear_all_soft_refs */ | |
| 1632 word_size); | |
| 1633 if (!gc_succeeded) { | |
| 1634 *succeeded = false; | |
| 1635 return NULL; | |
| 1636 } | |
| 1637 | |
| 1638 // Retry the allocation | |
| 1639 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1640 true /* expect_null_mutator_alloc_region */); |
| 342 | 1641 if (result != NULL) { |
| 1973 | 1642 assert(*succeeded, "sanity"); |
| 342 | 1643 return result; |
| 1644 } | |
| 1645 | |
| 1973 | 1646 // Then, try a Full GC that will collect all soft references. |
| 1647 gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1648 true, /* clear_all_soft_refs */ | |
| 1649 word_size); | |
| 1650 if (!gc_succeeded) { | |
| 1651 *succeeded = false; | |
| 1652 return NULL; | |
| 1653 } | |
| 1654 | |
| 1655 // Retry the allocation once more | |
| 1656 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1657 true /* expect_null_mutator_alloc_region */); |
| 342 | 1658 if (result != NULL) { |
| 1973 | 1659 assert(*succeeded, "sanity"); |
| 342 | 1660 return result; |
| 1661 } | |
| 1662 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1663 assert(!collector_policy()->should_clear_all_soft_refs(), |
| 1973 | 1664 "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
|
1665 |
| 342 | 1666 // What else? We might try synchronous finalization later. If the total |
| 1667 // space available is large enough for the allocation, then a more | |
| 1668 // complete compaction phase than we've tried so far might be | |
| 1669 // appropriate. | |
| 1973 | 1670 assert(*succeeded, "sanity"); |
| 342 | 1671 return NULL; |
| 1672 } | |
| 1673 | |
| 1674 // Attempting to expand the heap sufficiently | |
| 1675 // to support an allocation of the given "word_size". If | |
| 1676 // successful, perform the allocation and return the address of the | |
| 1677 // allocated block, or else "NULL". | |
| 1678 | |
| 1679 HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) { | |
| 2152 | 1680 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1681 | |
| 1682 verify_region_sets_optional(); | |
| 1973 | 1683 |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1684 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
|
1685 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1686 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1687 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
|
1688 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1689 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1690 if (expand(expand_bytes)) { |
| 3766 | 1691 _hrs.verify_optional(); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1692 verify_region_sets_optional(); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1693 return attempt_allocation_at_safepoint(word_size, |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1694 false /* expect_null_mutator_alloc_region */); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1695 } |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1696 return NULL; |
| 342 | 1697 } |
| 1698 | |
| 3766 | 1699 void G1CollectedHeap::update_committed_space(HeapWord* old_end, |
| 1700 HeapWord* new_end) { | |
| 1701 assert(old_end != new_end, "don't call this otherwise"); | |
| 1702 assert((HeapWord*) _g1_storage.high() == new_end, "invariant"); | |
| 1703 | |
| 1704 // Update the committed mem region. | |
| 1705 _g1_committed.set_end(new_end); | |
| 1706 // Tell the card table about the update. | |
| 1707 Universe::heap()->barrier_set()->resize_covered_region(_g1_committed); | |
| 1708 // Tell the BOT about the update. | |
| 1709 _bot_shared->resize(_g1_committed.word_size()); | |
| 1710 } | |
| 1711 | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1712 bool G1CollectedHeap::expand(size_t expand_bytes) { |
| 342 | 1713 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
|
1714 size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes); |
| 342 | 1715 aligned_expand_bytes = align_size_up(aligned_expand_bytes, |
| 1716 HeapRegion::GrainBytes); | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1717 ergo_verbose2(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1718 "expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1719 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
|
1720 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
|
1721 expand_bytes, aligned_expand_bytes); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1722 |
| 3766 | 1723 // First commit the memory. |
| 1724 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1725 bool successful = _g1_storage.expand_by(aligned_expand_bytes); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1726 if (successful) { |
| 3766 | 1727 // Then propagate this update to the necessary data structures. |
| 1728 HeapWord* new_end = (HeapWord*) _g1_storage.high(); | |
| 1729 update_committed_space(old_end, new_end); | |
| 1730 | |
| 1731 FreeRegionList expansion_list("Local Expansion List"); | |
| 1732 MemRegion mr = _hrs.expand_by(old_end, new_end, &expansion_list); | |
| 1733 assert(mr.start() == old_end, "post-condition"); | |
| 1734 // mr might be a smaller region than what was requested if | |
| 1735 // expand_by() was unable to allocate the HeapRegion instances | |
| 1736 assert(mr.end() <= new_end, "post-condition"); | |
| 1737 | |
| 1738 size_t actual_expand_bytes = mr.byte_size(); | |
| 1739 assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition"); | |
| 1740 assert(actual_expand_bytes == expansion_list.total_capacity_bytes(), | |
| 1741 "post-condition"); | |
| 1742 if (actual_expand_bytes < aligned_expand_bytes) { | |
| 1743 // We could not expand _hrs to the desired size. In this case we | |
| 1744 // need to shrink the committed space accordingly. | |
| 1745 assert(mr.end() < new_end, "invariant"); | |
| 1746 | |
| 1747 size_t diff_bytes = aligned_expand_bytes - actual_expand_bytes; | |
| 1748 // First uncommit the memory. | |
| 1749 _g1_storage.shrink_by(diff_bytes); | |
| 1750 // Then propagate this update to the necessary data structures. | |
| 1751 update_committed_space(new_end, mr.end()); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1752 } |
| 3766 | 1753 _free_list.add_as_tail(&expansion_list); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1754 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1755 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1756 HeapWord* curr = mr.start(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1757 while (curr < mr.end()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1758 HeapWord* curr_end = curr + HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1759 _hr_printer.commit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1760 curr = curr_end; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1761 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1762 assert(curr == mr.end(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1763 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1764 g1_policy()->record_new_heap_size(n_regions()); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1765 } else { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1766 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1767 "did not expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1768 ergo_format_reason("heap expansion operation failed")); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1769 // The expansion of the virtual storage space was unsuccessful. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1770 // 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
|
1771 if (G1ExitOnExpansionFailure && |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1772 _g1_storage.uncommitted_size() >= aligned_expand_bytes) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1773 // We had head room... |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1774 vm_exit_out_of_memory(aligned_expand_bytes, "G1 heap expansion"); |
| 342 | 1775 } |
| 1776 } | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1777 return successful; |
| 342 | 1778 } |
| 1779 | |
| 3766 | 1780 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) { |
| 342 | 1781 size_t old_mem_size = _g1_storage.committed_size(); |
| 1782 size_t aligned_shrink_bytes = | |
| 1783 ReservedSpace::page_align_size_down(shrink_bytes); | |
| 1784 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes, | |
| 1785 HeapRegion::GrainBytes); | |
| 1786 size_t num_regions_deleted = 0; | |
| 3766 | 1787 MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted); |
| 1788 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
| 1789 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
|
1790 |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1791 ergo_verbose3(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1792 "shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1793 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
|
1794 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
|
1795 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
|
1796 shrink_bytes, aligned_shrink_bytes, mr.byte_size()); |
| 3766 | 1797 if (mr.byte_size() > 0) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1798 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1799 HeapWord* curr = mr.end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1800 while (curr > mr.start()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1801 HeapWord* curr_end = curr; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1802 curr -= HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1803 _hr_printer.uncommit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1804 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1805 assert(curr == mr.start(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1806 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1807 |
| 342 | 1808 _g1_storage.shrink_by(mr.byte_size()); |
| 3766 | 1809 HeapWord* new_end = (HeapWord*) _g1_storage.high(); |
| 1810 assert(mr.start() == new_end, "post-condition"); | |
| 1811 | |
| 1812 _expansion_regions += num_regions_deleted; | |
| 1813 update_committed_space(old_end, new_end); | |
| 1814 HeapRegionRemSet::shrink_heap(n_regions()); | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1815 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
|
1816 } else { |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1817 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1818 "did not shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1819 ergo_format_reason("heap shrinking operation failed")); |
| 342 | 1820 } |
| 1821 } | |
| 1822 | |
| 1823 void G1CollectedHeap::shrink(size_t shrink_bytes) { | |
| 2152 | 1824 verify_region_sets_optional(); |
| 1825 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1826 // 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
|
1827 // 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
|
1828 // 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
|
1829 abandon_gc_alloc_regions(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1830 |
| 2152 | 1831 // Instead of tearing down / rebuilding the free lists here, we |
| 1832 // could instead use the remove_all_pending() method on free_list to | |
| 1833 // remove only the ones that we need to remove. | |
| 4072 | 1834 tear_down_region_sets(true /* free_list_only */); |
| 342 | 1835 shrink_helper(shrink_bytes); |
| 4072 | 1836 rebuild_region_sets(true /* free_list_only */); |
| 2152 | 1837 |
| 3766 | 1838 _hrs.verify_optional(); |
| 2152 | 1839 verify_region_sets_optional(); |
| 342 | 1840 } |
| 1841 | |
| 1842 // Public methods. | |
| 1843 | |
| 1844 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away | |
| 1845 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 1846 #endif // _MSC_VER | |
| 1847 | |
| 1848 | |
| 1849 G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) : | |
| 1850 SharedHeap(policy_), | |
| 1851 _g1_policy(policy_), | |
| 1111 | 1852 _dirty_card_queue_set(false), |
| 1705 | 1853 _into_cset_dirty_card_queue_set(false), |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1854 _is_alive_closure_cm(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1855 _is_alive_closure_stw(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1856 _ref_processor_cm(NULL), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1857 _ref_processor_stw(NULL), |
| 342 | 1858 _process_strong_tasks(new SubTasksDone(G1H_PS_NumElements)), |
| 1859 _bot_shared(NULL), | |
| 1860 _objs_with_preserved_marks(NULL), _preserved_marks_of_objs(NULL), | |
| 1861 _evac_failure_scan_stack(NULL) , | |
| 1862 _mark_in_progress(false), | |
| 2152 | 1863 _cg1r(NULL), _summary_bytes_used(0), |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1864 _g1mm(NULL), |
| 342 | 1865 _refine_cte_cl(NULL), |
| 1866 _full_collection(false), | |
| 2152 | 1867 _free_list("Master Free List"), |
| 1868 _secondary_free_list("Secondary Free List"), | |
| 4072 | 1869 _old_set("Old Set"), |
| 2152 | 1870 _humongous_set("Master Humongous Set"), |
| 1871 _free_regions_coming(false), | |
| 342 | 1872 _young_list(new YoungList(this)), |
| 1873 _gc_time_stamp(0), | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1874 _retained_old_gc_alloc_region(NULL), |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
1875 _expand_heap_after_alloc_failure(true), |
| 526 | 1876 _surviving_young_words(NULL), |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1877 _full_collections_completed(0), |
| 526 | 1878 _in_cset_fast_test(NULL), |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
1879 _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
|
1880 _dirty_cards_region_list(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1881 _worker_cset_start_region(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1882 _worker_cset_start_region_time_stamp(NULL) { |
| 342 | 1883 _g1h = this; // To catch bugs. |
| 1884 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { | |
| 1885 vm_exit_during_initialization("Failed necessary allocation."); | |
| 1886 } | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1887 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1888 _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1889 |
| 342 | 1890 int n_queues = MAX2((int)ParallelGCThreads, 1); |
| 1891 _task_queues = new RefToScanQueueSet(n_queues); | |
| 1892 | |
| 1893 int n_rem_sets = HeapRegionRemSet::num_par_rem_sets(); | |
| 1894 assert(n_rem_sets > 0, "Invariant."); | |
| 1895 | |
| 1896 HeapRegionRemSetIterator** iter_arr = | |
| 1897 NEW_C_HEAP_ARRAY(HeapRegionRemSetIterator*, n_queues); | |
| 1898 for (int i = 0; i < n_queues; i++) { | |
| 1899 iter_arr[i] = new HeapRegionRemSetIterator(); | |
| 1900 } | |
| 1901 _rem_set_iterator = iter_arr; | |
| 1902 | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1903 _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
|
1904 _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
|
1905 |
| 342 | 1906 for (int i = 0; i < n_queues; i++) { |
| 1907 RefToScanQueue* q = new RefToScanQueue(); | |
| 1908 q->initialize(); | |
| 1909 _task_queues->register_queue(i, q); | |
| 1910 } | |
| 1911 | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1912 clear_cset_start_regions(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1913 |
| 342 | 1914 guarantee(_task_queues != NULL, "task_queues allocation failure."); |
| 1915 } | |
| 1916 | |
| 1917 jint G1CollectedHeap::initialize() { | |
| 1166 | 1918 CollectedHeap::pre_initialize(); |
| 342 | 1919 os::enable_vtime(); |
| 1920 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1921 G1Log::init(); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1922 |
| 342 | 1923 // Necessary to satisfy locking discipline assertions. |
| 1924 | |
| 1925 MutexLocker x(Heap_lock); | |
| 1926 | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1927 // 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
|
1928 // it will be used then. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1929 _hr_printer.set_active(G1PrintHeapRegions); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1930 |
| 342 | 1931 // While there are no constraints in the GC code that HeapWordSize |
| 1932 // be any particular value, there are multiple other areas in the | |
| 1933 // system which believe this to be true (e.g. oop->object_size in some | |
| 1934 // cases incorrectly returns the size in wordSize units rather than | |
| 1935 // HeapWordSize). | |
| 1936 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); | |
| 1937 | |
| 1938 size_t init_byte_size = collector_policy()->initial_heap_byte_size(); | |
| 1939 size_t max_byte_size = collector_policy()->max_heap_byte_size(); | |
| 1940 | |
| 1941 // Ensure that the sizes are properly aligned. | |
| 1942 Universe::check_alignment(init_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1943 Universe::check_alignment(max_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1944 | |
| 1945 _cg1r = new ConcurrentG1Refine(); | |
| 1946 | |
| 1947 // Reserve the maximum. | |
| 1948 PermanentGenerationSpec* pgs = collector_policy()->permanent_generation(); | |
| 1949 // Includes the perm-gen. | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1950 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1951 // When compressed oops are enabled, the preferred heap base |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1952 // is calculated by subtracting the requested size from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1953 // 32Gb boundary and using the result as the base address for |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1954 // heap reservation. If the requested size is not aligned to |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1955 // HeapRegion::GrainBytes (i.e. the alignment that is passed |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1956 // into the ReservedHeapSpace constructor) then the actual |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1957 // base of the reserved heap may end up differing from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1958 // address that was requested (i.e. the preferred heap base). |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1959 // 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
|
1960 // compressed oops mode. |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1961 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1962 // 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
|
1963 // 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
|
1964 const size_t total_reserved = max_byte_size + |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1965 align_size_up(pgs->max_size(), HeapRegion::GrainBytes); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1966 Universe::check_alignment(total_reserved, HeapRegion::GrainBytes, "g1 heap and perm"); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1967 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1968 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
|
1969 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1970 ReservedHeapSpace heap_rs(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1971 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1972 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1973 if (UseCompressedOops) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1974 if (addr != NULL && !heap_rs.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1975 // 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
|
1976 // 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
|
1977 // Try again to reserver heap higher. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1978 addr = Universe::preferred_heap_base(total_reserved, Universe::ZeroBasedNarrowOop); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1979 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1980 ReservedHeapSpace heap_rs0(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1981 UseLargePages, addr); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1982 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1983 if (addr != NULL && !heap_rs0.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1984 // 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
|
1985 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
|
1986 assert(addr == NULL, ""); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1987 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1988 ReservedHeapSpace heap_rs1(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1989 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1990 heap_rs = heap_rs1; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1991 } else { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1992 heap_rs = heap_rs0; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1993 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1994 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1995 } |
| 342 | 1996 |
| 1997 if (!heap_rs.is_reserved()) { | |
| 1998 vm_exit_during_initialization("Could not reserve enough space for object heap"); | |
| 1999 return JNI_ENOMEM; | |
| 2000 } | |
| 2001 | |
| 2002 // It is important to do this in a way such that concurrent readers can't | |
| 2003 // temporarily think somethings in the heap. (I've actually seen this | |
| 2004 // happen in asserts: DLD.) | |
| 2005 _reserved.set_word_size(0); | |
| 2006 _reserved.set_start((HeapWord*)heap_rs.base()); | |
| 2007 _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size())); | |
| 2008 | |
| 2009 _expansion_regions = max_byte_size/HeapRegion::GrainBytes; | |
| 2010 | |
| 2011 // Create the gen rem set (and barrier set) for the entire reserved region. | |
| 2012 _rem_set = collector_policy()->create_rem_set(_reserved, 2); | |
| 2013 set_barrier_set(rem_set()->bs()); | |
| 2014 if (barrier_set()->is_a(BarrierSet::ModRef)) { | |
| 2015 _mr_bs = (ModRefBarrierSet*)_barrier_set; | |
| 2016 } else { | |
| 2017 vm_exit_during_initialization("G1 requires a mod ref bs."); | |
| 2018 return JNI_ENOMEM; | |
| 2019 } | |
| 2020 | |
| 2021 // Also create a G1 rem set. | |
| 1861 | 2022 if (mr_bs()->is_a(BarrierSet::CardTableModRef)) { |
| 2023 _g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs()); | |
| 342 | 2024 } else { |
| 1861 | 2025 vm_exit_during_initialization("G1 requires a cardtable mod ref bs."); |
| 2026 return JNI_ENOMEM; | |
| 342 | 2027 } |
| 2028 | |
| 2029 // Carve out the G1 part of the heap. | |
| 2030 | |
| 2031 ReservedSpace g1_rs = heap_rs.first_part(max_byte_size); | |
| 2032 _g1_reserved = MemRegion((HeapWord*)g1_rs.base(), | |
| 2033 g1_rs.size()/HeapWordSize); | |
| 2034 ReservedSpace perm_gen_rs = heap_rs.last_part(max_byte_size); | |
| 2035 | |
| 2036 _perm_gen = pgs->init(perm_gen_rs, pgs->init_size(), rem_set()); | |
| 2037 | |
| 2038 _g1_storage.initialize(g1_rs, 0); | |
| 2039 _g1_committed = MemRegion((HeapWord*)_g1_storage.low(), (size_t) 0); | |
| 3766 | 2040 _hrs.initialize((HeapWord*) _g1_reserved.start(), |
| 2041 (HeapWord*) _g1_reserved.end(), | |
| 2042 _expansion_regions); | |
| 342 | 2043 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2044 // 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
|
2045 // in the remembered set structures. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2046 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
|
2047 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
|
2048 |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2049 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
|
2050 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
|
2051 guarantee(HeapRegion::CardsPerRegion < max_cards_per_region, |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2052 "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
|
2053 |
| 2152 | 2054 HeapRegionSet::set_unrealistically_long_length(max_regions() + 1); |
| 2055 | |
| 342 | 2056 _bot_shared = new G1BlockOffsetSharedArray(_reserved, |
| 2057 heap_word_size(init_byte_size)); | |
| 2058 | |
| 2059 _g1h = this; | |
| 2060 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2061 _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
|
2062 _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
|
2063 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2064 // 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
|
2065 // 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
|
2066 // 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
|
2067 _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
|
2068 ((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
|
2069 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2070 // 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
|
2071 // 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
|
2072 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2073 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2074 |
| 342 | 2075 // Create the ConcurrentMark data structure and thread. |
| 2076 // (Must do this late, so that "max_regions" is defined.) | |
| 2077 _cm = new ConcurrentMark(heap_rs, (int) max_regions()); | |
| 2078 _cmThread = _cm->cmThread(); | |
| 2079 | |
| 2080 // Initialize the from_card cache structure of HeapRegionRemSet. | |
| 2081 HeapRegionRemSet::init_heap(max_regions()); | |
| 2082 | |
| 677 | 2083 // Now expand into the initial heap size. |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2084 if (!expand(init_byte_size)) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2085 vm_exit_during_initialization("Failed to allocate initial heap."); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2086 return JNI_ENOMEM; |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2087 } |
| 342 | 2088 |
| 2089 // Perform any initialization actions delegated to the policy. | |
| 2090 g1_policy()->init(); | |
| 2091 | |
| 2092 _refine_cte_cl = | |
| 2093 new RefineCardTableEntryClosure(ConcurrentG1RefineThread::sts(), | |
| 2094 g1_rem_set(), | |
| 2095 concurrent_g1_refine()); | |
| 2096 JavaThread::dirty_card_queue_set().set_closure(_refine_cte_cl); | |
| 2097 | |
| 2098 JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon, | |
| 2099 SATB_Q_FL_lock, | |
| 1111 | 2100 G1SATBProcessCompletedThreshold, |
| 342 | 2101 Shared_SATB_Q_lock); |
| 794 | 2102 |
| 2103 JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, | |
| 2104 DirtyCardQ_FL_lock, | |
| 1111 | 2105 concurrent_g1_refine()->yellow_zone(), |
| 2106 concurrent_g1_refine()->red_zone(), | |
| 794 | 2107 Shared_DirtyCardQ_lock); |
| 2108 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2109 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2110 dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2111 DirtyCardQ_FL_lock, |
| 1111 | 2112 -1, // never trigger processing |
| 2113 -1, // no limit on length | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2114 Shared_DirtyCardQ_lock, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2115 &JavaThread::dirty_card_queue_set()); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2116 } |
| 1705 | 2117 |
| 2118 // Initialize the card queue set used to hold cards containing | |
| 2119 // references into the collection set. | |
| 2120 _into_cset_dirty_card_queue_set.initialize(DirtyCardQ_CBL_mon, | |
| 2121 DirtyCardQ_FL_lock, | |
| 2122 -1, // never trigger processing | |
| 2123 -1, // no limit on length | |
| 2124 Shared_DirtyCardQ_lock, | |
| 2125 &JavaThread::dirty_card_queue_set()); | |
| 2126 | |
| 342 | 2127 // In case we're keeping closure specialization stats, initialize those |
| 2128 // counts and that mechanism. | |
| 2129 SpecializationStats::clear(); | |
| 2130 | |
| 2131 // Do later initialization work for concurrent refinement. | |
| 2132 _cg1r->init(); | |
| 2133 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2134 // 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
|
2135 // 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
|
2136 // space here, lots of asserts fire. |
| 3766 | 2137 |
| 2138 HeapRegion* dummy_region = new_heap_region(0 /* index of bottom region */, | |
| 2139 _g1_reserved.start()); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2140 // 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
|
2141 // 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
|
2142 // 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
|
2143 // 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
|
2144 dummy_region->set_young(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2145 // Make sure it's full. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2146 dummy_region->set_top(dummy_region->end()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2147 G1AllocRegion::setup(this, dummy_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2148 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2149 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2150 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2151 // 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
|
2152 // values in the heap have been properly initialized. |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
2153 _g1mm = new G1MonitoringSupport(this); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2154 |
| 342 | 2155 return JNI_OK; |
| 2156 } | |
| 2157 | |
| 2158 void G1CollectedHeap::ref_processing_init() { | |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2159 // Reference processing in G1 currently works as follows: |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2160 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2161 // * There are two reference processor instances. One is |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2162 // used to record and process discovered references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2163 // during concurrent marking; the other is used to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2164 // record and process references during STW pauses |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2165 // (both full and incremental). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2166 // * Both ref processors need to 'span' the entire heap as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2167 // the regions in the collection set may be dotted around. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2168 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2169 // * For the concurrent marking ref processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2170 // * Reference discovery is enabled at initial marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2171 // * Reference discovery is disabled and the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2172 // references processed etc during remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2173 // * Reference discovery is MT (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2174 // * Reference discovery requires a barrier (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2175 // * Reference processing may or may not be MT |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2176 // (depending on the value of ParallelRefProcEnabled |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2177 // and ParallelGCThreads). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2178 // * A full GC disables reference discovery by the CM |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2179 // ref processor and abandons any entries on it's |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2180 // discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2181 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2182 // * For the STW processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2183 // * 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
|
2184 // * Processing and enqueueing during a full GC is non-MT. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2185 // * During a full GC, references are processed after marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2186 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2187 // * 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
|
2188 // of an incremental evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2189 // * References are processed near the end of a STW evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2190 // * For both types of GC: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2191 // * Discovery is atomic - i.e. not concurrent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2192 // * Reference discovery will not need a barrier. |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2193 |
| 342 | 2194 SharedHeap::ref_processing_init(); |
| 2195 MemRegion mr = reserved_region(); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2196 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2197 // Concurrent Mark ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2198 _ref_processor_cm = |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2361
diff
changeset
|
2199 new ReferenceProcessor(mr, // span |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2200 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2201 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2202 (int) ParallelGCThreads, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2203 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2204 (ParallelGCThreads > 1) || (ConcGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2205 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2206 (int) MAX2(ParallelGCThreads, ConcGCThreads), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2207 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2208 false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2209 // Reference discovery is not atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2210 &_is_alive_closure_cm, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2211 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2212 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2213 true); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2214 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2215 // lists requires a barrier. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2216 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2217 // STW ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2218 _ref_processor_stw = |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2219 new ReferenceProcessor(mr, // span |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2220 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2221 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2222 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2223 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2224 (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2225 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2226 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2227 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2228 true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2229 // Reference discovery is atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2230 &_is_alive_closure_stw, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2231 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2232 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2233 false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2234 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2235 // lists requires a barrier. |
| 342 | 2236 } |
| 2237 | |
| 2238 size_t G1CollectedHeap::capacity() const { | |
| 2239 return _g1_committed.byte_size(); | |
| 2240 } | |
| 2241 | |
| 1705 | 2242 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, |
| 2243 DirtyCardQueue* into_cset_dcq, | |
| 2244 bool concurrent, | |
| 342 | 2245 int worker_i) { |
| 889 | 2246 // Clean cards in the hot card cache |
| 1705 | 2247 concurrent_g1_refine()->clean_up_cache(worker_i, g1_rem_set(), into_cset_dcq); |
| 889 | 2248 |
| 342 | 2249 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
| 2250 int n_completed_buffers = 0; | |
| 1705 | 2251 while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) { |
| 342 | 2252 n_completed_buffers++; |
| 2253 } | |
| 2254 g1_policy()->record_update_rs_processed_buffers(worker_i, | |
| 2255 (double) n_completed_buffers); | |
| 2256 dcqs.clear_n_completed_buffers(); | |
| 2257 assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!"); | |
| 2258 } | |
| 2259 | |
| 2260 | |
| 2261 // Computes the sum of the storage used by the various regions. | |
| 2262 | |
| 2263 size_t G1CollectedHeap::used() const { | |
|
862
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2264 assert(Heap_lock->owner() != NULL, |
|
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2265 "Should be owned on this thread's behalf."); |
| 342 | 2266 size_t result = _summary_bytes_used; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2267 // 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
|
2268 HeapRegion* hr = _mutator_alloc_region.get(); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2269 if (hr != NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2270 result += hr->used(); |
| 342 | 2271 return result; |
| 2272 } | |
| 2273 | |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2274 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
|
2275 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
|
2276 return result; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2277 } |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2278 |
| 342 | 2279 class SumUsedClosure: public HeapRegionClosure { |
| 2280 size_t _used; | |
| 2281 public: | |
| 2282 SumUsedClosure() : _used(0) {} | |
| 2283 bool doHeapRegion(HeapRegion* r) { | |
| 2284 if (!r->continuesHumongous()) { | |
| 2285 _used += r->used(); | |
| 2286 } | |
| 2287 return false; | |
| 2288 } | |
| 2289 size_t result() { return _used; } | |
| 2290 }; | |
| 2291 | |
| 2292 size_t G1CollectedHeap::recalculate_used() const { | |
| 2293 SumUsedClosure blk; | |
| 3766 | 2294 heap_region_iterate(&blk); |
| 342 | 2295 return blk.result(); |
| 2296 } | |
| 2297 | |
| 2298 size_t G1CollectedHeap::unsafe_max_alloc() { | |
| 2152 | 2299 if (free_regions() > 0) return HeapRegion::GrainBytes; |
| 342 | 2300 // otherwise, is there space in the current allocation region? |
| 2301 | |
| 2302 // We need to store the current allocation region in a local variable | |
| 2303 // here. The problem is that this method doesn't take any locks and | |
| 2304 // there may be other threads which overwrite the current allocation | |
| 2305 // region field. attempt_allocation(), for example, sets it to NULL | |
| 2306 // and this can happen *after* the NULL check here but before the call | |
| 2307 // to free(), resulting in a SIGSEGV. Note that this doesn't appear | |
| 2308 // to be a problem in the optimized build, since the two loads of the | |
| 2309 // current allocation region field are optimized away. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2310 HeapRegion* hr = _mutator_alloc_region.get(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2311 if (hr == NULL) { |
| 342 | 2312 return 0; |
| 2313 } | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2314 return hr->free(); |
| 342 | 2315 } |
| 2316 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2317 bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2318 switch (cause) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2319 case GCCause::_gc_locker: return GCLockerInvokesConcurrent; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2320 case GCCause::_java_lang_system_gc: return ExplicitGCInvokesConcurrent; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2321 case GCCause::_g1_humongous_allocation: return true; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2322 default: return false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2323 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2324 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2325 |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2326 #ifndef PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2327 void G1CollectedHeap::allocate_dummy_regions() { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2328 // Let's fill up most of the region |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2329 size_t word_size = HeapRegion::GrainWords - 1024; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2330 // 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
|
2331 guarantee(isHumongous(word_size), "sanity"); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2332 |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2333 for (uintx i = 0; i < G1DummyRegionsPerGC; ++i) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2334 // 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
|
2335 HeapWord* dummy_obj = humongous_obj_allocate(word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2336 if (dummy_obj != NULL) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2337 MemRegion mr(dummy_obj, word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2338 CollectedHeap::fill_with_object(mr); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2339 } else { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2340 // 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
|
2341 // again. Let's get out of the loop. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2342 break; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2343 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2344 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2345 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2346 #endif // !PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2347 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2348 void G1CollectedHeap::increment_full_collections_completed(bool concurrent) { |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2349 MonitorLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2350 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2351 // 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
|
2352 // 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
|
2353 // 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
|
2354 // assert here. |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2355 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2356 // 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
|
2357 // 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
|
2358 // collections have been started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2359 unsigned int full_collections_started = total_full_collections(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2360 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2361 // 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
|
2362 // 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
|
2363 // interrupt a concurrent cycle), the number of full collections |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2364 // 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
|
2365 // 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
|
2366 // behind the number of full collections started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2367 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2368 // 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
|
2369 assert(concurrent || |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2370 (full_collections_started == _full_collections_completed + 1) || |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2371 (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
|
2372 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
|
2373 "is inconsistent with _full_collections_completed = %u", |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2374 full_collections_started, _full_collections_completed)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2375 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2376 // 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
|
2377 assert(!concurrent || |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2378 (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
|
2379 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
|
2380 "full_collections_started = %u " |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2381 "is inconsistent with _full_collections_completed = %u", |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2382 full_collections_started, _full_collections_completed)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2383 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2384 _full_collections_completed += 1; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2385 |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2386 // 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
|
2387 // we wake up any waiters (especially when ExplicitInvokesConcurrent |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2388 // 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
|
2389 // 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
|
2390 if (concurrent) { |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2391 _cmThread->clear_in_progress(); |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2392 } |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2393 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2394 // 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
|
2395 // System.gc() with (with ExplicitGCInvokesConcurrent set or not) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2396 // 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
|
2397 // waiting in VM_G1IncCollectionPause::doit_epilogue(). |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2398 FullGCCount_lock->notify_all(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2399 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2400 |
| 342 | 2401 void G1CollectedHeap::collect_as_vm_thread(GCCause::Cause cause) { |
| 2152 | 2402 assert_at_safepoint(true /* should_be_vm_thread */); |
| 342 | 2403 GCCauseSetter gcs(this, cause); |
| 2404 switch (cause) { | |
| 2405 case GCCause::_heap_inspection: | |
| 2406 case GCCause::_heap_dump: { | |
| 2407 HandleMark hm; | |
| 2408 do_full_collection(false); // don't clear all soft refs | |
| 2409 break; | |
| 2410 } | |
| 2411 default: // XXX FIX ME | |
| 2412 ShouldNotReachHere(); // Unexpected use of this function | |
| 2413 } | |
| 2414 } | |
| 2415 | |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2416 void G1CollectedHeap::collect(GCCause::Cause cause) { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2417 assert_heap_not_locked(); |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2418 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2419 unsigned int gc_count_before; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2420 unsigned int full_gc_count_before; |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2421 bool retry_gc; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2422 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2423 do { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2424 retry_gc = false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2425 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2426 { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2427 MutexLocker ml(Heap_lock); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2428 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2429 // Read the GC count while holding the Heap_lock |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2430 gc_count_before = total_collections(); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2431 full_gc_count_before = total_full_collections(); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2432 } |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2433 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2434 if (should_do_concurrent_full_gc(cause)) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2435 // Schedule an initial-mark evacuation pause that will start a |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2436 // concurrent cycle. We're setting word_size to 0 which means that |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2437 // we are not requesting a post-GC allocation. |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2438 VM_G1IncCollectionPause op(gc_count_before, |
| 1973 | 2439 0, /* word_size */ |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2440 true, /* should_initiate_conc_mark */ |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2441 g1_policy()->max_pause_time_ms(), |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2442 cause); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2443 |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2444 VMThread::execute(&op); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2445 if (!op.pause_succeeded()) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2446 if (full_gc_count_before == total_full_collections()) { |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2447 retry_gc = op.should_retry_gc(); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2448 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2449 // A Full GC happened while we were trying to schedule the |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2450 // initial-mark GC. No point in starting a new cycle given |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2451 // that the whole heap was collected anyway. |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2452 } |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2453 |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2454 if (retry_gc) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2455 if (GC_locker::is_active_and_needs_gc()) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2456 GC_locker::stall_until_clear(); |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2457 } |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2458 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2459 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2460 } else { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2461 if (cause == GCCause::_gc_locker |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2462 DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2463 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2464 // Schedule a standard evacuation pause. We're setting word_size |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2465 // to 0 which means that we are not requesting a post-GC allocation. |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2466 VM_G1IncCollectionPause op(gc_count_before, |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2467 0, /* word_size */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2468 false, /* should_initiate_conc_mark */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2469 g1_policy()->max_pause_time_ms(), |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2470 cause); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2471 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2472 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2473 // Schedule a Full GC. |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2474 VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2475 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2476 } |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2477 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2478 } while (retry_gc); |
| 342 | 2479 } |
| 2480 | |
| 2481 bool G1CollectedHeap::is_in(const void* p) const { | |
| 4708 | 2482 if (_g1_committed.contains(p)) { |
| 2483 // Given that we know that p is in the committed space, | |
| 2484 // heap_region_containing_raw() should successfully | |
| 2485 // return the containing region. | |
| 2486 HeapRegion* hr = heap_region_containing_raw(p); | |
| 342 | 2487 return hr->is_in(p); |
| 2488 } else { | |
| 2489 return _perm_gen->as_gen()->is_in(p); | |
| 2490 } | |
| 2491 } | |
| 2492 | |
| 2493 // Iteration functions. | |
| 2494 | |
| 2495 // Iterates an OopClosure over all ref-containing fields of objects | |
| 2496 // within a HeapRegion. | |
| 2497 | |
| 2498 class IterateOopClosureRegionClosure: public HeapRegionClosure { | |
| 2499 MemRegion _mr; | |
| 2500 OopClosure* _cl; | |
| 2501 public: | |
| 2502 IterateOopClosureRegionClosure(MemRegion mr, OopClosure* cl) | |
| 2503 : _mr(mr), _cl(cl) {} | |
| 2504 bool doHeapRegion(HeapRegion* r) { | |
| 2505 if (! r->continuesHumongous()) { | |
| 2506 r->oop_iterate(_cl); | |
| 2507 } | |
| 2508 return false; | |
| 2509 } | |
| 2510 }; | |
| 2511 | |
| 678 | 2512 void G1CollectedHeap::oop_iterate(OopClosure* cl, bool do_perm) { |
| 342 | 2513 IterateOopClosureRegionClosure blk(_g1_committed, cl); |
| 3766 | 2514 heap_region_iterate(&blk); |
| 678 | 2515 if (do_perm) { |
| 2516 perm_gen()->oop_iterate(cl); | |
| 2517 } | |
| 342 | 2518 } |
| 2519 | |
| 678 | 2520 void G1CollectedHeap::oop_iterate(MemRegion mr, OopClosure* cl, bool do_perm) { |
| 342 | 2521 IterateOopClosureRegionClosure blk(mr, cl); |
| 3766 | 2522 heap_region_iterate(&blk); |
| 678 | 2523 if (do_perm) { |
| 2524 perm_gen()->oop_iterate(cl); | |
| 2525 } | |
| 342 | 2526 } |
| 2527 | |
| 2528 // Iterates an ObjectClosure over all objects within a HeapRegion. | |
| 2529 | |
| 2530 class IterateObjectClosureRegionClosure: public HeapRegionClosure { | |
| 2531 ObjectClosure* _cl; | |
| 2532 public: | |
| 2533 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {} | |
| 2534 bool doHeapRegion(HeapRegion* r) { | |
| 2535 if (! r->continuesHumongous()) { | |
| 2536 r->object_iterate(_cl); | |
| 2537 } | |
| 2538 return false; | |
| 2539 } | |
| 2540 }; | |
| 2541 | |
| 678 | 2542 void G1CollectedHeap::object_iterate(ObjectClosure* cl, bool do_perm) { |
| 342 | 2543 IterateObjectClosureRegionClosure blk(cl); |
| 3766 | 2544 heap_region_iterate(&blk); |
| 678 | 2545 if (do_perm) { |
| 2546 perm_gen()->object_iterate(cl); | |
| 2547 } | |
| 342 | 2548 } |
| 2549 | |
| 2550 void G1CollectedHeap::object_iterate_since_last_GC(ObjectClosure* cl) { | |
| 2551 // FIXME: is this right? | |
| 2552 guarantee(false, "object_iterate_since_last_GC not supported by G1 heap"); | |
| 2553 } | |
| 2554 | |
| 2555 // Calls a SpaceClosure on a HeapRegion. | |
| 2556 | |
| 2557 class SpaceClosureRegionClosure: public HeapRegionClosure { | |
| 2558 SpaceClosure* _cl; | |
| 2559 public: | |
| 2560 SpaceClosureRegionClosure(SpaceClosure* cl) : _cl(cl) {} | |
| 2561 bool doHeapRegion(HeapRegion* r) { | |
| 2562 _cl->do_space(r); | |
| 2563 return false; | |
| 2564 } | |
| 2565 }; | |
| 2566 | |
| 2567 void G1CollectedHeap::space_iterate(SpaceClosure* cl) { | |
| 2568 SpaceClosureRegionClosure blk(cl); | |
| 3766 | 2569 heap_region_iterate(&blk); |
| 342 | 2570 } |
| 2571 | |
| 3766 | 2572 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const { |
| 2573 _hrs.iterate(cl); | |
| 342 | 2574 } |
| 2575 | |
| 2576 void G1CollectedHeap::heap_region_iterate_from(HeapRegion* r, | |
| 3766 | 2577 HeapRegionClosure* cl) const { |
| 2578 _hrs.iterate_from(r, cl); | |
| 342 | 2579 } |
| 2580 | |
| 2581 void | |
| 2582 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl, | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2583 uint worker, |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2584 uint no_of_par_workers, |
| 342 | 2585 jint claim_value) { |
| 355 | 2586 const size_t regions = n_regions(); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2587 const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2588 no_of_par_workers : |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2589 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2590 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2591 no_of_par_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2592 "Non dynamic should use fixed number of workers"); |
| 355 | 2593 // 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
|
2594 const size_t start_index = regions / max_workers * (size_t) worker; |
| 355 | 2595 |
| 2596 // each worker will actually look at all regions | |
| 2597 for (size_t count = 0; count < regions; ++count) { | |
| 2598 const size_t index = (start_index + count) % regions; | |
| 2599 assert(0 <= index && index < regions, "sanity"); | |
| 2600 HeapRegion* r = region_at(index); | |
| 2601 // we'll ignore "continues humongous" regions (we'll process them | |
| 2602 // when we come across their corresponding "start humongous" | |
| 2603 // region) and regions already claimed | |
| 2604 if (r->claim_value() == claim_value || r->continuesHumongous()) { | |
| 2605 continue; | |
| 2606 } | |
| 2607 // OK, try to claim it | |
| 342 | 2608 if (r->claimHeapRegion(claim_value)) { |
| 355 | 2609 // success! |
| 2610 assert(!r->continuesHumongous(), "sanity"); | |
| 2611 if (r->startsHumongous()) { | |
| 2612 // If the region is "starts humongous" we'll iterate over its | |
| 2613 // "continues humongous" first; in fact we'll do them | |
| 2614 // first. The order is important. In on case, calling the | |
| 2615 // closure on the "starts humongous" region might de-allocate | |
| 2616 // and clear all its "continues humongous" regions and, as a | |
| 2617 // result, we might end up processing them twice. So, we'll do | |
| 2618 // them first (notice: most closures will ignore them anyway) and | |
| 2619 // then we'll do the "starts humongous" region. | |
| 2620 for (size_t ch_index = index + 1; ch_index < regions; ++ch_index) { | |
| 2621 HeapRegion* chr = region_at(ch_index); | |
| 2622 | |
| 2623 // if the region has already been claimed or it's not | |
| 2624 // "continues humongous" we're done | |
| 2625 if (chr->claim_value() == claim_value || | |
| 2626 !chr->continuesHumongous()) { | |
| 2627 break; | |
| 2628 } | |
| 2629 | |
| 2630 // Noone should have claimed it directly. We can given | |
| 2631 // that we claimed its "starts humongous" region. | |
| 2632 assert(chr->claim_value() != claim_value, "sanity"); | |
| 2633 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2634 | |
| 2635 if (chr->claimHeapRegion(claim_value)) { | |
| 2636 // we should always be able to claim it; noone else should | |
| 2637 // be trying to claim this region | |
| 2638 | |
| 2639 bool res2 = cl->doHeapRegion(chr); | |
| 2640 assert(!res2, "Should not abort"); | |
| 2641 | |
| 2642 // Right now, this holds (i.e., no closure that actually | |
| 2643 // does something with "continues humongous" regions | |
| 2644 // clears them). We might have to weaken it in the future, | |
| 2645 // but let's leave these two asserts here for extra safety. | |
| 2646 assert(chr->continuesHumongous(), "should still be the case"); | |
| 2647 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2648 } else { | |
| 2649 guarantee(false, "we should not reach here"); | |
| 2650 } | |
| 2651 } | |
| 2652 } | |
| 2653 | |
| 2654 assert(!r->continuesHumongous(), "sanity"); | |
| 2655 bool res = cl->doHeapRegion(r); | |
| 2656 assert(!res, "Should not abort"); | |
| 2657 } | |
| 2658 } | |
| 2659 } | |
| 2660 | |
| 390 | 2661 class ResetClaimValuesClosure: public HeapRegionClosure { |
| 2662 public: | |
| 2663 bool doHeapRegion(HeapRegion* r) { | |
| 2664 r->set_claim_value(HeapRegion::InitialClaimValue); | |
| 2665 return false; | |
| 2666 } | |
| 2667 }; | |
| 2668 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2669 void G1CollectedHeap::reset_heap_region_claim_values() { |
| 390 | 2670 ResetClaimValuesClosure blk; |
| 2671 heap_region_iterate(&blk); | |
| 2672 } | |
| 2673 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2674 void G1CollectedHeap::reset_cset_heap_region_claim_values() { |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2675 ResetClaimValuesClosure blk; |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2676 collection_set_iterate(&blk); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2677 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2678 |
| 355 | 2679 #ifdef ASSERT |
| 2680 // This checks whether all regions in the heap have the correct claim | |
| 2681 // value. I also piggy-backed on this a check to ensure that the | |
| 2682 // humongous_start_region() information on "continues humongous" | |
| 2683 // regions is correct. | |
| 2684 | |
| 2685 class CheckClaimValuesClosure : public HeapRegionClosure { | |
| 2686 private: | |
| 2687 jint _claim_value; | |
| 2688 size_t _failures; | |
| 2689 HeapRegion* _sh_region; | |
| 2690 public: | |
| 2691 CheckClaimValuesClosure(jint claim_value) : | |
| 2692 _claim_value(claim_value), _failures(0), _sh_region(NULL) { } | |
| 2693 bool doHeapRegion(HeapRegion* r) { | |
| 2694 if (r->claim_value() != _claim_value) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2695 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2696 "claim value = %d, should be %d", |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2697 HR_FORMAT_PARAMS(r), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2698 r->claim_value(), _claim_value); |
| 355 | 2699 ++_failures; |
| 2700 } | |
| 2701 if (!r->isHumongous()) { | |
| 2702 _sh_region = NULL; | |
| 2703 } else if (r->startsHumongous()) { | |
| 2704 _sh_region = r; | |
| 2705 } else if (r->continuesHumongous()) { | |
| 2706 if (r->humongous_start_region() != _sh_region) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2707 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2708 "HS = "PTR_FORMAT", should be "PTR_FORMAT, |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2709 HR_FORMAT_PARAMS(r), |
| 355 | 2710 r->humongous_start_region(), |
| 2711 _sh_region); | |
| 2712 ++_failures; | |
| 342 | 2713 } |
| 2714 } | |
| 355 | 2715 return false; |
| 2716 } | |
| 2717 size_t failures() { | |
| 2718 return _failures; | |
| 2719 } | |
| 2720 }; | |
| 2721 | |
| 2722 bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) { | |
| 2723 CheckClaimValuesClosure cl(claim_value); | |
| 2724 heap_region_iterate(&cl); | |
| 2725 return cl.failures() == 0; | |
| 2726 } | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2727 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2728 class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2729 jint _claim_value; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2730 size_t _failures; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2731 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2732 public: |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2733 CheckClaimValuesInCSetHRClosure(jint claim_value) : |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2734 _claim_value(claim_value), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2735 _failures(0) { } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2736 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2737 size_t failures() { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2738 return _failures; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2739 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2740 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2741 bool doHeapRegion(HeapRegion* hr) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2742 assert(hr->in_collection_set(), "how?"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2743 assert(!hr->isHumongous(), "H-region in CSet"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2744 if (hr->claim_value() != _claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2745 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
|
2746 "claim value = %d, should be %d", |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2747 HR_FORMAT_PARAMS(hr), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2748 hr->claim_value(), _claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2749 _failures += 1; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2750 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2751 return false; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2752 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2753 }; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2754 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2755 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
|
2756 CheckClaimValuesInCSetHRClosure cl(claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2757 collection_set_iterate(&cl); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2758 return cl.failures() == 0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2759 } |
| 355 | 2760 #endif // ASSERT |
| 342 | 2761 |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2762 // 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
|
2763 // 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
|
2764 void G1CollectedHeap::clear_cset_start_regions() { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2765 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
|
2766 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
|
2767 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2768 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
|
2769 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
|
2770 _worker_cset_start_region[i] = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2771 _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
|
2772 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2773 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2774 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2775 // 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
|
2776 // 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
|
2777 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
|
2778 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
|
2779 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2780 HeapRegion* result = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2781 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
|
2782 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2783 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
|
2784 // 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
|
2785 // 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
|
2786 // 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
|
2787 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2788 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
|
2789 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
|
2790 return result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2791 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2792 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2793 // 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
|
2794 // 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
|
2795 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2796 // 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
|
2797 // 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
|
2798 // avoid contention. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2799 // If we have: |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2800 // n collection set regions |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2801 // p threads |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2802 // 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
|
2803 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2804 result = g1_policy()->collection_set(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2805 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2806 size_t cs_size = g1_policy()->cset_region_length(); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2807 uint active_workers = workers()->active_workers(); |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2808 assert(UseDynamicNumberOfGCThreads || |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2809 active_workers == workers()->total_workers(), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2810 "Unless dynamic should use total workers"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2811 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2812 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
|
2813 size_t start_ind = 0; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2814 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2815 if (worker_i > 0 && |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2816 _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
|
2817 // Previous workers starting region is valid |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2818 // so let's iterate from there |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2819 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
|
2820 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
|
2821 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2822 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2823 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
|
2824 result = result->next_in_collection_set(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2825 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2826 } |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2827 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2828 // 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
|
2829 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2830 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
|
2831 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
|
2832 "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
|
2833 _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
|
2834 OrderAccess::storestore(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2835 _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
|
2836 return result; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2837 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2838 |
| 342 | 2839 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) { |
| 2840 HeapRegion* r = g1_policy()->collection_set(); | |
| 2841 while (r != NULL) { | |
| 2842 HeapRegion* next = r->next_in_collection_set(); | |
| 2843 if (cl->doHeapRegion(r)) { | |
| 2844 cl->incomplete(); | |
| 2845 return; | |
| 2846 } | |
| 2847 r = next; | |
| 2848 } | |
| 2849 } | |
| 2850 | |
| 2851 void G1CollectedHeap::collection_set_iterate_from(HeapRegion* r, | |
| 2852 HeapRegionClosure *cl) { | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2853 if (r == NULL) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2854 // 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
|
2855 return; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2856 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2857 |
| 342 | 2858 assert(r->in_collection_set(), |
| 2859 "Start region must be a member of the collection set."); | |
| 2860 HeapRegion* cur = r; | |
| 2861 while (cur != NULL) { | |
| 2862 HeapRegion* next = cur->next_in_collection_set(); | |
| 2863 if (cl->doHeapRegion(cur) && false) { | |
| 2864 cl->incomplete(); | |
| 2865 return; | |
| 2866 } | |
| 2867 cur = next; | |
| 2868 } | |
| 2869 cur = g1_policy()->collection_set(); | |
| 2870 while (cur != r) { | |
| 2871 HeapRegion* next = cur->next_in_collection_set(); | |
| 2872 if (cl->doHeapRegion(cur) && false) { | |
| 2873 cl->incomplete(); | |
| 2874 return; | |
| 2875 } | |
| 2876 cur = next; | |
| 2877 } | |
| 2878 } | |
| 2879 | |
| 2880 CompactibleSpace* G1CollectedHeap::first_compactible_space() { | |
| 3766 | 2881 return n_regions() > 0 ? region_at(0) : NULL; |
| 342 | 2882 } |
| 2883 | |
| 2884 | |
| 2885 Space* G1CollectedHeap::space_containing(const void* addr) const { | |
| 2886 Space* res = heap_region_containing(addr); | |
| 2887 if (res == NULL) | |
| 2888 res = perm_gen()->space_containing(addr); | |
| 2889 return res; | |
| 2890 } | |
| 2891 | |
| 2892 HeapWord* G1CollectedHeap::block_start(const void* addr) const { | |
| 2893 Space* sp = space_containing(addr); | |
| 2894 if (sp != NULL) { | |
| 2895 return sp->block_start(addr); | |
| 2896 } | |
| 2897 return NULL; | |
| 2898 } | |
| 2899 | |
| 2900 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { | |
| 2901 Space* sp = space_containing(addr); | |
| 2902 assert(sp != NULL, "block_size of address outside of heap"); | |
| 2903 return sp->block_size(addr); | |
| 2904 } | |
| 2905 | |
| 2906 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { | |
| 2907 Space* sp = space_containing(addr); | |
| 2908 return sp->block_is_obj(addr); | |
| 2909 } | |
| 2910 | |
| 2911 bool G1CollectedHeap::supports_tlab_allocation() const { | |
| 2912 return true; | |
| 2913 } | |
| 2914 | |
| 2915 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const { | |
| 2916 return HeapRegion::GrainBytes; | |
| 2917 } | |
| 2918 | |
| 2919 size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const { | |
| 2920 // Return the remaining space in the cur alloc region, but not less than | |
| 2921 // the min TLAB size. | |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2922 |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2923 // 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
|
2924 // 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
|
2925 // humongous objects. |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2926 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2927 HeapRegion* hr = _mutator_alloc_region.get(); |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2928 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
|
2929 if (hr == NULL) { |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
2930 return max_tlab_size; |
| 342 | 2931 } else { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2932 return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab_size); |
| 342 | 2933 } |
| 2934 } | |
| 2935 | |
| 2936 size_t G1CollectedHeap::max_capacity() const { | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2937 return _g1_reserved.byte_size(); |
| 342 | 2938 } |
| 2939 | |
| 2940 jlong G1CollectedHeap::millis_since_last_gc() { | |
| 2941 // assert(false, "NYI"); | |
| 2942 return 0; | |
| 2943 } | |
| 2944 | |
| 2945 void G1CollectedHeap::prepare_for_verify() { | |
| 2946 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { | |
| 2947 ensure_parsability(false); | |
| 2948 } | |
| 2949 g1_rem_set()->prepare_for_verify(); | |
| 2950 } | |
| 2951 | |
| 2952 class VerifyLivenessOopClosure: public OopClosure { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2953 G1CollectedHeap* _g1h; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2954 VerifyOption _vo; |
| 342 | 2955 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2956 VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo): |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2957 _g1h(g1h), _vo(vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2958 { } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2959 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
|
2960 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
|
2961 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2962 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
|
2963 oop obj = oopDesc::load_decode_heap_oop(p); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2964 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
|
2965 "Dead object referenced by a not dead object"); |
| 342 | 2966 } |
| 2967 }; | |
| 2968 | |
| 2969 class VerifyObjsInRegionClosure: public ObjectClosure { | |
| 811 | 2970 private: |
| 342 | 2971 G1CollectedHeap* _g1h; |
| 2972 size_t _live_bytes; | |
| 2973 HeapRegion *_hr; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2974 VerifyOption _vo; |
| 342 | 2975 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2976 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2977 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2978 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2979 VerifyObjsInRegionClosure(HeapRegion *hr, VerifyOption vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2980 : _live_bytes(0), _hr(hr), _vo(vo) { |
| 342 | 2981 _g1h = G1CollectedHeap::heap(); |
| 2982 } | |
| 2983 void do_object(oop o) { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2984 VerifyLivenessOopClosure isLive(_g1h, _vo); |
| 342 | 2985 assert(o != NULL, "Huh?"); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2986 if (!_g1h->is_obj_dead_cond(o, _vo)) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2987 // If the object is alive according to the mark word, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2988 // then verify that the marking information agrees. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2989 // Note we can't verify the contra-positive of the |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2990 // above: if the object is dead (according to the mark |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2991 // 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
|
2992 // but has since became dead, or may have been allocated |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2993 // since the last marking. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2994 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2995 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
|
2996 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
2997 |
| 342 | 2998 o->oop_iterate(&isLive); |
|
1389
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
2999 if (!_hr->obj_allocated_since_prev_marking(o)) { |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3000 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
|
3001 _live_bytes += (obj_size * HeapWordSize); |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3002 } |
| 342 | 3003 } |
| 3004 } | |
| 3005 size_t live_bytes() { return _live_bytes; } | |
| 3006 }; | |
| 3007 | |
| 3008 class PrintObjsInRegionClosure : public ObjectClosure { | |
| 3009 HeapRegion *_hr; | |
| 3010 G1CollectedHeap *_g1; | |
| 3011 public: | |
| 3012 PrintObjsInRegionClosure(HeapRegion *hr) : _hr(hr) { | |
| 3013 _g1 = G1CollectedHeap::heap(); | |
| 3014 }; | |
| 3015 | |
| 3016 void do_object(oop o) { | |
| 3017 if (o != NULL) { | |
| 3018 HeapWord *start = (HeapWord *) o; | |
| 3019 size_t word_sz = o->size(); | |
| 3020 gclog_or_tty->print("\nPrinting obj "PTR_FORMAT" of size " SIZE_FORMAT | |
| 3021 " isMarkedPrev %d isMarkedNext %d isAllocSince %d\n", | |
| 3022 (void*) o, word_sz, | |
| 3023 _g1->isMarkedPrev(o), | |
| 3024 _g1->isMarkedNext(o), | |
| 3025 _hr->obj_allocated_since_prev_marking(o)); | |
| 3026 HeapWord *end = start + word_sz; | |
| 3027 HeapWord *cur; | |
| 3028 int *val; | |
| 3029 for (cur = start; cur < end; cur++) { | |
| 3030 val = (int *) cur; | |
| 3031 gclog_or_tty->print("\t "PTR_FORMAT":"PTR_FORMAT"\n", val, *val); | |
| 3032 } | |
| 3033 } | |
| 3034 } | |
| 3035 }; | |
| 3036 | |
| 3037 class VerifyRegionClosure: public HeapRegionClosure { | |
| 811 | 3038 private: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3039 bool _allow_dirty; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3040 bool _par; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3041 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3042 bool _failures; |
| 811 | 3043 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3044 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3045 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3046 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3047 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
|
3048 : _allow_dirty(allow_dirty), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3049 _par(par), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3050 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3051 _failures(false) {} |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3052 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3053 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3054 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3055 } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3056 |
| 342 | 3057 bool doHeapRegion(HeapRegion* r) { |
| 390 | 3058 guarantee(_par || r->claim_value() == HeapRegion::InitialClaimValue, |
| 3059 "Should be unclaimed at verify points."); | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3060 if (!r->continuesHumongous()) { |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3061 bool failures = false; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3062 r->verify(_allow_dirty, _vo, &failures); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3063 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3064 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3065 } else { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3066 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3067 r->object_iterate(¬_dead_yet_cl); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3068 if (_vo != VerifyOption_G1UseNextMarking) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3069 if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3070 gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] " |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3071 "max_live_bytes "SIZE_FORMAT" " |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3072 "< calculated "SIZE_FORMAT, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3073 r->bottom(), r->end(), |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3074 r->max_live_bytes(), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3075 not_dead_yet_cl.live_bytes()); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3076 _failures = true; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3077 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3078 } else { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3079 // When vo == UseNextMarking we cannot currently do a sanity |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3080 // check on the live bytes as the calculation has not been |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3081 // finalized yet. |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3082 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3083 } |
| 342 | 3084 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3085 return false; // stop the region iteration if we hit a failure |
| 342 | 3086 } |
| 3087 }; | |
| 3088 | |
| 3089 class VerifyRootsClosure: public OopsInGenClosure { | |
| 3090 private: | |
| 3091 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3092 VerifyOption _vo; |
| 342 | 3093 bool _failures; |
| 3094 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3095 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3096 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3097 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3098 VerifyRootsClosure(VerifyOption vo) : |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3099 _g1h(G1CollectedHeap::heap()), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3100 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3101 _failures(false) { } |
| 342 | 3102 |
| 3103 bool failures() { return _failures; } | |
| 3104 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3105 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
|
3106 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3107 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3108 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
|
3109 if (_g1h->is_obj_dead_cond(obj, _vo)) { |
| 342 | 3110 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
|
3111 "points to dead obj "PTR_FORMAT, p, (void*) obj); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3112 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3113 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
|
3114 } |
| 342 | 3115 obj->print_on(gclog_or_tty); |
| 3116 _failures = true; | |
| 3117 } | |
| 3118 } | |
| 3119 } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3120 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3121 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
|
3122 void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 3123 }; |
| 3124 | |
| 390 | 3125 // This is the task used for parallel heap verification. |
| 3126 | |
| 3127 class G1ParVerifyTask: public AbstractGangTask { | |
| 3128 private: | |
| 3129 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3130 bool _allow_dirty; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3131 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3132 bool _failures; |
| 390 | 3133 |
| 3134 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3135 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3136 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3137 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3138 G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty, VerifyOption vo) : |
| 390 | 3139 AbstractGangTask("Parallel verify task"), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3140 _g1h(g1h), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3141 _allow_dirty(allow_dirty), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3142 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3143 _failures(false) { } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3144 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3145 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3146 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3147 } |
| 390 | 3148 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3149 void work(uint worker_id) { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3150 HandleMark hm; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3151 VerifyRegionClosure blk(_allow_dirty, true, _vo); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3152 _g1h->heap_region_par_iterate_chunked(&blk, worker_id, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3153 _g1h->workers()->active_workers(), |
| 390 | 3154 HeapRegion::ParVerifyClaimValue); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3155 if (blk.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 } |
| 3159 }; | |
| 3160 | |
| 342 | 3161 void G1CollectedHeap::verify(bool allow_dirty, bool silent) { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3162 verify(allow_dirty, silent, VerifyOption_G1UsePrevMarking); |
| 811 | 3163 } |
| 3164 | |
| 3165 void G1CollectedHeap::verify(bool allow_dirty, | |
| 3166 bool silent, | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3167 VerifyOption vo) { |
| 342 | 3168 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3169 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); } |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3170 VerifyRootsClosure rootsCl(vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3171 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3172 assert(Thread::current()->is_VM_thread(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3173 "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
|
3174 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3175 CodeBlobToOopClosure blobsCl(&rootsCl, /*do_marking=*/ false); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3176 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3177 // 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
|
3178 // system dictionary, the string table and the code cache. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
3179 const int so = SO_AllClasses | SO_Strings | SO_CodeCache; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3180 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3181 process_strong_roots(true, // activate StrongRootsScope |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3182 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
|
3183 // so we don't reset the dirty cards in the perm gen. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
3184 ScanningOption(so), // roots scanning options |
| 342 | 3185 &rootsCl, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3186 &blobsCl, |
| 342 | 3187 &rootsCl); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3188 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3189 // 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
|
3190 // 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
|
3191 // 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
|
3192 // 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
|
3193 // "Root location <x> points to dead ob <y>" failure. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3194 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3195 // 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
|
3196 // 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
|
3197 // references explicitly below. Whether the relevant cards are dirty |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3198 // is checked further below in the rem set verification. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3199 if (!silent) { gclog_or_tty->print("Permgen roots "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3200 perm_gen()->oop_iterate(&rootsCl); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3201 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3202 bool failures = rootsCl.failures(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3203 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3204 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3205 // 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
|
3206 // 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
|
3207 // verifying the region sets will fail. So we only verify |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3208 // the region sets when not in a full GC. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3209 if (!silent) { gclog_or_tty->print("HeapRegionSets "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3210 verify_region_sets(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3211 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3212 |
| 2152 | 3213 if (!silent) { gclog_or_tty->print("HeapRegions "); } |
| 390 | 3214 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { |
| 3215 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3216 "sanity check"); | |
| 3217 | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3218 G1ParVerifyTask task(this, allow_dirty, vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3219 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3220 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3221 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3222 int n_workers = workers()->active_workers(); |
| 390 | 3223 set_par_threads(n_workers); |
| 3224 workers()->run_task(&task); | |
| 3225 set_par_threads(0); | |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3226 if (task.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3227 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3228 } |
| 390 | 3229 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3230 // 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
|
3231 // The implication is that n_workers is > 0. |
| 390 | 3232 assert(check_heap_region_claim_values(HeapRegion::ParVerifyClaimValue), |
| 3233 "sanity check"); | |
| 3234 | |
| 3235 reset_heap_region_claim_values(); | |
| 3236 | |
| 3237 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3238 "sanity check"); | |
| 3239 } else { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3240 VerifyRegionClosure blk(allow_dirty, false, vo); |
| 3766 | 3241 heap_region_iterate(&blk); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3242 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3243 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3244 } |
| 390 | 3245 } |
| 2152 | 3246 if (!silent) gclog_or_tty->print("RemSet "); |
| 342 | 3247 rem_set()->verify(); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3248 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3249 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3250 gclog_or_tty->print_cr("Heap:"); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3251 // 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
|
3252 // 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
|
3253 // print_extended_on() instead of print_on(). |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3254 print_extended_on(gclog_or_tty); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3255 gclog_or_tty->print_cr(""); |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3256 #ifndef PRODUCT |
| 1044 | 3257 if (VerifyDuringGC && G1VerifyDuringGCPrintReachable) { |
| 1388 | 3258 concurrent_mark()->print_reachable("at-verification-failure", |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3259 vo, false /* all */); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3260 } |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3261 #endif |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3262 gclog_or_tty->flush(); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3263 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3264 guarantee(!failures, "there should not have been any failures"); |
| 342 | 3265 } else { |
| 3266 if (!silent) gclog_or_tty->print("(SKIPPING roots, heapRegions, remset) "); | |
| 3267 } | |
| 3268 } | |
| 3269 | |
| 3270 class PrintRegionClosure: public HeapRegionClosure { | |
| 3271 outputStream* _st; | |
| 3272 public: | |
| 3273 PrintRegionClosure(outputStream* st) : _st(st) {} | |
| 3274 bool doHeapRegion(HeapRegion* r) { | |
| 3275 r->print_on(_st); | |
| 3276 return false; | |
| 3277 } | |
| 3278 }; | |
| 3279 | |
| 3280 void G1CollectedHeap::print_on(outputStream* st) const { | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3281 st->print(" %-20s", "garbage-first heap"); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3282 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
|
3283 capacity()/K, used_unlocked()/K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3284 st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3285 _g1_storage.low_boundary(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3286 _g1_storage.high(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3287 _g1_storage.high_boundary()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3288 st->cr(); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
3289 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
|
3290 size_t young_regions = _young_list->length(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3291 st->print(SIZE_FORMAT " young (" SIZE_FORMAT "K), ", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3292 young_regions, young_regions * HeapRegion::GrainBytes / K); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3293 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
|
3294 st->print(SIZE_FORMAT " survivors (" SIZE_FORMAT "K)", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3295 survivor_regions, survivor_regions * HeapRegion::GrainBytes / K); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3296 st->cr(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3297 perm()->as_gen()->print_on(st); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3298 } |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3299 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3300 void G1CollectedHeap::print_extended_on(outputStream* st) const { |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3301 print_on(st); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3302 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3303 // Print the per-region information. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3304 st->cr(); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3305 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 | 3306 PrintRegionClosure blk(st); |
| 3766 | 3307 heap_region_iterate(&blk); |
| 342 | 3308 } |
| 3309 | |
| 3310 void G1CollectedHeap::print_gc_threads_on(outputStream* st) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3311 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 1019 | 3312 workers()->print_worker_threads_on(st); |
| 3313 } | |
| 3314 _cmThread->print_on(st); | |
| 342 | 3315 st->cr(); |
| 1019 | 3316 _cm->print_worker_threads_on(st); |
| 3317 _cg1r->print_worker_threads_on(st); | |
| 342 | 3318 st->cr(); |
| 3319 } | |
| 3320 | |
| 3321 void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3322 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 3323 workers()->threads_do(tc); |
| 3324 } | |
| 3325 tc->do_thread(_cmThread); | |
| 794 | 3326 _cg1r->threads_do(tc); |
| 342 | 3327 } |
| 3328 | |
| 3329 void G1CollectedHeap::print_tracing_info() const { | |
| 3330 // We'll overload this to mean "trace GC pause statistics." | |
| 3331 if (TraceGen0Time || TraceGen1Time) { | |
| 3332 // The "G1CollectorPolicy" is keeping track of these stats, so delegate | |
| 3333 // to that. | |
| 3334 g1_policy()->print_tracing_info(); | |
| 3335 } | |
| 751 | 3336 if (G1SummarizeRSetStats) { |
| 342 | 3337 g1_rem_set()->print_summary_info(); |
| 3338 } | |
| 1282 | 3339 if (G1SummarizeConcMark) { |
| 342 | 3340 concurrent_mark()->print_summary_info(); |
| 3341 } | |
| 3342 g1_policy()->print_yg_surv_rate_info(); | |
| 3343 SpecializationStats::print(); | |
| 3344 } | |
| 3345 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3346 #ifndef PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3347 // Helpful for debugging RSet issues. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3348 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3349 class PrintRSetsClosure : public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3350 private: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3351 const char* _msg; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3352 size_t _occupied_sum; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3353 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3354 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3355 bool doHeapRegion(HeapRegion* r) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3356 HeapRegionRemSet* hrrs = r->rem_set(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3357 size_t occupied = hrrs->occupied(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3358 _occupied_sum += occupied; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3359 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3360 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
|
3361 HR_FORMAT_PARAMS(r)); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3362 if (occupied == 0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3363 gclog_or_tty->print_cr(" RSet is empty"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3364 } else { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3365 hrrs->print(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3366 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3367 gclog_or_tty->print_cr("----------"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3368 return false; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3369 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3370 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3371 PrintRSetsClosure(const char* msg) : _msg(msg), _occupied_sum(0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3372 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3373 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3374 gclog_or_tty->print_cr(msg); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3375 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3376 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3377 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3378 ~PrintRSetsClosure() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3379 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
|
3380 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3381 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3382 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3383 }; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3384 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3385 void G1CollectedHeap::print_cset_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3386 PrintRSetsClosure cl("Printing CSet RSets"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3387 collection_set_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3388 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3389 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3390 void G1CollectedHeap::print_all_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3391 PrintRSetsClosure cl("Printing All RSets");; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3392 heap_region_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3393 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3394 #endif // PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3395 |
| 342 | 3396 G1CollectedHeap* G1CollectedHeap::heap() { |
| 3397 assert(_sh->kind() == CollectedHeap::G1CollectedHeap, | |
| 3398 "not a garbage-first heap"); | |
| 3399 return _g1h; | |
| 3400 } | |
| 3401 | |
| 3402 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) { | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3403 // always_do_update_barrier = false; |
| 342 | 3404 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); |
| 3405 // Call allocation profiler | |
| 3406 AllocationProfiler::iterate_since_last_gc(); | |
| 3407 // Fill TLAB's and such | |
| 3408 ensure_parsability(true); | |
| 3409 } | |
| 3410 | |
| 3411 void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) { | |
| 3412 // FIXME: what is this about? | |
| 3413 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled" | |
| 3414 // is set. | |
| 3415 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), | |
| 3416 "derived pointer present")); | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3417 // always_do_update_barrier = true; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3418 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3419 // We have just completed a GC. Update the soft reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3420 // policy with the new heap occupancy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3421 Universe::update_heap_info_at_gc(); |
| 342 | 3422 } |
| 3423 | |
| 1973 | 3424 HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size, |
| 3425 unsigned int gc_count_before, | |
| 3426 bool* succeeded) { | |
| 3427 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 3428 g1_policy()->record_stop_world_start(); |
| 1973 | 3429 VM_G1IncCollectionPause op(gc_count_before, |
| 3430 word_size, | |
| 3431 false, /* should_initiate_conc_mark */ | |
| 3432 g1_policy()->max_pause_time_ms(), | |
| 3433 GCCause::_g1_inc_collection_pause); | |
| 3434 VMThread::execute(&op); | |
| 3435 | |
| 3436 HeapWord* result = op.result(); | |
| 3437 bool ret_succeeded = op.prologue_succeeded() && op.pause_succeeded(); | |
| 3438 assert(result == NULL || ret_succeeded, | |
| 3439 "the result should be NULL if the VM did not succeed"); | |
| 3440 *succeeded = ret_succeeded; | |
| 3441 | |
| 3442 assert_heap_not_locked(); | |
| 3443 return result; | |
| 342 | 3444 } |
| 3445 | |
| 3446 void | |
| 3447 G1CollectedHeap::doConcurrentMark() { | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3448 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
|
3449 if (!_cmThread->in_progress()) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3450 _cmThread->set_started(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3451 CGC_lock->notify(); |
| 342 | 3452 } |
| 3453 } | |
| 3454 | |
| 3455 size_t G1CollectedHeap::pending_card_num() { | |
| 3456 size_t extra_cards = 0; | |
| 3457 JavaThread *curr = Threads::first(); | |
| 3458 while (curr != NULL) { | |
| 3459 DirtyCardQueue& dcq = curr->dirty_card_queue(); | |
| 3460 extra_cards += dcq.size(); | |
| 3461 curr = curr->next(); | |
| 3462 } | |
| 3463 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3464 size_t buffer_size = dcqs.buffer_size(); | |
| 3465 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 3466 return buffer_size * buffer_num + extra_cards; | |
| 3467 } | |
| 3468 | |
| 3469 size_t G1CollectedHeap::max_pending_card_num() { | |
| 3470 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3471 size_t buffer_size = dcqs.buffer_size(); | |
| 3472 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 3473 int thread_num = Threads::number_of_threads(); | |
| 3474 return (buffer_num + thread_num) * buffer_size; | |
| 3475 } | |
| 3476 | |
| 3477 size_t G1CollectedHeap::cards_scanned() { | |
| 1861 | 3478 return g1_rem_set()->cardsScanned(); |
| 342 | 3479 } |
| 3480 | |
| 3481 void | |
| 3482 G1CollectedHeap::setup_surviving_young_words() { | |
| 3483 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
|
3484 size_t array_length = g1_policy()->young_cset_region_length(); |
| 342 | 3485 _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, array_length); |
| 3486 if (_surviving_young_words == NULL) { | |
| 3487 vm_exit_out_of_memory(sizeof(size_t) * array_length, | |
| 3488 "Not enough space for young surv words summary."); | |
| 3489 } | |
| 3490 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
|
3491 #ifdef ASSERT |
| 342 | 3492 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
|
3493 assert( _surviving_young_words[i] == 0, "memset above" ); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3494 } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3495 #endif // !ASSERT |
| 342 | 3496 } |
| 3497 | |
| 3498 void | |
| 3499 G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { | |
| 3500 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
|
3501 size_t array_length = g1_policy()->young_cset_region_length(); |
| 342 | 3502 for (size_t i = 0; i < array_length; ++i) |
| 3503 _surviving_young_words[i] += surv_young_words[i]; | |
| 3504 } | |
| 3505 | |
| 3506 void | |
| 3507 G1CollectedHeap::cleanup_surviving_young_words() { | |
| 3508 guarantee( _surviving_young_words != NULL, "pre-condition" ); | |
| 3509 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words); | |
| 3510 _surviving_young_words = NULL; | |
| 3511 } | |
| 3512 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3513 #ifdef ASSERT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3514 class VerifyCSetClosure: public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3515 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3516 bool doHeapRegion(HeapRegion* hr) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3517 // 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
|
3518 // 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
|
3519 // 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
|
3520 // 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
|
3521 // 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
|
3522 // 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
|
3523 // 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
|
3524 // 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
|
3525 // evacuation failure handling. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3526 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
|
3527 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3528 // 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
|
3529 // perform on CSet regions. |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3530 return false; |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3531 } |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3532 }; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3533 #endif // ASSERT |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3534 |
| 1709 | 3535 #if TASKQUEUE_STATS |
| 3536 void G1CollectedHeap::print_taskqueue_stats_hdr(outputStream* const st) { | |
| 3537 st->print_raw_cr("GC Task Stats"); | |
| 3538 st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr(); | |
| 3539 st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); | |
| 3540 } | |
| 3541 | |
| 3542 void G1CollectedHeap::print_taskqueue_stats(outputStream* const st) const { | |
| 3543 print_taskqueue_stats_hdr(st); | |
| 3544 | |
| 3545 TaskQueueStats totals; | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3546 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3547 for (int i = 0; i < n; ++i) { |
| 3548 st->print("%3d ", i); task_queue(i)->stats.print(st); st->cr(); | |
| 3549 totals += task_queue(i)->stats; | |
| 3550 } | |
| 3551 st->print_raw("tot "); totals.print(st); st->cr(); | |
| 3552 | |
| 3553 DEBUG_ONLY(totals.verify()); | |
| 3554 } | |
| 3555 | |
| 3556 void G1CollectedHeap::reset_taskqueue_stats() { | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3557 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3558 for (int i = 0; i < n; ++i) { |
| 3559 task_queue(i)->stats.reset(); | |
| 3560 } | |
| 3561 } | |
| 3562 #endif // TASKQUEUE_STATS | |
| 3563 | |
| 1973 | 3564 bool |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3565 G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { |
| 2152 | 3566 assert_at_safepoint(true /* should_be_vm_thread */); |
| 3567 guarantee(!is_gc_active(), "collection is not reentrant"); | |
| 3568 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3569 if (GC_locker::check_active_before_gc()) { |
| 1973 | 3570 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3571 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3572 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
3573 SvcGCMarker sgcm(SvcGCMarker::MINOR); |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3574 ResourceMark rm; |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3575 |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
3576 print_heap_before_gc(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3577 |
| 4072 | 3578 HRSPhaseSetter x(HRSPhaseEvacuation); |
| 2152 | 3579 verify_region_sets_optional(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3580 verify_dirty_young_regions(); |
| 2152 | 3581 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3582 // This call will decide whether this pause is an initial-mark |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3583 // pause. If it is, during_initial_mark_pause() will return true |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3584 // for the duration of this pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3585 g1_policy()->decide_on_conc_mark_initiation(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3586 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3587 // We do not allow initial-mark to be piggy-backed on a mixed GC. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3588 assert(!g1_policy()->during_initial_mark_pause() || |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3589 g1_policy()->gcs_are_young(), "sanity"); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3590 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3591 // We also do not allow mixed GCs during marking. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3592 assert(!mark_in_progress() || g1_policy()->gcs_are_young(), "sanity"); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3593 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3594 // Record whether this pause is an initial mark. When the current |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3595 // thread has completed its logging output and it's safe to signal |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3596 // the CM thread, the flag's value in the policy has been reset. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3597 bool should_start_conc_mark = g1_policy()->during_initial_mark_pause(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3598 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3599 // Inner scope for scope based logging, timers, and stats collection |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3600 { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3601 char verbose_str[128]; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3602 sprintf(verbose_str, "GC pause "); |
| 4710 | 3603 if (g1_policy()->gcs_are_young()) { |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3604 strcat(verbose_str, "(young)"); |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3605 } else { |
| 4710 | 3606 strcat(verbose_str, "(mixed)"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3607 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3608 if (g1_policy()->during_initial_mark_pause()) { |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3609 strcat(verbose_str, " (initial-mark)"); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3610 // 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
|
3611 // full collection counter. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3612 increment_total_full_collections(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3613 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3614 |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3615 // if the log level is "finer" is on, we'll print long statistics information |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3616 // 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
|
3617 // is messy if we do. |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3618 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3619 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3620 TraceTime t(verbose_str, G1Log::fine() && !G1Log::finer(), true, gclog_or_tty); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3621 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3622 TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
3623 TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
3624 |
| 2361 | 3625 // If the secondary_free_list is not empty, append it to the |
| 3626 // free_list. No need to wait for the cleanup operation to finish; | |
| 3627 // the region allocation code will check the secondary_free_list | |
| 3628 // and wait if necessary. If the G1StressConcRegionFreeing flag is | |
| 3629 // set, skip this step so that the region allocation code has to | |
| 3630 // get entries from the secondary_free_list. | |
| 2152 | 3631 if (!G1StressConcRegionFreeing) { |
| 2361 | 3632 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 3633 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3634 |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3635 assert(check_young_list_well_formed(), |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3636 "young list should be well formed"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3637 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3638 // 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
|
3639 // 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
|
3640 // it will be set. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3641 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3642 { // 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
|
3643 IsGCActiveMark x; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3644 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3645 gc_prologue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3646 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
|
3647 increment_gc_time_stamp(); |
| 342 | 3648 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3649 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3650 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
|
3651 gclog_or_tty->print(" VerifyBeforeGC:"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3652 prepare_for_verify(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3653 Universe::verify(/* allow dirty */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3654 /* silent */ false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3655 /* option */ VerifyOption_G1UsePrevMarking); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3656 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3657 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3658 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3659 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3660 // Please see comment in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3661 // G1CollectedHeap::ref_processing_init() to see how |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3662 // reference processing currently works in G1. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3663 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3664 // Enable discovery in the STW reference processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3665 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3666 true /*verify_no_refs*/); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3667 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3668 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3669 // We want to temporarily turn off discovery by the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3670 // CM ref processor, if necessary, and turn it back on |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3671 // on again later if we do. Using a scoped |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3672 // NoRefDiscovery object will do this. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3673 NoRefDiscovery no_cm_discovery(ref_processor_cm()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3674 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3675 // 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
|
3676 // of the collection set!). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3677 release_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3678 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3679 // We should call this after we retire the mutator alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3680 // region(s) so that all the ALLOC / RETIRE events are generated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3681 // before the start GC event. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3682 _hr_printer.start_gc(false /* full */, (size_t) total_collections()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3683 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3684 // The elapsed time induced by the start time below deliberately elides |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3685 // the possible verification above. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3686 double start_time_sec = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3687 size_t start_used_bytes = used(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3688 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3689 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3690 gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3691 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3692 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
|
3693 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3694 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3695 g1_policy()->record_collection_pause_start(start_time_sec, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3696 start_used_bytes); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3697 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3698 double scan_wait_start = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3699 // We have to wait until the CM threads finish scanning the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3700 // root regions as it's the only way to ensure that all the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3701 // objects on them have been correctly scanned before we start |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3702 // moving them during the GC. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3703 bool waited = _cm->root_regions()->wait_until_scan_finished(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3704 if (waited) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3705 double scan_wait_end = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3706 double wait_time_ms = (scan_wait_end - scan_wait_start) * 1000.0; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3707 g1_policy()->record_root_region_scan_wait_time(wait_time_ms); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3708 } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3709 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3710 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3711 gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3712 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3713 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3714 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3715 if (g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3716 concurrent_mark()->checkpointRootsInitialPre(); |
|
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 perm_gen()->save_marks(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3719 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3720 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3721 gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3722 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3723 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
|
3724 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3725 |
|
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4910
diff
changeset
|
3726 g1_policy()->finalize_cset(target_pause_time_ms); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3727 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3728 _cm->note_start_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3729 // We should not verify the per-thread SATB buffers given that |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3730 // we have not filtered them yet (we'll do so during the |
|
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4910
diff
changeset
|
3731 // GC). We also call this after finalize_cset() to |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3732 // ensure that the CSet has been finalized. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3733 _cm->verify_no_cset_oops(true /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3734 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3735 false /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3736 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3737 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3738 if (_hr_printer.is_active()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3739 HeapRegion* hr = g1_policy()->collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3740 while (hr != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3741 G1HRPrinter::RegionType type; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3742 if (!hr->is_young()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3743 type = G1HRPrinter::Old; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3744 } else if (hr->is_survivor()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3745 type = G1HRPrinter::Survivor; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3746 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3747 type = G1HRPrinter::Eden; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3748 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3749 _hr_printer.cset(hr); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3750 hr = hr->next_in_collection_set(); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3751 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3752 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3753 |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3754 #ifdef ASSERT |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3755 VerifyCSetClosure cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3756 collection_set_iterate(&cl); |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3757 #endif // ASSERT |
| 1707 | 3758 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3759 setup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3760 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3761 // Initialize the GC alloc regions. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3762 init_gc_alloc_regions(); |
|
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 // Actually do the work... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3765 evacuate_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3766 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3767 // We do this to mainly verify the per-thread SATB buffers |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3768 // (which have been filtered by now) since we didn't verify |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3769 // them earlier. No point in re-checking the stacks / enqueued |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3770 // buffers given that the CSet has not changed since last time |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3771 // we checked. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3772 _cm->verify_no_cset_oops(false /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3773 false /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3774 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3775 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3776 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3777 free_collection_set(g1_policy()->collection_set()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3778 g1_policy()->clear_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3779 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3780 cleanup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3781 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3782 // Start a new incremental collection set for the next pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3783 g1_policy()->start_incremental_cset_building(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3784 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3785 // Clear the _cset_fast_test bitmap in anticipation of adding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3786 // regions to the incremental collection set for the next |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3787 // evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3788 clear_cset_fast_test(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3789 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3790 _young_list->reset_sampled_info(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3791 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3792 // Don't check the whole heap at this point as the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3793 // GC alloc regions from this pause have been tagged |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3794 // as survivors and moved on to the survivor list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3795 // Survivor regions will fail the !is_young() check. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3796 assert(check_young_list_empty(false /* check_heap */), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3797 "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
|
3798 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3799 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3800 gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3801 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3802 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3803 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3804 g1_policy()->record_survivor_regions(_young_list->survivor_length(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3805 _young_list->first_survivor_region(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3806 _young_list->last_survivor_region()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3807 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3808 _young_list->reset_auxilary_lists(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3809 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3810 if (evacuation_failed()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3811 _summary_bytes_used = recalculate_used(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3812 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3813 // The "used" of the the collection set have already been subtracted |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3814 // when they were freed. Add in the bytes evacuated. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3815 _summary_bytes_used += g1_policy()->bytes_copied_during_gc(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3816 } |
|
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 (g1_policy()->during_initial_mark_pause()) { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3819 // We have to do this before we notify the CM threads that |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3820 // they can start working to make sure that all the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3821 // appropriate initialization is done on the CM object. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3822 concurrent_mark()->checkpointRootsInitialPost(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3823 set_marking_started(); |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3824 // Note that we don't actually trigger the CM thread at |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3825 // this point. We do that later when we're sure that |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3826 // the current thread has completed its logging output. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3827 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3828 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3829 allocate_dummy_regions(); |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
3830 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3831 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3832 gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3833 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3834 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
|
3835 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3836 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3837 init_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3838 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3839 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3840 size_t expand_bytes = g1_policy()->expansion_amount(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3841 if (expand_bytes > 0) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3842 size_t bytes_before = capacity(); |
| 4785 | 3843 // No need for an ergo verbose message here, |
| 3844 // expansion_amount() does this when it returns a value > 0. | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3845 if (!expand(expand_bytes)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3846 // We failed to expand the heap so let's verify that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3847 // committed/uncommitted amount match the backing store |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3848 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3849 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3850 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3851 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3852 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3853 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3854 // We redo the verificaiton but now wrt to the new CSet which |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3855 // has just got initialized after the previous CSet was freed. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3856 _cm->verify_no_cset_oops(true /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3857 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3858 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3859 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3860 _cm->note_end_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3861 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3862 double end_time_sec = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3863 double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3864 g1_policy()->record_pause_time_ms(pause_time_ms); |
| 4711 | 3865 int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
| 3866 workers()->active_workers() : 1); | |
| 3867 g1_policy()->record_collection_pause_end(active_workers); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3868 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3869 MemoryService::track_memory_usage(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3870 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3871 // 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
|
3872 // update buffers to bring the RSets up-to-date if |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3873 // G1HRRSFlushLogBuffersOnVerify has been set. While scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3874 // 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
|
3875 // regions we just allocated to (i.e., the GC alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3876 // regions). However, during the last GC we called |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3877 // set_saved_mark() on all the GC alloc regions, so card |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3878 // scanning might skip the [saved_mark_word()...top()] area of |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3879 // those regions (i.e., the area we allocated objects into |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3880 // during the last GC). But it shouldn't. Given that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3881 // saved_mark_word() is conditional on whether the GC time stamp |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3882 // 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
|
3883 // 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
|
3884 // regions and saved_mark_word() will simply return top() for |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3885 // 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
|
3886 // than iterating over the regions and fixing them. In fact, the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3887 // GC time stamp increment here also ensures that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3888 // saved_mark_word() will return top() between pauses, i.e., |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3889 // during concurrent refinement. So we don't need the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3890 // is_gc_active() check to decided which top to use when |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3891 // scanning cards (see CR 7039627). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3892 increment_gc_time_stamp(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3893 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3894 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3895 HandleMark hm; // Discard invalid handles created during verification |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3896 gclog_or_tty->print(" VerifyAfterGC:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3897 prepare_for_verify(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3898 Universe::verify(/* allow dirty */ true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3899 /* silent */ false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3900 /* option */ VerifyOption_G1UsePrevMarking); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3901 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3902 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3903 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3904 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3905 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3906 // 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
|
3907 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3908 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3909 // 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
|
3910 // 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
|
3911 // 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
|
3912 // RETIRE events are generated before the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3913 _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
|
3914 |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
3378
diff
changeset
|
3915 // 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
|
3916 g1_policy()->print_heap_transition(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3917 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3918 if (mark_in_progress()) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3919 concurrent_mark()->update_g1_committed(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3920 } |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3921 |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3922 #ifdef TRACESPINNING |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3923 ParallelTaskTerminator::print_termination_counts(); |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
3924 #endif |
| 342 | 3925 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3926 gc_epilogue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3927 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3928 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3929 if (ExitAfterGCNum > 0 && total_collections() == ExitAfterGCNum) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3930 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
|
3931 print_tracing_info(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3932 vm_exit(-1); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3933 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3934 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3935 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3936 // The closing of the inner scope, immediately above, will complete |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3937 // logging at the "fine" level. The record_collection_pause_end() call |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3938 // above will complete logging at the "finer" level. |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3939 // |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3940 // It is not yet to safe, however, to tell the concurrent mark to |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3941 // start as we have some optional output below. We don't want the |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3942 // output from the concurrent mark thread interfering with this |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3943 // logging output either. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3944 |
| 3766 | 3945 _hrs.verify_optional(); |
| 2152 | 3946 verify_region_sets_optional(); |
| 3947 | |
| 1709 | 3948 TASKQUEUE_STATS_ONLY(if (ParallelGCVerbose) print_taskqueue_stats()); |
| 3949 TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); | |
| 3950 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
3951 print_heap_after_gc(); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
3952 g1mm()->update_sizes(); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3953 |
|
884
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3954 if (G1SummarizeRSetStats && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3955 (G1SummarizeRSetStatsPeriod > 0) && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3956 (total_collections() % G1SummarizeRSetStatsPeriod == 0)) { |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3957 g1_rem_set()->print_summary_info(); |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
3958 } |
| 1973 | 3959 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3960 // It should now be safe to tell the concurrent mark thread to start |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3961 // without its logging output interfering with the logging output |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3962 // that came from the pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3963 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3964 if (should_start_conc_mark) { |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3965 // CAUTION: after the doConcurrentMark() call below, |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3966 // the concurrent marking thread(s) could be running |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3967 // concurrently with us. Make sure that anything after |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3968 // this point does not assume that we are the only GC thread |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3969 // running. Note: of course, the actual marking work will |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3970 // not start until the safepoint itself is released in |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3971 // ConcurrentGCThread::safepoint_desynchronize(). |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3972 doConcurrentMark(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3973 } |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3974 |
| 1973 | 3975 return true; |
| 342 | 3976 } |
| 3977 | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3978 size_t G1CollectedHeap::desired_plab_sz(GCAllocPurpose purpose) |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3979 { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3980 size_t gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3981 switch (purpose) { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3982 case GCAllocForSurvived: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3983 gclab_word_size = YoungPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3984 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3985 case GCAllocForTenured: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3986 gclab_word_size = OldPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3987 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3988 default: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3989 assert(false, "unknown GCAllocPurpose"); |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3990 gclab_word_size = OldPLABSize; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3991 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3992 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3993 return gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3994 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
3995 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3996 void G1CollectedHeap::init_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3997 assert(_mutator_alloc_region.get() == NULL, "pre-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3998 _mutator_alloc_region.init(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3999 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4000 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4001 void G1CollectedHeap::release_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4002 _mutator_alloc_region.release(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4003 assert(_mutator_alloc_region.get() == NULL, "post-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4004 } |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4005 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4006 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
|
4007 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
|
4008 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4009 _survivor_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4010 _old_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4011 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
|
4012 _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
|
4013 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4014 // 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
|
4015 // 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
|
4016 // 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
|
4017 // 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
|
4018 // 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
|
4019 // 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
|
4020 // 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
|
4021 // 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
|
4022 // 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
|
4023 if (retained_region != NULL && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4024 !retained_region->in_collection_set() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4025 !(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
|
4026 !retained_region->is_empty() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4027 !retained_region->isHumongous()) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4028 retained_region->set_saved_mark(); |
| 4072 | 4029 // The retained region was added to the old region set when it was |
| 4030 // retired. We have to remove it now, since we don't allow regions | |
| 4031 // we allocate to in the region sets. We'll re-add it later, when | |
| 4032 // it's retired again. | |
| 4033 _old_set.remove(retained_region); | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4034 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4035 retained_region->note_start_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4036 _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
|
4037 _hr_printer.reuse(retained_region); |
| 342 | 4038 } |
| 4039 } | |
| 4040 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4041 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
|
4042 _survivor_gc_alloc_region.release(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4043 // 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
|
4044 // _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
|
4045 // _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
|
4046 // 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
|
4047 // condition. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4048 _retained_old_gc_alloc_region = _old_gc_alloc_region.release(); |
| 342 | 4049 } |
| 4050 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4051 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
|
4052 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
|
4053 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
|
4054 _retained_old_gc_alloc_region = NULL; |
| 342 | 4055 } |
| 4056 | |
| 4057 void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) { | |
| 4058 _drain_in_progress = false; | |
| 4059 set_evac_failure_closure(cl); | |
| 4060 _evac_failure_scan_stack = new (ResourceObj::C_HEAP) GrowableArray<oop>(40, true); | |
| 4061 } | |
| 4062 | |
| 4063 void G1CollectedHeap::finalize_for_evac_failure() { | |
| 4064 assert(_evac_failure_scan_stack != NULL && | |
| 4065 _evac_failure_scan_stack->length() == 0, | |
| 4066 "Postcondition"); | |
| 4067 assert(!_drain_in_progress, "Postcondition"); | |
| 1045 | 4068 delete _evac_failure_scan_stack; |
| 342 | 4069 _evac_failure_scan_stack = NULL; |
| 4070 } | |
| 4071 | |
| 4072 void G1CollectedHeap::remove_self_forwarding_pointers() { | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4073 assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4074 assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4075 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4076 G1ParRemoveSelfForwardPtrsTask rsfp_task(this); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4077 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4078 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4079 set_par_threads(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4080 workers()->run_task(&rsfp_task); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4081 set_par_threads(0); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4082 } else { |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4083 rsfp_task.work(0); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4084 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4085 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4086 assert(check_cset_heap_region_claim_values(HeapRegion::ParEvacFailureClaimValue), "sanity"); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4087 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4088 // Reset the claim values in the regions in the collection set. |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4089 reset_cset_heap_region_claim_values(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4090 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4091 assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); |
| 342 | 4092 assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); |
| 4093 | |
| 4094 // Now restore saved marks, if any. | |
| 4095 if (_objs_with_preserved_marks != NULL) { | |
| 4096 assert(_preserved_marks_of_objs != NULL, "Both or none."); | |
| 4097 guarantee(_objs_with_preserved_marks->length() == | |
| 4098 _preserved_marks_of_objs->length(), "Both or none."); | |
| 4099 for (int i = 0; i < _objs_with_preserved_marks->length(); i++) { | |
| 4100 oop obj = _objs_with_preserved_marks->at(i); | |
| 4101 markOop m = _preserved_marks_of_objs->at(i); | |
| 4102 obj->set_mark(m); | |
| 4103 } | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4104 |
| 342 | 4105 // Delete the preserved marks growable arrays (allocated on the C heap). |
| 4106 delete _objs_with_preserved_marks; | |
| 4107 delete _preserved_marks_of_objs; | |
| 4108 _objs_with_preserved_marks = NULL; | |
| 4109 _preserved_marks_of_objs = NULL; | |
| 4110 } | |
| 4111 } | |
| 4112 | |
| 4113 void G1CollectedHeap::push_on_evac_failure_scan_stack(oop obj) { | |
| 4114 _evac_failure_scan_stack->push(obj); | |
| 4115 } | |
| 4116 | |
| 4117 void G1CollectedHeap::drain_evac_failure_scan_stack() { | |
| 4118 assert(_evac_failure_scan_stack != NULL, "precondition"); | |
| 4119 | |
| 4120 while (_evac_failure_scan_stack->length() > 0) { | |
| 4121 oop obj = _evac_failure_scan_stack->pop(); | |
| 4122 _evac_failure_closure->set_region(heap_region_containing(obj)); | |
| 4123 obj->oop_iterate_backwards(_evac_failure_closure); | |
| 4124 } | |
| 4125 } | |
| 4126 | |
| 4127 oop | |
| 4128 G1CollectedHeap::handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4129 oop old) { |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4130 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
|
4131 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
|
4132 (HeapWord*) old)); |
| 342 | 4133 markOop m = old->mark(); |
| 4134 oop forward_ptr = old->forward_to_atomic(old); | |
| 4135 if (forward_ptr == NULL) { | |
| 4136 // 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
|
4137 |
| 342 | 4138 if (_evac_failure_closure != cl) { |
| 4139 MutexLockerEx x(EvacFailureStack_lock, Mutex::_no_safepoint_check_flag); | |
| 4140 assert(!_drain_in_progress, | |
| 4141 "Should only be true while someone holds the lock."); | |
| 4142 // Set the global evac-failure closure to the current thread's. | |
| 4143 assert(_evac_failure_closure == NULL, "Or locking has failed."); | |
| 4144 set_evac_failure_closure(cl); | |
| 4145 // Now do the common part. | |
| 4146 handle_evacuation_failure_common(old, m); | |
| 4147 // Reset to NULL. | |
| 4148 set_evac_failure_closure(NULL); | |
| 4149 } else { | |
| 4150 // The lock is already held, and this is recursive. | |
| 4151 assert(_drain_in_progress, "This should only be the recursive case."); | |
| 4152 handle_evacuation_failure_common(old, m); | |
| 4153 } | |
| 4154 return old; | |
| 4155 } 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
|
4156 // 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
|
4157 // 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
|
4158 // 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
|
4159 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
|
4160 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
|
4161 "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
|
4162 (HeapWord*) old, (HeapWord*) forward_ptr)); |
| 342 | 4163 return forward_ptr; |
| 4164 } | |
| 4165 } | |
| 4166 | |
| 4167 void G1CollectedHeap::handle_evacuation_failure_common(oop old, markOop m) { | |
| 4168 set_evacuation_failed(true); | |
| 4169 | |
| 4170 preserve_mark_if_necessary(old, m); | |
| 4171 | |
| 4172 HeapRegion* r = heap_region_containing(old); | |
| 4173 if (!r->evacuation_failed()) { | |
| 4174 r->set_evacuation_failed(true); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4175 _hr_printer.evac_failure(r); |
| 342 | 4176 } |
| 4177 | |
| 4178 push_on_evac_failure_scan_stack(old); | |
| 4179 | |
| 4180 if (!_drain_in_progress) { | |
| 4181 // prevent recursion in copy_to_survivor_space() | |
| 4182 _drain_in_progress = true; | |
| 4183 drain_evac_failure_scan_stack(); | |
| 4184 _drain_in_progress = false; | |
| 4185 } | |
| 4186 } | |
| 4187 | |
| 4188 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
|
4189 assert(evacuation_failed(), "Oversaving!"); |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4190 // 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
|
4191 // case of a promotion failure. |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4192 if (m->must_be_preserved_for_promotion_failure(obj)) { |
| 342 | 4193 if (_objs_with_preserved_marks == NULL) { |
| 4194 assert(_preserved_marks_of_objs == NULL, "Both or none."); | |
| 4195 _objs_with_preserved_marks = | |
| 4196 new (ResourceObj::C_HEAP) GrowableArray<oop>(40, true); | |
| 4197 _preserved_marks_of_objs = | |
| 4198 new (ResourceObj::C_HEAP) GrowableArray<markOop>(40, true); | |
| 4199 } | |
| 4200 _objs_with_preserved_marks->push(obj); | |
| 4201 _preserved_marks_of_objs->push(m); | |
| 4202 } | |
| 4203 } | |
| 4204 | |
| 4205 HeapWord* G1CollectedHeap::par_allocate_during_gc(GCAllocPurpose purpose, | |
| 4206 size_t word_size) { | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4207 if (purpose == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4208 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
|
4209 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4210 return result; |
| 342 | 4211 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4212 // 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
|
4213 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4214 return old_attempt_allocation(word_size); |
| 342 | 4215 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4216 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4217 assert(purpose == GCAllocForTenured, "sanity"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4218 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
|
4219 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4220 return result; |
| 342 | 4221 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4222 // 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
|
4223 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4224 return survivor_attempt_allocation(word_size); |
| 342 | 4225 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4226 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4227 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4228 ShouldNotReachHere(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4229 // 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
|
4230 return NULL; |
| 342 | 4231 } |
| 4232 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4233 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4234 ParGCAllocBuffer(gclab_word_size), _retired(false) { } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4235 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4236 G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num) |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4237 : _g1h(g1h), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4238 _refs(g1h->task_queue(queue_num)), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4239 _dcq(&g1h->dirty_card_queue_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4240 _ct_bs((CardTableModRefBS*)_g1h->barrier_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4241 _g1_rem(g1h->g1_rem_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4242 _hash_seed(17), _queue_num(queue_num), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4243 _term_attempts(0), |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4244 _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)), |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4245 _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
|
4246 _age_table(false), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4247 _strong_roots_time(0), _term_time(0), |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4248 _alloc_buffer_waste(0), _undo_waste(0) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4249 // we allocate G1YoungSurvRateNumRegions plus one entries, since |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4250 // 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
|
4251 // non-young regions (where the age is -1) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4252 // 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
|
4253 // 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
|
4254 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
|
4255 size_t array_length = PADDING_ELEM_NUM + |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4256 real_length + |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4257 PADDING_ELEM_NUM; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4258 _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
|
4259 if (_surviving_young_words_base == NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4260 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
|
4261 "Not enough space for young surv histo."); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4262 _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
|
4263 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
|
4264 |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4265 _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4266 _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4267 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4268 _start = os::elapsedTime(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4269 } |
| 342 | 4270 |
| 1709 | 4271 void |
| 4272 G1ParScanThreadState::print_termination_stats_hdr(outputStream* const st) | |
| 4273 { | |
| 4274 st->print_raw_cr("GC Termination Stats"); | |
| 4275 st->print_raw_cr(" elapsed --strong roots-- -------termination-------" | |
| 4276 " ------waste (KiB)------"); | |
| 4277 st->print_raw_cr("thr ms ms % ms % attempts" | |
| 4278 " total alloc undo"); | |
| 4279 st->print_raw_cr("--- --------- --------- ------ --------- ------ --------" | |
| 4280 " ------- ------- -------"); | |
| 4281 } | |
| 4282 | |
| 4283 void | |
| 4284 G1ParScanThreadState::print_termination_stats(int i, | |
| 4285 outputStream* const st) const | |
| 4286 { | |
| 4287 const double elapsed_ms = elapsed_time() * 1000.0; | |
| 4288 const double s_roots_ms = strong_roots_time() * 1000.0; | |
| 4289 const double term_ms = term_time() * 1000.0; | |
| 4290 st->print_cr("%3d %9.2f %9.2f %6.2f " | |
| 4291 "%9.2f %6.2f " SIZE_FORMAT_W(8) " " | |
| 4292 SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), | |
| 4293 i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms, | |
| 4294 term_ms, term_ms * 100 / elapsed_ms, term_attempts(), | |
| 4295 (alloc_buffer_waste() + undo_waste()) * HeapWordSize / K, | |
| 4296 alloc_buffer_waste() * HeapWordSize / K, | |
| 4297 undo_waste() * HeapWordSize / K); | |
| 4298 } | |
| 4299 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4300 #ifdef ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4301 bool G1ParScanThreadState::verify_ref(narrowOop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4302 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4303 assert(UseCompressedOops, "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4304 assert(!has_partial_array_mask(ref), err_msg("ref=" PTR_FORMAT, ref)); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4305 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4306 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4307 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4308 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4309 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4310 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4311 bool G1ParScanThreadState::verify_ref(oop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4312 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4313 if (has_partial_array_mask(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4314 // Must be in the collection set--it's already been copied. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4315 oop p = clear_partial_array_mask(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4316 assert(_g1h->obj_in_cs(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4317 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4318 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4319 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4320 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4321 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4322 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4323 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4324 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4325 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4326 bool G1ParScanThreadState::verify_task(StarTask ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4327 if (ref.is_narrow()) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4328 return verify_ref((narrowOop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4329 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4330 return verify_ref((oop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4331 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4332 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4333 #endif // ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4334 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4335 void G1ParScanThreadState::trim_queue() { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4336 assert(_evac_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4337 assert(_evac_failure_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4338 assert(_partial_scan_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4339 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4340 StarTask ref; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4341 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4342 // Drain the overflow stack first, so other threads can steal. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4343 while (refs()->pop_overflow(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4344 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4345 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4346 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4347 while (refs()->pop_local(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4348 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4349 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4350 } while (!refs()->is_empty()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4351 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4352 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4353 G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4354 G1ParScanThreadState* par_scan_state) : |
| 342 | 4355 _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
|
4356 _par_scan_state(par_scan_state), |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4357 _worker_id(par_scan_state->queue_num()), |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4358 _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
|
4359 _mark_in_progress(_g1->mark_in_progress()) { } |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4360 |
| 5987 | 4361 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4362 void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>::mark_object(oop obj) { | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4363 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4364 HeapRegion* hr = _g1->heap_region_containing(obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4365 assert(hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4366 assert(!hr->in_collection_set(), "should not mark objects in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4367 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4368 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4369 // We know that the object is not moving so it's safe to read its size. |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4370 _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4371 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4372 |
| 5987 | 4373 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4374 void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> | |
| 4375 ::mark_forwarded_object(oop from_obj, oop to_obj) { | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4376 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4377 assert(from_obj->is_forwarded(), "from obj should be forwarded"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4378 assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4379 assert(from_obj != to_obj, "should not be self-forwarded"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4380 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4381 HeapRegion* from_hr = _g1->heap_region_containing(from_obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4382 assert(from_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4383 assert(from_hr->in_collection_set(), "from obj should be in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4384 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4385 HeapRegion* to_hr = _g1->heap_region_containing(to_obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4386 assert(to_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4387 assert(!to_hr->in_collection_set(), "should not mark objects in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4388 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4389 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4390 // The object might be in the process of being copied by another |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4391 // worker so we cannot trust that its to-space image is |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4392 // well-formed. So we have to read its size from its from-space |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4393 // image which we know should not be changing. |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4394 _cm->grayRoot(to_obj, (size_t) from_obj->size(), _worker_id); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4395 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4396 |
| 5987 | 4397 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4398 oop G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> | |
| 4399 ::copy_to_survivor_space(oop old) { | |
| 342 | 4400 size_t word_sz = old->size(); |
| 4401 HeapRegion* from_region = _g1->heap_region_containing_raw(old); | |
| 4402 // +1 to make the -1 indexes valid... | |
| 4403 int young_index = from_region->young_index_in_cset()+1; | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4404 assert( (from_region->is_young() && young_index > 0) || |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4405 (!from_region->is_young() && young_index == 0), "invariant" ); |
| 342 | 4406 G1CollectorPolicy* g1p = _g1->g1_policy(); |
| 4407 markOop m = old->mark(); | |
| 545 | 4408 int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age() |
| 4409 : m->age(); | |
| 4410 GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age, | |
| 342 | 4411 word_sz); |
| 4412 HeapWord* obj_ptr = _par_scan_state->allocate(alloc_purpose, word_sz); | |
| 4413 oop obj = oop(obj_ptr); | |
| 4414 | |
| 4415 if (obj_ptr == NULL) { | |
| 4416 // This will either forward-to-self, or detect that someone else has | |
| 4417 // installed a forwarding pointer. | |
| 4418 OopsInHeapRegionClosure* cl = _par_scan_state->evac_failure_closure(); | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4419 return _g1->handle_evacuation_failure_par(cl, old); |
| 342 | 4420 } |
| 4421 | |
| 526 | 4422 // We're going to allocate linearly, so might as well prefetch ahead. |
| 4423 Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes); | |
| 4424 | |
| 342 | 4425 oop forward_ptr = old->forward_to_atomic(obj); |
| 4426 if (forward_ptr == NULL) { | |
| 4427 Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz); | |
| 526 | 4428 if (g1p->track_object_age(alloc_purpose)) { |
| 4429 // We could simply do obj->incr_age(). However, this causes a | |
| 4430 // performance issue. obj->incr_age() will first check whether | |
| 4431 // the object has a displaced mark by checking its mark word; | |
| 4432 // getting the mark word from the new location of the object | |
| 4433 // stalls. So, given that we already have the mark word and we | |
| 4434 // are about to install it anyway, it's better to increase the | |
| 4435 // age on the mark word, when the object does not have a | |
| 4436 // displaced mark word. We're not expecting many objects to have | |
| 4437 // a displaced marked word, so that case is not optimized | |
| 4438 // further (it could be...) and we simply call obj->incr_age(). | |
| 4439 | |
| 4440 if (m->has_displaced_mark_helper()) { | |
| 4441 // in this case, we have to install the mark word first, | |
| 4442 // otherwise obj looks to be forwarded (the old mark word, | |
| 4443 // which contains the forward pointer, was copied) | |
| 4444 obj->set_mark(m); | |
| 4445 obj->incr_age(); | |
| 4446 } else { | |
| 4447 m = m->incr_age(); | |
| 545 | 4448 obj->set_mark(m); |
| 526 | 4449 } |
| 545 | 4450 _par_scan_state->age_table()->add(obj, word_sz); |
| 4451 } else { | |
| 4452 obj->set_mark(m); | |
| 526 | 4453 } |
| 4454 | |
| 342 | 4455 size_t* surv_young_words = _par_scan_state->surviving_young_words(); |
| 4456 surv_young_words[young_index] += word_sz; | |
| 4457 | |
| 4458 if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) { | |
|
4784
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4459 // We keep track of the next start index in the length field of |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4460 // the to-space object. The actual length can be found in the |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4461 // length field of the from-space object. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4462 arrayOop(obj)->set_length(0); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4463 oop* old_p = set_partial_array_mask(old); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4464 _par_scan_state->push_on_queue(old_p); |
| 342 | 4465 } else { |
| 526 | 4466 // No point in using the slower heap_region_containing() method, |
| 4467 // given that we know obj is in the heap. | |
| 5987 | 4468 _scanner.set_region(_g1->heap_region_containing_raw(obj)); |
| 4469 obj->oop_iterate_backwards(&_scanner); | |
| 342 | 4470 } |
| 4471 } else { | |
| 4472 _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); | |
| 4473 obj = forward_ptr; | |
| 4474 } | |
| 4475 return obj; | |
| 4476 } | |
| 4477 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4478 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
|
4479 template <class T> |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4480 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
|
4481 ::do_oop_work(T* p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4482 oop obj = oopDesc::load_decode_heap_oop(p); |
| 342 | 4483 assert(barrier != G1BarrierRS || obj != NULL, |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4484 "Precondition: G1BarrierRS implies obj is non-NULL"); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4485 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4486 assert(_worker_id == _par_scan_state->queue_num(), "sanity"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4487 |
| 526 | 4488 // 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
|
4489 if (_g1->in_cset_fast_test(obj)) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4490 oop forwardee; |
| 526 | 4491 if (obj->is_forwarded()) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4492 forwardee = obj->forwardee(); |
| 526 | 4493 } else { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4494 forwardee = copy_to_survivor_space(obj); |
| 342 | 4495 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4496 assert(forwardee != NULL, "forwardee should not be NULL"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4497 oopDesc::encode_store_heap_oop(p, forwardee); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4498 if (do_mark_object && forwardee != obj) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4499 // If the object is self-forwarded we don't need to explicitly |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4500 // mark it, the evacuation failure protocol will do so. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4501 mark_forwarded_object(obj, forwardee); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4502 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4503 |
| 526 | 4504 // When scanning the RS, we only care about objs in CS. |
| 4505 if (barrier == G1BarrierRS) { | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4506 _par_scan_state->update_rs(_from, p, _worker_id); |
| 342 | 4507 } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4508 } else { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4509 // 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
|
4510 // 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
|
4511 // be true) then attempt to mark the object. |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4512 if (do_mark_object && _g1->is_in_g1_reserved(obj)) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4513 mark_object(obj); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4514 } |
| 526 | 4515 } |
| 4516 | |
| 4517 if (barrier == G1BarrierEvac && obj != NULL) { | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4518 _par_scan_state->update_rs(_from, p, _worker_id); |
| 526 | 4519 } |
| 4520 | |
| 4521 if (do_gen_barrier && obj != NULL) { | |
| 4522 par_do_barrier(p); | |
| 4523 } | |
| 4524 } | |
| 4525 | |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4526 template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(oop* p); |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4527 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
|
4528 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4529 template <class T> void G1ParScanPartialArrayClosure::do_oop_nv(T* p) { |
| 526 | 4530 assert(has_partial_array_mask(p), "invariant"); |
|
4784
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4531 oop from_obj = clear_partial_array_mask(p); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4532 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4533 assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap."); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4534 assert(from_obj->is_objArray(), "must be obj array"); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4535 objArrayOop from_obj_array = objArrayOop(from_obj); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4536 // The from-space object contains the real length. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4537 int length = from_obj_array->length(); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4538 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4539 assert(from_obj->is_forwarded(), "must be forwarded"); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4540 oop to_obj = from_obj->forwardee(); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4541 assert(from_obj != to_obj, "should not be chunking self-forwarded objects"); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4542 objArrayOop to_obj_array = objArrayOop(to_obj); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4543 // We keep track of the next start index in the length field of the |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4544 // to-space object. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4545 int next_index = to_obj_array->length(); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4546 assert(0 <= next_index && next_index < length, |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4547 err_msg("invariant, next index: %d, length: %d", next_index, length)); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4548 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4549 int start = next_index; |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4550 int end = length; |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4551 int remainder = end - start; |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4552 // We'll try not to push a range that's smaller than ParGCArrayScanChunk. |
| 342 | 4553 if (remainder > 2 * ParGCArrayScanChunk) { |
| 4554 end = start + ParGCArrayScanChunk; | |
|
4784
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4555 to_obj_array->set_length(end); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4556 // Push the remainder before we process the range in case another |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4557 // worker has run out of things to do and can steal it. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4558 oop* from_obj_p = set_partial_array_mask(from_obj); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4559 _par_scan_state->push_on_queue(from_obj_p); |
| 342 | 4560 } else { |
|
4784
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4561 assert(length == end, "sanity"); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4562 // We'll process the final range for this object. Restore the length |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4563 // so that the heap remains parsable in case of evacuation failure. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4564 to_obj_array->set_length(end); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4565 } |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4566 _scanner.set_region(_g1->heap_region_containing_raw(to_obj)); |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4567 // Process indexes [start,end). It will also process the header |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4568 // along with the first chunk (i.e., the chunk with start == 0). |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4569 // Note that at this point the length field of to_obj_array is not |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4570 // correct given that we are using it to keep track of the next |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4571 // start index. oop_iterate_range() (thankfully!) ignores the length |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4572 // field and only relies on the start / end parameters. It does |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4573 // however return the size of the object which will be incorrect. So |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4574 // we have to ignore it even if we wanted to use it. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4575 to_obj_array->oop_iterate_range(&_scanner, start, end); |
| 342 | 4576 } |
| 4577 | |
| 4578 class G1ParEvacuateFollowersClosure : public VoidClosure { | |
| 4579 protected: | |
| 4580 G1CollectedHeap* _g1h; | |
| 4581 G1ParScanThreadState* _par_scan_state; | |
| 4582 RefToScanQueueSet* _queues; | |
| 4583 ParallelTaskTerminator* _terminator; | |
| 4584 | |
| 4585 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } | |
| 4586 RefToScanQueueSet* queues() { return _queues; } | |
| 4587 ParallelTaskTerminator* terminator() { return _terminator; } | |
| 4588 | |
| 4589 public: | |
| 4590 G1ParEvacuateFollowersClosure(G1CollectedHeap* g1h, | |
| 4591 G1ParScanThreadState* par_scan_state, | |
| 4592 RefToScanQueueSet* queues, | |
| 4593 ParallelTaskTerminator* terminator) | |
| 4594 : _g1h(g1h), _par_scan_state(par_scan_state), | |
| 4595 _queues(queues), _terminator(terminator) {} | |
| 4596 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4597 void do_void(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4598 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4599 private: |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4600 inline bool offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4601 }; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4602 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4603 bool G1ParEvacuateFollowersClosure::offer_termination() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4604 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4605 pss->start_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4606 const bool res = terminator()->offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4607 pss->end_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4608 return res; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4609 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4610 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4611 void G1ParEvacuateFollowersClosure::do_void() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4612 StarTask stolen_task; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4613 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4614 pss->trim_queue(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4615 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4616 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4617 while (queues()->steal(pss->queue_num(), pss->hash_seed(), stolen_task)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4618 assert(pss->verify_task(stolen_task), "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4619 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
|
4620 pss->deal_with_reference((narrowOop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4621 } else { |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4622 pss->deal_with_reference((oop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4623 } |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4624 |
|
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4625 // 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
|
4626 // 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
|
4627 // we drain the queues as necessary. |
| 342 | 4628 pss->trim_queue(); |
| 4629 } | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4630 } while (!offer_termination()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4631 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4632 pss->retire_alloc_buffers(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4633 } |
| 342 | 4634 |
| 4635 class G1ParTask : public AbstractGangTask { | |
| 4636 protected: | |
| 4637 G1CollectedHeap* _g1h; | |
| 4638 RefToScanQueueSet *_queues; | |
| 4639 ParallelTaskTerminator _terminator; | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4640 uint _n_workers; |
| 342 | 4641 |
| 4642 Mutex _stats_lock; | |
| 4643 Mutex* stats_lock() { return &_stats_lock; } | |
| 4644 | |
| 4645 size_t getNCards() { | |
| 4646 return (_g1h->capacity() + G1BlockOffsetSharedArray::N_bytes - 1) | |
| 4647 / G1BlockOffsetSharedArray::N_bytes; | |
| 4648 } | |
| 4649 | |
| 4650 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4651 G1ParTask(G1CollectedHeap* g1h, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4652 RefToScanQueueSet *task_queues) |
| 342 | 4653 : AbstractGangTask("G1 collection"), |
| 4654 _g1h(g1h), | |
| 4655 _queues(task_queues), | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4656 _terminator(0, _queues), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4657 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true) |
| 342 | 4658 {} |
| 4659 | |
| 4660 RefToScanQueueSet* queues() { return _queues; } | |
| 4661 | |
| 4662 RefToScanQueue *work_queue(int i) { | |
| 4663 return queues()->queue(i); | |
| 4664 } | |
| 4665 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4666 ParallelTaskTerminator* terminator() { return &_terminator; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4667 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4668 virtual void set_for_termination(int active_workers) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4669 // 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
|
4670 // 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
|
4671 // for SequentialSubTasksDone. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4672 // This task also uses SubTasksDone in SharedHeap and G1CollectedHeap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4673 // both of which need setting by set_n_termination(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4674 _g1h->SharedHeap::set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4675 _g1h->set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4676 terminator()->reset_for_reuse(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4677 _n_workers = active_workers; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4678 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4679 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4680 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4681 if (worker_id >= _n_workers) return; // no work needed this round |
| 1611 | 4682 |
| 4683 double start_time_ms = os::elapsedTime() * 1000.0; | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4684 _g1h->g1_policy()->record_gc_worker_start_time(worker_id, start_time_ms); |
| 1611 | 4685 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4686 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4687 ResourceMark rm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4688 HandleMark hm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4689 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4690 ReferenceProcessor* rp = _g1h->ref_processor_stw(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4691 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4692 G1ParScanThreadState pss(_g1h, worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4693 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4694 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4695 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4696 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4697 pss.set_evac_closure(&scan_evac_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4698 pss.set_evac_failure_closure(&evac_failure_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4699 pss.set_partial_scan_closure(&partial_scan_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4700 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4701 G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4702 G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4703 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4704 G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4705 G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4706 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4707 OopClosure* scan_root_cl = &only_scan_root_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4708 OopsInHeapRegionClosure* scan_perm_cl = &only_scan_perm_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4709 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4710 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4711 // We also need to mark copied objects. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4712 scan_root_cl = &scan_mark_root_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4713 scan_perm_cl = &scan_mark_perm_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4714 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4715 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4716 G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4717 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4718 pss.start_strong_roots(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4719 _g1h->g1_process_strong_roots(/* not collecting perm */ false, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4720 SharedHeap::SO_AllClasses, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4721 scan_root_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4722 &push_heap_rs_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4723 scan_perm_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4724 worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4725 pss.end_strong_roots(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4726 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4727 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4728 double start = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4729 G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4730 evac.do_void(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4731 double elapsed_ms = (os::elapsedTime()-start)*1000.0; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4732 double term_ms = pss.term_time()*1000.0; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4733 _g1h->g1_policy()->record_obj_copy_time(worker_id, elapsed_ms-term_ms); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4734 _g1h->g1_policy()->record_termination(worker_id, term_ms, pss.term_attempts()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4735 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4736 _g1h->g1_policy()->record_thread_age_table(pss.age_table()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4737 _g1h->update_surviving_young_words(pss.surviving_young_words()+1); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4738 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4739 // Clean up any par-expanded rem sets. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4740 HeapRegionRemSet::par_cleanup(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4741 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4742 if (ParallelGCVerbose) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4743 MutexLocker x(stats_lock()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4744 pss.print_termination_stats(worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4745 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4746 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4747 assert(pss.refs()->is_empty(), "should be empty"); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4748 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4749 // Close the inner scope so that the ResourceMark and HandleMark |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4750 // destructors are executed here and are included as part of the |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4751 // "GC Worker Time". |
| 342 | 4752 } |
| 4753 | |
| 1611 | 4754 double end_time_ms = os::elapsedTime() * 1000.0; |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4755 _g1h->g1_policy()->record_gc_worker_end_time(worker_id, end_time_ms); |
| 342 | 4756 } |
| 4757 }; | |
| 4758 | |
| 4759 // *** Common G1 Evacuation Stuff | |
| 4760 | |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4761 // Closures that support the filtering of CodeBlobs scanned during |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4762 // external root scanning. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4763 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4764 // Closure applied to reference fields in code blobs (specifically nmethods) |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4765 // to determine whether an nmethod contains references that point into |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4766 // the collection set. Used as a predicate when walking code roots so |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4767 // that only nmethods that point into the collection set are added to the |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4768 // 'marked' list. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4769 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4770 class G1FilteredCodeBlobToOopClosure : public CodeBlobToOopClosure { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4771 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4772 class G1PointsIntoCSOopClosure : public OopClosure { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4773 G1CollectedHeap* _g1; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4774 bool _points_into_cs; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4775 public: |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4776 G1PointsIntoCSOopClosure(G1CollectedHeap* g1) : |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4777 _g1(g1), _points_into_cs(false) { } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4778 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4779 bool points_into_cs() const { return _points_into_cs; } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4780 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4781 template <class T> |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4782 void do_oop_nv(T* p) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4783 if (!_points_into_cs) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4784 T heap_oop = oopDesc::load_heap_oop(p); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4785 if (!oopDesc::is_null(heap_oop) && |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4786 _g1->in_cset_fast_test(oopDesc::decode_heap_oop_not_null(heap_oop))) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4787 _points_into_cs = true; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4788 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4789 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4790 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4791 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4792 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4793 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4794 }; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4795 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4796 G1CollectedHeap* _g1; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4797 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4798 public: |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4799 G1FilteredCodeBlobToOopClosure(G1CollectedHeap* g1, OopClosure* cl) : |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4800 CodeBlobToOopClosure(cl, true), _g1(g1) { } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4801 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4802 virtual void do_code_blob(CodeBlob* cb) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4803 nmethod* nm = cb->as_nmethod_or_null(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4804 if (nm != NULL && !(nm->test_oops_do_mark())) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4805 G1PointsIntoCSOopClosure predicate_cl(_g1); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4806 nm->oops_do(&predicate_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4807 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4808 if (predicate_cl.points_into_cs()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4809 // At least one of the reference fields or the oop relocations |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4810 // in the nmethod points into the collection set. We have to |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4811 // 'mark' this nmethod. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4812 // Note: Revisit the following if CodeBlobToOopClosure::do_code_blob() |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4813 // or MarkingCodeBlobClosure::do_code_blob() change. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4814 if (!nm->test_set_oops_do_mark()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4815 do_newly_marked_nmethod(nm); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4816 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4817 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4818 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4819 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4820 }; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4821 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4822 // This method is run in a GC worker. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4823 |
| 342 | 4824 void |
| 4825 G1CollectedHeap:: | |
| 4826 g1_process_strong_roots(bool collecting_perm_gen, | |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
4827 ScanningOption so, |
| 342 | 4828 OopClosure* scan_non_heap_roots, |
| 4829 OopsInHeapRegionClosure* scan_rs, | |
| 4830 OopsInGenClosure* scan_perm, | |
| 4831 int worker_i) { | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4832 |
| 342 | 4833 // First scan the strong roots, including the perm gen. |
| 4834 double ext_roots_start = os::elapsedTime(); | |
| 4835 double closure_app_time_sec = 0.0; | |
| 4836 | |
| 4837 BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); | |
| 4838 BufferingOopsInGenClosure buf_scan_perm(scan_perm); | |
| 4839 buf_scan_perm.set_generation(perm_gen()); | |
| 4840 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4841 // 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
|
4842 // unaligned oop locations. |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4843 G1FilteredCodeBlobToOopClosure eager_scan_code_roots(this, scan_non_heap_roots); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4844 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4845 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
|
4846 collecting_perm_gen, so, |
| 342 | 4847 &buf_scan_non_heap_roots, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4848 &eager_scan_code_roots, |
| 342 | 4849 &buf_scan_perm); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4850 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4851 // 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
|
4852 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
|
4853 // We need to treat the discovered reference lists of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4854 // concurrent mark ref processor as roots and keep entries |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4855 // (which are added by the marking threads) on them live |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4856 // until they can be processed at the end of marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4857 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
|
4858 } |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4859 |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4860 // Finish up any enqueued closure apps (attributed as object copy time). |
| 342 | 4861 buf_scan_non_heap_roots.done(); |
| 4862 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
|
4863 |
| 342 | 4864 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
|
4865 |
| 342 | 4866 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
|
4867 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
|
4868 buf_scan_non_heap_roots.closure_app_seconds(); |
| 342 | 4869 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
|
4870 |
| 342 | 4871 double ext_root_time_ms = |
| 4872 ((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
|
4873 |
| 342 | 4874 g1_policy()->record_ext_root_scan_time(worker_i, ext_root_time_ms); |
| 4875 | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4876 // During conc marking we have to filter the per-thread SATB buffers |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4877 // to make sure we remove any oops into the CSet (which will show up |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4878 // as implicitly live). |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4879 if (!_process_strong_tasks->is_task_claimed(G1H_PS_filter_satb_buffers)) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4880 if (mark_in_progress()) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4881 JavaThread::satb_mark_queue_set().filter_thread_buffers(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4882 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4883 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4884 double satb_filtering_ms = (os::elapsedTime() - ext_roots_end) * 1000.0; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4885 g1_policy()->record_satb_filtering_time(worker_i, satb_filtering_ms); |
| 342 | 4886 |
| 4887 // Now scan the complement of the collection set. | |
| 4888 if (scan_rs != NULL) { | |
| 4889 g1_rem_set()->oops_into_collection_set_do(scan_rs, worker_i); | |
| 4890 } | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4891 |
| 342 | 4892 _process_strong_tasks->all_tasks_completed(); |
| 4893 } | |
| 4894 | |
| 4895 void | |
| 4896 G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure, | |
| 4897 OopClosure* non_root_closure) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
4898 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
|
4899 SharedHeap::process_weak_roots(root_closure, &roots_in_blobs, non_root_closure); |
| 342 | 4900 } |
| 4901 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4902 // Weak Reference Processing support |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4903 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4904 // An always "is_alive" closure that is used to preserve referents. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4905 // 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
|
4906 // of referent objects that are pointed to by reference objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4907 // discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4908 class G1AlwaysAliveClosure: public BoolObjectClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4909 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4910 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4911 G1AlwaysAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4912 void do_object(oop p) { assert(false, "Do not call."); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4913 bool do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4914 if (p != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4915 return true; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4916 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4917 return false; |
|
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 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4920 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4921 bool G1STWIsAliveClosure::do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4922 // An object is reachable if it is outside the collection set, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4923 // or is inside and copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4924 return !_g1->obj_in_cs(p) || p->is_forwarded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4925 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4926 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4927 // Non Copying Keep Alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4928 class G1KeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4929 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4930 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4931 G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4932 void do_oop(narrowOop* p) { guarantee(false, "Not needed"); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4933 void do_oop( oop* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4934 oop obj = *p; |
|
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 if (_g1->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4937 assert( obj->is_forwarded(), "invariant" ); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4938 *p = obj->forwardee(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4939 } |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4943 // Copying Keep Alive closure - can be called from both |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4944 // serial and parallel code as long as different worker |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4945 // threads utilize different G1ParScanThreadState instances |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4946 // and different queues. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4947 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4948 class G1CopyingKeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4949 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4950 OopClosure* _copy_non_heap_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4951 OopsInHeapRegionClosure* _copy_perm_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4952 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4953 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4954 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4955 G1CopyingKeepAliveClosure(G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4956 OopClosure* non_heap_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4957 OopsInHeapRegionClosure* perm_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4958 G1ParScanThreadState* pss): |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4959 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4960 _copy_non_heap_obj_cl(non_heap_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4961 _copy_perm_obj_cl(perm_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4962 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4963 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4964 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4965 virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4966 virtual void do_oop( oop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4967 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4968 template <class T> void do_oop_work(T* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4969 oop obj = oopDesc::load_decode_heap_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4970 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4971 if (_g1h->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4972 // If the referent object has been forwarded (either copied |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4973 // 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
|
4974 // evacuation failure) then we need to update the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4975 // field and, if both reference and referent are in the G1 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4976 // heap, update the RSet for the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4977 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4978 // 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
|
4979 // it alive by policy. Therefore we have copy the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4980 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4981 // 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
|
4982 // on the PSS queue. When the queue is drained (after each |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4983 // phase of reference processing) the object and it's followers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4984 // will be copied, the reference field set to point to the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4985 // new location, and the RSet updated. Otherwise we need to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4986 // use the the non-heap or perm closures directly to copy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4987 // the refernt object and update the pointer, while avoiding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4988 // updating the RSet. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4989 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4990 if (_g1h->is_in_g1_reserved(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4991 _par_scan_state->push_on_queue(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4992 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4993 // The reference field is not in the G1 heap. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4994 if (_g1h->perm_gen()->is_in(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4995 _copy_perm_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4996 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4997 _copy_non_heap_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4998 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4999 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5000 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5001 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5002 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5003 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5004 // Serial drain queue closure. Called as the 'complete_gc' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5005 // closure for each discovered list in some of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5006 // reference processing phases. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5007 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5008 class G1STWDrainQueueClosure: public VoidClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5009 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5010 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5011 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5012 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5013 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } |
|
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 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5016 G1STWDrainQueueClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5017 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5018 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5019 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5020 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5021 void do_void() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5022 G1ParScanThreadState* const pss = par_scan_state(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5023 pss->trim_queue(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5024 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5025 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5026 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5027 // Parallel Reference Processing closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5028 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5029 // Implementation of AbstractRefProcTaskExecutor for parallel reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5030 // processing during G1 evacuation pauses. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5031 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5032 class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5033 private: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5034 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5035 RefToScanQueueSet* _queues; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5036 FlexibleWorkGang* _workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5037 int _active_workers; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5038 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5039 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5040 G1STWRefProcTaskExecutor(G1CollectedHeap* g1h, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5041 FlexibleWorkGang* workers, |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5042 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5043 int n_workers) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5044 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5045 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5046 _workers(workers), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5047 _active_workers(n_workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5048 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5049 assert(n_workers > 0, "shouldn't call this otherwise"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5050 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5051 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5052 // Executes the given task using concurrent marking worker threads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5053 virtual void execute(ProcessTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5054 virtual void execute(EnqueueTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5055 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5056 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5057 // Gang task for possibly parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5058 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5059 class G1STWRefProcTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5060 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5061 ProcessTask& _proc_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5062 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5063 RefToScanQueueSet *_task_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5064 ParallelTaskTerminator* _terminator; |
|
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 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5067 G1STWRefProcTaskProxy(ProcessTask& proc_task, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5068 G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5069 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5070 ParallelTaskTerminator* terminator) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5071 AbstractGangTask("Process reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5072 _proc_task(proc_task), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5073 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5074 _task_queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5075 _terminator(terminator) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5076 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5077 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5078 virtual void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5079 // The reference processing task executed by a single worker. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5080 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5081 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5082 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5083 G1STWIsAliveClosure is_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5084 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5085 G1ParScanThreadState pss(_g1h, worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5086 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5087 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5088 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5089 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5090 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5091 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5092 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5093 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5094 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5095 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5096 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
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 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5099 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5100 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5101 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5102 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5103 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5104 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5105 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5106 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5107 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5108 } |
|
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 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5111 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
|
5112 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5113 // Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5114 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator); |
|
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 // Call the reference processing task's work routine. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5117 _proc_task.work(worker_id, is_alive, keep_alive, drain_queue); |
|
3979
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 // 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
|
5120 // of the processing tasks (specifically phase2 - pp2_work) execute |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5121 // the complete_gc closure (which ordinarily would drain the queue) so |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5122 // the queue may not be empty. |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5126 // Driver routine for parallel reference processing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5127 // Creates an instance of the ref processing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5128 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5129 void G1STWRefProcTaskExecutor::execute(ProcessTask& proc_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5130 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5131 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5132 ParallelTaskTerminator terminator(_active_workers, _queues); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5133 G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5134 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5135 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5136 _workers->run_task(&proc_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5137 _g1h->set_par_threads(0); |
|
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 // Gang task for parallel reference enqueueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5141 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5142 class G1STWRefEnqueueTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5143 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5144 EnqueueTask& _enq_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5145 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5146 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5147 G1STWRefEnqueueTaskProxy(EnqueueTask& enq_task) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5148 AbstractGangTask("Enqueue reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5149 _enq_task(enq_task) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5150 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5151 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5152 virtual void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5153 _enq_task.work(worker_id); |
|
3979
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 }; |
|
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 // Driver routine for parallel reference enqueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5158 // Creates an instance of the ref enqueueing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5159 // task and has the worker threads execute it. |
|
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 void G1STWRefProcTaskExecutor::execute(EnqueueTask& enq_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5162 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5163 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5164 G1STWRefEnqueueTaskProxy enq_task_proxy(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 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5167 _workers->run_task(&enq_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5168 _g1h->set_par_threads(0); |
|
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 // End of weak reference support closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5172 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5173 // Abstract task used to preserve (i.e. copy) any referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5174 // 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
|
5175 // objects discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5176 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5177 class G1ParPreserveCMReferentsTask: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5178 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5179 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5180 RefToScanQueueSet *_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5181 ParallelTaskTerminator _terminator; |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5182 uint _n_workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5183 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5184 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5185 G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5186 AbstractGangTask("ParPreserveCMReferents"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5187 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5188 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5189 _terminator(workers, _queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5190 _n_workers(workers) |
|
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 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5193 void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5194 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5195 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5196 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5197 G1ParScanThreadState pss(_g1h, worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5198 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5199 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5200 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5201 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5202 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5203 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5204 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5205 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5206 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
|
5207 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5208 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5209 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5210 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
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 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5213 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5214 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5215 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5216 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5217 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5218 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5219 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5220 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5221 copy_perm_cl = ©_mark_perm_cl; |
|
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 // Is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5225 G1AlwaysAliveClosure always_alive(_g1h); |
|
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 // Copying keep alive closure. Applied to referent objects that need |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5228 // to be copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5229 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
|
5230 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5231 ReferenceProcessor* rp = _g1h->ref_processor_cm(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5232 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5233 uint limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q(); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5234 uint stride = MIN2(MAX2(_n_workers, 1U), limit); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5235 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5236 // 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
|
5237 // 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
|
5238 // change the worker ids. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5239 assert(0 <= worker_id && worker_id < limit, "sanity"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5240 assert(!rp->discovery_is_atomic(), "check this code"); |
|
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 // Select discovered lists [i, i+stride, i+2*stride,...,limit) |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5243 for (uint idx = worker_id; idx < limit; idx += stride) { |
|
4014
bf2d2b8b1726
7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents:
4013
diff
changeset
|
5244 DiscoveredList& ref_list = rp->discovered_refs()[idx]; |
|
3979
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 DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5247 while (iter.has_next()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5248 // Since discovery is not atomic for the CM ref processor, we |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5249 // can see some null referent objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5250 iter.load_ptrs(DEBUG_ONLY(true)); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5251 oop ref = iter.obj(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5252 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5253 // This will filter nulls. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5254 if (iter.is_referent_alive()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5255 iter.make_referent_alive(); |
|
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 iter.move_to_next(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5258 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5259 } |
|
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 // Drain the queue - which may cause stealing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5262 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5263 drain_queue.do_void(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5264 // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5265 assert(pss.refs()->is_empty(), "should be"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5266 } |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5269 // Weak Reference processing during an evacuation pause (part 1). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5270 void G1CollectedHeap::process_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5271 double ref_proc_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5272 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5273 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5274 assert(rp->discovery_enabled(), "should have been enabled"); |
|
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 // Any reference objects, in the collection set, that were 'discovered' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5277 // 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
|
5278 // applying the external root copy closure to the discovered lists, or |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5279 // by following an RSet entry). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5280 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5281 // 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
|
5282 // 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
|
5283 // processor would have seen that the reference object had already |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5284 // been 'discovered' and would have skipped discovering the reference, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5285 // 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
|
5286 // 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
|
5287 // referent object. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5288 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5289 // We need to explicitly copy these referent objects - the references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5290 // will be processed at the end of remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5291 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5292 // 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
|
5293 // 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
|
5294 // referents points to another object which is also referenced by an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5295 // object discovered by the STW ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5296 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5297 uint active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5298 workers()->active_workers() : 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5299 |
| 4711 | 5300 assert(!G1CollectedHeap::use_parallel_gc_threads() || |
| 5301 active_workers == workers()->active_workers(), | |
| 5302 "Need to reset active_workers"); | |
| 5303 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5304 set_par_threads(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5305 G1ParPreserveCMReferentsTask keep_cm_referents(this, active_workers, _task_queues); |
|
3979
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 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5308 workers()->run_task(&keep_cm_referents); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5309 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5310 keep_cm_referents.work(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5311 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5312 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5313 set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5314 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5315 // Closure to test whether a referent is alive. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5316 G1STWIsAliveClosure is_alive(this); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5317 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5318 // Even when parallel reference processing is enabled, the processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5319 // 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
|
5320 // 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
|
5321 // JNI refs. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5322 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5323 // Use only a single queue for this PSS. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5324 G1ParScanThreadState pss(this, 0); |
|
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 // We do not embed a reference processor in the copying/scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5327 // closures while we're actually processing the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5328 // reference objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5329 G1ParScanHeapEvacClosure scan_evac_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5330 G1ParScanHeapEvacFailureClosure evac_failure_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5331 G1ParScanPartialArrayClosure partial_scan_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5332 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5333 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5334 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5335 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5336 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5337 assert(pss.refs()->is_empty(), "pre-condition"); |
|
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 G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5340 G1ParScanPermClosure only_copy_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5341 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5342 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5343 G1ParScanAndMarkPermClosure copy_mark_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5344 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5345 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5346 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5347 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5348 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5349 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5350 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5351 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5352 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5353 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5354 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5355 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
|
5356 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5357 // Serial Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5358 G1STWDrainQueueClosure drain_queue(this, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5359 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5360 // Setup the soft refs policy... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5361 rp->setup_policy(false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5362 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5363 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5364 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5365 rp->process_discovered_references(&is_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5366 &keep_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5367 &drain_queue, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5368 NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5369 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5370 // Parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5371 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5372 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5373 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5374 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5375 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
|
5376 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5377 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5378 // We have completed copying any necessary live referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5379 // (that were not copied during the actual pause) so we can |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5380 // retire any active alloc buffers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5381 pss.retire_alloc_buffers(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5382 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
|
5383 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5384 double ref_proc_time = os::elapsedTime() - ref_proc_start; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5385 g1_policy()->record_ref_proc_time(ref_proc_time * 1000.0); |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5388 // Weak Reference processing during an evacuation pause (part 2). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5389 void G1CollectedHeap::enqueue_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5390 double ref_enq_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5391 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5392 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5393 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
|
5394 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5395 // Now enqueue any remaining on the discovered lists on to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5396 // the pending list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5397 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5398 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5399 rp->enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5400 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5401 // Parallel reference enqueuing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5402 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5403 uint active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5404 assert(active_workers == workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5405 "Need to reset active_workers"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5406 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5407 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5408 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5409 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5410 rp->enqueue_discovered_references(&par_task_executor); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5411 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5412 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5413 rp->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5414 assert(!rp->discovery_enabled(), "should have been disabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5415 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5416 // FIXME |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5417 // 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
|
5418 // 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
|
5419 // and could signicantly increase the pause time. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5420 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5421 double ref_enq_time = os::elapsedTime() - ref_enq_start; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5422 g1_policy()->record_ref_enq_time(ref_enq_time * 1000.0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5423 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5424 |
| 342 | 5425 void G1CollectedHeap::evacuate_collection_set() { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
5426 _expand_heap_after_alloc_failure = true; |
| 342 | 5427 set_evacuation_failed(false); |
| 5428 | |
| 5429 g1_rem_set()->prepare_for_oops_into_collection_set_do(); | |
| 5430 concurrent_g1_refine()->set_use_cache(false); | |
| 889 | 5431 concurrent_g1_refine()->clear_hot_cache_claimed_index(); |
| 5432 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5433 uint n_workers; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5434 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5435 n_workers = |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5436 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5437 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5438 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5439 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5440 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5441 "If not dynamic should be using all the workers"); |
| 4711 | 5442 workers()->set_active_workers(n_workers); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5443 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5444 } else { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5445 assert(n_par_threads() == 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5446 "Should be the original non-parallel value"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5447 n_workers = 1; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5448 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5449 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5450 G1ParTask g1_par_task(this, _task_queues); |
| 342 | 5451 |
| 5452 init_for_evac_failure(NULL); | |
| 5453 | |
| 5454 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
|
5455 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5456 assert(dirty_card_queue_set().completed_buffers_num() == 0, "Should be empty"); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5457 double start_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5458 double end_par_time_sec; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5459 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5460 { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5461 StrongRootsScope srs(this); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5462 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5463 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5464 // The individual threads will set their evac-failure closures. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5465 if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5466 // These tasks use ShareHeap::_process_strong_tasks |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5467 assert(UseDynamicNumberOfGCThreads || |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5468 workers()->active_workers() == workers()->total_workers(), |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5469 "If not dynamic should be using all the workers"); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5470 workers()->run_task(&g1_par_task); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5471 } else { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5472 g1_par_task.set_for_termination(n_workers); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5473 g1_par_task.work(0); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5474 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5475 end_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5476 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5477 // Closing the inner scope will execute the destructor |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5478 // for the StrongRootsScope object. We record the current |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5479 // elapsed time before closing the scope so that time |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5480 // taken for the SRS destructor is NOT included in the |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5481 // reported parallel time. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5482 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5483 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5484 double par_time_ms = (end_par_time_sec - start_par_time_sec) * 1000.0; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5485 g1_policy()->record_par_time(par_time_ms); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5486 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5487 double code_root_fixup_time_ms = |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5488 (os::elapsedTime() - end_par_time_sec) * 1000.0; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5489 g1_policy()->record_code_root_fixup_time(code_root_fixup_time_ms); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5490 |
| 342 | 5491 set_par_threads(0); |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5492 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5493 // Process any discovered reference objects - we have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5494 // to do this _before_ we retire the GC alloc regions |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5495 // as we may have to copy some 'reachable' referent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5496 // objects (and their reachable sub-graphs) that were |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5497 // not copied during the pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5498 process_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5499 |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5500 // Weak root processing. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5501 // 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
|
5502 // 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
|
5503 // here too. |
| 342 | 5504 { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5505 G1STWIsAliveClosure is_alive(this); |
| 342 | 5506 G1KeepAliveClosure keep_alive(this); |
| 5507 JNIHandles::weak_oops_do(&is_alive, &keep_alive); | |
| 5508 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5509 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5510 release_gc_alloc_regions(); |
| 342 | 5511 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
|
5512 |
| 889 | 5513 concurrent_g1_refine()->clear_hot_cache(); |
| 342 | 5514 concurrent_g1_refine()->set_use_cache(true); |
| 5515 | |
| 5516 finalize_for_evac_failure(); | |
| 5517 | |
| 5518 if (evacuation_failed()) { | |
| 5519 remove_self_forwarding_pointers(); | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
5520 if (G1Log::finer()) { |
|
1719
b63010841f78
6975964: G1: print out a more descriptive message for evacuation failure when +PrintGCDetails is set
tonyp
parents:
1718
diff
changeset
|
5521 gclog_or_tty->print(" (to-space overflow)"); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
5522 } else if (G1Log::fine()) { |
| 342 | 5523 gclog_or_tty->print("--"); |
| 5524 } | |
| 5525 } | |
| 5526 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5527 // Enqueue any remaining references remaining on the STW |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5528 // reference processor's discovered lists. We need to do |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5529 // this after the card table is cleaned (and verified) as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5530 // the act of enqueuing entries on to the pending list |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5531 // will log these updates (and dirty their associated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5532 // cards). We need these updates logged to update any |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5533 // RSets. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5534 enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5535 |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5536 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5537 RedirtyLoggedCardTableEntryFastClosure redirty; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5538 dirty_card_queue_set().set_closure(&redirty); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5539 dirty_card_queue_set().apply_closure_to_all_completed_buffers(); |
| 1111 | 5540 |
| 5541 DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set(); | |
| 5542 dcq.merge_bufferlists(&dirty_card_queue_set()); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5543 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
|
5544 } |
| 342 | 5545 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
| 5546 } | |
| 5547 | |
| 2173 | 5548 void G1CollectedHeap::free_region_if_empty(HeapRegion* hr, |
| 2152 | 5549 size_t* pre_used, |
| 5550 FreeRegionList* free_list, | |
| 4072 | 5551 OldRegionSet* old_proxy_set, |
| 2152 | 5552 HumongousRegionSet* humongous_proxy_set, |
| 2173 | 5553 HRRSCleanupTask* hrrs_cleanup_task, |
| 2152 | 5554 bool par) { |
| 5555 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) { | |
| 5556 if (hr->isHumongous()) { | |
| 5557 assert(hr->startsHumongous(), "we should only see starts humongous"); | |
| 5558 free_humongous_region(hr, pre_used, free_list, humongous_proxy_set, par); | |
| 5559 } else { | |
| 4072 | 5560 _old_set.remove_with_proxy(hr, old_proxy_set); |
| 2152 | 5561 free_region(hr, pre_used, free_list, par); |
| 342 | 5562 } |
| 2173 | 5563 } else { |
| 5564 hr->rem_set()->do_cleanup_work(hrrs_cleanup_task); | |
| 342 | 5565 } |
| 5566 } | |
| 5567 | |
| 2152 | 5568 void G1CollectedHeap::free_region(HeapRegion* hr, |
| 5569 size_t* pre_used, | |
| 5570 FreeRegionList* free_list, | |
| 5571 bool par) { | |
| 5572 assert(!hr->isHumongous(), "this is only for non-humongous regions"); | |
| 5573 assert(!hr->is_empty(), "the region should not be empty"); | |
| 5574 assert(free_list != NULL, "pre-condition"); | |
| 5575 | |
| 5576 *pre_used += hr->used(); | |
| 5577 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
|
5578 free_list->add_as_head(hr); |
| 2152 | 5579 } |
| 5580 | |
| 5581 void G1CollectedHeap::free_humongous_region(HeapRegion* hr, | |
| 5582 size_t* pre_used, | |
| 5583 FreeRegionList* free_list, | |
| 5584 HumongousRegionSet* humongous_proxy_set, | |
| 5585 bool par) { | |
| 5586 assert(hr->startsHumongous(), "this is only for starts humongous regions"); | |
| 5587 assert(free_list != NULL, "pre-condition"); | |
| 5588 assert(humongous_proxy_set != NULL, "pre-condition"); | |
| 5589 | |
| 5590 size_t hr_used = hr->used(); | |
| 5591 size_t hr_capacity = hr->capacity(); | |
| 5592 size_t hr_pre_used = 0; | |
| 5593 _humongous_set.remove_with_proxy(hr, humongous_proxy_set); | |
| 5594 hr->set_notHumongous(); | |
| 5595 free_region(hr, &hr_pre_used, free_list, par); | |
| 5596 | |
| 3766 | 5597 size_t i = hr->hrs_index() + 1; |
| 2152 | 5598 size_t num = 1; |
| 3766 | 5599 while (i < n_regions()) { |
| 5600 HeapRegion* curr_hr = region_at(i); | |
| 2152 | 5601 if (!curr_hr->continuesHumongous()) { |
| 5602 break; | |
| 5603 } | |
| 5604 curr_hr->set_notHumongous(); | |
| 5605 free_region(curr_hr, &hr_pre_used, free_list, par); | |
| 5606 num += 1; | |
| 5607 i += 1; | |
| 5608 } | |
| 5609 assert(hr_pre_used == hr_used, | |
| 5610 err_msg("hr_pre_used: "SIZE_FORMAT" and hr_used: "SIZE_FORMAT" " | |
| 5611 "should be the same", hr_pre_used, hr_used)); | |
| 5612 *pre_used += hr_pre_used; | |
| 5613 } | |
| 5614 | |
| 5615 void G1CollectedHeap::update_sets_after_freeing_regions(size_t pre_used, | |
| 5616 FreeRegionList* free_list, | |
| 4072 | 5617 OldRegionSet* old_proxy_set, |
| 2152 | 5618 HumongousRegionSet* humongous_proxy_set, |
| 5619 bool par) { | |
| 5620 if (pre_used > 0) { | |
| 5621 Mutex* lock = (par) ? ParGCRareEvent_lock : NULL; | |
| 342 | 5622 MutexLockerEx x(lock, Mutex::_no_safepoint_check_flag); |
| 2152 | 5623 assert(_summary_bytes_used >= pre_used, |
| 5624 err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" " | |
| 5625 "should be >= pre_used: "SIZE_FORMAT, | |
| 5626 _summary_bytes_used, pre_used)); | |
| 342 | 5627 _summary_bytes_used -= pre_used; |
| 2152 | 5628 } |
| 5629 if (free_list != NULL && !free_list->is_empty()) { | |
| 5630 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
|
5631 _free_list.add_as_head(free_list); |
| 2152 | 5632 } |
| 4072 | 5633 if (old_proxy_set != NULL && !old_proxy_set->is_empty()) { |
| 5634 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5635 _old_set.update_from_proxy(old_proxy_set); | |
| 5636 } | |
| 2152 | 5637 if (humongous_proxy_set != NULL && !humongous_proxy_set->is_empty()) { |
| 5638 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5639 _humongous_set.update_from_proxy(humongous_proxy_set); | |
| 342 | 5640 } |
| 5641 } | |
| 5642 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5643 class G1ParCleanupCTTask : public AbstractGangTask { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5644 CardTableModRefBS* _ct_bs; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5645 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5646 HeapRegion* volatile _su_head; |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5647 public: |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5648 G1ParCleanupCTTask(CardTableModRefBS* ct_bs, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5649 G1CollectedHeap* g1h) : |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5650 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
|
5651 _ct_bs(ct_bs), _g1h(g1h) { } |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5652 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5653 void work(uint worker_id) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5654 HeapRegion* r; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5655 while (r = _g1h->pop_dirty_cards_region()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5656 clear_cards(r); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5657 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5658 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5659 |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5660 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
|
5661 // 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
|
5662 if (!r->is_survivor()) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5663 _ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5664 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5665 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5666 }; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5667 |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5668 #ifndef PRODUCT |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5669 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
|
5670 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5671 CardTableModRefBS* _ct_bs; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5672 public: |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5673 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
|
5674 : _g1h(g1h), _ct_bs(ct_bs) { } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5675 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
|
5676 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
|
5677 _g1h->verify_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5678 } else { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5679 _g1h->verify_not_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5680 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5681 return false; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5682 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5683 }; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5684 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5685 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
|
5686 // 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
|
5687 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
|
5688 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
|
5689 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
|
5690 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5691 |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5692 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
|
5693 // 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
|
5694 // 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
|
5695 // 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
|
5696 // 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
|
5697 // 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
|
5698 // 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
|
5699 // is dirty. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5700 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
|
5701 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
|
5702 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
|
5703 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5704 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5705 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
|
5706 CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5707 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
|
5708 verify_dirty_region(hr); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5709 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5710 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5711 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5712 void G1CollectedHeap::verify_dirty_young_regions() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5713 verify_dirty_young_list(_young_list->first_region()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5714 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
|
5715 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5716 #endif |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5717 |
| 342 | 5718 void G1CollectedHeap::cleanUpCardTable() { |
| 5719 CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set()); | |
| 5720 double start = os::elapsedTime(); | |
| 5721 | |
| 4023 | 5722 { |
| 5723 // Iterate over the dirty cards region list. | |
| 5724 G1ParCleanupCTTask cleanup_task(ct_bs, this); | |
| 5725 | |
| 4711 | 5726 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 5727 set_par_threads(); | |
| 4023 | 5728 workers()->run_task(&cleanup_task); |
| 5729 set_par_threads(0); | |
| 5730 } else { | |
| 5731 while (_dirty_cards_region_list) { | |
| 5732 HeapRegion* r = _dirty_cards_region_list; | |
| 5733 cleanup_task.clear_cards(r); | |
| 5734 _dirty_cards_region_list = r->get_next_dirty_cards_region(); | |
| 5735 if (_dirty_cards_region_list == r) { | |
| 5736 // The last region. | |
| 5737 _dirty_cards_region_list = NULL; | |
| 5738 } | |
| 5739 r->set_next_dirty_cards_region(NULL); | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5740 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5741 } |
| 4023 | 5742 #ifndef PRODUCT |
| 5743 if (G1VerifyCTCleanup || VerifyAfterGC) { | |
| 5744 G1VerifyCardTableCleanup cleanup_verifier(this, ct_bs); | |
| 5745 heap_region_iterate(&cleanup_verifier); | |
| 5746 } | |
| 5747 #endif | |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5748 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5749 |
| 342 | 5750 double elapsed = os::elapsedTime() - start; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5751 g1_policy()->record_clear_ct_time(elapsed * 1000.0); |
| 342 | 5752 } |
| 5753 | |
| 5754 void G1CollectedHeap::free_collection_set(HeapRegion* cs_head) { | |
| 2152 | 5755 size_t pre_used = 0; |
| 5756 FreeRegionList local_free_list("Local List for CSet Freeing"); | |
| 5757 | |
| 342 | 5758 double young_time_ms = 0.0; |
| 5759 double non_young_time_ms = 0.0; | |
| 5760 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5761 // 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
|
5762 // 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
|
5763 // 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
|
5764 _young_list->clear(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5765 |
| 342 | 5766 G1CollectorPolicy* policy = g1_policy(); |
| 5767 | |
| 5768 double start_sec = os::elapsedTime(); | |
| 5769 bool non_young = true; | |
| 5770 | |
| 5771 HeapRegion* cur = cs_head; | |
| 5772 int age_bound = -1; | |
| 5773 size_t rs_lengths = 0; | |
| 5774 | |
| 5775 while (cur != NULL) { | |
| 2361 | 5776 assert(!is_on_master_free_list(cur), "sanity"); |
| 342 | 5777 if (non_young) { |
| 5778 if (cur->is_young()) { | |
| 5779 double end_sec = os::elapsedTime(); | |
| 5780 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
| 5781 non_young_time_ms += elapsed_ms; | |
| 5782 | |
| 5783 start_sec = os::elapsedTime(); | |
| 5784 non_young = false; | |
| 5785 } | |
| 5786 } else { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5787 if (!cur->is_young()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5788 double end_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5789 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
|
5790 young_time_ms += elapsed_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5791 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5792 start_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5793 non_young = true; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5794 } |
| 342 | 5795 } |
| 5796 | |
| 5797 rs_lengths += cur->rem_set()->occupied(); | |
| 5798 | |
| 5799 HeapRegion* next = cur->next_in_collection_set(); | |
| 5800 assert(cur->in_collection_set(), "bad CS"); | |
| 5801 cur->set_next_in_collection_set(NULL); | |
| 5802 cur->set_in_collection_set(false); | |
| 5803 | |
| 5804 if (cur->is_young()) { | |
| 5805 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
|
5806 assert(index != -1, "invariant"); |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
5807 assert((size_t) index < policy->young_cset_region_length(), "invariant"); |
| 342 | 5808 size_t words_survived = _surviving_young_words[index]; |
| 5809 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
|
5810 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5811 // 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
|
5812 // (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
|
5813 // 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
|
5814 // _next_young_region field. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5815 cur->set_next_young_region(NULL); |
| 342 | 5816 } else { |
| 5817 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
|
5818 assert(index == -1, "invariant"); |
| 342 | 5819 } |
| 5820 | |
| 5821 assert( (cur->is_young() && cur->young_index_in_cset() > -1) || | |
| 5822 (!cur->is_young() && cur->young_index_in_cset() == -1), | |
| 5823 "invariant" ); | |
| 5824 | |
| 5825 if (!cur->evacuation_failed()) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5826 MemRegion used_mr = cur->used_region(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5827 |
| 342 | 5828 // And the region is empty. |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5829 assert(!used_mr.is_empty(), "Should not have empty regions in a CS."); |
| 2152 | 5830 free_region(cur, &pre_used, &local_free_list, false /* par */); |
| 342 | 5831 } else { |
| 5832 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
|
5833 if (cur->is_young()) { |
| 342 | 5834 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
|
5835 } |
| 342 | 5836 cur->set_not_young(); |
| 5837 cur->set_evacuation_failed(false); | |
| 4072 | 5838 // The region is now considered to be old. |
| 5839 _old_set.add(cur); | |
| 342 | 5840 } |
| 5841 cur = next; | |
| 5842 } | |
| 5843 | |
| 5844 policy->record_max_rs_lengths(rs_lengths); | |
| 5845 policy->cset_regions_freed(); | |
| 5846 | |
| 5847 double end_sec = os::elapsedTime(); | |
| 5848 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
|
5849 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5850 if (non_young) { |
| 342 | 5851 non_young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5852 } else { |
| 342 | 5853 young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5854 } |
| 342 | 5855 |
| 2152 | 5856 update_sets_after_freeing_regions(pre_used, &local_free_list, |
| 4072 | 5857 NULL /* old_proxy_set */, |
| 2152 | 5858 NULL /* humongous_proxy_set */, |
| 5859 false /* par */); | |
| 342 | 5860 policy->record_young_free_cset_time_ms(young_time_ms); |
| 5861 policy->record_non_young_free_cset_time_ms(non_young_time_ms); | |
| 5862 } | |
| 5863 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5864 // 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
|
5865 // 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
|
5866 // 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
|
5867 // 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
|
5868 // 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
|
5869 // 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
|
5870 // 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
|
5871 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5872 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
|
5873 HeapRegion* cur = cs_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5874 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5875 while (cur != NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5876 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
|
5877 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
|
5878 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
|
5879 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
|
5880 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
|
5881 cur = next; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5882 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5883 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5884 |
| 2152 | 5885 void G1CollectedHeap::set_free_regions_coming() { |
| 5886 if (G1ConcRegionFreeingVerbose) { | |
| 5887 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 5888 "setting free regions coming"); | |
| 5889 } | |
| 5890 | |
| 5891 assert(!free_regions_coming(), "pre-condition"); | |
| 5892 _free_regions_coming = true; | |
| 342 | 5893 } |
| 5894 | |
| 2152 | 5895 void G1CollectedHeap::reset_free_regions_coming() { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
5896 assert(free_regions_coming(), "pre-condition"); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
5897 |
| 2152 | 5898 { |
| 5899 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 5900 _free_regions_coming = false; | |
| 5901 SecondaryFreeList_lock->notify_all(); | |
| 5902 } | |
| 5903 | |
| 5904 if (G1ConcRegionFreeingVerbose) { | |
| 5905 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 5906 "reset free regions coming"); | |
| 342 | 5907 } |
| 5908 } | |
| 5909 | |
| 2152 | 5910 void G1CollectedHeap::wait_while_free_regions_coming() { |
| 5911 // Most of the time we won't have to wait, so let's do a quick test | |
| 5912 // first before we take the lock. | |
| 5913 if (!free_regions_coming()) { | |
| 5914 return; | |
| 5915 } | |
| 5916 | |
| 5917 if (G1ConcRegionFreeingVerbose) { | |
| 5918 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 5919 "waiting for free regions"); | |
| 342 | 5920 } |
| 5921 | |
| 5922 { | |
| 2152 | 5923 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 5924 while (free_regions_coming()) { | |
| 5925 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 342 | 5926 } |
| 2152 | 5927 } |
| 5928 | |
| 5929 if (G1ConcRegionFreeingVerbose) { | |
| 5930 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 5931 "done waiting for free regions"); | |
| 5932 } | |
| 342 | 5933 } |
| 5934 | |
| 5935 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) { | |
| 5936 assert(heap_lock_held_for_gc(), | |
| 5937 "the heap lock should already be held by or for this thread"); | |
| 5938 _young_list->push_region(hr); | |
| 5939 } | |
| 5940 | |
| 5941 class NoYoungRegionsClosure: public HeapRegionClosure { | |
| 5942 private: | |
| 5943 bool _success; | |
| 5944 public: | |
| 5945 NoYoungRegionsClosure() : _success(true) { } | |
| 5946 bool doHeapRegion(HeapRegion* r) { | |
| 5947 if (r->is_young()) { | |
| 5948 gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", | |
| 5949 r->bottom(), r->end()); | |
| 5950 _success = false; | |
| 5951 } | |
| 5952 return false; | |
| 5953 } | |
| 5954 bool success() { return _success; } | |
| 5955 }; | |
| 5956 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5957 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
|
5958 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
|
5959 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5960 if (check_heap) { |
| 342 | 5961 NoYoungRegionsClosure closure; |
| 5962 heap_region_iterate(&closure); | |
| 5963 ret = ret && closure.success(); | |
| 5964 } | |
| 5965 | |
| 5966 return ret; | |
| 5967 } | |
| 5968 | |
| 4072 | 5969 class TearDownRegionSetsClosure : public HeapRegionClosure { |
| 5970 private: | |
| 5971 OldRegionSet *_old_set; | |
| 2152 | 5972 |
| 342 | 5973 public: |
| 4072 | 5974 TearDownRegionSetsClosure(OldRegionSet* old_set) : _old_set(old_set) { } |
| 2152 | 5975 |
| 342 | 5976 bool doHeapRegion(HeapRegion* r) { |
| 4072 | 5977 if (r->is_empty()) { |
| 5978 // We ignore empty regions, we'll empty the free list afterwards | |
| 5979 } else if (r->is_young()) { | |
| 5980 // We ignore young regions, we'll empty the young list afterwards | |
| 5981 } else if (r->isHumongous()) { | |
| 5982 // We ignore humongous regions, we're not tearing down the | |
| 5983 // humongous region set | |
| 342 | 5984 } else { |
| 4072 | 5985 // The rest should be old |
| 5986 _old_set->remove(r); | |
| 342 | 5987 } |
| 5988 return false; | |
| 5989 } | |
| 5990 | |
| 4072 | 5991 ~TearDownRegionSetsClosure() { |
| 5992 assert(_old_set->is_empty(), "post-condition"); | |
| 2152 | 5993 } |
| 342 | 5994 }; |
| 5995 | |
| 4072 | 5996 void G1CollectedHeap::tear_down_region_sets(bool free_list_only) { |
| 5997 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 5998 | |
| 5999 if (!free_list_only) { | |
| 6000 TearDownRegionSetsClosure cl(&_old_set); | |
| 6001 heap_region_iterate(&cl); | |
| 6002 | |
| 6003 // Need to do this after the heap iteration to be able to | |
| 6004 // recognize the young regions and ignore them during the iteration. | |
| 6005 _young_list->empty_list(); | |
| 6006 } | |
| 6007 _free_list.remove_all(); | |
| 6008 } | |
| 6009 | |
| 6010 class RebuildRegionSetsClosure : public HeapRegionClosure { | |
| 6011 private: | |
| 6012 bool _free_list_only; | |
| 6013 OldRegionSet* _old_set; | |
| 6014 FreeRegionList* _free_list; | |
| 6015 size_t _total_used; | |
| 6016 | |
| 6017 public: | |
| 6018 RebuildRegionSetsClosure(bool free_list_only, | |
| 6019 OldRegionSet* old_set, FreeRegionList* free_list) : | |
| 6020 _free_list_only(free_list_only), | |
| 6021 _old_set(old_set), _free_list(free_list), _total_used(0) { | |
| 6022 assert(_free_list->is_empty(), "pre-condition"); | |
| 6023 if (!free_list_only) { | |
| 6024 assert(_old_set->is_empty(), "pre-condition"); | |
| 6025 } | |
| 6026 } | |
| 6027 | |
| 6028 bool doHeapRegion(HeapRegion* r) { | |
| 6029 if (r->continuesHumongous()) { | |
| 6030 return false; | |
| 6031 } | |
| 6032 | |
| 6033 if (r->is_empty()) { | |
| 6034 // Add free regions to the free list | |
| 6035 _free_list->add_as_tail(r); | |
| 6036 } else if (!_free_list_only) { | |
| 6037 assert(!r->is_young(), "we should not come across young regions"); | |
| 6038 | |
| 6039 if (r->isHumongous()) { | |
| 6040 // We ignore humongous regions, we left the humongous set unchanged | |
| 6041 } else { | |
| 6042 // The rest should be old, add them to the old set | |
| 6043 _old_set->add(r); | |
| 6044 } | |
| 6045 _total_used += r->used(); | |
| 6046 } | |
| 6047 | |
| 6048 return false; | |
| 6049 } | |
| 6050 | |
| 6051 size_t total_used() { | |
| 6052 return _total_used; | |
| 6053 } | |
| 6054 }; | |
| 6055 | |
| 6056 void G1CollectedHeap::rebuild_region_sets(bool free_list_only) { | |
| 6057 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6058 | |
| 6059 RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list); | |
| 6060 heap_region_iterate(&cl); | |
| 6061 | |
| 6062 if (!free_list_only) { | |
| 6063 _summary_bytes_used = cl.total_used(); | |
| 6064 } | |
| 6065 assert(_summary_bytes_used == recalculate_used(), | |
| 6066 err_msg("inconsistent _summary_bytes_used, " | |
| 6067 "value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, | |
| 6068 _summary_bytes_used, recalculate_used())); | |
| 342 | 6069 } |
| 6070 | |
| 6071 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) { | |
| 6072 _refine_cte_cl->set_concurrent(concurrent); | |
| 6073 } | |
| 6074 | |
| 6075 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { | |
| 6076 HeapRegion* hr = heap_region_containing(p); | |
| 6077 if (hr == NULL) { | |
| 6078 return is_in_permanent(p); | |
| 6079 } else { | |
| 6080 return hr->is_in(p); | |
| 6081 } | |
| 6082 } | |
| 2152 | 6083 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6084 // 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
|
6085 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6086 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
|
6087 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6088 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
|
6089 assert(!force || g1_policy()->can_expand_young_list(), |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6090 "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
|
6091 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
|
6092 if (force || !young_list_full) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6093 HeapRegion* new_alloc_region = new_region(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6094 false /* do_expand */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6095 if (new_alloc_region != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6096 set_region_short_lived_locked(new_alloc_region); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6097 _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
|
6098 return new_alloc_region; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6099 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6100 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6101 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6102 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6103 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6104 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
|
6105 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6106 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
|
6107 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
|
6108 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6109 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
|
6110 _summary_bytes_used += allocated_bytes; |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6111 _hr_printer.retire(alloc_region); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6112 // 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
|
6113 // 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
|
6114 // used space has been recored in _summary_bytes_used. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6115 g1mm()->update_eden_size(); |
|
2433
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 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6118 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
|
6119 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6120 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
|
6121 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6122 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6123 void G1CollectedHeap::set_par_threads() { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6124 // 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
|
6125 // in the workgroup. |
| 4711 | 6126 assert(G1CollectedHeap::use_parallel_gc_threads(), "shouldn't be here otherwise"); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
6127 uint n_workers = workers()->active_workers(); |
| 4711 | 6128 assert(UseDynamicNumberOfGCThreads || |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6129 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6130 "Otherwise should be using the total number of workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6131 if (n_workers == 0) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6132 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
|
6133 n_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6134 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6135 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6136 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6137 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6138 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6139 void MutatorAllocRegion::retire_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6140 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6141 _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
|
6142 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6143 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6144 // 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
|
6145 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6146 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
|
6147 size_t count, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6148 GCAllocPurpose ap) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6149 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
|
6150 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6151 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
|
6152 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
|
6153 true /* do_expand */); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6154 if (new_alloc_region != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6155 // 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
|
6156 // 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
|
6157 // for survivors too. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6158 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
|
6159 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6160 new_alloc_region->set_survivor(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6161 _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
|
6162 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6163 _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
|
6164 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6165 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6166 new_alloc_region->note_start_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6167 return new_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6168 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6169 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
|
6170 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6171 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6172 return NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6173 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6174 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6175 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
|
6176 size_t allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6177 GCAllocPurpose ap) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6178 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6179 alloc_region->note_end_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6180 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
|
6181 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6182 young_list()->add_survivor_region(alloc_region); |
| 4072 | 6183 } else { |
| 6184 _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
|
6185 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6186 _hr_printer.retire(alloc_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6187 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6188 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6189 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
|
6190 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6191 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
|
6192 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
|
6193 } |
|
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 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
|
6196 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6197 _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
|
6198 GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6199 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6200 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6201 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
|
6202 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6203 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
|
6204 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
|
6205 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6206 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6207 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
|
6208 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6209 _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
|
6210 GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6211 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6212 // Heap region set verification |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6213 |
| 2152 | 6214 class VerifyRegionListsClosure : public HeapRegionClosure { |
| 6215 private: | |
| 4072 | 6216 FreeRegionList* _free_list; |
| 6217 OldRegionSet* _old_set; | |
| 2152 | 6218 HumongousRegionSet* _humongous_set; |
| 6219 size_t _region_count; | |
| 6220 | |
| 6221 public: | |
| 4072 | 6222 VerifyRegionListsClosure(OldRegionSet* old_set, |
| 6223 HumongousRegionSet* humongous_set, | |
| 2152 | 6224 FreeRegionList* free_list) : |
| 4072 | 6225 _old_set(old_set), _humongous_set(humongous_set), |
| 6226 _free_list(free_list), _region_count(0) { } | |
| 2152 | 6227 |
| 6228 size_t region_count() { return _region_count; } | |
| 6229 | |
| 6230 bool doHeapRegion(HeapRegion* hr) { | |
| 6231 _region_count += 1; | |
| 6232 | |
| 6233 if (hr->continuesHumongous()) { | |
| 6234 return false; | |
| 6235 } | |
| 6236 | |
| 6237 if (hr->is_young()) { | |
| 6238 // TODO | |
| 6239 } else if (hr->startsHumongous()) { | |
| 6240 _humongous_set->verify_next_region(hr); | |
| 6241 } else if (hr->is_empty()) { | |
| 6242 _free_list->verify_next_region(hr); | |
| 4072 | 6243 } else { |
| 6244 _old_set->verify_next_region(hr); | |
| 2152 | 6245 } |
| 6246 return false; | |
| 6247 } | |
| 6248 }; | |
| 6249 | |
| 3766 | 6250 HeapRegion* G1CollectedHeap::new_heap_region(size_t hrs_index, |
| 6251 HeapWord* bottom) { | |
| 6252 HeapWord* end = bottom + HeapRegion::GrainWords; | |
| 6253 MemRegion mr(bottom, end); | |
| 6254 assert(_g1_reserved.contains(mr), "invariant"); | |
| 6255 // This might return NULL if the allocation fails | |
| 6256 return new HeapRegion(hrs_index, _bot_shared, mr, true /* is_zeroed */); | |
| 6257 } | |
| 6258 | |
| 2152 | 6259 void G1CollectedHeap::verify_region_sets() { |
| 6260 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); | |
| 6261 | |
| 6262 // First, check the explicit lists. | |
| 6263 _free_list.verify(); | |
| 6264 { | |
| 6265 // Given that a concurrent operation might be adding regions to | |
| 6266 // the secondary free list we have to take the lock before | |
| 6267 // verifying it. | |
| 6268 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 6269 _secondary_free_list.verify(); | |
| 6270 } | |
| 4072 | 6271 _old_set.verify(); |
| 2152 | 6272 _humongous_set.verify(); |
| 6273 | |
| 6274 // If a concurrent region freeing operation is in progress it will | |
| 6275 // be difficult to correctly attributed any free regions we come | |
| 6276 // across to the correct free list given that they might belong to | |
| 6277 // one of several (free_list, secondary_free_list, any local lists, | |
| 6278 // etc.). So, if that's the case we will skip the rest of the | |
| 6279 // verification operation. Alternatively, waiting for the concurrent | |
| 6280 // operation to complete will have a non-trivial effect on the GC's | |
| 6281 // operation (no concurrent operation will last longer than the | |
| 6282 // interval between two calls to verification) and it might hide | |
| 6283 // any issues that we would like to catch during testing. | |
| 6284 if (free_regions_coming()) { | |
| 6285 return; | |
| 6286 } | |
| 6287 | |
| 2361 | 6288 // Make sure we append the secondary_free_list on the free_list so |
| 6289 // that all free regions we will come across can be safely | |
| 6290 // attributed to the free_list. | |
| 6291 append_secondary_free_list_if_not_empty_with_lock(); | |
| 2152 | 6292 |
| 6293 // Finally, make sure that the region accounting in the lists is | |
| 6294 // consistent with what we see in the heap. | |
| 4072 | 6295 _old_set.verify_start(); |
| 2152 | 6296 _humongous_set.verify_start(); |
| 6297 _free_list.verify_start(); | |
| 6298 | |
| 4072 | 6299 VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list); |
| 2152 | 6300 heap_region_iterate(&cl); |
| 6301 | |
| 4072 | 6302 _old_set.verify_end(); |
| 2152 | 6303 _humongous_set.verify_end(); |
| 6304 _free_list.verify_end(); | |
| 342 | 6305 } |