Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 6629:c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
Summary: Add the flags G1EvacuationFailureALot flag (and supporting flags) to force trigger evacuation failures. The support flags control how often to trigger an evacuation failure and during which types of evacuation pause. This functionality is analogous to that of PromotionFailureALot for the other collectors.
Reviewed-by: brutisso
| author | johnc |
|---|---|
| date | Tue, 28 Aug 2012 15:20:08 -0700 |
| parents | bb3f6194fedb |
| children | da91efe96a93 |
| 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" |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
36 #include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
37 #include "gc_implementation/g1/g1Log.hpp" |
| 1972 | 38 #include "gc_implementation/g1/g1MarkSweep.hpp" |
| 39 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
| 40 #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
|
41 #include "gc_implementation/g1/heapRegion.inline.hpp" |
| 1972 | 42 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
| 43 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 44 #include "gc_implementation/g1/vm_operations_g1.hpp" | |
| 45 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 46 #include "memory/gcLocker.inline.hpp" | |
| 47 #include "memory/genOopClosures.inline.hpp" | |
| 48 #include "memory/generationSpec.hpp" | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
49 #include "memory/referenceProcessor.hpp" |
| 1972 | 50 #include "oops/oop.inline.hpp" |
| 51 #include "oops/oop.pcgc.inline.hpp" | |
| 52 #include "runtime/aprofiler.hpp" | |
| 53 #include "runtime/vmThread.hpp" | |
| 342 | 54 |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
55 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
|
56 |
| 342 | 57 // turn it on so that the contents of the young list (scan-only / |
| 58 // to-be-collected) are printed at "strategic" points before / during | |
| 59 // / 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
|
60 #define YOUNG_LIST_VERBOSE 0 |
| 342 | 61 // CURRENT STATUS |
| 62 // This file is under construction. Search for "FIXME". | |
| 63 | |
| 64 // INVARIANTS/NOTES | |
| 65 // | |
| 66 // All allocation activity covered by the G1CollectedHeap interface is | |
| 1973 | 67 // serialized by acquiring the HeapLock. This happens in mem_allocate |
| 68 // and allocate_new_tlab, which are the "entry" points to the | |
| 69 // allocation code from the rest of the JVM. (Note that this does not | |
| 70 // apply to TLAB allocation, which is not part of this interface: it | |
| 71 // is done by clients of this interface.) | |
| 342 | 72 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
73 // Notes on implementation of parallelism in different tasks. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
74 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
75 // G1ParVerifyTask uses heap_region_par_iterate_chunked() for parallelism. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
76 // 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
|
77 // 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
|
78 // G1ParTask executes g1_process_strong_roots() -> |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
79 // SharedHeap::process_strong_roots() which calls eventuall to |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
80 // CardTableModRefBS::par_non_clean_card_iterate_work() which uses |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
81 // SequentialSubTasksDone. SharedHeap::process_strong_roots() also |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
82 // directly uses SubTasksDone (_process_strong_tasks field in SharedHeap). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
83 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
84 |
| 342 | 85 // Local to this file. |
| 86 | |
| 87 class RefineCardTableEntryClosure: public CardTableEntryClosure { | |
| 88 SuspendibleThreadSet* _sts; | |
| 89 G1RemSet* _g1rs; | |
| 90 ConcurrentG1Refine* _cg1r; | |
| 91 bool _concurrent; | |
| 92 public: | |
| 93 RefineCardTableEntryClosure(SuspendibleThreadSet* sts, | |
| 94 G1RemSet* g1rs, | |
| 95 ConcurrentG1Refine* cg1r) : | |
| 96 _sts(sts), _g1rs(g1rs), _cg1r(cg1r), _concurrent(true) | |
| 97 {} | |
| 98 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 1705 | 99 bool oops_into_cset = _g1rs->concurrentRefineOneCard(card_ptr, worker_i, false); |
| 100 // This path is executed by the concurrent refine or mutator threads, | |
| 101 // concurrently, and so we do not care if card_ptr contains references | |
| 102 // that point into the collection set. | |
| 103 assert(!oops_into_cset, "should be"); | |
| 104 | |
| 342 | 105 if (_concurrent && _sts->should_yield()) { |
| 106 // Caller will actually yield. | |
| 107 return false; | |
| 108 } | |
| 109 // Otherwise, we finished successfully; return true. | |
| 110 return true; | |
| 111 } | |
| 112 void set_concurrent(bool b) { _concurrent = b; } | |
| 113 }; | |
| 114 | |
| 115 | |
| 116 class ClearLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 117 int _calls; | |
| 118 G1CollectedHeap* _g1h; | |
| 119 CardTableModRefBS* _ctbs; | |
| 120 int _histo[256]; | |
| 121 public: | |
| 122 ClearLoggedCardTableEntryClosure() : | |
| 123 _calls(0) | |
| 124 { | |
| 125 _g1h = G1CollectedHeap::heap(); | |
| 126 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 127 for (int i = 0; i < 256; i++) _histo[i] = 0; | |
| 128 } | |
| 129 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 130 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 131 _calls++; | |
| 132 unsigned char* ujb = (unsigned char*)card_ptr; | |
| 133 int ind = (int)(*ujb); | |
| 134 _histo[ind]++; | |
| 135 *card_ptr = -1; | |
| 136 } | |
| 137 return true; | |
| 138 } | |
| 139 int calls() { return _calls; } | |
| 140 void print_histo() { | |
| 141 gclog_or_tty->print_cr("Card table value histogram:"); | |
| 142 for (int i = 0; i < 256; i++) { | |
| 143 if (_histo[i] != 0) { | |
| 144 gclog_or_tty->print_cr(" %d: %d", i, _histo[i]); | |
| 145 } | |
| 146 } | |
| 147 } | |
| 148 }; | |
| 149 | |
| 150 class RedirtyLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
| 151 int _calls; | |
| 152 G1CollectedHeap* _g1h; | |
| 153 CardTableModRefBS* _ctbs; | |
| 154 public: | |
| 155 RedirtyLoggedCardTableEntryClosure() : | |
| 156 _calls(0) | |
| 157 { | |
| 158 _g1h = G1CollectedHeap::heap(); | |
| 159 _ctbs = (CardTableModRefBS*)_g1h->barrier_set(); | |
| 160 } | |
| 161 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 162 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) { | |
| 163 _calls++; | |
| 164 *card_ptr = 0; | |
| 165 } | |
| 166 return true; | |
| 167 } | |
| 168 int calls() { return _calls; } | |
| 169 }; | |
| 170 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
171 class RedirtyLoggedCardTableEntryFastClosure : public CardTableEntryClosure { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
172 public: |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
173 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
|
174 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
175 return true; |
|
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 }; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
178 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
179 YoungList::YoungList(G1CollectedHeap* g1h) : |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
180 _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
|
181 _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
|
182 guarantee(check_list_empty(false), "just making sure..."); |
| 342 | 183 } |
| 184 | |
| 185 void YoungList::push_region(HeapRegion *hr) { | |
| 186 assert(!hr->is_young(), "should not already be young"); | |
| 187 assert(hr->get_next_young_region() == NULL, "cause it should!"); | |
| 188 | |
| 189 hr->set_next_young_region(_head); | |
| 190 _head = hr; | |
| 191 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
192 _g1h->g1_policy()->set_region_eden(hr, (int) _length); |
| 342 | 193 ++_length; |
| 194 } | |
| 195 | |
| 196 void YoungList::add_survivor_region(HeapRegion* hr) { | |
| 545 | 197 assert(hr->is_survivor(), "should be flagged as survivor region"); |
| 342 | 198 assert(hr->get_next_young_region() == NULL, "cause it should!"); |
| 199 | |
| 200 hr->set_next_young_region(_survivor_head); | |
| 201 if (_survivor_head == NULL) { | |
| 545 | 202 _survivor_tail = hr; |
| 342 | 203 } |
| 204 _survivor_head = hr; | |
| 205 ++_survivor_length; | |
| 206 } | |
| 207 | |
| 208 void YoungList::empty_list(HeapRegion* list) { | |
| 209 while (list != NULL) { | |
| 210 HeapRegion* next = list->get_next_young_region(); | |
| 211 list->set_next_young_region(NULL); | |
| 212 list->uninstall_surv_rate_group(); | |
| 213 list->set_not_young(); | |
| 214 list = next; | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 void YoungList::empty_list() { | |
| 219 assert(check_list_well_formed(), "young list should be well formed"); | |
| 220 | |
| 221 empty_list(_head); | |
| 222 _head = NULL; | |
| 223 _length = 0; | |
| 224 | |
| 225 empty_list(_survivor_head); | |
| 226 _survivor_head = NULL; | |
| 545 | 227 _survivor_tail = NULL; |
| 342 | 228 _survivor_length = 0; |
| 229 | |
| 230 _last_sampled_rs_lengths = 0; | |
| 231 | |
| 232 assert(check_list_empty(false), "just making sure..."); | |
| 233 } | |
| 234 | |
| 235 bool YoungList::check_list_well_formed() { | |
| 236 bool ret = true; | |
| 237 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
238 uint length = 0; |
| 342 | 239 HeapRegion* curr = _head; |
| 240 HeapRegion* last = NULL; | |
| 241 while (curr != NULL) { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
242 if (!curr->is_young()) { |
| 342 | 243 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
|
244 "incorrectly tagged (y: %d, surv: %d)", |
| 342 | 245 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
|
246 curr->is_young(), curr->is_survivor()); |
| 342 | 247 ret = false; |
| 248 } | |
| 249 ++length; | |
| 250 last = curr; | |
| 251 curr = curr->get_next_young_region(); | |
| 252 } | |
| 253 ret = ret && (length == _length); | |
| 254 | |
| 255 if (!ret) { | |
| 256 gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!"); | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
257 gclog_or_tty->print_cr("### list has %u entries, _length is %u", |
| 342 | 258 length, _length); |
| 259 } | |
| 260 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
261 return ret; |
| 342 | 262 } |
| 263 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
264 bool YoungList::check_list_empty(bool check_sample) { |
| 342 | 265 bool ret = true; |
| 266 | |
| 267 if (_length != 0) { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
268 gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %u", |
| 342 | 269 _length); |
| 270 ret = false; | |
| 271 } | |
| 272 if (check_sample && _last_sampled_rs_lengths != 0) { | |
| 273 gclog_or_tty->print_cr("### YOUNG LIST has non-zero last sampled RS lengths"); | |
| 274 ret = false; | |
| 275 } | |
| 276 if (_head != NULL) { | |
| 277 gclog_or_tty->print_cr("### YOUNG LIST does not have a NULL head"); | |
| 278 ret = false; | |
| 279 } | |
| 280 if (!ret) { | |
| 281 gclog_or_tty->print_cr("### YOUNG LIST does not seem empty"); | |
| 282 } | |
| 283 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
284 return ret; |
| 342 | 285 } |
| 286 | |
| 287 void | |
| 288 YoungList::rs_length_sampling_init() { | |
| 289 _sampled_rs_lengths = 0; | |
| 290 _curr = _head; | |
| 291 } | |
| 292 | |
| 293 bool | |
| 294 YoungList::rs_length_sampling_more() { | |
| 295 return _curr != NULL; | |
| 296 } | |
| 297 | |
| 298 void | |
| 299 YoungList::rs_length_sampling_next() { | |
| 300 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
|
301 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
|
302 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
303 _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
|
304 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
305 // 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
|
306 // 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
|
307 // 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
|
308 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
|
309 // 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
|
310 _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
|
311 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
312 |
| 342 | 313 _curr = _curr->get_next_young_region(); |
| 314 if (_curr == NULL) { | |
| 315 _last_sampled_rs_lengths = _sampled_rs_lengths; | |
| 316 // gclog_or_tty->print_cr("last sampled RS lengths = %d", _last_sampled_rs_lengths); | |
| 317 } | |
| 318 } | |
| 319 | |
| 320 void | |
| 321 YoungList::reset_auxilary_lists() { | |
| 322 guarantee( is_empty(), "young list should be empty" ); | |
| 323 assert(check_list_well_formed(), "young list should be well formed"); | |
| 324 | |
| 325 // Add survivor regions to SurvRateGroup. | |
| 326 _g1h->g1_policy()->note_start_adding_survivor_regions(); | |
| 545 | 327 _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
|
328 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
329 int young_index_in_cset = 0; |
| 342 | 330 for (HeapRegion* curr = _survivor_head; |
| 331 curr != NULL; | |
| 332 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
|
333 _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
|
334 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
335 // 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
|
336 // 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
|
337 // pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
338 _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
|
339 young_index_in_cset += 1; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
340 } |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
341 assert((uint) young_index_in_cset == _survivor_length, "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) { | |
|
6027
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
372 gclog_or_tty->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", |
|
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
373 HR_FORMAT_PARAMS(curr), |
| 342 | 374 curr->prev_top_at_mark_start(), |
| 375 curr->next_top_at_mark_start(), | |
|
6027
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
376 curr->age_in_surv_rate_group_cond()); |
| 342 | 377 curr = curr->get_next_young_region(); |
| 378 } | |
| 379 } | |
| 380 | |
| 381 gclog_or_tty->print_cr(""); | |
| 382 } | |
| 383 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
384 void G1CollectedHeap::push_dirty_cards_region(HeapRegion* hr) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
385 { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
386 // 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
|
387 // by installing a self pointer. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
388 HeapRegion* next = hr->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
389 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
390 HeapRegion* res = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
391 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
|
392 NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
393 if (res == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
394 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
395 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
396 // Put the region to the dirty cards region list. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
397 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
398 next = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
399 Atomic::cmpxchg_ptr(hr, &_dirty_cards_region_list, head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
400 if (next == head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
401 assert(hr->get_next_dirty_cards_region() == hr, |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
402 "hr->get_next_dirty_cards_region() != hr"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
403 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
404 // The last region in the list points to itself. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
405 hr->set_next_dirty_cards_region(hr); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
406 } else { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
407 hr->set_next_dirty_cards_region(next); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
408 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
409 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
410 } while (next != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
411 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
412 } |
|
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 HeapRegion* G1CollectedHeap::pop_dirty_cards_region() |
|
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 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
418 HeapRegion* hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
419 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
420 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
421 if (head == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
422 return NULL; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
423 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
424 HeapRegion* new_head = head->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
425 if (head == new_head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
426 // The last region. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
427 new_head = 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 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
|
430 head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
431 } while (hr != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
432 assert(hr != NULL, "invariant"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
433 hr->set_next_dirty_cards_region(NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
434 return hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
435 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
436 |
| 342 | 437 void G1CollectedHeap::stop_conc_gc_threads() { |
| 794 | 438 _cg1r->stop(); |
| 342 | 439 _cmThread->stop(); |
| 440 } | |
| 441 | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
442 #ifdef ASSERT |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
443 // 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
|
444 // 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
|
445 // 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
|
446 // 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
|
447 // regions have been retired. It is used for debugging |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
448 // 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
|
449 // 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
|
450 // inaccurate, it is sufficient for G1 because the conservative |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
451 // implementation of is_scavengable() for G1 will indicate that |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
452 // all nmethods must be scanned during a partial collection. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
453 bool G1CollectedHeap::is_in_partial_collection(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
454 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
455 return hr != NULL && hr->in_collection_set(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
456 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
457 #endif |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
458 |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
459 // 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
|
460 // can move in an incremental collecction. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
461 bool G1CollectedHeap::is_scavengable(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
462 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
463 G1CollectorPolicy* g1p = g1h->g1_policy(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
464 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
465 if (hr == NULL) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
466 // perm gen (or null) |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
467 return false; |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
468 } else { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
469 return !hr->isHumongous(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
470 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
471 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
472 |
| 342 | 473 void G1CollectedHeap::check_ct_logs_at_safepoint() { |
| 474 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 475 CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set(); | |
| 476 | |
| 477 // Count the dirty cards at the start. | |
| 478 CountNonCleanMemRegionClosure count1(this); | |
| 479 ct_bs->mod_card_iterate(&count1); | |
| 480 int orig_count = count1.n(); | |
| 481 | |
| 482 // First clear the logged cards. | |
| 483 ClearLoggedCardTableEntryClosure clear; | |
| 484 dcqs.set_closure(&clear); | |
| 485 dcqs.apply_closure_to_all_completed_buffers(); | |
| 486 dcqs.iterate_closure_all_threads(false); | |
| 487 clear.print_histo(); | |
| 488 | |
| 489 // Now ensure that there's no dirty cards. | |
| 490 CountNonCleanMemRegionClosure count2(this); | |
| 491 ct_bs->mod_card_iterate(&count2); | |
| 492 if (count2.n() != 0) { | |
| 493 gclog_or_tty->print_cr("Card table has %d entries; %d originally", | |
| 494 count2.n(), orig_count); | |
| 495 } | |
| 496 guarantee(count2.n() == 0, "Card table should be clean."); | |
| 497 | |
| 498 RedirtyLoggedCardTableEntryClosure redirty; | |
| 499 JavaThread::dirty_card_queue_set().set_closure(&redirty); | |
| 500 dcqs.apply_closure_to_all_completed_buffers(); | |
| 501 dcqs.iterate_closure_all_threads(false); | |
| 502 gclog_or_tty->print_cr("Log entries = %d, dirty cards = %d.", | |
| 503 clear.calls(), orig_count); | |
| 504 guarantee(redirty.calls() == clear.calls(), | |
| 505 "Or else mechanism is broken."); | |
| 506 | |
| 507 CountNonCleanMemRegionClosure count3(this); | |
| 508 ct_bs->mod_card_iterate(&count3); | |
| 509 if (count3.n() != orig_count) { | |
| 510 gclog_or_tty->print_cr("Should have restored them all: orig = %d, final = %d.", | |
| 511 orig_count, count3.n()); | |
| 512 guarantee(count3.n() >= orig_count, "Should have restored them all."); | |
| 513 } | |
| 514 | |
| 515 JavaThread::dirty_card_queue_set().set_closure(_refine_cte_cl); | |
| 516 } | |
| 517 | |
| 518 // Private class members. | |
| 519 | |
| 520 G1CollectedHeap* G1CollectedHeap::_g1h; | |
| 521 | |
| 522 // Private methods. | |
| 523 | |
| 2152 | 524 HeapRegion* |
| 2361 | 525 G1CollectedHeap::new_region_try_secondary_free_list() { |
| 2152 | 526 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 527 while (!_secondary_free_list.is_empty() || free_regions_coming()) { | |
| 528 if (!_secondary_free_list.is_empty()) { | |
| 529 if (G1ConcRegionFreeingVerbose) { | |
| 530 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
531 "secondary_free_list has %u entries", |
| 2152 | 532 _secondary_free_list.length()); |
| 533 } | |
| 534 // It looks as if there are free regions available on the | |
| 535 // secondary_free_list. Let's move them to the free_list and try | |
| 536 // again to allocate from it. | |
| 537 append_secondary_free_list(); | |
| 538 | |
| 539 assert(!_free_list.is_empty(), "if the secondary_free_list was not " | |
| 540 "empty we should have moved at least one entry to the free_list"); | |
| 541 HeapRegion* res = _free_list.remove_head(); | |
| 542 if (G1ConcRegionFreeingVerbose) { | |
| 543 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 544 "allocated "HR_FORMAT" from secondary_free_list", | |
| 545 HR_FORMAT_PARAMS(res)); | |
| 546 } | |
| 547 return res; | |
| 548 } | |
| 549 | |
| 550 // Wait here until we get notifed either when (a) there are no | |
| 551 // more free regions coming or (b) some regions have been moved on | |
| 552 // the secondary_free_list. | |
| 553 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 554 } | |
| 555 | |
| 556 if (G1ConcRegionFreeingVerbose) { | |
| 557 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 558 "could not allocate from secondary_free_list"); | |
| 559 } | |
| 560 return NULL; | |
| 561 } | |
| 562 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
563 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
|
564 assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords, |
| 2152 | 565 "the only time we use this to allocate a humongous region is " |
| 566 "when we are allocating a single humongous region"); | |
| 567 | |
| 568 HeapRegion* res; | |
| 569 if (G1StressConcRegionFreeing) { | |
| 570 if (!_secondary_free_list.is_empty()) { | |
| 571 if (G1ConcRegionFreeingVerbose) { | |
| 572 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 573 "forced to look at the secondary_free_list"); | |
| 574 } | |
| 2361 | 575 res = new_region_try_secondary_free_list(); |
| 2152 | 576 if (res != NULL) { |
| 577 return res; | |
| 578 } | |
| 579 } | |
| 580 } | |
| 581 res = _free_list.remove_head_or_null(); | |
| 582 if (res == NULL) { | |
| 583 if (G1ConcRegionFreeingVerbose) { | |
| 584 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 585 "res == NULL, trying the secondary_free_list"); | |
| 586 } | |
| 2361 | 587 res = new_region_try_secondary_free_list(); |
| 2152 | 588 } |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
589 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
|
590 // 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
|
591 // 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
|
592 // 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
|
593 // 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
|
594 assert(SafepointSynchronize::is_at_safepoint(), "invariant"); |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
595 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
596 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
597 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
598 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
|
599 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
600 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
601 if (expand(word_size * HeapWordSize)) { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
602 // 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
|
603 // 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
|
604 // 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
|
605 // 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
|
606 // 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
|
607 // 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
|
608 // use remove_head_or_null(). |
| 3766 | 609 res = _free_list.remove_head_or_null(); |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
610 } else { |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
611 _expand_heap_after_alloc_failure = false; |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
612 } |
| 342 | 613 } |
| 614 return res; | |
| 615 } | |
| 616 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
617 uint G1CollectedHeap::humongous_obj_allocate_find_first(uint num_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
618 size_t word_size) { |
| 2361 | 619 assert(isHumongous(word_size), "word_size should be humongous"); |
| 620 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 621 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
622 uint first = G1_NULL_HRS_INDEX; |
| 2152 | 623 if (num_regions == 1) { |
| 624 // Only one region to allocate, no need to go through the slower | |
| 625 // path. The caller will attempt the expasion if this fails, so | |
| 626 // 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
|
627 HeapRegion* hr = new_region(word_size, false /* do_expand */); |
| 2152 | 628 if (hr != NULL) { |
| 629 first = hr->hrs_index(); | |
| 630 } else { | |
| 3766 | 631 first = G1_NULL_HRS_INDEX; |
| 2152 | 632 } |
| 633 } else { | |
| 634 // We can't allocate humongous regions while cleanupComplete() is | |
| 635 // running, since some of the regions we find to be empty might not | |
| 636 // yet be added to the free list and it is not straightforward to | |
| 637 // know which list they are on so that we can remove them. Note | |
| 638 // that we only need to do this if we need to allocate more than | |
| 639 // one region to satisfy the current humongous allocation | |
| 640 // request. If we are only allocating one region we use the common | |
| 641 // region allocation code (see above). | |
| 642 wait_while_free_regions_coming(); | |
| 2361 | 643 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 644 |
| 645 if (free_regions() >= num_regions) { | |
| 3766 | 646 first = _hrs.find_contiguous(num_regions); |
| 647 if (first != G1_NULL_HRS_INDEX) { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
648 for (uint i = first; i < first + num_regions; ++i) { |
| 3766 | 649 HeapRegion* hr = region_at(i); |
| 2152 | 650 assert(hr->is_empty(), "sanity"); |
| 2361 | 651 assert(is_on_master_free_list(hr), "sanity"); |
| 2152 | 652 hr->set_pending_removal(true); |
| 653 } | |
| 654 _free_list.remove_all_pending(num_regions); | |
| 655 } | |
| 656 } | |
| 657 } | |
| 658 return first; | |
| 659 } | |
| 660 | |
| 2361 | 661 HeapWord* |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
662 G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
663 uint num_regions, |
| 2361 | 664 size_t word_size) { |
| 3766 | 665 assert(first != G1_NULL_HRS_INDEX, "pre-condition"); |
| 2361 | 666 assert(isHumongous(word_size), "word_size should be humongous"); |
| 667 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 668 | |
| 669 // Index of last region in the series + 1. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
670 uint last = first + num_regions; |
| 2361 | 671 |
| 672 // We need to initialize the region(s) we just discovered. This is | |
| 673 // a bit tricky given that it can happen concurrently with | |
| 674 // refinement threads refining cards on these regions and | |
| 675 // potentially wanting to refine the BOT as they are scanning | |
| 676 // those cards (this can happen shortly after a cleanup; see CR | |
| 677 // 6991377). So we have to set up the region(s) carefully and in | |
| 678 // a specific order. | |
| 679 | |
| 680 // The word size sum of all the regions we will allocate. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
681 size_t word_size_sum = (size_t) num_regions * HeapRegion::GrainWords; |
| 2361 | 682 assert(word_size <= word_size_sum, "sanity"); |
| 683 | |
| 684 // This will be the "starts humongous" region. | |
| 3766 | 685 HeapRegion* first_hr = region_at(first); |
| 2361 | 686 // The header of the new object will be placed at the bottom of |
| 687 // the first region. | |
| 688 HeapWord* new_obj = first_hr->bottom(); | |
| 689 // This will be the new end of the first region in the series that | |
| 690 // should also match the end of the last region in the seriers. | |
| 691 HeapWord* new_end = new_obj + word_size_sum; | |
| 692 // This will be the new top of the first region that will reflect | |
| 693 // this allocation. | |
| 694 HeapWord* new_top = new_obj + word_size; | |
| 695 | |
| 696 // First, we need to zero the header of the space that we will be | |
| 697 // allocating. When we update top further down, some refinement | |
| 698 // threads might try to scan the region. By zeroing the header we | |
| 699 // ensure that any thread that will try to scan the region will | |
| 700 // come across the zero klass word and bail out. | |
| 701 // | |
| 702 // NOTE: It would not have been correct to have used | |
| 703 // CollectedHeap::fill_with_object() and make the space look like | |
| 704 // an int array. The thread that is doing the allocation will | |
| 705 // later update the object header to a potentially different array | |
| 706 // type and, for a very short period of time, the klass and length | |
| 707 // fields will be inconsistent. This could cause a refinement | |
| 708 // thread to calculate the object size incorrectly. | |
| 709 Copy::fill_to_words(new_obj, oopDesc::header_size(), 0); | |
| 710 | |
| 711 // We will set up the first region as "starts humongous". This | |
| 712 // will also update the BOT covering all the regions to reflect | |
| 713 // that there is a single object that starts at the bottom of the | |
| 714 // first region. | |
| 715 first_hr->set_startsHumongous(new_top, new_end); | |
| 716 | |
| 717 // Then, if there are any, we will set up the "continues | |
| 718 // humongous" regions. | |
| 719 HeapRegion* hr = NULL; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
720 for (uint i = first + 1; i < last; ++i) { |
| 3766 | 721 hr = region_at(i); |
| 2361 | 722 hr->set_continuesHumongous(first_hr); |
| 723 } | |
| 724 // If we have "continues humongous" regions (hr != NULL), then the | |
| 725 // end of the last one should match new_end. | |
| 726 assert(hr == NULL || hr->end() == new_end, "sanity"); | |
| 727 | |
| 728 // Up to this point no concurrent thread would have been able to | |
| 729 // do any scanning on any region in this series. All the top | |
| 730 // fields still point to bottom, so the intersection between | |
| 731 // [bottom,top] and [card_start,card_end] will be empty. Before we | |
| 732 // update the top fields, we'll do a storestore to make sure that | |
| 733 // no thread sees the update to top before the zeroing of the | |
| 734 // object header and the BOT initialization. | |
| 735 OrderAccess::storestore(); | |
| 736 | |
| 737 // Now that the BOT and the object header have been initialized, | |
| 738 // we can update top of the "starts humongous" region. | |
| 739 assert(first_hr->bottom() < new_top && new_top <= first_hr->end(), | |
| 740 "new_top should be in this region"); | |
| 741 first_hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
742 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
743 HeapWord* bottom = first_hr->bottom(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
744 HeapWord* end = first_hr->orig_end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
745 if ((first + 1) == last) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
746 // the series has a single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
747 _hr_printer.alloc(G1HRPrinter::SingleHumongous, first_hr, new_top); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
748 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
749 // the series has more than one humongous regions |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
750 _hr_printer.alloc(G1HRPrinter::StartsHumongous, first_hr, end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
751 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
752 } |
| 2361 | 753 |
| 754 // Now, we will update the top fields of the "continues humongous" | |
| 755 // regions. The reason we need to do this is that, otherwise, | |
| 756 // these regions would look empty and this will confuse parts of | |
| 757 // G1. For example, the code that looks for a consecutive number | |
| 758 // of empty regions will consider them empty and try to | |
| 759 // re-allocate them. We can extend is_empty() to also include | |
| 760 // !continuesHumongous(), but it is easier to just update the top | |
| 761 // fields here. The way we set top for all regions (i.e., top == | |
| 762 // end for all regions but the last one, top == new_top for the | |
| 763 // last one) is actually used when we will free up the humongous | |
| 764 // region in free_humongous_region(). | |
| 765 hr = NULL; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
766 for (uint i = first + 1; i < last; ++i) { |
| 3766 | 767 hr = region_at(i); |
| 2361 | 768 if ((i + 1) == last) { |
| 769 // last continues humongous region | |
| 770 assert(hr->bottom() < new_top && new_top <= hr->end(), | |
| 771 "new_top should fall on this region"); | |
| 772 hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
773 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, new_top); |
| 2361 | 774 } else { |
| 775 // not last one | |
| 776 assert(new_top > hr->end(), "new_top should be above this region"); | |
| 777 hr->set_top(hr->end()); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
778 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, hr->end()); |
| 2361 | 779 } |
| 780 } | |
| 781 // If we have continues humongous regions (hr != NULL), then the | |
| 782 // end of the last one should match new_end and its top should | |
| 783 // match new_top. | |
| 784 assert(hr == NULL || | |
| 785 (hr->end() == new_end && hr->top() == new_top), "sanity"); | |
| 786 | |
| 787 assert(first_hr->used() == word_size * HeapWordSize, "invariant"); | |
| 788 _summary_bytes_used += first_hr->used(); | |
| 789 _humongous_set.add(first_hr); | |
| 790 | |
| 791 return new_obj; | |
| 792 } | |
| 793 | |
| 342 | 794 // If could fit into free regions w/o expansion, try. |
| 795 // Otherwise, if can expand, do so. | |
| 796 // Otherwise, if using ex regions might help, try with ex given back. | |
| 1973 | 797 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) { |
| 2152 | 798 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
| 799 | |
| 800 verify_region_sets_optional(); | |
| 342 | 801 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
802 size_t word_size_rounded = round_to(word_size, HeapRegion::GrainWords); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
803 uint num_regions = (uint) (word_size_rounded / HeapRegion::GrainWords); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
804 uint x_num = expansion_regions(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
805 uint fs = _hrs.free_suffix(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
806 uint first = humongous_obj_allocate_find_first(num_regions, word_size); |
| 3766 | 807 if (first == G1_NULL_HRS_INDEX) { |
| 2152 | 808 // The only thing we can do now is attempt expansion. |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
809 if (fs + x_num >= num_regions) { |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
810 // 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
|
811 // 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
|
812 // 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
|
813 // should have succeeded and we wouldn't be here. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
814 // |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
815 // 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
|
816 // 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
|
817 // room available. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
818 assert(num_regions > fs, "earlier allocation should have succeeded"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
819 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
820 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
821 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
822 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
|
823 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
824 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
825 if (expand((num_regions - fs) * HeapRegion::GrainBytes)) { |
| 3766 | 826 // Even though the heap was expanded, it might not have |
| 827 // reached the desired size. So, we cannot assume that the | |
| 828 // allocation will succeed. | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
829 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
|
830 } |
| 2152 | 831 } |
| 832 } | |
| 833 | |
| 2361 | 834 HeapWord* result = NULL; |
| 3766 | 835 if (first != G1_NULL_HRS_INDEX) { |
| 2361 | 836 result = |
| 837 humongous_obj_allocate_initialize_regions(first, num_regions, word_size); | |
| 838 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
|
839 |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
840 // A successful humongous object allocation changes the used space |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
841 // 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
|
842 // sizes and update the jstat counters here. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
843 g1mm()->update_sizes(); |
| 2152 | 844 } |
| 845 | |
| 846 verify_region_sets_optional(); | |
| 2361 | 847 |
| 848 return result; | |
| 342 | 849 } |
| 850 | |
| 1973 | 851 HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) { |
| 852 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
|
853 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
|
854 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
855 unsigned int dummy_gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
856 return attempt_allocation(word_size, &dummy_gc_count_before); |
| 342 | 857 } |
| 858 | |
| 859 HeapWord* | |
| 860 G1CollectedHeap::mem_allocate(size_t word_size, | |
| 1973 | 861 bool* gc_overhead_limit_was_exceeded) { |
| 862 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 863 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
864 // Loop until the allocation is satisified, or unsatisfied after GC. |
| 1973 | 865 for (int try_count = 1; /* we'll return */; try_count += 1) { |
| 866 unsigned int gc_count_before; | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
867 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
868 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
869 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
870 result = attempt_allocation(word_size, &gc_count_before); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
871 } else { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
872 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
|
873 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
874 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
875 return result; |
| 342 | 876 } |
| 877 | |
| 878 // Create the garbage collection operation... | |
| 1973 | 879 VM_G1CollectForAllocation op(gc_count_before, word_size); |
| 342 | 880 // ...and get the VM thread to execute it. |
| 881 VMThread::execute(&op); | |
| 1973 | 882 |
| 883 if (op.prologue_succeeded() && op.pause_succeeded()) { | |
| 884 // If the operation was successful we'll return the result even | |
| 885 // if it is NULL. If the allocation attempt failed immediately | |
| 886 // after a Full GC, it's unlikely we'll be able to allocate now. | |
| 887 HeapWord* result = op.result(); | |
| 888 if (result != NULL && !isHumongous(word_size)) { | |
| 889 // Allocations that take place on VM operations do not do any | |
| 890 // card dirtying and we have to do it here. We only have to do | |
| 891 // this for non-humongous allocations, though. | |
| 892 dirty_young_block(result, word_size); | |
| 893 } | |
| 342 | 894 return result; |
| 1973 | 895 } else { |
| 896 assert(op.result() == NULL, | |
| 897 "the result should be NULL if the VM op did not succeed"); | |
| 342 | 898 } |
| 899 | |
| 900 // Give a warning if we seem to be looping forever. | |
| 901 if ((QueuedAllocationWarningCount > 0) && | |
| 902 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 1973 | 903 warning("G1CollectedHeap::mem_allocate retries %d times", try_count); |
| 342 | 904 } |
| 905 } | |
| 1973 | 906 |
| 907 ShouldNotReachHere(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
908 return NULL; |
| 342 | 909 } |
| 910 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
911 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
|
912 unsigned int *gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
913 // 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
|
914 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
915 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
916 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
|
917 "be called for humongous allocation requests"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
918 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
919 // 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
|
920 // (attempt_allocation()) failed to allocate. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
921 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
922 // 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
|
923 // 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
|
924 // 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
|
925 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
926 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
927 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
|
928 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
929 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
930 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
931 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
932 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
933 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
934 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
|
935 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
936 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
937 return result; |
|
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 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
940 // 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
|
941 // 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
|
942 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
|
943 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
944 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
945 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
|
946 // 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
|
947 // 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
|
948 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
|
949 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
950 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
951 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
952 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
953 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
954 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
955 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
956 // The GCLocker may not be active but the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
957 // GC may not yet have been performed (GCLocker::needs_gc() |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
958 // returns true). In this case we do not try this GC and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
959 // wait until the GCLocker initiated GC is performed, and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
960 // then retry the allocation. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
961 if (GC_locker::needs_gc()) { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
962 should_try_gc = false; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
963 } else { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
964 // Read the GC count while still holding the Heap_lock. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
965 gc_count_before = total_collections(); |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
966 should_try_gc = true; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
967 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
968 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
969 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
970 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
971 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
972 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
973 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
|
974 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
975 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
|
976 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
977 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
978 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
979 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
980 // 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
|
981 // 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
|
982 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
983 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
984 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
985 return NULL; |
|
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 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
988 // The GCLocker is either active or the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
989 // GC has not yet been performed. Stall until it is and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
990 // then retry the allocation. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
991 GC_locker::stall_until_clear(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
992 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
993 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
994 // 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
|
995 // 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
|
996 // 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
|
997 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
998 // 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
|
999 // 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
|
1000 // 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
|
1001 // iteration (after taking the Heap_lock). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1002 result = _mutator_alloc_region.attempt_allocation(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1003 false /* bot_updates */); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
1004 if (result != NULL) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1005 return result; |
|
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 // 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
|
1009 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1010 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1011 warning("G1CollectedHeap::attempt_allocation_slow() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1012 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1013 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1014 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1015 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1016 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1017 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1018 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1019 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1020 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
|
1021 unsigned int * gc_count_before_ret) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1022 // 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
|
1023 // 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
|
1024 // 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
|
1025 // 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
|
1026 // 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
|
1027 // 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
|
1028 // 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
|
1029 // 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
|
1030 // 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
|
1031 // much as possible. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1032 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1033 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1034 assert(isHumongous(word_size), "attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1035 "should only be called for humongous allocations"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1036 |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1037 // 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
|
1038 // 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
|
1039 // 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
|
1040 // 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
|
1041 // 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
|
1042 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
|
1043 word_size)) { |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1044 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
|
1045 } |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1046 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1047 // 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
|
1048 // 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
|
1049 // 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
|
1050 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1051 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1052 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
|
1053 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1054 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1055 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1056 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1057 MutexLockerEx x(Heap_lock); |
|
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 // 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
|
1060 // 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
|
1061 // 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
|
1062 result = humongous_obj_allocate(word_size); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1063 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1064 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1065 } |
|
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 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1068 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1069 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1070 // The GCLocker may not be active but the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1071 // GC may not yet have been performed (GCLocker::needs_gc() |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1072 // returns true). In this case we do not try this GC and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1073 // wait until the GCLocker initiated GC is performed, and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1074 // then retry the allocation. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1075 if (GC_locker::needs_gc()) { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1076 should_try_gc = false; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1077 } else { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1078 // Read the GC count while still holding the Heap_lock. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1079 gc_count_before = total_collections(); |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1080 should_try_gc = true; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1081 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1082 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1083 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1084 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1085 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1086 // 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
|
1087 // 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
|
1088 // 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
|
1089 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1090 bool succeeded; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1091 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
|
1092 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1093 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
|
1094 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1095 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1096 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1097 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1098 // 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
|
1099 // 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
|
1100 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1101 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1102 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1103 return NULL; |
|
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 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1106 // The GCLocker is either active or the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1107 // GC has not yet been performed. Stall until it is and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1108 // then retry the allocation. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1109 GC_locker::stall_until_clear(); |
|
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 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1112 // 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
|
1113 // 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
|
1114 // 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
|
1115 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1116 // 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
|
1117 // warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1118 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1119 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1120 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1121 warning("G1CollectedHeap::attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1122 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1123 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1124 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1125 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1126 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1127 return NULL; |
|
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 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1130 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
|
1131 bool expect_null_mutator_alloc_region) { |
| 2152 | 1132 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
|
1133 assert(_mutator_alloc_region.get() == NULL || |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1134 !expect_null_mutator_alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1135 "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
|
1136 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1137 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1138 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
|
1139 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1140 } else { |
|
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1141 HeapWord* result = humongous_obj_allocate(word_size); |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1142 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
|
1143 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
|
1144 } |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1145 return result; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1146 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1147 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1148 ShouldNotReachHere(); |
| 342 | 1149 } |
| 1150 | |
| 1151 class PostMCRemSetClearClosure: public HeapRegionClosure { | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1152 G1CollectedHeap* _g1h; |
| 342 | 1153 ModRefBarrierSet* _mr_bs; |
| 1154 public: | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1155 PostMCRemSetClearClosure(G1CollectedHeap* g1h, ModRefBarrierSet* mr_bs) : |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1156 _g1h(g1h), _mr_bs(mr_bs) { } |
| 342 | 1157 bool doHeapRegion(HeapRegion* r) { |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1158 if (r->continuesHumongous()) { |
| 342 | 1159 return false; |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1160 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1161 _g1h->reset_gc_time_stamps(r); |
| 342 | 1162 HeapRegionRemSet* hrrs = r->rem_set(); |
| 1163 if (hrrs != NULL) hrrs->clear(); | |
| 1164 // You might think here that we could clear just the cards | |
| 1165 // corresponding to the used region. But no: if we leave a dirty card | |
| 1166 // in a region we might allocate into, then it would prevent that card | |
| 1167 // from being enqueued, and cause it to be missed. | |
| 1168 // Re: the performance cost: we shouldn't be doing full GC anyway! | |
| 1169 _mr_bs->clear(MemRegion(r->bottom(), r->end())); | |
| 1170 return false; | |
| 1171 } | |
| 1172 }; | |
| 1173 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1174 void G1CollectedHeap::clear_rsets_post_compaction() { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1175 PostMCRemSetClearClosure rs_clear(this, mr_bs()); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1176 heap_region_iterate(&rs_clear); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1177 } |
| 342 | 1178 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1179 class RebuildRSOutOfRegionClosure: public HeapRegionClosure { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1180 G1CollectedHeap* _g1h; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1181 UpdateRSOopClosure _cl; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1182 int _worker_i; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1183 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1184 RebuildRSOutOfRegionClosure(G1CollectedHeap* g1, int worker_i = 0) : |
| 1861 | 1185 _cl(g1->g1_rem_set(), worker_i), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1186 _worker_i(worker_i), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1187 _g1h(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1188 { } |
|
1960
878b57474103
6978187: G1: assert(ParallelGCThreads> 1 || n_yielded() == _hrrs->occupied()) strikes again
johnc
parents:
1883
diff
changeset
|
1189 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1190 bool doHeapRegion(HeapRegion* r) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1191 if (!r->continuesHumongous()) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1192 _cl.set_from(r); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1193 r->oop_iterate(&_cl); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1194 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1195 return false; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1196 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1197 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1198 |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1199 class ParRebuildRSTask: public AbstractGangTask { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1200 G1CollectedHeap* _g1; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1201 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1202 ParRebuildRSTask(G1CollectedHeap* g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1203 : AbstractGangTask("ParRebuildRSTask"), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1204 _g1(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1205 { } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1206 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1207 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1208 RebuildRSOutOfRegionClosure rebuild_rs(_g1, worker_id); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1209 _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
|
1210 _g1->workers()->active_workers(), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1211 HeapRegion::RebuildRSClaimValue); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1212 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1213 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1214 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1215 class PostCompactionPrinterClosure: public HeapRegionClosure { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1216 private: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1217 G1HRPrinter* _hr_printer; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1218 public: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1219 bool doHeapRegion(HeapRegion* hr) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1220 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
|
1221 // We only generate output for non-empty regions. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1222 if (!hr->is_empty()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1223 if (!hr->isHumongous()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1224 _hr_printer->post_compaction(hr, G1HRPrinter::Old); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1225 } else if (hr->startsHumongous()) { |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1226 if (hr->region_num() == 1) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1227 // single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1228 _hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1229 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1230 _hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1231 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1232 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1233 assert(hr->continuesHumongous(), "only way to get here"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1234 _hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1235 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1236 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1237 return false; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1238 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1239 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1240 PostCompactionPrinterClosure(G1HRPrinter* hr_printer) |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1241 : _hr_printer(hr_printer) { } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1242 }; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1243 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1244 void G1CollectedHeap::print_hrs_post_compaction() { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1245 PostCompactionPrinterClosure cl(hr_printer()); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1246 heap_region_iterate(&cl); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1247 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1248 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1249 double G1CollectedHeap::verify(bool guard, const char* msg) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1250 double verify_time_ms = 0.0; |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1251 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1252 if (guard && total_collections() >= VerifyGCStartAt) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1253 double verify_start = os::elapsedTime(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1254 HandleMark hm; // Discard invalid handles created during verification |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1255 gclog_or_tty->print(msg); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1256 prepare_for_verify(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1257 Universe::verify(false /* silent */, VerifyOption_G1UsePrevMarking); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1258 verify_time_ms = (os::elapsedTime() - verify_start) * 1000; |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1259 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1260 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1261 return verify_time_ms; |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1262 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1263 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1264 void G1CollectedHeap::verify_before_gc() { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1265 double verify_time_ms = verify(VerifyBeforeGC, " VerifyBeforeGC:"); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1266 g1_policy()->phase_times()->record_verify_before_time_ms(verify_time_ms); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1267 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1268 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1269 void G1CollectedHeap::verify_after_gc() { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1270 double verify_time_ms = verify(VerifyAfterGC, " VerifyAfterGC:"); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1271 g1_policy()->phase_times()->record_verify_after_time_ms(verify_time_ms); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1272 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1273 |
| 1973 | 1274 bool G1CollectedHeap::do_collection(bool explicit_gc, |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1275 bool clear_all_soft_refs, |
| 342 | 1276 size_t word_size) { |
| 2152 | 1277 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1278 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1279 if (GC_locker::check_active_before_gc()) { |
| 1973 | 1280 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1281 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1282 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
1283 SvcGCMarker sgcm(SvcGCMarker::FULL); |
| 342 | 1284 ResourceMark rm; |
| 1285 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
1286 print_heap_before_gc(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1287 |
| 4072 | 1288 HRSPhaseSetter x(HRSPhaseFullGC); |
| 2152 | 1289 verify_region_sets_optional(); |
| 342 | 1290 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1291 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
|
1292 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
|
1293 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1294 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
|
1295 |
| 342 | 1296 { |
| 1297 IsGCActiveMark x; | |
| 1298 | |
| 1299 // Timing | |
| 6030 | 1300 assert(gc_cause() != GCCause::_java_lang_system_gc || explicit_gc, "invariant"); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1301 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1302 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
| 6030 | 1303 |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6059
diff
changeset
|
1304 TraceTime t(GCCauseString("Full GC", gc_cause()), G1Log::fine(), true, gclog_or_tty); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
1305 TraceCollectorStats tcs(g1mm()->full_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
1306 TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1307 |
| 342 | 1308 double start = os::elapsedTime(); |
| 1309 g1_policy()->record_full_collection_start(); | |
| 1310 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1311 // 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
|
1312 // 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
|
1313 // 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
|
1314 // following two methods. |
| 2152 | 1315 wait_while_free_regions_coming(); |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1316 // 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
|
1317 // 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
|
1318 // 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
|
1319 // 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
|
1320 // early. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1321 _cm->root_regions()->abort(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
1322 _cm->root_regions()->wait_until_scan_finished(); |
| 2361 | 1323 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 1324 |
| 342 | 1325 gc_prologue(true); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1326 increment_total_collections(true /* full gc */); |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
1327 increment_old_marking_cycles_started(); |
| 342 | 1328 |
| 1329 size_t g1h_prev_used = used(); | |
| 1330 assert(used() == recalculate_used(), "Should be equal"); | |
| 1331 | |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1332 verify_before_gc(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1333 |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1334 pre_full_gc_dump(); |
| 342 | 1335 |
| 1336 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
| 1337 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1338 // Disable discovery and empty the discovered lists |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1339 // for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1340 ref_processor_cm()->disable_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1341 ref_processor_cm()->abandon_partial_discovery(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1342 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1343 |
| 1344 // 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
|
1345 // 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
|
1346 // wait_until_scan_finished() below. |
| 342 | 1347 concurrent_mark()->abort(); |
| 1348 | |
| 1349 // 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
|
1350 release_mutator_alloc_region(); |
| 636 | 1351 abandon_gc_alloc_regions(); |
| 1861 | 1352 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
|
1353 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1354 // 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
|
1355 // 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
|
1356 // before the start GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1357 _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
|
1358 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1359 // 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
|
1360 // 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
|
1361 // 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
|
1362 // after this full GC. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1363 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
|
1364 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
|
1365 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
|
1366 |
| 4072 | 1367 tear_down_region_sets(false /* free_list_only */); |
| 4710 | 1368 g1_policy()->set_gcs_are_young(true); |
| 342 | 1369 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1370 // See the comments in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1371 // G1CollectedHeap::ref_processing_init() about |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1372 // how reference processing currently works in G1. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
1373 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1374 // 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
|
1375 ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1376 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1377 // 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
|
1378 ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1379 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1380 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
|
1381 ref_processor_stw()->setup_policy(do_clear_all_soft_refs); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1382 |
| 342 | 1383 // Do collection work |
| 1384 { | |
| 1385 HandleMark hm; // Discard invalid handles created during gc | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1386 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs); |
| 342 | 1387 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1388 |
| 2152 | 1389 assert(free_regions() == 0, "we should not have added any free regions"); |
| 4072 | 1390 rebuild_region_sets(false /* free_list_only */); |
| 342 | 1391 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1392 // Enqueue any discovered reference objects that have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1393 // not been removed from the discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1394 ref_processor_stw()->enqueue_discovered_references(); |
| 342 | 1395 |
| 1396 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
| 1397 | |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1398 MemoryService::track_memory_usage(); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
1399 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1400 verify_after_gc(); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1401 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1402 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1403 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1404 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1405 // Note: since we've just done a full GC, concurrent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1406 // marking is no longer active. Therefore we need not |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1407 // re-enable reference discovery for the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1408 // 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
|
1409 assert(!ref_processor_cm()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1410 ref_processor_cm()->verify_no_references_recorded(); |
| 342 | 1411 |
| 1412 reset_gc_time_stamp(); | |
| 1413 // Since everything potentially moved, we will clear all remembered | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1414 // sets, and clear all cards. Later we will rebuild remebered |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1415 // sets. We will also reset the GC time stamps of the regions. |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1416 clear_rsets_post_compaction(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1417 check_gc_time_stamps(); |
| 342 | 1418 |
| 1419 // Resize the heap if necessary. | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1420 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size); |
| 342 | 1421 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1422 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1423 // 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
|
1424 // that all the COMMIT / UNCOMMIT events are generated before |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1425 // the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1426 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1427 print_hrs_post_compaction(); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1428 _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
|
1429 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1430 |
| 342 | 1431 if (_cg1r->use_cache()) { |
| 1432 _cg1r->clear_and_record_card_counts(); | |
| 1433 _cg1r->clear_hot_cache(); | |
| 1434 } | |
| 1435 | |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1436 // Rebuild remembered sets of all regions. |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
1437 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1438 uint n_workers = |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1439 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1440 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1441 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1442 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1443 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1444 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1445 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1446 // 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
|
1447 // 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
|
1448 // 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
|
1449 // 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
|
1450 // may be code that is "possibly_parallel". |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1451 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1452 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1453 ParRebuildRSTask rebuild_rs_task(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1454 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1455 HeapRegion::InitialClaimValue), "sanity check"); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1456 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1457 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1458 "Unless dynamic should use total workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1459 // Use the most recent number of active workers |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1460 assert(workers()->active_workers() > 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1461 "Active workers not properly set"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1462 set_par_threads(workers()->active_workers()); |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1463 workers()->run_task(&rebuild_rs_task); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1464 set_par_threads(0); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1465 assert(check_heap_region_claim_values( |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1466 HeapRegion::RebuildRSClaimValue), "sanity check"); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1467 reset_heap_region_claim_values(); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1468 } else { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1469 RebuildRSOutOfRegionClosure rebuild_rs(this); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1470 heap_region_iterate(&rebuild_rs); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1471 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1472 |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1473 if (G1Log::fine()) { |
| 342 | 1474 print_size_transition(gclog_or_tty, g1h_prev_used, used(), capacity()); |
| 1475 } | |
| 1476 | |
| 1477 if (true) { // FIXME | |
| 1478 // Ask the permanent generation to adjust size for full collections | |
| 1479 perm()->compute_new_size(); | |
| 1480 } | |
| 1481 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1482 // 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
|
1483 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
|
1484 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
|
1485 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1486 // 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
|
1487 // 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
|
1488 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1489 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1490 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1491 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1492 |
| 342 | 1493 double end = os::elapsedTime(); |
| 1494 g1_policy()->record_full_collection_end(); | |
| 1495 | |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1496 #ifdef TRACESPINNING |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1497 ParallelTaskTerminator::print_termination_counts(); |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1498 #endif |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1499 |
| 342 | 1500 gc_epilogue(true); |
| 1501 | |
| 794 | 1502 // Discard all rset updates |
| 1503 JavaThread::dirty_card_queue_set().abandon_logs(); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1504 assert(!G1DeferredRSUpdate |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
1505 || (G1DeferredRSUpdate && (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any"); |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1506 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1507 _young_list->reset_sampled_info(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1508 // At this point there should be no regions in the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1509 // entire heap tagged as young. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1510 assert( check_young_list_empty(true /* check_heap */), |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1511 "young list should be empty at this point"); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1512 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1513 // Update the number of full collections that have been completed. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1514 increment_old_marking_cycles_completed(false /* concurrent */); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1515 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1516 _hrs.verify_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1517 verify_region_sets_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1518 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1519 print_heap_after_gc(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1520 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1521 // We must call G1MonitoringSupport::update_sizes() in the same scoping level |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1522 // as an active TraceMemoryManagerStats object (i.e. before the destructor for the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1523 // TraceMemoryManagerStats is called) so that the G1 memory pools are updated |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1524 // before any GC notifications are raised. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1525 g1mm()->update_sizes(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1526 } |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1527 |
|
3869
7f776886a215
6810861: G1: support -XX:+{PrintClassHistogram,HeapDump}{Before,After}FullGC
ysr
parents:
3867
diff
changeset
|
1528 post_full_gc_dump(); |
| 1973 | 1529 |
| 1530 return true; | |
| 342 | 1531 } |
| 1532 | |
| 1533 void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) { | |
| 1973 | 1534 // do_collection() will return whether it succeeded in performing |
| 1535 // the GC. Currently, there is no facility on the | |
| 1536 // do_full_collection() API to notify the caller than the collection | |
| 1537 // did not succeed (e.g., because it was locked out by the GC | |
| 1538 // locker). So, right now, we'll ignore the return value. | |
| 1539 bool dummy = do_collection(true, /* explicit_gc */ | |
| 1540 clear_all_soft_refs, | |
| 1541 0 /* word_size */); | |
| 342 | 1542 } |
| 1543 | |
| 1544 // This code is mostly copied from TenuredGeneration. | |
| 1545 void | |
| 1546 G1CollectedHeap:: | |
| 1547 resize_if_necessary_after_full_collection(size_t word_size) { | |
| 1548 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, "sanity check"); | |
| 1549 | |
| 1550 // Include the current allocation, if any, and bytes that will be | |
| 1551 // pre-allocated to support collections, as "used". | |
| 1552 const size_t used_after_gc = used(); | |
| 1553 const size_t capacity_after_gc = capacity(); | |
| 1554 const size_t free_after_gc = capacity_after_gc - used_after_gc; | |
| 1555 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1556 // This is enforced in arguments.cpp. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1557 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1558 "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
|
1559 |
| 342 | 1560 // 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
|
1561 const double minimum_free_percentage = (double) MinHeapFreeRatio / 100.0; |
| 342 | 1562 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
|
1563 const double maximum_free_percentage = (double) MaxHeapFreeRatio / 100.0; |
| 342 | 1564 const double minimum_used_percentage = 1.0 - maximum_free_percentage; |
| 1565 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1566 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
|
1567 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
|
1568 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1569 // 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
|
1570 // 32-bit size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1571 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
|
1572 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
|
1573 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
|
1574 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1575 // 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
|
1576 // 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
|
1577 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
|
1578 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
|
1579 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1580 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
|
1581 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1582 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1583 // 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
|
1584 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
|
1585 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
|
1586 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1587 // 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
|
1588 // 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
|
1589 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
|
1590 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
|
1591 "maximum_desired_capacity = "SIZE_FORMAT, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1592 minimum_desired_capacity, maximum_desired_capacity)); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1593 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1594 // 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
|
1595 // 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
|
1596 // 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
|
1597 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
|
1598 // 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
|
1599 // 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
|
1600 // 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
|
1601 maximum_desired_capacity = MAX2(maximum_desired_capacity, min_heap_size); |
| 342 | 1602 |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1603 if (capacity_after_gc < minimum_desired_capacity) { |
| 342 | 1604 // Don't expand unless it's significant |
| 1605 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
|
1606 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1607 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1608 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
|
1609 "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
|
1610 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1611 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1612 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
|
1613 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
|
1614 minimum_desired_capacity, (double) MinHeapFreeRatio); |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1615 expand(expand_bytes); |
| 342 | 1616 |
| 1617 // 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
|
1618 } else if (capacity_after_gc > maximum_desired_capacity) { |
| 342 | 1619 // Capacity too large, compute shrinking size |
| 1620 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
|
1621 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1622 "attempt heap shrinking", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1623 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
|
1624 "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
|
1625 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1626 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1627 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
|
1628 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
|
1629 maximum_desired_capacity, (double) MaxHeapFreeRatio); |
| 342 | 1630 shrink(shrink_bytes); |
| 1631 } | |
| 1632 } | |
| 1633 | |
| 1634 | |
| 1635 HeapWord* | |
| 1973 | 1636 G1CollectedHeap::satisfy_failed_allocation(size_t word_size, |
| 1637 bool* succeeded) { | |
| 2152 | 1638 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1973 | 1639 |
| 1640 *succeeded = true; | |
| 1641 // Let's attempt the allocation first. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1642 HeapWord* result = |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1643 attempt_allocation_at_safepoint(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1644 false /* expect_null_mutator_alloc_region */); |
| 1973 | 1645 if (result != NULL) { |
| 1646 assert(*succeeded, "sanity"); | |
| 1647 return result; | |
| 1648 } | |
| 342 | 1649 |
| 1650 // In a G1 heap, we're supposed to keep allocation from failing by | |
| 1651 // incremental pauses. Therefore, at least for now, we'll favor | |
| 1652 // expansion over collection. (This might change in the future if we can | |
| 1653 // do something smarter than full collection to satisfy a failed alloc.) | |
| 1654 result = expand_and_allocate(word_size); | |
| 1655 if (result != NULL) { | |
| 1973 | 1656 assert(*succeeded, "sanity"); |
| 342 | 1657 return result; |
| 1658 } | |
| 1659 | |
| 1973 | 1660 // Expansion didn't work, we'll try to do a Full GC. |
| 1661 bool gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1662 false, /* clear_all_soft_refs */ | |
| 1663 word_size); | |
| 1664 if (!gc_succeeded) { | |
| 1665 *succeeded = false; | |
| 1666 return NULL; | |
| 1667 } | |
| 1668 | |
| 1669 // Retry the allocation | |
| 1670 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1671 true /* expect_null_mutator_alloc_region */); |
| 342 | 1672 if (result != NULL) { |
| 1973 | 1673 assert(*succeeded, "sanity"); |
| 342 | 1674 return result; |
| 1675 } | |
| 1676 | |
| 1973 | 1677 // Then, try a Full GC that will collect all soft references. |
| 1678 gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1679 true, /* clear_all_soft_refs */ | |
| 1680 word_size); | |
| 1681 if (!gc_succeeded) { | |
| 1682 *succeeded = false; | |
| 1683 return NULL; | |
| 1684 } | |
| 1685 | |
| 1686 // Retry the allocation once more | |
| 1687 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1688 true /* expect_null_mutator_alloc_region */); |
| 342 | 1689 if (result != NULL) { |
| 1973 | 1690 assert(*succeeded, "sanity"); |
| 342 | 1691 return result; |
| 1692 } | |
| 1693 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1694 assert(!collector_policy()->should_clear_all_soft_refs(), |
| 1973 | 1695 "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
|
1696 |
| 342 | 1697 // What else? We might try synchronous finalization later. If the total |
| 1698 // space available is large enough for the allocation, then a more | |
| 1699 // complete compaction phase than we've tried so far might be | |
| 1700 // appropriate. | |
| 1973 | 1701 assert(*succeeded, "sanity"); |
| 342 | 1702 return NULL; |
| 1703 } | |
| 1704 | |
| 1705 // Attempting to expand the heap sufficiently | |
| 1706 // to support an allocation of the given "word_size". If | |
| 1707 // successful, perform the allocation and return the address of the | |
| 1708 // allocated block, or else "NULL". | |
| 1709 | |
| 1710 HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) { | |
| 2152 | 1711 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1712 | |
| 1713 verify_region_sets_optional(); | |
| 1973 | 1714 |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1715 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
|
1716 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1717 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1718 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
|
1719 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1720 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1721 if (expand(expand_bytes)) { |
| 3766 | 1722 _hrs.verify_optional(); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1723 verify_region_sets_optional(); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1724 return attempt_allocation_at_safepoint(word_size, |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1725 false /* expect_null_mutator_alloc_region */); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1726 } |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1727 return NULL; |
| 342 | 1728 } |
| 1729 | |
| 3766 | 1730 void G1CollectedHeap::update_committed_space(HeapWord* old_end, |
| 1731 HeapWord* new_end) { | |
| 1732 assert(old_end != new_end, "don't call this otherwise"); | |
| 1733 assert((HeapWord*) _g1_storage.high() == new_end, "invariant"); | |
| 1734 | |
| 1735 // Update the committed mem region. | |
| 1736 _g1_committed.set_end(new_end); | |
| 1737 // Tell the card table about the update. | |
| 1738 Universe::heap()->barrier_set()->resize_covered_region(_g1_committed); | |
| 1739 // Tell the BOT about the update. | |
| 1740 _bot_shared->resize(_g1_committed.word_size()); | |
| 1741 } | |
| 1742 | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1743 bool G1CollectedHeap::expand(size_t expand_bytes) { |
| 342 | 1744 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
|
1745 size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes); |
| 342 | 1746 aligned_expand_bytes = align_size_up(aligned_expand_bytes, |
| 1747 HeapRegion::GrainBytes); | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1748 ergo_verbose2(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1749 "expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1750 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
|
1751 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
|
1752 expand_bytes, aligned_expand_bytes); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1753 |
| 3766 | 1754 // First commit the memory. |
| 1755 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1756 bool successful = _g1_storage.expand_by(aligned_expand_bytes); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1757 if (successful) { |
| 3766 | 1758 // Then propagate this update to the necessary data structures. |
| 1759 HeapWord* new_end = (HeapWord*) _g1_storage.high(); | |
| 1760 update_committed_space(old_end, new_end); | |
| 1761 | |
| 1762 FreeRegionList expansion_list("Local Expansion List"); | |
| 1763 MemRegion mr = _hrs.expand_by(old_end, new_end, &expansion_list); | |
| 1764 assert(mr.start() == old_end, "post-condition"); | |
| 1765 // mr might be a smaller region than what was requested if | |
| 1766 // expand_by() was unable to allocate the HeapRegion instances | |
| 1767 assert(mr.end() <= new_end, "post-condition"); | |
| 1768 | |
| 1769 size_t actual_expand_bytes = mr.byte_size(); | |
| 1770 assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition"); | |
| 1771 assert(actual_expand_bytes == expansion_list.total_capacity_bytes(), | |
| 1772 "post-condition"); | |
| 1773 if (actual_expand_bytes < aligned_expand_bytes) { | |
| 1774 // We could not expand _hrs to the desired size. In this case we | |
| 1775 // need to shrink the committed space accordingly. | |
| 1776 assert(mr.end() < new_end, "invariant"); | |
| 1777 | |
| 1778 size_t diff_bytes = aligned_expand_bytes - actual_expand_bytes; | |
| 1779 // First uncommit the memory. | |
| 1780 _g1_storage.shrink_by(diff_bytes); | |
| 1781 // Then propagate this update to the necessary data structures. | |
| 1782 update_committed_space(new_end, mr.end()); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1783 } |
| 3766 | 1784 _free_list.add_as_tail(&expansion_list); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1785 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1786 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1787 HeapWord* curr = mr.start(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1788 while (curr < mr.end()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1789 HeapWord* curr_end = curr + HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1790 _hr_printer.commit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1791 curr = curr_end; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1792 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1793 assert(curr == mr.end(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1794 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1795 g1_policy()->record_new_heap_size(n_regions()); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1796 } else { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1797 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1798 "did not expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1799 ergo_format_reason("heap expansion operation failed")); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1800 // The expansion of the virtual storage space was unsuccessful. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1801 // 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
|
1802 if (G1ExitOnExpansionFailure && |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1803 _g1_storage.uncommitted_size() >= aligned_expand_bytes) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1804 // We had head room... |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1805 vm_exit_out_of_memory(aligned_expand_bytes, "G1 heap expansion"); |
| 342 | 1806 } |
| 1807 } | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1808 return successful; |
| 342 | 1809 } |
| 1810 | |
| 3766 | 1811 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) { |
| 342 | 1812 size_t old_mem_size = _g1_storage.committed_size(); |
| 1813 size_t aligned_shrink_bytes = | |
| 1814 ReservedSpace::page_align_size_down(shrink_bytes); | |
| 1815 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes, | |
| 1816 HeapRegion::GrainBytes); | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
1817 uint num_regions_deleted = 0; |
| 3766 | 1818 MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted); |
| 1819 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
| 1820 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
|
1821 |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1822 ergo_verbose3(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1823 "shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1824 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
|
1825 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
|
1826 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
|
1827 shrink_bytes, aligned_shrink_bytes, mr.byte_size()); |
| 3766 | 1828 if (mr.byte_size() > 0) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1829 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1830 HeapWord* curr = mr.end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1831 while (curr > mr.start()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1832 HeapWord* curr_end = curr; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1833 curr -= HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1834 _hr_printer.uncommit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1835 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1836 assert(curr == mr.start(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1837 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1838 |
| 342 | 1839 _g1_storage.shrink_by(mr.byte_size()); |
| 3766 | 1840 HeapWord* new_end = (HeapWord*) _g1_storage.high(); |
| 1841 assert(mr.start() == new_end, "post-condition"); | |
| 1842 | |
| 1843 _expansion_regions += num_regions_deleted; | |
| 1844 update_committed_space(old_end, new_end); | |
| 1845 HeapRegionRemSet::shrink_heap(n_regions()); | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1846 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
|
1847 } else { |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1848 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1849 "did not shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1850 ergo_format_reason("heap shrinking operation failed")); |
| 342 | 1851 } |
| 1852 } | |
| 1853 | |
| 1854 void G1CollectedHeap::shrink(size_t shrink_bytes) { | |
| 2152 | 1855 verify_region_sets_optional(); |
| 1856 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1857 // 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
|
1858 // 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
|
1859 // 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
|
1860 abandon_gc_alloc_regions(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1861 |
| 2152 | 1862 // Instead of tearing down / rebuilding the free lists here, we |
| 1863 // could instead use the remove_all_pending() method on free_list to | |
| 1864 // remove only the ones that we need to remove. | |
| 4072 | 1865 tear_down_region_sets(true /* free_list_only */); |
| 342 | 1866 shrink_helper(shrink_bytes); |
| 4072 | 1867 rebuild_region_sets(true /* free_list_only */); |
| 2152 | 1868 |
| 3766 | 1869 _hrs.verify_optional(); |
| 2152 | 1870 verify_region_sets_optional(); |
| 342 | 1871 } |
| 1872 | |
| 1873 // Public methods. | |
| 1874 | |
| 1875 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away | |
| 1876 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 1877 #endif // _MSC_VER | |
| 1878 | |
| 1879 | |
| 1880 G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) : | |
| 1881 SharedHeap(policy_), | |
| 1882 _g1_policy(policy_), | |
| 1111 | 1883 _dirty_card_queue_set(false), |
| 1705 | 1884 _into_cset_dirty_card_queue_set(false), |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1885 _is_alive_closure_cm(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1886 _is_alive_closure_stw(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1887 _ref_processor_cm(NULL), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1888 _ref_processor_stw(NULL), |
| 342 | 1889 _process_strong_tasks(new SubTasksDone(G1H_PS_NumElements)), |
| 1890 _bot_shared(NULL), | |
| 1891 _objs_with_preserved_marks(NULL), _preserved_marks_of_objs(NULL), | |
| 1892 _evac_failure_scan_stack(NULL) , | |
| 1893 _mark_in_progress(false), | |
| 2152 | 1894 _cg1r(NULL), _summary_bytes_used(0), |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1895 _g1mm(NULL), |
| 342 | 1896 _refine_cte_cl(NULL), |
| 1897 _full_collection(false), | |
| 2152 | 1898 _free_list("Master Free List"), |
| 1899 _secondary_free_list("Secondary Free List"), | |
| 4072 | 1900 _old_set("Old Set"), |
| 2152 | 1901 _humongous_set("Master Humongous Set"), |
| 1902 _free_regions_coming(false), | |
| 342 | 1903 _young_list(new YoungList(this)), |
| 1904 _gc_time_stamp(0), | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1905 _retained_old_gc_alloc_region(NULL), |
| 6595 | 1906 _survivor_plab_stats(YoungPLABSize, PLABWeight), |
| 1907 _old_plab_stats(OldPLABSize, PLABWeight), | |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
1908 _expand_heap_after_alloc_failure(true), |
| 526 | 1909 _surviving_young_words(NULL), |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
1910 _old_marking_cycles_started(0), |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
1911 _old_marking_cycles_completed(0), |
| 526 | 1912 _in_cset_fast_test(NULL), |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
1913 _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
|
1914 _dirty_cards_region_list(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1915 _worker_cset_start_region(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1916 _worker_cset_start_region_time_stamp(NULL) { |
| 342 | 1917 _g1h = this; // To catch bugs. |
| 1918 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { | |
| 1919 vm_exit_during_initialization("Failed necessary allocation."); | |
| 1920 } | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1921 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1922 _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1923 |
| 342 | 1924 int n_queues = MAX2((int)ParallelGCThreads, 1); |
| 1925 _task_queues = new RefToScanQueueSet(n_queues); | |
| 1926 | |
| 1927 int n_rem_sets = HeapRegionRemSet::num_par_rem_sets(); | |
| 1928 assert(n_rem_sets > 0, "Invariant."); | |
| 1929 | |
| 1930 HeapRegionRemSetIterator** iter_arr = | |
| 6197 | 1931 NEW_C_HEAP_ARRAY(HeapRegionRemSetIterator*, n_queues, mtGC); |
| 342 | 1932 for (int i = 0; i < n_queues; i++) { |
| 1933 iter_arr[i] = new HeapRegionRemSetIterator(); | |
| 1934 } | |
| 1935 _rem_set_iterator = iter_arr; | |
| 1936 | |
| 6197 | 1937 _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues, mtGC); |
| 1938 _worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues, mtGC); | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1939 |
| 342 | 1940 for (int i = 0; i < n_queues; i++) { |
| 1941 RefToScanQueue* q = new RefToScanQueue(); | |
| 1942 q->initialize(); | |
| 1943 _task_queues->register_queue(i, q); | |
| 1944 } | |
| 1945 | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1946 clear_cset_start_regions(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1947 |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1948 // Initialize the G1EvacuationFailureALot counters and flags. |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1949 NOT_PRODUCT(reset_evacuation_should_fail();) |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1950 |
| 342 | 1951 guarantee(_task_queues != NULL, "task_queues allocation failure."); |
| 6610 | 1952 #ifdef SPARC |
| 1953 // Issue a stern warning, but allow use for experimentation and debugging. | |
| 1954 if (VM_Version::is_sun4v() && UseMemSetInBOT) { | |
| 1955 assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error"); | |
| 1956 warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability" | |
| 1957 " on sun4v; please understand that you are using at your own risk!"); | |
| 1958 } | |
| 1959 #endif | |
| 342 | 1960 } |
| 1961 | |
| 1962 jint G1CollectedHeap::initialize() { | |
| 1166 | 1963 CollectedHeap::pre_initialize(); |
| 342 | 1964 os::enable_vtime(); |
| 1965 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1966 G1Log::init(); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1967 |
| 342 | 1968 // Necessary to satisfy locking discipline assertions. |
| 1969 | |
| 1970 MutexLocker x(Heap_lock); | |
| 1971 | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1972 // 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
|
1973 // it will be used then. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1974 _hr_printer.set_active(G1PrintHeapRegions); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1975 |
| 342 | 1976 // While there are no constraints in the GC code that HeapWordSize |
| 1977 // be any particular value, there are multiple other areas in the | |
| 1978 // system which believe this to be true (e.g. oop->object_size in some | |
| 1979 // cases incorrectly returns the size in wordSize units rather than | |
| 1980 // HeapWordSize). | |
| 1981 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); | |
| 1982 | |
| 1983 size_t init_byte_size = collector_policy()->initial_heap_byte_size(); | |
| 1984 size_t max_byte_size = collector_policy()->max_heap_byte_size(); | |
| 1985 | |
| 1986 // Ensure that the sizes are properly aligned. | |
| 1987 Universe::check_alignment(init_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1988 Universe::check_alignment(max_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 1989 | |
| 1990 _cg1r = new ConcurrentG1Refine(); | |
| 1991 | |
| 1992 // Reserve the maximum. | |
| 1993 PermanentGenerationSpec* pgs = collector_policy()->permanent_generation(); | |
| 1994 // Includes the perm-gen. | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
1995 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1996 // When compressed oops are enabled, the preferred heap base |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1997 // is calculated by subtracting the requested size from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1998 // 32Gb boundary and using the result as the base address for |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
1999 // heap reservation. If the requested size is not aligned to |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2000 // HeapRegion::GrainBytes (i.e. the alignment that is passed |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2001 // into the ReservedHeapSpace constructor) then the actual |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2002 // base of the reserved heap may end up differing from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2003 // address that was requested (i.e. the preferred heap base). |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2004 // 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
|
2005 // compressed oops mode. |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2006 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2007 // 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
|
2008 // 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
|
2009 const size_t total_reserved = max_byte_size + |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2010 align_size_up(pgs->max_size(), HeapRegion::GrainBytes); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2011 Universe::check_alignment(total_reserved, HeapRegion::GrainBytes, "g1 heap and perm"); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2012 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2013 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
|
2014 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2015 ReservedHeapSpace heap_rs(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2016 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2017 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2018 if (UseCompressedOops) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2019 if (addr != NULL && !heap_rs.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2020 // 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
|
2021 // 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
|
2022 // Try again to reserver heap higher. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2023 addr = Universe::preferred_heap_base(total_reserved, Universe::ZeroBasedNarrowOop); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2024 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2025 ReservedHeapSpace heap_rs0(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2026 UseLargePages, addr); |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2027 |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2028 if (addr != NULL && !heap_rs0.is_reserved()) { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2029 // 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
|
2030 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
|
2031 assert(addr == NULL, ""); |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2032 |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2033 ReservedHeapSpace heap_rs1(total_reserved, HeapRegion::GrainBytes, |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2034 UseLargePages, addr); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2035 heap_rs = heap_rs1; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2036 } else { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2037 heap_rs = heap_rs0; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2038 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2039 } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2040 } |
| 342 | 2041 |
| 2042 if (!heap_rs.is_reserved()) { | |
| 2043 vm_exit_during_initialization("Could not reserve enough space for object heap"); | |
| 2044 return JNI_ENOMEM; | |
| 2045 } | |
| 2046 | |
| 2047 // It is important to do this in a way such that concurrent readers can't | |
| 2048 // temporarily think somethings in the heap. (I've actually seen this | |
| 2049 // happen in asserts: DLD.) | |
| 2050 _reserved.set_word_size(0); | |
| 2051 _reserved.set_start((HeapWord*)heap_rs.base()); | |
| 2052 _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size())); | |
| 2053 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2054 _expansion_regions = (uint) (max_byte_size / HeapRegion::GrainBytes); |
| 342 | 2055 |
| 2056 // Create the gen rem set (and barrier set) for the entire reserved region. | |
| 2057 _rem_set = collector_policy()->create_rem_set(_reserved, 2); | |
| 2058 set_barrier_set(rem_set()->bs()); | |
| 2059 if (barrier_set()->is_a(BarrierSet::ModRef)) { | |
| 2060 _mr_bs = (ModRefBarrierSet*)_barrier_set; | |
| 2061 } else { | |
| 2062 vm_exit_during_initialization("G1 requires a mod ref bs."); | |
| 2063 return JNI_ENOMEM; | |
| 2064 } | |
| 2065 | |
| 2066 // Also create a G1 rem set. | |
| 1861 | 2067 if (mr_bs()->is_a(BarrierSet::CardTableModRef)) { |
| 2068 _g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs()); | |
| 342 | 2069 } else { |
| 1861 | 2070 vm_exit_during_initialization("G1 requires a cardtable mod ref bs."); |
| 2071 return JNI_ENOMEM; | |
| 342 | 2072 } |
| 2073 | |
| 2074 // Carve out the G1 part of the heap. | |
| 2075 | |
| 2076 ReservedSpace g1_rs = heap_rs.first_part(max_byte_size); | |
| 2077 _g1_reserved = MemRegion((HeapWord*)g1_rs.base(), | |
| 2078 g1_rs.size()/HeapWordSize); | |
| 2079 ReservedSpace perm_gen_rs = heap_rs.last_part(max_byte_size); | |
| 2080 | |
| 2081 _perm_gen = pgs->init(perm_gen_rs, pgs->init_size(), rem_set()); | |
| 2082 | |
| 2083 _g1_storage.initialize(g1_rs, 0); | |
| 2084 _g1_committed = MemRegion((HeapWord*)_g1_storage.low(), (size_t) 0); | |
| 3766 | 2085 _hrs.initialize((HeapWord*) _g1_reserved.start(), |
| 2086 (HeapWord*) _g1_reserved.end(), | |
| 2087 _expansion_regions); | |
| 342 | 2088 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2089 // 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
|
2090 // in the remembered set structures. |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2091 const uint max_region_idx = (1U << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2092 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
|
2093 |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2094 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
|
2095 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
|
2096 guarantee(HeapRegion::CardsPerRegion < max_cards_per_region, |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2097 "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
|
2098 |
| 2152 | 2099 HeapRegionSet::set_unrealistically_long_length(max_regions() + 1); |
| 2100 | |
| 342 | 2101 _bot_shared = new G1BlockOffsetSharedArray(_reserved, |
| 2102 heap_word_size(init_byte_size)); | |
| 2103 | |
| 2104 _g1h = this; | |
| 2105 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2106 _in_cset_fast_test_length = max_regions(); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2107 _in_cset_fast_test_base = |
| 6197 | 2108 NEW_C_HEAP_ARRAY(bool, (size_t) _in_cset_fast_test_length, mtGC); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2109 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2110 // 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
|
2111 // 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
|
2112 // 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
|
2113 _in_cset_fast_test = _in_cset_fast_test_base - |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2114 ((uintx) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2115 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2116 // 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
|
2117 // 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
|
2118 // evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2119 clear_cset_fast_test(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2120 |
| 342 | 2121 // Create the ConcurrentMark data structure and thread. |
| 2122 // (Must do this late, so that "max_regions" is defined.) | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2123 _cm = new ConcurrentMark(heap_rs, max_regions()); |
| 342 | 2124 _cmThread = _cm->cmThread(); |
| 2125 | |
| 2126 // Initialize the from_card cache structure of HeapRegionRemSet. | |
| 2127 HeapRegionRemSet::init_heap(max_regions()); | |
| 2128 | |
| 677 | 2129 // Now expand into the initial heap size. |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2130 if (!expand(init_byte_size)) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2131 vm_exit_during_initialization("Failed to allocate initial heap."); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2132 return JNI_ENOMEM; |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2133 } |
| 342 | 2134 |
| 2135 // Perform any initialization actions delegated to the policy. | |
| 2136 g1_policy()->init(); | |
| 2137 | |
| 2138 _refine_cte_cl = | |
| 2139 new RefineCardTableEntryClosure(ConcurrentG1RefineThread::sts(), | |
| 2140 g1_rem_set(), | |
| 2141 concurrent_g1_refine()); | |
| 2142 JavaThread::dirty_card_queue_set().set_closure(_refine_cte_cl); | |
| 2143 | |
| 2144 JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon, | |
| 2145 SATB_Q_FL_lock, | |
| 1111 | 2146 G1SATBProcessCompletedThreshold, |
| 342 | 2147 Shared_SATB_Q_lock); |
| 794 | 2148 |
| 2149 JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, | |
| 2150 DirtyCardQ_FL_lock, | |
| 1111 | 2151 concurrent_g1_refine()->yellow_zone(), |
| 2152 concurrent_g1_refine()->red_zone(), | |
| 794 | 2153 Shared_DirtyCardQ_lock); |
| 2154 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2155 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2156 dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2157 DirtyCardQ_FL_lock, |
| 1111 | 2158 -1, // never trigger processing |
| 2159 -1, // no limit on length | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2160 Shared_DirtyCardQ_lock, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2161 &JavaThread::dirty_card_queue_set()); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2162 } |
| 1705 | 2163 |
| 2164 // Initialize the card queue set used to hold cards containing | |
| 2165 // references into the collection set. | |
| 2166 _into_cset_dirty_card_queue_set.initialize(DirtyCardQ_CBL_mon, | |
| 2167 DirtyCardQ_FL_lock, | |
| 2168 -1, // never trigger processing | |
| 2169 -1, // no limit on length | |
| 2170 Shared_DirtyCardQ_lock, | |
| 2171 &JavaThread::dirty_card_queue_set()); | |
| 2172 | |
| 342 | 2173 // In case we're keeping closure specialization stats, initialize those |
| 2174 // counts and that mechanism. | |
| 2175 SpecializationStats::clear(); | |
| 2176 | |
| 2177 // Do later initialization work for concurrent refinement. | |
| 2178 _cg1r->init(); | |
| 2179 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2180 // 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
|
2181 // 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
|
2182 // space here, lots of asserts fire. |
| 3766 | 2183 |
| 2184 HeapRegion* dummy_region = new_heap_region(0 /* index of bottom region */, | |
| 2185 _g1_reserved.start()); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2186 // 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
|
2187 // 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
|
2188 // 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
|
2189 // 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
|
2190 dummy_region->set_young(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2191 // Make sure it's full. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2192 dummy_region->set_top(dummy_region->end()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2193 G1AllocRegion::setup(this, dummy_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2194 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2195 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2196 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2197 // 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
|
2198 // values in the heap have been properly initialized. |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
2199 _g1mm = new G1MonitoringSupport(this); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2200 |
| 342 | 2201 return JNI_OK; |
| 2202 } | |
| 2203 | |
| 2204 void G1CollectedHeap::ref_processing_init() { | |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2205 // Reference processing in G1 currently works as follows: |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2206 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2207 // * There are two reference processor instances. One is |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2208 // used to record and process discovered references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2209 // during concurrent marking; the other is used to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2210 // record and process references during STW pauses |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2211 // (both full and incremental). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2212 // * Both ref processors need to 'span' the entire heap as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2213 // the regions in the collection set may be dotted around. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2214 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2215 // * For the concurrent marking ref processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2216 // * Reference discovery is enabled at initial marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2217 // * Reference discovery is disabled and the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2218 // references processed etc during remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2219 // * Reference discovery is MT (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2220 // * Reference discovery requires a barrier (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2221 // * Reference processing may or may not be MT |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2222 // (depending on the value of ParallelRefProcEnabled |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2223 // and ParallelGCThreads). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2224 // * A full GC disables reference discovery by the CM |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2225 // ref processor and abandons any entries on it's |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2226 // discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2227 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2228 // * For the STW processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2229 // * 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
|
2230 // * Processing and enqueueing during a full GC is non-MT. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2231 // * During a full GC, references are processed after marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2232 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2233 // * 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
|
2234 // of an incremental evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2235 // * References are processed near the end of a STW evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2236 // * For both types of GC: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2237 // * Discovery is atomic - i.e. not concurrent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2238 // * Reference discovery will not need a barrier. |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2239 |
| 342 | 2240 SharedHeap::ref_processing_init(); |
| 2241 MemRegion mr = reserved_region(); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2242 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2243 // Concurrent Mark ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2244 _ref_processor_cm = |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2361
diff
changeset
|
2245 new ReferenceProcessor(mr, // span |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2246 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2247 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2248 (int) ParallelGCThreads, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2249 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2250 (ParallelGCThreads > 1) || (ConcGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2251 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2252 (int) MAX2(ParallelGCThreads, ConcGCThreads), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2253 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2254 false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2255 // Reference discovery is not atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2256 &_is_alive_closure_cm, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2257 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2258 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2259 true); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2260 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2261 // lists requires a barrier. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2262 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2263 // STW ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2264 _ref_processor_stw = |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2265 new ReferenceProcessor(mr, // span |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2266 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2267 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2268 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2269 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2270 (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2271 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2272 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2273 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2274 true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2275 // Reference discovery is atomic |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2276 &_is_alive_closure_stw, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2277 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2278 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2279 false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2280 // Setting next fields of discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2281 // lists requires a barrier. |
| 342 | 2282 } |
| 2283 | |
| 2284 size_t G1CollectedHeap::capacity() const { | |
| 2285 return _g1_committed.byte_size(); | |
| 2286 } | |
| 2287 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2288 void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2289 assert(!hr->continuesHumongous(), "pre-condition"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2290 hr->reset_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2291 if (hr->startsHumongous()) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2292 uint first_index = hr->hrs_index() + 1; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2293 uint last_index = hr->last_hc_index(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2294 for (uint i = first_index; i < last_index; i += 1) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2295 HeapRegion* chr = region_at(i); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2296 assert(chr->continuesHumongous(), "sanity"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2297 chr->reset_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2298 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2299 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2300 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2301 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2302 #ifndef PRODUCT |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2303 class CheckGCTimeStampsHRClosure : public HeapRegionClosure { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2304 private: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2305 unsigned _gc_time_stamp; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2306 bool _failures; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2307 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2308 public: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2309 CheckGCTimeStampsHRClosure(unsigned gc_time_stamp) : |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2310 _gc_time_stamp(gc_time_stamp), _failures(false) { } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2311 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2312 virtual bool doHeapRegion(HeapRegion* hr) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2313 unsigned region_gc_time_stamp = hr->get_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2314 if (_gc_time_stamp != region_gc_time_stamp) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2315 gclog_or_tty->print_cr("Region "HR_FORMAT" has GC time stamp = %d, " |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2316 "expected %d", HR_FORMAT_PARAMS(hr), |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2317 region_gc_time_stamp, _gc_time_stamp); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2318 _failures = true; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2319 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2320 return false; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2321 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2322 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2323 bool failures() { return _failures; } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2324 }; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2325 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2326 void G1CollectedHeap::check_gc_time_stamps() { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2327 CheckGCTimeStampsHRClosure cl(_gc_time_stamp); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2328 heap_region_iterate(&cl); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2329 guarantee(!cl.failures(), "all GC time stamps should have been reset"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2330 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2331 #endif // PRODUCT |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2332 |
| 1705 | 2333 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, |
| 2334 DirtyCardQueue* into_cset_dcq, | |
| 2335 bool concurrent, | |
| 342 | 2336 int worker_i) { |
| 889 | 2337 // Clean cards in the hot card cache |
| 1705 | 2338 concurrent_g1_refine()->clean_up_cache(worker_i, g1_rem_set(), into_cset_dcq); |
| 889 | 2339 |
| 342 | 2340 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
| 2341 int n_completed_buffers = 0; | |
| 1705 | 2342 while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) { |
| 342 | 2343 n_completed_buffers++; |
| 2344 } | |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2345 g1_policy()->phase_times()->record_update_rs_processed_buffers(worker_i, n_completed_buffers); |
| 342 | 2346 dcqs.clear_n_completed_buffers(); |
| 2347 assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!"); | |
| 2348 } | |
| 2349 | |
| 2350 | |
| 2351 // Computes the sum of the storage used by the various regions. | |
| 2352 | |
| 2353 size_t G1CollectedHeap::used() const { | |
|
862
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2354 assert(Heap_lock->owner() != NULL, |
|
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2355 "Should be owned on this thread's behalf."); |
| 342 | 2356 size_t result = _summary_bytes_used; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2357 // 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
|
2358 HeapRegion* hr = _mutator_alloc_region.get(); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2359 if (hr != NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2360 result += hr->used(); |
| 342 | 2361 return result; |
| 2362 } | |
| 2363 | |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2364 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
|
2365 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
|
2366 return result; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2367 } |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2368 |
| 342 | 2369 class SumUsedClosure: public HeapRegionClosure { |
| 2370 size_t _used; | |
| 2371 public: | |
| 2372 SumUsedClosure() : _used(0) {} | |
| 2373 bool doHeapRegion(HeapRegion* r) { | |
| 2374 if (!r->continuesHumongous()) { | |
| 2375 _used += r->used(); | |
| 2376 } | |
| 2377 return false; | |
| 2378 } | |
| 2379 size_t result() { return _used; } | |
| 2380 }; | |
| 2381 | |
| 2382 size_t G1CollectedHeap::recalculate_used() const { | |
| 2383 SumUsedClosure blk; | |
| 3766 | 2384 heap_region_iterate(&blk); |
| 342 | 2385 return blk.result(); |
| 2386 } | |
| 2387 | |
| 2388 size_t G1CollectedHeap::unsafe_max_alloc() { | |
| 2152 | 2389 if (free_regions() > 0) return HeapRegion::GrainBytes; |
| 342 | 2390 // otherwise, is there space in the current allocation region? |
| 2391 | |
| 2392 // We need to store the current allocation region in a local variable | |
| 2393 // here. The problem is that this method doesn't take any locks and | |
| 2394 // there may be other threads which overwrite the current allocation | |
| 2395 // region field. attempt_allocation(), for example, sets it to NULL | |
| 2396 // and this can happen *after* the NULL check here but before the call | |
| 2397 // to free(), resulting in a SIGSEGV. Note that this doesn't appear | |
| 2398 // to be a problem in the optimized build, since the two loads of the | |
| 2399 // current allocation region field are optimized away. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2400 HeapRegion* hr = _mutator_alloc_region.get(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2401 if (hr == NULL) { |
| 342 | 2402 return 0; |
| 2403 } | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2404 return hr->free(); |
| 342 | 2405 } |
| 2406 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2407 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
|
2408 switch (cause) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2409 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
|
2410 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
|
2411 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
|
2412 default: return false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2413 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2414 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2415 |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2416 #ifndef PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2417 void G1CollectedHeap::allocate_dummy_regions() { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2418 // Let's fill up most of the region |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2419 size_t word_size = HeapRegion::GrainWords - 1024; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2420 // 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
|
2421 guarantee(isHumongous(word_size), "sanity"); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2422 |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2423 for (uintx i = 0; i < G1DummyRegionsPerGC; ++i) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2424 // 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
|
2425 HeapWord* dummy_obj = humongous_obj_allocate(word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2426 if (dummy_obj != NULL) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2427 MemRegion mr(dummy_obj, word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2428 CollectedHeap::fill_with_object(mr); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2429 } else { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2430 // 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
|
2431 // again. Let's get out of the loop. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2432 break; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2433 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2434 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2435 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2436 #endif // !PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2437 |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2438 void G1CollectedHeap::increment_old_marking_cycles_started() { |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2439 assert(_old_marking_cycles_started == _old_marking_cycles_completed || |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2440 _old_marking_cycles_started == _old_marking_cycles_completed + 1, |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2441 err_msg("Wrong marking cycle count (started: %d, completed: %d)", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2442 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2443 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2444 _old_marking_cycles_started++; |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2445 } |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2446 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2447 void G1CollectedHeap::increment_old_marking_cycles_completed(bool concurrent) { |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2448 MonitorLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2449 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2450 // 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
|
2451 // 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
|
2452 // 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
|
2453 // assert here. |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2454 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2455 // 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
|
2456 // 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
|
2457 // interrupt a concurrent cycle), the number of full collections |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2458 // 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
|
2459 // 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
|
2460 // behind the number of full collections started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2461 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2462 // 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
|
2463 assert(concurrent || |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2464 (_old_marking_cycles_started == _old_marking_cycles_completed + 1) || |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2465 (_old_marking_cycles_started == _old_marking_cycles_completed + 2), |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2466 err_msg("for inner caller (Full GC): _old_marking_cycles_started = %u " |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2467 "is inconsistent with _old_marking_cycles_completed = %u", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2468 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2469 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2470 // 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
|
2471 assert(!concurrent || |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2472 (_old_marking_cycles_started == _old_marking_cycles_completed + 1), |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2473 err_msg("for outer caller (concurrent cycle): " |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2474 "_old_marking_cycles_started = %u " |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2475 "is inconsistent with _old_marking_cycles_completed = %u", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2476 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2477 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2478 _old_marking_cycles_completed += 1; |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2479 |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2480 // 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
|
2481 // we wake up any waiters (especially when ExplicitInvokesConcurrent |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2482 // 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
|
2483 // 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
|
2484 if (concurrent) { |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2485 _cmThread->clear_in_progress(); |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2486 } |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2487 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2488 // 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
|
2489 // System.gc() with (with ExplicitGCInvokesConcurrent set or not) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2490 // 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
|
2491 // waiting in VM_G1IncCollectionPause::doit_epilogue(). |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2492 FullGCCount_lock->notify_all(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2493 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2494 |
| 342 | 2495 void G1CollectedHeap::collect_as_vm_thread(GCCause::Cause cause) { |
| 2152 | 2496 assert_at_safepoint(true /* should_be_vm_thread */); |
| 342 | 2497 GCCauseSetter gcs(this, cause); |
| 2498 switch (cause) { | |
| 2499 case GCCause::_heap_inspection: | |
| 2500 case GCCause::_heap_dump: { | |
| 2501 HandleMark hm; | |
| 2502 do_full_collection(false); // don't clear all soft refs | |
| 2503 break; | |
| 2504 } | |
| 2505 default: // XXX FIX ME | |
| 2506 ShouldNotReachHere(); // Unexpected use of this function | |
| 2507 } | |
| 2508 } | |
| 2509 | |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2510 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
|
2511 assert_heap_not_locked(); |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2512 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2513 unsigned int gc_count_before; |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2514 unsigned int old_marking_count_before; |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2515 bool retry_gc; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2516 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2517 do { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2518 retry_gc = false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2519 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2520 { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2521 MutexLocker ml(Heap_lock); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2522 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2523 // 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
|
2524 gc_count_before = total_collections(); |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2525 old_marking_count_before = _old_marking_cycles_started; |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2526 } |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2527 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2528 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
|
2529 // 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
|
2530 // 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
|
2531 // we are not requesting a post-GC allocation. |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2532 VM_G1IncCollectionPause op(gc_count_before, |
| 1973 | 2533 0, /* word_size */ |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2534 true, /* should_initiate_conc_mark */ |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2535 g1_policy()->max_pause_time_ms(), |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2536 cause); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2537 |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2538 VMThread::execute(&op); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2539 if (!op.pause_succeeded()) { |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2540 if (old_marking_count_before == _old_marking_cycles_started) { |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2541 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
|
2542 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2543 // 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
|
2544 // 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
|
2545 // 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
|
2546 } |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2547 |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2548 if (retry_gc) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2549 if (GC_locker::is_active_and_needs_gc()) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2550 GC_locker::stall_until_clear(); |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2551 } |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2552 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2553 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2554 } else { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2555 if (cause == GCCause::_gc_locker |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2556 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
|
2557 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2558 // 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
|
2559 // 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
|
2560 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
|
2561 0, /* word_size */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2562 false, /* should_initiate_conc_mark */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2563 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
|
2564 cause); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2565 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2566 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2567 // Schedule a Full GC. |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2568 VM_G1CollectFull op(gc_count_before, old_marking_count_before, cause); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2569 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2570 } |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2571 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2572 } while (retry_gc); |
| 342 | 2573 } |
| 2574 | |
| 2575 bool G1CollectedHeap::is_in(const void* p) const { | |
| 4708 | 2576 if (_g1_committed.contains(p)) { |
| 2577 // Given that we know that p is in the committed space, | |
| 2578 // heap_region_containing_raw() should successfully | |
| 2579 // return the containing region. | |
| 2580 HeapRegion* hr = heap_region_containing_raw(p); | |
| 342 | 2581 return hr->is_in(p); |
| 2582 } else { | |
| 2583 return _perm_gen->as_gen()->is_in(p); | |
| 2584 } | |
| 2585 } | |
| 2586 | |
| 2587 // Iteration functions. | |
| 2588 | |
| 2589 // Iterates an OopClosure over all ref-containing fields of objects | |
| 2590 // within a HeapRegion. | |
| 2591 | |
| 2592 class IterateOopClosureRegionClosure: public HeapRegionClosure { | |
| 2593 MemRegion _mr; | |
| 2594 OopClosure* _cl; | |
| 2595 public: | |
| 2596 IterateOopClosureRegionClosure(MemRegion mr, OopClosure* cl) | |
| 2597 : _mr(mr), _cl(cl) {} | |
| 2598 bool doHeapRegion(HeapRegion* r) { | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2599 if (!r->continuesHumongous()) { |
| 342 | 2600 r->oop_iterate(_cl); |
| 2601 } | |
| 2602 return false; | |
| 2603 } | |
| 2604 }; | |
| 2605 | |
| 678 | 2606 void G1CollectedHeap::oop_iterate(OopClosure* cl, bool do_perm) { |
| 342 | 2607 IterateOopClosureRegionClosure blk(_g1_committed, cl); |
| 3766 | 2608 heap_region_iterate(&blk); |
| 678 | 2609 if (do_perm) { |
| 2610 perm_gen()->oop_iterate(cl); | |
| 2611 } | |
| 342 | 2612 } |
| 2613 | |
| 678 | 2614 void G1CollectedHeap::oop_iterate(MemRegion mr, OopClosure* cl, bool do_perm) { |
| 342 | 2615 IterateOopClosureRegionClosure blk(mr, cl); |
| 3766 | 2616 heap_region_iterate(&blk); |
| 678 | 2617 if (do_perm) { |
| 2618 perm_gen()->oop_iterate(cl); | |
| 2619 } | |
| 342 | 2620 } |
| 2621 | |
| 2622 // Iterates an ObjectClosure over all objects within a HeapRegion. | |
| 2623 | |
| 2624 class IterateObjectClosureRegionClosure: public HeapRegionClosure { | |
| 2625 ObjectClosure* _cl; | |
| 2626 public: | |
| 2627 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {} | |
| 2628 bool doHeapRegion(HeapRegion* r) { | |
| 2629 if (! r->continuesHumongous()) { | |
| 2630 r->object_iterate(_cl); | |
| 2631 } | |
| 2632 return false; | |
| 2633 } | |
| 2634 }; | |
| 2635 | |
| 678 | 2636 void G1CollectedHeap::object_iterate(ObjectClosure* cl, bool do_perm) { |
| 342 | 2637 IterateObjectClosureRegionClosure blk(cl); |
| 3766 | 2638 heap_region_iterate(&blk); |
| 678 | 2639 if (do_perm) { |
| 2640 perm_gen()->object_iterate(cl); | |
| 2641 } | |
| 342 | 2642 } |
| 2643 | |
| 2644 void G1CollectedHeap::object_iterate_since_last_GC(ObjectClosure* cl) { | |
| 2645 // FIXME: is this right? | |
| 2646 guarantee(false, "object_iterate_since_last_GC not supported by G1 heap"); | |
| 2647 } | |
| 2648 | |
| 2649 // Calls a SpaceClosure on a HeapRegion. | |
| 2650 | |
| 2651 class SpaceClosureRegionClosure: public HeapRegionClosure { | |
| 2652 SpaceClosure* _cl; | |
| 2653 public: | |
| 2654 SpaceClosureRegionClosure(SpaceClosure* cl) : _cl(cl) {} | |
| 2655 bool doHeapRegion(HeapRegion* r) { | |
| 2656 _cl->do_space(r); | |
| 2657 return false; | |
| 2658 } | |
| 2659 }; | |
| 2660 | |
| 2661 void G1CollectedHeap::space_iterate(SpaceClosure* cl) { | |
| 2662 SpaceClosureRegionClosure blk(cl); | |
| 3766 | 2663 heap_region_iterate(&blk); |
| 342 | 2664 } |
| 2665 | |
| 3766 | 2666 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const { |
| 2667 _hrs.iterate(cl); | |
| 342 | 2668 } |
| 2669 | |
| 2670 void | |
| 2671 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl, | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2672 uint worker_id, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2673 uint no_of_par_workers, |
| 342 | 2674 jint claim_value) { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2675 const uint regions = n_regions(); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2676 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
|
2677 no_of_par_workers : |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2678 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2679 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2680 no_of_par_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2681 "Non dynamic should use fixed number of workers"); |
| 355 | 2682 // try to spread out the starting points of the workers |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2683 const HeapRegion* start_hr = |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2684 start_region_for_worker(worker_id, no_of_par_workers); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2685 const uint start_index = start_hr->hrs_index(); |
| 355 | 2686 |
| 2687 // each worker will actually look at all regions | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2688 for (uint count = 0; count < regions; ++count) { |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2689 const uint index = (start_index + count) % regions; |
| 355 | 2690 assert(0 <= index && index < regions, "sanity"); |
| 2691 HeapRegion* r = region_at(index); | |
| 2692 // we'll ignore "continues humongous" regions (we'll process them | |
| 2693 // when we come across their corresponding "start humongous" | |
| 2694 // region) and regions already claimed | |
| 2695 if (r->claim_value() == claim_value || r->continuesHumongous()) { | |
| 2696 continue; | |
| 2697 } | |
| 2698 // OK, try to claim it | |
| 342 | 2699 if (r->claimHeapRegion(claim_value)) { |
| 355 | 2700 // success! |
| 2701 assert(!r->continuesHumongous(), "sanity"); | |
| 2702 if (r->startsHumongous()) { | |
| 2703 // If the region is "starts humongous" we'll iterate over its | |
| 2704 // "continues humongous" first; in fact we'll do them | |
| 2705 // first. The order is important. In on case, calling the | |
| 2706 // closure on the "starts humongous" region might de-allocate | |
| 2707 // and clear all its "continues humongous" regions and, as a | |
| 2708 // result, we might end up processing them twice. So, we'll do | |
| 2709 // them first (notice: most closures will ignore them anyway) and | |
| 2710 // then we'll do the "starts humongous" region. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2711 for (uint ch_index = index + 1; ch_index < regions; ++ch_index) { |
| 355 | 2712 HeapRegion* chr = region_at(ch_index); |
| 2713 | |
| 2714 // if the region has already been claimed or it's not | |
| 2715 // "continues humongous" we're done | |
| 2716 if (chr->claim_value() == claim_value || | |
| 2717 !chr->continuesHumongous()) { | |
| 2718 break; | |
| 2719 } | |
| 2720 | |
| 2721 // Noone should have claimed it directly. We can given | |
| 2722 // that we claimed its "starts humongous" region. | |
| 2723 assert(chr->claim_value() != claim_value, "sanity"); | |
| 2724 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2725 | |
| 2726 if (chr->claimHeapRegion(claim_value)) { | |
| 2727 // we should always be able to claim it; noone else should | |
| 2728 // be trying to claim this region | |
| 2729 | |
| 2730 bool res2 = cl->doHeapRegion(chr); | |
| 2731 assert(!res2, "Should not abort"); | |
| 2732 | |
| 2733 // Right now, this holds (i.e., no closure that actually | |
| 2734 // does something with "continues humongous" regions | |
| 2735 // clears them). We might have to weaken it in the future, | |
| 2736 // but let's leave these two asserts here for extra safety. | |
| 2737 assert(chr->continuesHumongous(), "should still be the case"); | |
| 2738 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2739 } else { | |
| 2740 guarantee(false, "we should not reach here"); | |
| 2741 } | |
| 2742 } | |
| 2743 } | |
| 2744 | |
| 2745 assert(!r->continuesHumongous(), "sanity"); | |
| 2746 bool res = cl->doHeapRegion(r); | |
| 2747 assert(!res, "Should not abort"); | |
| 2748 } | |
| 2749 } | |
| 2750 } | |
| 2751 | |
| 390 | 2752 class ResetClaimValuesClosure: public HeapRegionClosure { |
| 2753 public: | |
| 2754 bool doHeapRegion(HeapRegion* r) { | |
| 2755 r->set_claim_value(HeapRegion::InitialClaimValue); | |
| 2756 return false; | |
| 2757 } | |
| 2758 }; | |
| 2759 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2760 void G1CollectedHeap::reset_heap_region_claim_values() { |
| 390 | 2761 ResetClaimValuesClosure blk; |
| 2762 heap_region_iterate(&blk); | |
| 2763 } | |
| 2764 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2765 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
|
2766 ResetClaimValuesClosure blk; |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2767 collection_set_iterate(&blk); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2768 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2769 |
| 355 | 2770 #ifdef ASSERT |
| 2771 // This checks whether all regions in the heap have the correct claim | |
| 2772 // value. I also piggy-backed on this a check to ensure that the | |
| 2773 // humongous_start_region() information on "continues humongous" | |
| 2774 // regions is correct. | |
| 2775 | |
| 2776 class CheckClaimValuesClosure : public HeapRegionClosure { | |
| 2777 private: | |
| 2778 jint _claim_value; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2779 uint _failures; |
| 355 | 2780 HeapRegion* _sh_region; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2781 |
| 355 | 2782 public: |
| 2783 CheckClaimValuesClosure(jint claim_value) : | |
| 2784 _claim_value(claim_value), _failures(0), _sh_region(NULL) { } | |
| 2785 bool doHeapRegion(HeapRegion* r) { | |
| 2786 if (r->claim_value() != _claim_value) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2787 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2788 "claim value = %d, should be %d", |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2789 HR_FORMAT_PARAMS(r), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2790 r->claim_value(), _claim_value); |
| 355 | 2791 ++_failures; |
| 2792 } | |
| 2793 if (!r->isHumongous()) { | |
| 2794 _sh_region = NULL; | |
| 2795 } else if (r->startsHumongous()) { | |
| 2796 _sh_region = r; | |
| 2797 } else if (r->continuesHumongous()) { | |
| 2798 if (r->humongous_start_region() != _sh_region) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2799 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2800 "HS = "PTR_FORMAT", should be "PTR_FORMAT, |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2801 HR_FORMAT_PARAMS(r), |
| 355 | 2802 r->humongous_start_region(), |
| 2803 _sh_region); | |
| 2804 ++_failures; | |
| 342 | 2805 } |
| 2806 } | |
| 355 | 2807 return false; |
| 2808 } | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2809 uint failures() { return _failures; } |
| 355 | 2810 }; |
| 2811 | |
| 2812 bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) { | |
| 2813 CheckClaimValuesClosure cl(claim_value); | |
| 2814 heap_region_iterate(&cl); | |
| 2815 return cl.failures() == 0; | |
| 2816 } | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2817 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2818 class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2819 private: |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2820 jint _claim_value; |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2821 uint _failures; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2822 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2823 public: |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2824 CheckClaimValuesInCSetHRClosure(jint claim_value) : |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2825 _claim_value(claim_value), _failures(0) { } |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2826 |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2827 uint failures() { return _failures; } |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2828 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2829 bool doHeapRegion(HeapRegion* hr) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2830 assert(hr->in_collection_set(), "how?"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2831 assert(!hr->isHumongous(), "H-region in CSet"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2832 if (hr->claim_value() != _claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2833 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
|
2834 "claim value = %d, should be %d", |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2835 HR_FORMAT_PARAMS(hr), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2836 hr->claim_value(), _claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2837 _failures += 1; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2838 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2839 return false; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2840 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2841 }; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2842 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2843 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
|
2844 CheckClaimValuesInCSetHRClosure cl(claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2845 collection_set_iterate(&cl); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2846 return cl.failures() == 0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2847 } |
| 355 | 2848 #endif // ASSERT |
| 342 | 2849 |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2850 // 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
|
2851 // 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
|
2852 void G1CollectedHeap::clear_cset_start_regions() { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2853 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
|
2854 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
|
2855 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2856 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
|
2857 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
|
2858 _worker_cset_start_region[i] = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2859 _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
|
2860 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2861 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2862 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2863 // 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
|
2864 // 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
|
2865 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
|
2866 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
|
2867 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2868 HeapRegion* result = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2869 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
|
2870 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2871 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
|
2872 // 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
|
2873 // 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
|
2874 // 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
|
2875 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2876 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
|
2877 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
|
2878 return result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2879 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2880 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2881 // 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
|
2882 // 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
|
2883 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2884 // 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
|
2885 // 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
|
2886 // avoid contention. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2887 // If we have: |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2888 // n collection set regions |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2889 // p threads |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2890 // 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
|
2891 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2892 result = g1_policy()->collection_set(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2893 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2894 uint 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
|
2895 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
|
2896 assert(UseDynamicNumberOfGCThreads || |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2897 active_workers == workers()->total_workers(), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2898 "Unless dynamic should use total workers"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2899 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2900 uint end_ind = (cs_size * worker_i) / active_workers; |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2901 uint start_ind = 0; |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2902 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2903 if (worker_i > 0 && |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2904 _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
|
2905 // Previous workers starting region is valid |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2906 // so let's iterate from there |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2907 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
|
2908 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
|
2909 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2910 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2911 for (uint i = start_ind; i < end_ind; i++) { |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2912 result = result->next_in_collection_set(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2913 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2914 } |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2915 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2916 // 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
|
2917 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2918 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
|
2919 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
|
2920 "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
|
2921 _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
|
2922 OrderAccess::storestore(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2923 _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
|
2924 return result; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2925 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2926 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2927 HeapRegion* G1CollectedHeap::start_region_for_worker(uint worker_i, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2928 uint no_of_par_workers) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2929 uint worker_num = |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2930 G1CollectedHeap::use_parallel_gc_threads() ? no_of_par_workers : 1U; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2931 assert(UseDynamicNumberOfGCThreads || |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2932 no_of_par_workers == workers()->total_workers(), |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2933 "Non dynamic should use fixed number of workers"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2934 const uint start_index = n_regions() * worker_i / worker_num; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2935 return region_at(start_index); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2936 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2937 |
| 342 | 2938 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) { |
| 2939 HeapRegion* r = g1_policy()->collection_set(); | |
| 2940 while (r != NULL) { | |
| 2941 HeapRegion* next = r->next_in_collection_set(); | |
| 2942 if (cl->doHeapRegion(r)) { | |
| 2943 cl->incomplete(); | |
| 2944 return; | |
| 2945 } | |
| 2946 r = next; | |
| 2947 } | |
| 2948 } | |
| 2949 | |
| 2950 void G1CollectedHeap::collection_set_iterate_from(HeapRegion* r, | |
| 2951 HeapRegionClosure *cl) { | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2952 if (r == NULL) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2953 // 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
|
2954 return; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2955 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2956 |
| 342 | 2957 assert(r->in_collection_set(), |
| 2958 "Start region must be a member of the collection set."); | |
| 2959 HeapRegion* cur = r; | |
| 2960 while (cur != NULL) { | |
| 2961 HeapRegion* next = cur->next_in_collection_set(); | |
| 2962 if (cl->doHeapRegion(cur) && false) { | |
| 2963 cl->incomplete(); | |
| 2964 return; | |
| 2965 } | |
| 2966 cur = next; | |
| 2967 } | |
| 2968 cur = g1_policy()->collection_set(); | |
| 2969 while (cur != r) { | |
| 2970 HeapRegion* next = cur->next_in_collection_set(); | |
| 2971 if (cl->doHeapRegion(cur) && false) { | |
| 2972 cl->incomplete(); | |
| 2973 return; | |
| 2974 } | |
| 2975 cur = next; | |
| 2976 } | |
| 2977 } | |
| 2978 | |
| 2979 CompactibleSpace* G1CollectedHeap::first_compactible_space() { | |
| 3766 | 2980 return n_regions() > 0 ? region_at(0) : NULL; |
| 342 | 2981 } |
| 2982 | |
| 2983 | |
| 2984 Space* G1CollectedHeap::space_containing(const void* addr) const { | |
| 2985 Space* res = heap_region_containing(addr); | |
| 2986 if (res == NULL) | |
| 2987 res = perm_gen()->space_containing(addr); | |
| 2988 return res; | |
| 2989 } | |
| 2990 | |
| 2991 HeapWord* G1CollectedHeap::block_start(const void* addr) const { | |
| 2992 Space* sp = space_containing(addr); | |
| 2993 if (sp != NULL) { | |
| 2994 return sp->block_start(addr); | |
| 2995 } | |
| 2996 return NULL; | |
| 2997 } | |
| 2998 | |
| 2999 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { | |
| 3000 Space* sp = space_containing(addr); | |
| 3001 assert(sp != NULL, "block_size of address outside of heap"); | |
| 3002 return sp->block_size(addr); | |
| 3003 } | |
| 3004 | |
| 3005 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { | |
| 3006 Space* sp = space_containing(addr); | |
| 3007 return sp->block_is_obj(addr); | |
| 3008 } | |
| 3009 | |
| 3010 bool G1CollectedHeap::supports_tlab_allocation() const { | |
| 3011 return true; | |
| 3012 } | |
| 3013 | |
| 3014 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const { | |
| 3015 return HeapRegion::GrainBytes; | |
| 3016 } | |
| 3017 | |
| 3018 size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const { | |
| 3019 // Return the remaining space in the cur alloc region, but not less than | |
| 3020 // the min TLAB size. | |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3021 |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3022 // 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
|
3023 // 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
|
3024 // humongous objects. |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3025 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3026 HeapRegion* hr = _mutator_alloc_region.get(); |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3027 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
|
3028 if (hr == NULL) { |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3029 return max_tlab_size; |
| 342 | 3030 } else { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3031 return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab_size); |
| 342 | 3032 } |
| 3033 } | |
| 3034 | |
| 3035 size_t G1CollectedHeap::max_capacity() const { | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3036 return _g1_reserved.byte_size(); |
| 342 | 3037 } |
| 3038 | |
| 3039 jlong G1CollectedHeap::millis_since_last_gc() { | |
| 3040 // assert(false, "NYI"); | |
| 3041 return 0; | |
| 3042 } | |
| 3043 | |
| 3044 void G1CollectedHeap::prepare_for_verify() { | |
| 3045 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { | |
| 3046 ensure_parsability(false); | |
| 3047 } | |
| 3048 g1_rem_set()->prepare_for_verify(); | |
| 3049 } | |
| 3050 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3051 bool G1CollectedHeap::allocated_since_marking(oop obj, HeapRegion* hr, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3052 VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3053 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3054 case VerifyOption_G1UsePrevMarking: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3055 return hr->obj_allocated_since_prev_marking(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3056 case VerifyOption_G1UseNextMarking: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3057 return hr->obj_allocated_since_next_marking(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3058 case VerifyOption_G1UseMarkWord: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3059 return false; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3060 default: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3061 ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3062 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3063 return false; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3064 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3065 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3066 HeapWord* G1CollectedHeap::top_at_mark_start(HeapRegion* hr, VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3067 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3068 case VerifyOption_G1UsePrevMarking: return hr->prev_top_at_mark_start(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3069 case VerifyOption_G1UseNextMarking: return hr->next_top_at_mark_start(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3070 case VerifyOption_G1UseMarkWord: return NULL; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3071 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3072 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3073 return NULL; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3074 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3075 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3076 bool G1CollectedHeap::is_marked(oop obj, VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3077 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3078 case VerifyOption_G1UsePrevMarking: return isMarkedPrev(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3079 case VerifyOption_G1UseNextMarking: return isMarkedNext(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3080 case VerifyOption_G1UseMarkWord: return obj->is_gc_marked(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3081 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3082 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3083 return false; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3084 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3085 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3086 const char* G1CollectedHeap::top_at_mark_start_str(VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3087 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3088 case VerifyOption_G1UsePrevMarking: return "PTAMS"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3089 case VerifyOption_G1UseNextMarking: return "NTAMS"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3090 case VerifyOption_G1UseMarkWord: return "NONE"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3091 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3092 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3093 return NULL; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3094 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3095 |
| 342 | 3096 class VerifyLivenessOopClosure: public OopClosure { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3097 G1CollectedHeap* _g1h; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3098 VerifyOption _vo; |
| 342 | 3099 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3100 VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo): |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3101 _g1h(g1h), _vo(vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3102 { } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3103 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
|
3104 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
|
3105 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3106 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
|
3107 oop obj = oopDesc::load_decode_heap_oop(p); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3108 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
|
3109 "Dead object referenced by a not dead object"); |
| 342 | 3110 } |
| 3111 }; | |
| 3112 | |
| 3113 class VerifyObjsInRegionClosure: public ObjectClosure { | |
| 811 | 3114 private: |
| 342 | 3115 G1CollectedHeap* _g1h; |
| 3116 size_t _live_bytes; | |
| 3117 HeapRegion *_hr; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3118 VerifyOption _vo; |
| 342 | 3119 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3120 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3121 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3122 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3123 VerifyObjsInRegionClosure(HeapRegion *hr, VerifyOption vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3124 : _live_bytes(0), _hr(hr), _vo(vo) { |
| 342 | 3125 _g1h = G1CollectedHeap::heap(); |
| 3126 } | |
| 3127 void do_object(oop o) { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3128 VerifyLivenessOopClosure isLive(_g1h, _vo); |
| 342 | 3129 assert(o != NULL, "Huh?"); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3130 if (!_g1h->is_obj_dead_cond(o, _vo)) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3131 // If the object is alive according to the mark word, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3132 // then verify that the marking information agrees. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3133 // Note we can't verify the contra-positive of the |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3134 // above: if the object is dead (according to the mark |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3135 // 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
|
3136 // but has since became dead, or may have been allocated |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3137 // since the last marking. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3138 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3139 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
|
3140 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3141 |
| 342 | 3142 o->oop_iterate(&isLive); |
|
1389
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3143 if (!_hr->obj_allocated_since_prev_marking(o)) { |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3144 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
|
3145 _live_bytes += (obj_size * HeapWordSize); |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3146 } |
| 342 | 3147 } |
| 3148 } | |
| 3149 size_t live_bytes() { return _live_bytes; } | |
| 3150 }; | |
| 3151 | |
| 3152 class PrintObjsInRegionClosure : public ObjectClosure { | |
| 3153 HeapRegion *_hr; | |
| 3154 G1CollectedHeap *_g1; | |
| 3155 public: | |
| 3156 PrintObjsInRegionClosure(HeapRegion *hr) : _hr(hr) { | |
| 3157 _g1 = G1CollectedHeap::heap(); | |
| 3158 }; | |
| 3159 | |
| 3160 void do_object(oop o) { | |
| 3161 if (o != NULL) { | |
| 3162 HeapWord *start = (HeapWord *) o; | |
| 3163 size_t word_sz = o->size(); | |
| 3164 gclog_or_tty->print("\nPrinting obj "PTR_FORMAT" of size " SIZE_FORMAT | |
| 3165 " isMarkedPrev %d isMarkedNext %d isAllocSince %d\n", | |
| 3166 (void*) o, word_sz, | |
| 3167 _g1->isMarkedPrev(o), | |
| 3168 _g1->isMarkedNext(o), | |
| 3169 _hr->obj_allocated_since_prev_marking(o)); | |
| 3170 HeapWord *end = start + word_sz; | |
| 3171 HeapWord *cur; | |
| 3172 int *val; | |
| 3173 for (cur = start; cur < end; cur++) { | |
| 3174 val = (int *) cur; | |
| 3175 gclog_or_tty->print("\t "PTR_FORMAT":"PTR_FORMAT"\n", val, *val); | |
| 3176 } | |
| 3177 } | |
| 3178 } | |
| 3179 }; | |
| 3180 | |
| 3181 class VerifyRegionClosure: public HeapRegionClosure { | |
| 811 | 3182 private: |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3183 bool _par; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3184 VerifyOption _vo; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3185 bool _failures; |
| 811 | 3186 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3187 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3188 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3189 // _vo == UseMarkWord -> use mark word from object header. |
| 6008 | 3190 VerifyRegionClosure(bool par, VerifyOption vo) |
| 3191 : _par(par), | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3192 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3193 _failures(false) {} |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3194 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3195 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3196 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3197 } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3198 |
| 342 | 3199 bool doHeapRegion(HeapRegion* r) { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3200 if (!r->continuesHumongous()) { |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3201 bool failures = false; |
| 6008 | 3202 r->verify(_vo, &failures); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3203 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3204 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3205 } else { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3206 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3207 r->object_iterate(¬_dead_yet_cl); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3208 if (_vo != VerifyOption_G1UseNextMarking) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3209 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
|
3210 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
|
3211 "max_live_bytes "SIZE_FORMAT" " |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3212 "< calculated "SIZE_FORMAT, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3213 r->bottom(), r->end(), |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3214 r->max_live_bytes(), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3215 not_dead_yet_cl.live_bytes()); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3216 _failures = true; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3217 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3218 } else { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3219 // 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
|
3220 // 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
|
3221 // finalized yet. |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3222 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3223 } |
| 342 | 3224 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3225 return false; // stop the region iteration if we hit a failure |
| 342 | 3226 } |
| 3227 }; | |
| 3228 | |
| 3229 class VerifyRootsClosure: public OopsInGenClosure { | |
| 3230 private: | |
| 3231 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3232 VerifyOption _vo; |
| 342 | 3233 bool _failures; |
| 3234 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3235 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3236 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3237 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3238 VerifyRootsClosure(VerifyOption vo) : |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3239 _g1h(G1CollectedHeap::heap()), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3240 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3241 _failures(false) { } |
| 342 | 3242 |
| 3243 bool failures() { return _failures; } | |
| 3244 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3245 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
|
3246 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3247 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3248 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
|
3249 if (_g1h->is_obj_dead_cond(obj, _vo)) { |
| 342 | 3250 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
|
3251 "points to dead obj "PTR_FORMAT, p, (void*) obj); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3252 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3253 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
|
3254 } |
| 342 | 3255 obj->print_on(gclog_or_tty); |
| 3256 _failures = true; | |
| 3257 } | |
| 3258 } | |
| 3259 } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3260 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3261 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
|
3262 void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 3263 }; |
| 3264 | |
| 390 | 3265 // This is the task used for parallel heap verification. |
| 3266 | |
| 3267 class G1ParVerifyTask: public AbstractGangTask { | |
| 3268 private: | |
| 3269 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3270 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3271 bool _failures; |
| 390 | 3272 |
| 3273 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3274 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3275 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3276 // _vo == UseMarkWord -> use mark word from object header. |
| 6008 | 3277 G1ParVerifyTask(G1CollectedHeap* g1h, VerifyOption vo) : |
| 390 | 3278 AbstractGangTask("Parallel verify task"), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3279 _g1h(g1h), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3280 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3281 _failures(false) { } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3282 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3283 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3284 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3285 } |
| 390 | 3286 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3287 void work(uint worker_id) { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3288 HandleMark hm; |
| 6008 | 3289 VerifyRegionClosure blk(true, _vo); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3290 _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
|
3291 _g1h->workers()->active_workers(), |
| 390 | 3292 HeapRegion::ParVerifyClaimValue); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3293 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3294 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3295 } |
| 390 | 3296 } |
| 3297 }; | |
| 3298 | |
| 6008 | 3299 void G1CollectedHeap::verify(bool silent) { |
| 3300 verify(silent, VerifyOption_G1UsePrevMarking); | |
| 3301 } | |
| 3302 | |
| 3303 void G1CollectedHeap::verify(bool silent, | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3304 VerifyOption vo) { |
| 342 | 3305 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3306 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); } |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3307 VerifyRootsClosure rootsCl(vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3308 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3309 assert(Thread::current()->is_VM_thread(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3310 "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
|
3311 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3312 CodeBlobToOopClosure blobsCl(&rootsCl, /*do_marking=*/ false); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3313 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3314 // 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
|
3315 // 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
|
3316 const int so = SO_AllClasses | SO_Strings | SO_CodeCache; |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3317 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3318 process_strong_roots(true, // activate StrongRootsScope |
|
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3319 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
|
3320 // 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
|
3321 ScanningOption(so), // roots scanning options |
| 342 | 3322 &rootsCl, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
3323 &blobsCl, |
| 342 | 3324 &rootsCl); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3325 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3326 // 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
|
3327 // 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
|
3328 // 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
|
3329 // 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
|
3330 // "Root location <x> points to dead ob <y>" failure. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3331 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3332 // 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
|
3333 // 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
|
3334 // references explicitly below. Whether the relevant cards are dirty |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3335 // is checked further below in the rem set verification. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3336 if (!silent) { gclog_or_tty->print("Permgen roots "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3337 perm_gen()->oop_iterate(&rootsCl); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3338 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3339 bool failures = rootsCl.failures(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3340 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3341 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3342 // 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
|
3343 // 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
|
3344 // verifying the region sets will fail. So we only verify |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3345 // the region sets when not in a full GC. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3346 if (!silent) { gclog_or_tty->print("HeapRegionSets "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3347 verify_region_sets(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3348 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3349 |
| 2152 | 3350 if (!silent) { gclog_or_tty->print("HeapRegions "); } |
| 390 | 3351 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { |
| 3352 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3353 "sanity check"); | |
| 3354 | |
| 6008 | 3355 G1ParVerifyTask task(this, vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3356 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3357 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3358 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3359 int n_workers = workers()->active_workers(); |
| 390 | 3360 set_par_threads(n_workers); |
| 3361 workers()->run_task(&task); | |
| 3362 set_par_threads(0); | |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3363 if (task.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3364 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3365 } |
| 390 | 3366 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3367 // 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
|
3368 // The implication is that n_workers is > 0. |
| 390 | 3369 assert(check_heap_region_claim_values(HeapRegion::ParVerifyClaimValue), |
| 3370 "sanity check"); | |
| 3371 | |
| 3372 reset_heap_region_claim_values(); | |
| 3373 | |
| 3374 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3375 "sanity check"); | |
| 3376 } else { | |
| 6008 | 3377 VerifyRegionClosure blk(false, vo); |
| 3766 | 3378 heap_region_iterate(&blk); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3379 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3380 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3381 } |
| 390 | 3382 } |
| 2152 | 3383 if (!silent) gclog_or_tty->print("RemSet "); |
| 342 | 3384 rem_set()->verify(); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3385 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3386 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3387 gclog_or_tty->print_cr("Heap:"); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3388 // 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
|
3389 // 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
|
3390 // print_extended_on() instead of print_on(). |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3391 print_extended_on(gclog_or_tty); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3392 gclog_or_tty->print_cr(""); |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3393 #ifndef PRODUCT |
| 1044 | 3394 if (VerifyDuringGC && G1VerifyDuringGCPrintReachable) { |
| 1388 | 3395 concurrent_mark()->print_reachable("at-verification-failure", |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3396 vo, false /* all */); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3397 } |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3398 #endif |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3399 gclog_or_tty->flush(); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3400 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3401 guarantee(!failures, "there should not have been any failures"); |
| 342 | 3402 } else { |
| 3403 if (!silent) gclog_or_tty->print("(SKIPPING roots, heapRegions, remset) "); | |
| 3404 } | |
| 3405 } | |
| 3406 | |
| 3407 class PrintRegionClosure: public HeapRegionClosure { | |
| 3408 outputStream* _st; | |
| 3409 public: | |
| 3410 PrintRegionClosure(outputStream* st) : _st(st) {} | |
| 3411 bool doHeapRegion(HeapRegion* r) { | |
| 3412 r->print_on(_st); | |
| 3413 return false; | |
| 3414 } | |
| 3415 }; | |
| 3416 | |
| 3417 void G1CollectedHeap::print_on(outputStream* st) const { | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3418 st->print(" %-20s", "garbage-first heap"); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3419 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
|
3420 capacity()/K, used_unlocked()/K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3421 st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3422 _g1_storage.low_boundary(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3423 _g1_storage.high(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3424 _g1_storage.high_boundary()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3425 st->cr(); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
3426 st->print(" region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3427 uint young_regions = _young_list->length(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3428 st->print("%u young (" SIZE_FORMAT "K), ", young_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3429 (size_t) young_regions * HeapRegion::GrainBytes / K); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3430 uint survivor_regions = g1_policy()->recorded_survivor_regions(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3431 st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3432 (size_t) survivor_regions * HeapRegion::GrainBytes / K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3433 st->cr(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3434 perm()->as_gen()->print_on(st); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3435 } |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3436 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3437 void G1CollectedHeap::print_extended_on(outputStream* st) const { |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3438 print_on(st); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3439 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3440 // Print the per-region information. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3441 st->cr(); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3442 st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3443 "HS=humongous(starts), HC=humongous(continues), " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3444 "CS=collection set, F=free, TS=gc time stamp, " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3445 "PTAMS=previous top-at-mark-start, " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3446 "NTAMS=next top-at-mark-start)"); |
| 342 | 3447 PrintRegionClosure blk(st); |
| 3766 | 3448 heap_region_iterate(&blk); |
| 342 | 3449 } |
| 3450 | |
| 3451 void G1CollectedHeap::print_gc_threads_on(outputStream* st) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3452 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 1019 | 3453 workers()->print_worker_threads_on(st); |
| 3454 } | |
| 3455 _cmThread->print_on(st); | |
| 342 | 3456 st->cr(); |
| 1019 | 3457 _cm->print_worker_threads_on(st); |
| 3458 _cg1r->print_worker_threads_on(st); | |
| 342 | 3459 st->cr(); |
| 3460 } | |
| 3461 | |
| 3462 void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3463 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 3464 workers()->threads_do(tc); |
| 3465 } | |
| 3466 tc->do_thread(_cmThread); | |
| 794 | 3467 _cg1r->threads_do(tc); |
| 342 | 3468 } |
| 3469 | |
| 3470 void G1CollectedHeap::print_tracing_info() const { | |
| 3471 // We'll overload this to mean "trace GC pause statistics." | |
| 3472 if (TraceGen0Time || TraceGen1Time) { | |
| 3473 // The "G1CollectorPolicy" is keeping track of these stats, so delegate | |
| 3474 // to that. | |
| 3475 g1_policy()->print_tracing_info(); | |
| 3476 } | |
| 751 | 3477 if (G1SummarizeRSetStats) { |
| 342 | 3478 g1_rem_set()->print_summary_info(); |
| 3479 } | |
| 1282 | 3480 if (G1SummarizeConcMark) { |
| 342 | 3481 concurrent_mark()->print_summary_info(); |
| 3482 } | |
| 3483 g1_policy()->print_yg_surv_rate_info(); | |
| 3484 SpecializationStats::print(); | |
| 3485 } | |
| 3486 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3487 #ifndef PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3488 // Helpful for debugging RSet issues. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3489 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3490 class PrintRSetsClosure : public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3491 private: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3492 const char* _msg; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3493 size_t _occupied_sum; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3494 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3495 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3496 bool doHeapRegion(HeapRegion* r) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3497 HeapRegionRemSet* hrrs = r->rem_set(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3498 size_t occupied = hrrs->occupied(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3499 _occupied_sum += occupied; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3500 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3501 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
|
3502 HR_FORMAT_PARAMS(r)); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3503 if (occupied == 0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3504 gclog_or_tty->print_cr(" RSet is empty"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3505 } else { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3506 hrrs->print(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3507 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3508 gclog_or_tty->print_cr("----------"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3509 return false; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3510 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3511 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3512 PrintRSetsClosure(const char* msg) : _msg(msg), _occupied_sum(0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3513 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3514 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3515 gclog_or_tty->print_cr(msg); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3516 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3517 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3518 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3519 ~PrintRSetsClosure() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3520 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
|
3521 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3522 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3523 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3524 }; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3525 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3526 void G1CollectedHeap::print_cset_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3527 PrintRSetsClosure cl("Printing CSet RSets"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3528 collection_set_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3529 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3530 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3531 void G1CollectedHeap::print_all_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3532 PrintRSetsClosure cl("Printing All RSets");; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3533 heap_region_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3534 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3535 #endif // PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3536 |
| 342 | 3537 G1CollectedHeap* G1CollectedHeap::heap() { |
| 3538 assert(_sh->kind() == CollectedHeap::G1CollectedHeap, | |
| 3539 "not a garbage-first heap"); | |
| 3540 return _g1h; | |
| 3541 } | |
| 3542 | |
| 3543 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) { | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3544 // always_do_update_barrier = false; |
| 342 | 3545 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); |
| 3546 // Call allocation profiler | |
| 3547 AllocationProfiler::iterate_since_last_gc(); | |
| 3548 // Fill TLAB's and such | |
| 3549 ensure_parsability(true); | |
| 3550 } | |
| 3551 | |
| 3552 void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) { | |
| 3553 // FIXME: what is this about? | |
| 3554 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled" | |
| 3555 // is set. | |
| 3556 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), | |
| 3557 "derived pointer present")); | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3558 // always_do_update_barrier = true; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3559 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3560 // We have just completed a GC. Update the soft reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3561 // policy with the new heap occupancy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3562 Universe::update_heap_info_at_gc(); |
| 342 | 3563 } |
| 3564 | |
| 1973 | 3565 HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size, |
| 3566 unsigned int gc_count_before, | |
| 3567 bool* succeeded) { | |
| 3568 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 3569 g1_policy()->record_stop_world_start(); |
| 1973 | 3570 VM_G1IncCollectionPause op(gc_count_before, |
| 3571 word_size, | |
| 3572 false, /* should_initiate_conc_mark */ | |
| 3573 g1_policy()->max_pause_time_ms(), | |
| 3574 GCCause::_g1_inc_collection_pause); | |
| 3575 VMThread::execute(&op); | |
| 3576 | |
| 3577 HeapWord* result = op.result(); | |
| 3578 bool ret_succeeded = op.prologue_succeeded() && op.pause_succeeded(); | |
| 3579 assert(result == NULL || ret_succeeded, | |
| 3580 "the result should be NULL if the VM did not succeed"); | |
| 3581 *succeeded = ret_succeeded; | |
| 3582 | |
| 3583 assert_heap_not_locked(); | |
| 3584 return result; | |
| 342 | 3585 } |
| 3586 | |
| 3587 void | |
| 3588 G1CollectedHeap::doConcurrentMark() { | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3589 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
|
3590 if (!_cmThread->in_progress()) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3591 _cmThread->set_started(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3592 CGC_lock->notify(); |
| 342 | 3593 } |
| 3594 } | |
| 3595 | |
| 3596 size_t G1CollectedHeap::pending_card_num() { | |
| 3597 size_t extra_cards = 0; | |
| 3598 JavaThread *curr = Threads::first(); | |
| 3599 while (curr != NULL) { | |
| 3600 DirtyCardQueue& dcq = curr->dirty_card_queue(); | |
| 3601 extra_cards += dcq.size(); | |
| 3602 curr = curr->next(); | |
| 3603 } | |
| 3604 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3605 size_t buffer_size = dcqs.buffer_size(); | |
| 3606 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 6611 | 3607 |
| 3608 // PtrQueueSet::buffer_size() and PtrQueue:size() return sizes | |
| 3609 // in bytes - not the number of 'entries'. We need to convert | |
| 3610 // into a number of cards. | |
| 3611 return (buffer_size * buffer_num + extra_cards) / oopSize; | |
| 342 | 3612 } |
| 3613 | |
| 3614 size_t G1CollectedHeap::cards_scanned() { | |
| 1861 | 3615 return g1_rem_set()->cardsScanned(); |
| 342 | 3616 } |
| 3617 | |
| 3618 void | |
| 3619 G1CollectedHeap::setup_surviving_young_words() { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3620 assert(_surviving_young_words == NULL, "pre-condition"); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3621 uint array_length = g1_policy()->young_cset_region_length(); |
| 6197 | 3622 _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length, mtGC); |
| 342 | 3623 if (_surviving_young_words == NULL) { |
| 3624 vm_exit_out_of_memory(sizeof(size_t) * array_length, | |
| 3625 "Not enough space for young surv words summary."); | |
| 3626 } | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3627 memset(_surviving_young_words, 0, (size_t) array_length * sizeof(size_t)); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3628 #ifdef ASSERT |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3629 for (uint i = 0; i < array_length; ++i) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3630 assert( _surviving_young_words[i] == 0, "memset above" ); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3631 } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3632 #endif // !ASSERT |
| 342 | 3633 } |
| 3634 | |
| 3635 void | |
| 3636 G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { | |
| 3637 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3638 uint array_length = g1_policy()->young_cset_region_length(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3639 for (uint i = 0; i < array_length; ++i) { |
| 342 | 3640 _surviving_young_words[i] += surv_young_words[i]; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3641 } |
| 342 | 3642 } |
| 3643 | |
| 3644 void | |
| 3645 G1CollectedHeap::cleanup_surviving_young_words() { | |
| 3646 guarantee( _surviving_young_words != NULL, "pre-condition" ); | |
| 6197 | 3647 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words, mtGC); |
| 342 | 3648 _surviving_young_words = NULL; |
| 3649 } | |
| 3650 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3651 #ifdef ASSERT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3652 class VerifyCSetClosure: public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3653 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3654 bool doHeapRegion(HeapRegion* hr) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3655 // 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
|
3656 // 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
|
3657 // 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
|
3658 // 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
|
3659 // 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
|
3660 // 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
|
3661 // 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
|
3662 // 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
|
3663 // evacuation failure handling. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3664 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
|
3665 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3666 // 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
|
3667 // perform on CSet regions. |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3668 return false; |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3669 } |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3670 }; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3671 #endif // ASSERT |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3672 |
| 1709 | 3673 #if TASKQUEUE_STATS |
| 3674 void G1CollectedHeap::print_taskqueue_stats_hdr(outputStream* const st) { | |
| 3675 st->print_raw_cr("GC Task Stats"); | |
| 3676 st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr(); | |
| 3677 st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); | |
| 3678 } | |
| 3679 | |
| 3680 void G1CollectedHeap::print_taskqueue_stats(outputStream* const st) const { | |
| 3681 print_taskqueue_stats_hdr(st); | |
| 3682 | |
| 3683 TaskQueueStats totals; | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3684 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3685 for (int i = 0; i < n; ++i) { |
| 3686 st->print("%3d ", i); task_queue(i)->stats.print(st); st->cr(); | |
| 3687 totals += task_queue(i)->stats; | |
| 3688 } | |
| 3689 st->print_raw("tot "); totals.print(st); st->cr(); | |
| 3690 | |
| 3691 DEBUG_ONLY(totals.verify()); | |
| 3692 } | |
| 3693 | |
| 3694 void G1CollectedHeap::reset_taskqueue_stats() { | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3695 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3696 for (int i = 0; i < n; ++i) { |
| 3697 task_queue(i)->stats.reset(); | |
| 3698 } | |
| 3699 } | |
| 3700 #endif // TASKQUEUE_STATS | |
| 3701 | |
| 1973 | 3702 bool |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3703 G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { |
| 2152 | 3704 assert_at_safepoint(true /* should_be_vm_thread */); |
| 3705 guarantee(!is_gc_active(), "collection is not reentrant"); | |
| 3706 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3707 if (GC_locker::check_active_before_gc()) { |
| 1973 | 3708 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3709 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3710 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
3711 SvcGCMarker sgcm(SvcGCMarker::MINOR); |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3712 ResourceMark rm; |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3713 |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
3714 print_heap_before_gc(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3715 |
| 4072 | 3716 HRSPhaseSetter x(HRSPhaseEvacuation); |
| 2152 | 3717 verify_region_sets_optional(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3718 verify_dirty_young_regions(); |
| 2152 | 3719 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3720 // 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
|
3721 // 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
|
3722 // for the duration of this pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3723 g1_policy()->decide_on_conc_mark_initiation(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3724 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3725 // 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
|
3726 assert(!g1_policy()->during_initial_mark_pause() || |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3727 g1_policy()->gcs_are_young(), "sanity"); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3728 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3729 // 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
|
3730 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
|
3731 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3732 // 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
|
3733 // 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
|
3734 // 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
|
3735 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
|
3736 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3737 // 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
|
3738 { |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3739 if (g1_policy()->during_initial_mark_pause()) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3740 // 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
|
3741 // full collection counter. |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
3742 increment_old_marking_cycles_started(); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3743 } |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3744 // 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
|
3745 // 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
|
3746 // is messy if we do. |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3747 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3748 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
| 6030 | 3749 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3750 int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3751 workers()->active_workers() : 1); |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3752 double pause_start_sec = os::elapsedTime(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3753 g1_policy()->phase_times()->note_gc_start(active_workers); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3754 bool initial_mark_gc = g1_policy()->during_initial_mark_pause(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3755 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3756 TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
3757 TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
3758 |
| 2361 | 3759 // If the secondary_free_list is not empty, append it to the |
| 3760 // free_list. No need to wait for the cleanup operation to finish; | |
| 3761 // the region allocation code will check the secondary_free_list | |
| 3762 // and wait if necessary. If the G1StressConcRegionFreeing flag is | |
| 3763 // set, skip this step so that the region allocation code has to | |
| 3764 // get entries from the secondary_free_list. | |
| 2152 | 3765 if (!G1StressConcRegionFreeing) { |
| 2361 | 3766 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 3767 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3768 |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3769 assert(check_young_list_well_formed(), |
|
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
3770 "young list should be well formed"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3771 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3772 // 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
|
3773 // 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
|
3774 // it will be set. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3775 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3776 { // 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
|
3777 IsGCActiveMark x; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3778 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3779 gc_prologue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3780 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
|
3781 increment_gc_time_stamp(); |
| 342 | 3782 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3783 verify_before_gc(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3784 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3785 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3786 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3787 // Please see comment in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3788 // G1CollectedHeap::ref_processing_init() to see how |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3789 // reference processing currently works in G1. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3790 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3791 // Enable discovery in the STW reference processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3792 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3793 true /*verify_no_refs*/); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3794 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3795 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3796 // We want to temporarily turn off discovery by the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3797 // CM ref processor, if necessary, and turn it back on |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3798 // on again later if we do. Using a scoped |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3799 // NoRefDiscovery object will do this. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3800 NoRefDiscovery no_cm_discovery(ref_processor_cm()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3801 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3802 // 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
|
3803 // of the collection set!). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3804 release_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3805 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3806 // We should call this after we retire the mutator alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3807 // region(s) so that all the ALLOC / RETIRE events are generated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3808 // before the start GC event. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3809 _hr_printer.start_gc(false /* full */, (size_t) total_collections()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3810 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3811 // This timing is only used by the ergonomics to handle our pause target. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3812 // It is unclear why this should not include the full pause. We will |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3813 // investigate this in CR 7178365. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3814 // |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3815 // Preserving the old comment here if that helps the investigation: |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3816 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3817 // The elapsed time induced by the start time below deliberately elides |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3818 // the possible verification above. |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3819 double sample_start_time_sec = os::elapsedTime(); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3820 size_t start_used_bytes = used(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3821 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3822 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3823 gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3824 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3825 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
|
3826 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3827 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3828 g1_policy()->record_collection_pause_start(sample_start_time_sec, |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3829 start_used_bytes); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3830 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3831 double scan_wait_start = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3832 // 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
|
3833 // 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
|
3834 // 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
|
3835 // moving them during the GC. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3836 bool waited = _cm->root_regions()->wait_until_scan_finished(); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3837 double wait_time_ms = 0.0; |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3838 if (waited) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3839 double scan_wait_end = os::elapsedTime(); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3840 wait_time_ms = (scan_wait_end - scan_wait_start) * 1000.0; |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3841 } |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3842 g1_policy()->phase_times()->record_root_region_scan_wait_time(wait_time_ms); |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3843 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3844 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3845 gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3846 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3847 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3848 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3849 if (g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3850 concurrent_mark()->checkpointRootsInitialPre(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3851 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3852 perm_gen()->save_marks(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3853 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3854 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3855 gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3856 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3857 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
|
3858 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3859 |
|
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4910
diff
changeset
|
3860 g1_policy()->finalize_cset(target_pause_time_ms); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3861 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3862 _cm->note_start_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3863 // 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
|
3864 // 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
|
3865 // 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
|
3866 // ensure that the CSet has been finalized. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3867 _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
|
3868 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3869 false /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3870 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3871 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3872 if (_hr_printer.is_active()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3873 HeapRegion* hr = g1_policy()->collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3874 while (hr != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3875 G1HRPrinter::RegionType type; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3876 if (!hr->is_young()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3877 type = G1HRPrinter::Old; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3878 } else if (hr->is_survivor()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3879 type = G1HRPrinter::Survivor; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3880 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3881 type = G1HRPrinter::Eden; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3882 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3883 _hr_printer.cset(hr); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3884 hr = hr->next_in_collection_set(); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3885 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
3886 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3887 |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3888 #ifdef ASSERT |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3889 VerifyCSetClosure cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3890 collection_set_iterate(&cl); |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3891 #endif // ASSERT |
| 1707 | 3892 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3893 setup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3894 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3895 // Initialize the GC alloc regions. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3896 init_gc_alloc_regions(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3897 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3898 // Actually do the work... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3899 evacuate_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3900 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3901 // 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
|
3902 // (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
|
3903 // 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
|
3904 // 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
|
3905 // we checked. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3906 _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
|
3907 false /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3908 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3909 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3910 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3911 free_collection_set(g1_policy()->collection_set()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3912 g1_policy()->clear_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3913 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3914 cleanup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3915 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3916 // Start a new incremental collection set for the next pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3917 g1_policy()->start_incremental_cset_building(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3918 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3919 // Clear the _cset_fast_test bitmap in anticipation of adding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3920 // regions to the incremental collection set for the next |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3921 // evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3922 clear_cset_fast_test(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3923 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3924 _young_list->reset_sampled_info(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3925 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3926 // Don't check the whole heap at this point as the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3927 // GC alloc regions from this pause have been tagged |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3928 // as survivors and moved on to the survivor list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3929 // Survivor regions will fail the !is_young() check. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3930 assert(check_young_list_empty(false /* check_heap */), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3931 "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
|
3932 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3933 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3934 gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3935 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3936 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3937 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3938 g1_policy()->record_survivor_regions(_young_list->survivor_length(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3939 _young_list->first_survivor_region(), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3940 _young_list->last_survivor_region()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3941 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3942 _young_list->reset_auxilary_lists(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3943 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3944 if (evacuation_failed()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3945 _summary_bytes_used = recalculate_used(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3946 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3947 // The "used" of the the collection set have already been subtracted |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3948 // when they were freed. Add in the bytes evacuated. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3949 _summary_bytes_used += g1_policy()->bytes_copied_during_gc(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3950 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3951 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3952 if (g1_policy()->during_initial_mark_pause()) { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
3953 // 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
|
3954 // 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
|
3955 // appropriate initialization is done on the CM object. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3956 concurrent_mark()->checkpointRootsInitialPost(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3957 set_marking_started(); |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3958 // 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
|
3959 // 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
|
3960 // the current thread has completed its logging output. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3961 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3962 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3963 allocate_dummy_regions(); |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
3964 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3965 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3966 gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3967 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3968 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
|
3969 #endif // YOUNG_LIST_VERBOSE |
| 342 | 3970 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3971 init_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3972 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3973 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3974 size_t expand_bytes = g1_policy()->expansion_amount(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3975 if (expand_bytes > 0) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3976 size_t bytes_before = capacity(); |
| 4785 | 3977 // No need for an ergo verbose message here, |
| 3978 // expansion_amount() does this when it returns a value > 0. | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3979 if (!expand(expand_bytes)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3980 // We failed to expand the heap so let's verify that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3981 // committed/uncommitted amount match the backing store |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3982 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3983 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3984 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3985 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
3986 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3987 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3988 // 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
|
3989 // 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
|
3990 _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
|
3991 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3992 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3993 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3994 _cm->note_end_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3995 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3996 // This timing is only used by the ergonomics to handle our pause target. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3997 // It is unclear why this should not include the full pause. We will |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3998 // investigate this in CR 7178365. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3999 double sample_end_time_sec = os::elapsedTime(); |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4000 double pause_time_ms = (sample_end_time_sec - sample_start_time_sec) * MILLIUNITS; |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4001 g1_policy()->record_collection_pause_end(pause_time_ms); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4002 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4003 MemoryService::track_memory_usage(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4004 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4005 // 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
|
4006 // update buffers to bring the RSets up-to-date if |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4007 // G1HRRSFlushLogBuffersOnVerify has been set. While scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4008 // 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
|
4009 // regions we just allocated to (i.e., the GC alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4010 // regions). However, during the last GC we called |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4011 // set_saved_mark() on all the GC alloc regions, so card |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4012 // scanning might skip the [saved_mark_word()...top()] area of |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4013 // those regions (i.e., the area we allocated objects into |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4014 // during the last GC). But it shouldn't. Given that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4015 // saved_mark_word() is conditional on whether the GC time stamp |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4016 // 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
|
4017 // 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
|
4018 // regions and saved_mark_word() will simply return top() for |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4019 // 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
|
4020 // than iterating over the regions and fixing them. In fact, the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4021 // GC time stamp increment here also ensures that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4022 // saved_mark_word() will return top() between pauses, i.e., |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4023 // during concurrent refinement. So we don't need the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4024 // is_gc_active() check to decided which top to use when |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4025 // scanning cards (see CR 7039627). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4026 increment_gc_time_stamp(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4027 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4028 verify_after_gc(); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4029 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4030 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4031 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4032 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4033 // 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
|
4034 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
4035 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4036 // 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
|
4037 // 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
|
4038 // 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
|
4039 // RETIRE events are generated before the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4040 _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
|
4041 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4042 if (mark_in_progress()) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4043 concurrent_mark()->update_g1_committed(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4044 } |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4045 |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4046 #ifdef TRACESPINNING |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4047 ParallelTaskTerminator::print_termination_counts(); |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4048 #endif |
| 342 | 4049 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4050 gc_epilogue(false); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4051 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4052 if (G1Log::fine()) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4053 if (PrintGCTimeStamps) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4054 gclog_or_tty->stamp(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4055 gclog_or_tty->print(": "); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4056 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4057 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4058 GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause()) |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4059 .append(g1_policy()->gcs_are_young() ? " (young)" : " (mixed)") |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4060 .append(initial_mark_gc ? " (initial-mark)" : ""); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4061 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4062 double pause_time_sec = os::elapsedTime() - pause_start_sec; |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4063 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4064 if (G1Log::finer()) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4065 if (evacuation_failed()) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4066 gc_cause_str.append(" (to-space exhausted)"); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4067 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4068 gclog_or_tty->print_cr("[%s, %3.7f secs]", (const char*)gc_cause_str, pause_time_sec); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4069 g1_policy()->phase_times()->note_gc_end(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4070 g1_policy()->phase_times()->print(pause_time_sec); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4071 g1_policy()->print_detailed_heap_transition(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4072 } else { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4073 if (evacuation_failed()) { |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4074 gc_cause_str.append("--"); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4075 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4076 gclog_or_tty->print("[%s", (const char*)gc_cause_str); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4077 g1_policy()->print_heap_transition(); |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4078 gclog_or_tty->print_cr(", %3.7f secs]", pause_time_sec); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4079 } |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4080 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4081 } |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4082 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4083 // It is not yet to safe to tell the concurrent mark to |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4084 // start as we have some optional output below. We don't want the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4085 // output from the concurrent mark thread interfering with this |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4086 // logging output either. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4087 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4088 _hrs.verify_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4089 verify_region_sets_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4090 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4091 TASKQUEUE_STATS_ONLY(if (ParallelGCVerbose) print_taskqueue_stats()); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4092 TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4093 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4094 print_heap_after_gc(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4095 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4096 // We must call G1MonitoringSupport::update_sizes() in the same scoping level |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4097 // as an active TraceMemoryManagerStats object (i.e. before the destructor for the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4098 // TraceMemoryManagerStats is called) so that the G1 memory pools are updated |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4099 // before any GC notifications are raised. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4100 g1mm()->update_sizes(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4101 } |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
4102 |
|
884
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
4103 if (G1SummarizeRSetStats && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
4104 (G1SummarizeRSetStatsPeriod > 0) && |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
4105 (total_collections() % G1SummarizeRSetStatsPeriod == 0)) { |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
4106 g1_rem_set()->print_summary_info(); |
|
83b687ce3090
6866591: G1: print update buffer processing stats more often
tonyp
parents:
883
diff
changeset
|
4107 } |
| 1973 | 4108 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4109 // 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
|
4110 // 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
|
4111 // that came from the pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4112 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4113 if (should_start_conc_mark) { |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4114 // CAUTION: after the doConcurrentMark() call below, |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4115 // the concurrent marking thread(s) could be running |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4116 // concurrently with us. Make sure that anything after |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4117 // 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
|
4118 // 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
|
4119 // 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
|
4120 // ConcurrentGCThread::safepoint_desynchronize(). |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4121 doConcurrentMark(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4122 } |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4123 |
| 1973 | 4124 return true; |
| 342 | 4125 } |
| 4126 | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4127 size_t G1CollectedHeap::desired_plab_sz(GCAllocPurpose purpose) |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4128 { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4129 size_t gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4130 switch (purpose) { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4131 case GCAllocForSurvived: |
| 6595 | 4132 gclab_word_size = _survivor_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4133 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4134 case GCAllocForTenured: |
| 6595 | 4135 gclab_word_size = _old_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4136 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4137 default: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4138 assert(false, "unknown GCAllocPurpose"); |
| 6595 | 4139 gclab_word_size = _old_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4140 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4141 } |
| 6595 | 4142 |
| 4143 // Prevent humongous PLAB sizes for two reasons: | |
| 4144 // * PLABs are allocated using a similar paths as oops, but should | |
| 4145 // never be in a humongous region | |
| 4146 // * Allowing humongous PLABs needlessly churns the region free lists | |
| 4147 return MIN2(_humongous_object_threshold_in_words, gclab_word_size); | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4148 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4149 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4150 void G1CollectedHeap::init_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4151 assert(_mutator_alloc_region.get() == NULL, "pre-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4152 _mutator_alloc_region.init(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4153 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4154 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4155 void G1CollectedHeap::release_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4156 _mutator_alloc_region.release(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4157 assert(_mutator_alloc_region.get() == NULL, "post-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4158 } |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4159 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4160 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
|
4161 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
|
4162 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4163 _survivor_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4164 _old_gc_alloc_region.init(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4165 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
|
4166 _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
|
4167 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4168 // 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
|
4169 // 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
|
4170 // 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
|
4171 // 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
|
4172 // 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
|
4173 // 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
|
4174 // 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
|
4175 // 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
|
4176 // 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
|
4177 if (retained_region != NULL && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4178 !retained_region->in_collection_set() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4179 !(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
|
4180 !retained_region->is_empty() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4181 !retained_region->isHumongous()) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4182 retained_region->set_saved_mark(); |
| 4072 | 4183 // The retained region was added to the old region set when it was |
| 4184 // retired. We have to remove it now, since we don't allow regions | |
| 4185 // we allocate to in the region sets. We'll re-add it later, when | |
| 4186 // it's retired again. | |
| 4187 _old_set.remove(retained_region); | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4188 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
|
4189 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
|
4190 _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
|
4191 _hr_printer.reuse(retained_region); |
| 342 | 4192 } |
| 4193 } | |
| 4194 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4195 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
|
4196 _survivor_gc_alloc_region.release(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4197 // 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
|
4198 // _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
|
4199 // _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
|
4200 // 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
|
4201 // condition. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4202 _retained_old_gc_alloc_region = _old_gc_alloc_region.release(); |
| 6595 | 4203 |
| 4204 if (ResizePLAB) { | |
| 4205 _survivor_plab_stats.adjust_desired_plab_sz(); | |
| 4206 _old_plab_stats.adjust_desired_plab_sz(); | |
| 4207 } | |
| 342 | 4208 } |
| 4209 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4210 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
|
4211 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
|
4212 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
|
4213 _retained_old_gc_alloc_region = NULL; |
| 342 | 4214 } |
| 4215 | |
| 4216 void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) { | |
| 4217 _drain_in_progress = false; | |
| 4218 set_evac_failure_closure(cl); | |
| 6197 | 4219 _evac_failure_scan_stack = new (ResourceObj::C_HEAP, mtGC) GrowableArray<oop>(40, true); |
| 342 | 4220 } |
| 4221 | |
| 4222 void G1CollectedHeap::finalize_for_evac_failure() { | |
| 4223 assert(_evac_failure_scan_stack != NULL && | |
| 4224 _evac_failure_scan_stack->length() == 0, | |
| 4225 "Postcondition"); | |
| 4226 assert(!_drain_in_progress, "Postcondition"); | |
| 1045 | 4227 delete _evac_failure_scan_stack; |
| 342 | 4228 _evac_failure_scan_stack = NULL; |
| 4229 } | |
| 4230 | |
| 4231 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
|
4232 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
|
4233 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4234 G1ParRemoveSelfForwardPtrsTask rsfp_task(this); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4235 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4236 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4237 set_par_threads(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4238 workers()->run_task(&rsfp_task); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4239 set_par_threads(0); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4240 } else { |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4241 rsfp_task.work(0); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4242 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4243 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4244 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
|
4245 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4246 // 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
|
4247 reset_cset_heap_region_claim_values(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4248 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4249 assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); |
| 342 | 4250 |
| 4251 // Now restore saved marks, if any. | |
| 4252 if (_objs_with_preserved_marks != NULL) { | |
| 4253 assert(_preserved_marks_of_objs != NULL, "Both or none."); | |
| 4254 guarantee(_objs_with_preserved_marks->length() == | |
| 4255 _preserved_marks_of_objs->length(), "Both or none."); | |
| 4256 for (int i = 0; i < _objs_with_preserved_marks->length(); i++) { | |
| 4257 oop obj = _objs_with_preserved_marks->at(i); | |
| 4258 markOop m = _preserved_marks_of_objs->at(i); | |
| 4259 obj->set_mark(m); | |
| 4260 } | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4261 |
| 342 | 4262 // Delete the preserved marks growable arrays (allocated on the C heap). |
| 4263 delete _objs_with_preserved_marks; | |
| 4264 delete _preserved_marks_of_objs; | |
| 4265 _objs_with_preserved_marks = NULL; | |
| 4266 _preserved_marks_of_objs = NULL; | |
| 4267 } | |
| 4268 } | |
| 4269 | |
| 4270 void G1CollectedHeap::push_on_evac_failure_scan_stack(oop obj) { | |
| 4271 _evac_failure_scan_stack->push(obj); | |
| 4272 } | |
| 4273 | |
| 4274 void G1CollectedHeap::drain_evac_failure_scan_stack() { | |
| 4275 assert(_evac_failure_scan_stack != NULL, "precondition"); | |
| 4276 | |
| 4277 while (_evac_failure_scan_stack->length() > 0) { | |
| 4278 oop obj = _evac_failure_scan_stack->pop(); | |
| 4279 _evac_failure_closure->set_region(heap_region_containing(obj)); | |
| 4280 obj->oop_iterate_backwards(_evac_failure_closure); | |
| 4281 } | |
| 4282 } | |
| 4283 | |
| 4284 oop | |
| 4285 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
|
4286 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
|
4287 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
|
4288 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
|
4289 (HeapWord*) old)); |
| 342 | 4290 markOop m = old->mark(); |
| 4291 oop forward_ptr = old->forward_to_atomic(old); | |
| 4292 if (forward_ptr == NULL) { | |
| 4293 // 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
|
4294 |
| 342 | 4295 if (_evac_failure_closure != cl) { |
| 4296 MutexLockerEx x(EvacFailureStack_lock, Mutex::_no_safepoint_check_flag); | |
| 4297 assert(!_drain_in_progress, | |
| 4298 "Should only be true while someone holds the lock."); | |
| 4299 // Set the global evac-failure closure to the current thread's. | |
| 4300 assert(_evac_failure_closure == NULL, "Or locking has failed."); | |
| 4301 set_evac_failure_closure(cl); | |
| 4302 // Now do the common part. | |
| 4303 handle_evacuation_failure_common(old, m); | |
| 4304 // Reset to NULL. | |
| 4305 set_evac_failure_closure(NULL); | |
| 4306 } else { | |
| 4307 // The lock is already held, and this is recursive. | |
| 4308 assert(_drain_in_progress, "This should only be the recursive case."); | |
| 4309 handle_evacuation_failure_common(old, m); | |
| 4310 } | |
| 4311 return old; | |
| 4312 } 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
|
4313 // 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
|
4314 // 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
|
4315 // 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
|
4316 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
|
4317 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
|
4318 "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
|
4319 (HeapWord*) old, (HeapWord*) forward_ptr)); |
| 342 | 4320 return forward_ptr; |
| 4321 } | |
| 4322 } | |
| 4323 | |
| 4324 void G1CollectedHeap::handle_evacuation_failure_common(oop old, markOop m) { | |
| 4325 set_evacuation_failed(true); | |
| 4326 | |
| 4327 preserve_mark_if_necessary(old, m); | |
| 4328 | |
| 4329 HeapRegion* r = heap_region_containing(old); | |
| 4330 if (!r->evacuation_failed()) { | |
| 4331 r->set_evacuation_failed(true); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4332 _hr_printer.evac_failure(r); |
| 342 | 4333 } |
| 4334 | |
| 4335 push_on_evac_failure_scan_stack(old); | |
| 4336 | |
| 4337 if (!_drain_in_progress) { | |
| 4338 // prevent recursion in copy_to_survivor_space() | |
| 4339 _drain_in_progress = true; | |
| 4340 drain_evac_failure_scan_stack(); | |
| 4341 _drain_in_progress = false; | |
| 4342 } | |
| 4343 } | |
| 4344 | |
| 4345 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
|
4346 assert(evacuation_failed(), "Oversaving!"); |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4347 // 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
|
4348 // case of a promotion failure. |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4349 if (m->must_be_preserved_for_promotion_failure(obj)) { |
| 342 | 4350 if (_objs_with_preserved_marks == NULL) { |
| 4351 assert(_preserved_marks_of_objs == NULL, "Both or none."); | |
| 4352 _objs_with_preserved_marks = | |
| 6197 | 4353 new (ResourceObj::C_HEAP, mtGC) GrowableArray<oop>(40, true); |
| 342 | 4354 _preserved_marks_of_objs = |
| 6197 | 4355 new (ResourceObj::C_HEAP, mtGC) GrowableArray<markOop>(40, true); |
| 342 | 4356 } |
| 4357 _objs_with_preserved_marks->push(obj); | |
| 4358 _preserved_marks_of_objs->push(m); | |
| 4359 } | |
| 4360 } | |
| 4361 | |
| 4362 HeapWord* G1CollectedHeap::par_allocate_during_gc(GCAllocPurpose purpose, | |
| 4363 size_t word_size) { | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4364 if (purpose == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4365 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
|
4366 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4367 return result; |
| 342 | 4368 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4369 // 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
|
4370 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4371 return old_attempt_allocation(word_size); |
| 342 | 4372 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4373 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4374 assert(purpose == GCAllocForTenured, "sanity"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4375 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
|
4376 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4377 return result; |
| 342 | 4378 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4379 // 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
|
4380 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4381 return survivor_attempt_allocation(word_size); |
| 342 | 4382 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4383 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4384 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4385 ShouldNotReachHere(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4386 // 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
|
4387 return NULL; |
| 342 | 4388 } |
| 4389 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4390 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
|
4391 ParGCAllocBuffer(gclab_word_size), _retired(false) { } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4392 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4393 G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num) |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4394 : _g1h(g1h), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4395 _refs(g1h->task_queue(queue_num)), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4396 _dcq(&g1h->dirty_card_queue_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4397 _ct_bs((CardTableModRefBS*)_g1h->barrier_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4398 _g1_rem(g1h->g1_rem_set()), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4399 _hash_seed(17), _queue_num(queue_num), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4400 _term_attempts(0), |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4401 _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)), |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4402 _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
|
4403 _age_table(false), |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4404 _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
|
4405 _alloc_buffer_waste(0), _undo_waste(0) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4406 // we allocate G1YoungSurvRateNumRegions plus one entries, since |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4407 // 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
|
4408 // non-young regions (where the age is -1) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4409 // 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
|
4410 // an attempt to eliminate cache contention |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4411 uint real_length = 1 + _g1h->g1_policy()->young_cset_region_length(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4412 uint array_length = PADDING_ELEM_NUM + |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4413 real_length + |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4414 PADDING_ELEM_NUM; |
| 6197 | 4415 _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length, mtGC); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4416 if (_surviving_young_words_base == NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4417 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
|
4418 "Not enough space for young surv histo."); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4419 _surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4420 memset(_surviving_young_words, 0, (size_t) real_length * sizeof(size_t)); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4421 |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4422 _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4423 _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4424 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4425 _start = os::elapsedTime(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4426 } |
| 342 | 4427 |
| 1709 | 4428 void |
| 4429 G1ParScanThreadState::print_termination_stats_hdr(outputStream* const st) | |
| 4430 { | |
| 4431 st->print_raw_cr("GC Termination Stats"); | |
| 4432 st->print_raw_cr(" elapsed --strong roots-- -------termination-------" | |
| 4433 " ------waste (KiB)------"); | |
| 4434 st->print_raw_cr("thr ms ms % ms % attempts" | |
| 4435 " total alloc undo"); | |
| 4436 st->print_raw_cr("--- --------- --------- ------ --------- ------ --------" | |
| 4437 " ------- ------- -------"); | |
| 4438 } | |
| 4439 | |
| 4440 void | |
| 4441 G1ParScanThreadState::print_termination_stats(int i, | |
| 4442 outputStream* const st) const | |
| 4443 { | |
| 4444 const double elapsed_ms = elapsed_time() * 1000.0; | |
| 4445 const double s_roots_ms = strong_roots_time() * 1000.0; | |
| 4446 const double term_ms = term_time() * 1000.0; | |
| 4447 st->print_cr("%3d %9.2f %9.2f %6.2f " | |
| 4448 "%9.2f %6.2f " SIZE_FORMAT_W(8) " " | |
| 4449 SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), | |
| 4450 i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms, | |
| 4451 term_ms, term_ms * 100 / elapsed_ms, term_attempts(), | |
| 4452 (alloc_buffer_waste() + undo_waste()) * HeapWordSize / K, | |
| 4453 alloc_buffer_waste() * HeapWordSize / K, | |
| 4454 undo_waste() * HeapWordSize / K); | |
| 4455 } | |
| 4456 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4457 #ifdef ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4458 bool G1ParScanThreadState::verify_ref(narrowOop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4459 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4460 assert(UseCompressedOops, "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4461 assert(!has_partial_array_mask(ref), err_msg("ref=" PTR_FORMAT, ref)); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4462 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4463 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4464 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4465 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4466 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4467 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4468 bool G1ParScanThreadState::verify_ref(oop* ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4469 assert(ref != NULL, "invariant"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4470 if (has_partial_array_mask(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4471 // Must be in the collection set--it's already been copied. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4472 oop p = clear_partial_array_mask(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4473 assert(_g1h->obj_in_cs(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4474 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4475 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4476 oop p = oopDesc::load_decode_heap_oop(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4477 assert(_g1h->is_in_g1_reserved(p), |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4478 err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p))); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4479 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4480 return true; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4481 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4482 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4483 bool G1ParScanThreadState::verify_task(StarTask ref) const { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4484 if (ref.is_narrow()) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4485 return verify_ref((narrowOop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4486 } else { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4487 return verify_ref((oop*) ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4488 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4489 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4490 #endif // ASSERT |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4491 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4492 void G1ParScanThreadState::trim_queue() { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4493 assert(_evac_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4494 assert(_evac_failure_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4495 assert(_partial_scan_cl != NULL, "not set"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4496 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4497 StarTask ref; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4498 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4499 // Drain the overflow stack first, so other threads can steal. |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4500 while (refs()->pop_overflow(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4501 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4502 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4503 |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4504 while (refs()->pop_local(ref)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4505 deal_with_reference(ref); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4506 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4507 } while (!refs()->is_empty()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4508 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4509 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4510 G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4511 G1ParScanThreadState* par_scan_state) : |
| 342 | 4512 _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
|
4513 _par_scan_state(par_scan_state), |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4514 _worker_id(par_scan_state->queue_num()), |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4515 _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
|
4516 _mark_in_progress(_g1->mark_in_progress()) { } |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4517 |
| 5987 | 4518 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4519 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
|
4520 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4521 HeapRegion* hr = _g1->heap_region_containing(obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4522 assert(hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4523 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
|
4524 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4525 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4526 // 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
|
4527 _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
|
4528 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4529 |
| 5987 | 4530 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4531 void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> | |
| 4532 ::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
|
4533 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4534 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
|
4535 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
|
4536 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
|
4537 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4538 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
|
4539 assert(from_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4540 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
|
4541 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4542 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
|
4543 assert(to_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4544 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
|
4545 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4546 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4547 // 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
|
4548 // 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
|
4549 // 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
|
4550 // image which we know should not be changing. |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4551 _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
|
4552 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4553 |
| 5987 | 4554 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
| 4555 oop G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> | |
| 4556 ::copy_to_survivor_space(oop old) { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
4557 size_t word_sz = old->size(); |
| 342 | 4558 HeapRegion* from_region = _g1->heap_region_containing_raw(old); |
| 4559 // +1 to make the -1 indexes valid... | |
| 4560 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
|
4561 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
|
4562 (!from_region->is_young() && young_index == 0), "invariant" ); |
| 342 | 4563 G1CollectorPolicy* g1p = _g1->g1_policy(); |
| 4564 markOop m = old->mark(); | |
| 545 | 4565 int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age() |
| 4566 : m->age(); | |
| 4567 GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age, | |
| 342 | 4568 word_sz); |
| 4569 HeapWord* obj_ptr = _par_scan_state->allocate(alloc_purpose, word_sz); | |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4570 #ifndef PRODUCT |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4571 // Should this evacuation fail? |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4572 if (_g1->evacuation_should_fail()) { |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4573 if (obj_ptr != NULL) { |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4574 _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4575 obj_ptr = NULL; |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4576 } |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4577 } |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4578 #endif // !PRODUCT |
| 342 | 4579 |
| 4580 if (obj_ptr == NULL) { | |
| 4581 // This will either forward-to-self, or detect that someone else has | |
| 4582 // installed a forwarding pointer. | |
| 4583 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
|
4584 return _g1->handle_evacuation_failure_par(cl, old); |
| 342 | 4585 } |
| 4586 | |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4587 oop obj = oop(obj_ptr); |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
4588 |
| 526 | 4589 // We're going to allocate linearly, so might as well prefetch ahead. |
| 4590 Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes); | |
| 4591 | |
| 342 | 4592 oop forward_ptr = old->forward_to_atomic(obj); |
| 4593 if (forward_ptr == NULL) { | |
| 4594 Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz); | |
| 526 | 4595 if (g1p->track_object_age(alloc_purpose)) { |
| 4596 // We could simply do obj->incr_age(). However, this causes a | |
| 4597 // performance issue. obj->incr_age() will first check whether | |
| 4598 // the object has a displaced mark by checking its mark word; | |
| 4599 // getting the mark word from the new location of the object | |
| 4600 // stalls. So, given that we already have the mark word and we | |
| 4601 // are about to install it anyway, it's better to increase the | |
| 4602 // age on the mark word, when the object does not have a | |
| 4603 // displaced mark word. We're not expecting many objects to have | |
| 4604 // a displaced marked word, so that case is not optimized | |
| 4605 // further (it could be...) and we simply call obj->incr_age(). | |
| 4606 | |
| 4607 if (m->has_displaced_mark_helper()) { | |
| 4608 // in this case, we have to install the mark word first, | |
| 4609 // otherwise obj looks to be forwarded (the old mark word, | |
| 4610 // which contains the forward pointer, was copied) | |
| 4611 obj->set_mark(m); | |
| 4612 obj->incr_age(); | |
| 4613 } else { | |
| 4614 m = m->incr_age(); | |
| 545 | 4615 obj->set_mark(m); |
| 526 | 4616 } |
| 545 | 4617 _par_scan_state->age_table()->add(obj, word_sz); |
| 4618 } else { | |
| 4619 obj->set_mark(m); | |
| 526 | 4620 } |
| 4621 | |
| 342 | 4622 size_t* surv_young_words = _par_scan_state->surviving_young_words(); |
| 4623 surv_young_words[young_index] += word_sz; | |
| 4624 | |
| 4625 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
|
4626 // 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
|
4627 // 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
|
4628 // 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
|
4629 arrayOop(obj)->set_length(0); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4630 oop* old_p = set_partial_array_mask(old); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4631 _par_scan_state->push_on_queue(old_p); |
| 342 | 4632 } else { |
| 526 | 4633 // No point in using the slower heap_region_containing() method, |
| 4634 // given that we know obj is in the heap. | |
| 5987 | 4635 _scanner.set_region(_g1->heap_region_containing_raw(obj)); |
| 4636 obj->oop_iterate_backwards(&_scanner); | |
| 342 | 4637 } |
| 4638 } else { | |
| 4639 _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); | |
| 4640 obj = forward_ptr; | |
| 4641 } | |
| 4642 return obj; | |
| 4643 } | |
| 4644 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4645 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
|
4646 template <class T> |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4647 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
|
4648 ::do_oop_work(T* p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4649 oop obj = oopDesc::load_decode_heap_oop(p); |
| 342 | 4650 assert(barrier != G1BarrierRS || obj != NULL, |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4651 "Precondition: G1BarrierRS implies obj is non-NULL"); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4652 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4653 assert(_worker_id == _par_scan_state->queue_num(), "sanity"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4654 |
| 526 | 4655 // 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
|
4656 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
|
4657 oop forwardee; |
| 526 | 4658 if (obj->is_forwarded()) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4659 forwardee = obj->forwardee(); |
| 526 | 4660 } else { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4661 forwardee = copy_to_survivor_space(obj); |
| 342 | 4662 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4663 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
|
4664 oopDesc::encode_store_heap_oop(p, forwardee); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4665 if (do_mark_object && forwardee != obj) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4666 // 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
|
4667 // 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
|
4668 mark_forwarded_object(obj, forwardee); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4669 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4670 |
| 526 | 4671 // When scanning the RS, we only care about objs in CS. |
| 4672 if (barrier == G1BarrierRS) { | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4673 _par_scan_state->update_rs(_from, p, _worker_id); |
| 342 | 4674 } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4675 } else { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4676 // 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
|
4677 // 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
|
4678 // 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
|
4679 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
|
4680 mark_object(obj); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4681 } |
| 526 | 4682 } |
| 4683 | |
| 4684 if (barrier == G1BarrierEvac && obj != NULL) { | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4685 _par_scan_state->update_rs(_from, p, _worker_id); |
| 526 | 4686 } |
| 4687 | |
| 4688 if (do_gen_barrier && obj != NULL) { | |
| 4689 par_do_barrier(p); | |
| 4690 } | |
| 4691 } | |
| 4692 | |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4693 template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(oop* p); |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4694 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
|
4695 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4696 template <class T> void G1ParScanPartialArrayClosure::do_oop_nv(T* p) { |
| 526 | 4697 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
|
4698 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
|
4699 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4700 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
|
4701 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
|
4702 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
|
4703 // 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
|
4704 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
|
4705 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4706 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
|
4707 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
|
4708 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
|
4709 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
|
4710 // 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
|
4711 // to-space object. |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4712 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
|
4713 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
|
4714 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
|
4715 |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4716 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
|
4717 int end = length; |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4718 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
|
4719 // We'll try not to push a range that's smaller than ParGCArrayScanChunk. |
| 342 | 4720 if (remainder > 2 * ParGCArrayScanChunk) { |
| 4721 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
|
4722 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
|
4723 // 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
|
4724 // 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
|
4725 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
|
4726 _par_scan_state->push_on_queue(from_obj_p); |
| 342 | 4727 } else { |
|
4784
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4728 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
|
4729 // 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
|
4730 // 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
|
4731 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
|
4732 } |
|
02838862dec8
7121623: G1: always be able to reliably calculate the length of a forwarded chunked array
tonyp
parents:
4783
diff
changeset
|
4733 _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
|
4734 // 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
|
4735 // 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
|
4736 // 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
|
4737 // 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
|
4738 // 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
|
4739 // 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
|
4740 // 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
|
4741 // 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
|
4742 to_obj_array->oop_iterate_range(&_scanner, start, end); |
| 342 | 4743 } |
| 4744 | |
| 4745 class G1ParEvacuateFollowersClosure : public VoidClosure { | |
| 4746 protected: | |
| 4747 G1CollectedHeap* _g1h; | |
| 4748 G1ParScanThreadState* _par_scan_state; | |
| 4749 RefToScanQueueSet* _queues; | |
| 4750 ParallelTaskTerminator* _terminator; | |
| 4751 | |
| 4752 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } | |
| 4753 RefToScanQueueSet* queues() { return _queues; } | |
| 4754 ParallelTaskTerminator* terminator() { return _terminator; } | |
| 4755 | |
| 4756 public: | |
| 4757 G1ParEvacuateFollowersClosure(G1CollectedHeap* g1h, | |
| 4758 G1ParScanThreadState* par_scan_state, | |
| 4759 RefToScanQueueSet* queues, | |
| 4760 ParallelTaskTerminator* terminator) | |
| 4761 : _g1h(g1h), _par_scan_state(par_scan_state), | |
| 4762 _queues(queues), _terminator(terminator) {} | |
| 4763 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4764 void do_void(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4765 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4766 private: |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4767 inline bool offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4768 }; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4769 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4770 bool G1ParEvacuateFollowersClosure::offer_termination() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4771 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4772 pss->start_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4773 const bool res = terminator()->offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4774 pss->end_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4775 return res; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4776 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4777 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4778 void G1ParEvacuateFollowersClosure::do_void() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4779 StarTask stolen_task; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4780 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4781 pss->trim_queue(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4782 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4783 do { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4784 while (queues()->steal(pss->queue_num(), pss->hash_seed(), stolen_task)) { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4785 assert(pss->verify_task(stolen_task), "sanity"); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4786 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
|
4787 pss->deal_with_reference((narrowOop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4788 } else { |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4789 pss->deal_with_reference((oop*) stolen_task); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4790 } |
|
1883
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4791 |
|
35e4e086d5f5
6990359: G1: don't push a stolen entry on the taskqueue, deal with it directly
tonyp
parents:
1862
diff
changeset
|
4792 // 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
|
4793 // 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
|
4794 // we drain the queues as necessary. |
| 342 | 4795 pss->trim_queue(); |
| 4796 } | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4797 } while (!offer_termination()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4798 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4799 pss->retire_alloc_buffers(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4800 } |
| 342 | 4801 |
| 4802 class G1ParTask : public AbstractGangTask { | |
| 4803 protected: | |
| 4804 G1CollectedHeap* _g1h; | |
| 4805 RefToScanQueueSet *_queues; | |
| 4806 ParallelTaskTerminator _terminator; | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4807 uint _n_workers; |
| 342 | 4808 |
| 4809 Mutex _stats_lock; | |
| 4810 Mutex* stats_lock() { return &_stats_lock; } | |
| 4811 | |
| 4812 size_t getNCards() { | |
| 4813 return (_g1h->capacity() + G1BlockOffsetSharedArray::N_bytes - 1) | |
| 4814 / G1BlockOffsetSharedArray::N_bytes; | |
| 4815 } | |
| 4816 | |
| 4817 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4818 G1ParTask(G1CollectedHeap* g1h, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4819 RefToScanQueueSet *task_queues) |
| 342 | 4820 : AbstractGangTask("G1 collection"), |
| 4821 _g1h(g1h), | |
| 4822 _queues(task_queues), | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4823 _terminator(0, _queues), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4824 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true) |
| 342 | 4825 {} |
| 4826 | |
| 4827 RefToScanQueueSet* queues() { return _queues; } | |
| 4828 | |
| 4829 RefToScanQueue *work_queue(int i) { | |
| 4830 return queues()->queue(i); | |
| 4831 } | |
| 4832 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4833 ParallelTaskTerminator* terminator() { return &_terminator; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4834 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4835 virtual void set_for_termination(int active_workers) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4836 // 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
|
4837 // 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
|
4838 // for SequentialSubTasksDone. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4839 // This task also uses SubTasksDone in SharedHeap and G1CollectedHeap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4840 // both of which need setting by set_n_termination(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4841 _g1h->SharedHeap::set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4842 _g1h->set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4843 terminator()->reset_for_reuse(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4844 _n_workers = active_workers; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4845 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4846 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4847 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4848 if (worker_id >= _n_workers) return; // no work needed this round |
| 1611 | 4849 |
| 4850 double start_time_ms = os::elapsedTime() * 1000.0; | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4851 _g1h->g1_policy()->phase_times()->record_gc_worker_start_time(worker_id, start_time_ms); |
| 1611 | 4852 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4853 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4854 ResourceMark rm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4855 HandleMark hm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4856 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4857 ReferenceProcessor* rp = _g1h->ref_processor_stw(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4858 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4859 G1ParScanThreadState pss(_g1h, worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4860 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4861 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4862 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4863 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4864 pss.set_evac_closure(&scan_evac_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4865 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
|
4866 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
|
4867 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4868 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
|
4869 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
|
4870 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4871 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
|
4872 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
|
4873 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4874 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
|
4875 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
|
4876 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4877 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
|
4878 // We also need to mark copied objects. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4879 scan_root_cl = &scan_mark_root_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4880 scan_perm_cl = &scan_mark_perm_cl; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4881 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4882 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4883 G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4884 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4885 pss.start_strong_roots(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4886 _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
|
4887 SharedHeap::SO_AllClasses, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4888 scan_root_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4889 &push_heap_rs_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4890 scan_perm_cl, |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4891 worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4892 pss.end_strong_roots(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4893 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4894 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4895 double start = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4896 G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4897 evac.do_void(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4898 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
|
4899 double term_ms = pss.term_time()*1000.0; |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4900 _g1h->g1_policy()->phase_times()->add_obj_copy_time(worker_id, elapsed_ms-term_ms); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4901 _g1h->g1_policy()->phase_times()->record_termination(worker_id, term_ms, pss.term_attempts()); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4902 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4903 _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
|
4904 _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
|
4905 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4906 if (ParallelGCVerbose) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4907 MutexLocker x(stats_lock()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4908 pss.print_termination_stats(worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4909 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4910 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4911 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
|
4912 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4913 // 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
|
4914 // 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
|
4915 // "GC Worker Time". |
| 342 | 4916 } |
| 4917 | |
| 1611 | 4918 double end_time_ms = os::elapsedTime() * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4919 _g1h->g1_policy()->phase_times()->record_gc_worker_end_time(worker_id, end_time_ms); |
| 342 | 4920 } |
| 4921 }; | |
| 4922 | |
| 4923 // *** Common G1 Evacuation Stuff | |
| 4924 | |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4925 // 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
|
4926 // external root scanning. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4927 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4928 // 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
|
4929 // 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
|
4930 // 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
|
4931 // 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
|
4932 // 'marked' list. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4933 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4934 class G1FilteredCodeBlobToOopClosure : public CodeBlobToOopClosure { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4935 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4936 class G1PointsIntoCSOopClosure : public OopClosure { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4937 G1CollectedHeap* _g1; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4938 bool _points_into_cs; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4939 public: |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4940 G1PointsIntoCSOopClosure(G1CollectedHeap* g1) : |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4941 _g1(g1), _points_into_cs(false) { } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4942 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4943 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
|
4944 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4945 template <class T> |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4946 void do_oop_nv(T* p) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4947 if (!_points_into_cs) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4948 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
|
4949 if (!oopDesc::is_null(heap_oop) && |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4950 _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
|
4951 _points_into_cs = true; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4952 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4953 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4954 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4955 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4956 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
|
4957 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
|
4958 }; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4959 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4960 G1CollectedHeap* _g1; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4961 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4962 public: |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4963 G1FilteredCodeBlobToOopClosure(G1CollectedHeap* g1, OopClosure* cl) : |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4964 CodeBlobToOopClosure(cl, true), _g1(g1) { } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4965 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4966 virtual void do_code_blob(CodeBlob* cb) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4967 nmethod* nm = cb->as_nmethod_or_null(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4968 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
|
4969 G1PointsIntoCSOopClosure predicate_cl(_g1); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4970 nm->oops_do(&predicate_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4971 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4972 if (predicate_cl.points_into_cs()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4973 // 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
|
4974 // 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
|
4975 // 'mark' this nmethod. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4976 // 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
|
4977 // or MarkingCodeBlobClosure::do_code_blob() change. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4978 if (!nm->test_set_oops_do_mark()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4979 do_newly_marked_nmethod(nm); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4980 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4981 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4982 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4983 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4984 }; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4985 |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4986 // This method is run in a GC worker. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4987 |
| 342 | 4988 void |
| 4989 G1CollectedHeap:: | |
| 4990 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
|
4991 ScanningOption so, |
| 342 | 4992 OopClosure* scan_non_heap_roots, |
| 4993 OopsInHeapRegionClosure* scan_rs, | |
| 4994 OopsInGenClosure* scan_perm, | |
| 4995 int worker_i) { | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4996 |
| 342 | 4997 // First scan the strong roots, including the perm gen. |
| 4998 double ext_roots_start = os::elapsedTime(); | |
| 4999 double closure_app_time_sec = 0.0; | |
| 5000 | |
| 5001 BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); | |
| 5002 BufferingOopsInGenClosure buf_scan_perm(scan_perm); | |
| 5003 buf_scan_perm.set_generation(perm_gen()); | |
| 5004 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5005 // 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
|
5006 // unaligned oop locations. |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5007 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
|
5008 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5009 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
|
5010 collecting_perm_gen, so, |
| 342 | 5011 &buf_scan_non_heap_roots, |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5012 &eager_scan_code_roots, |
| 342 | 5013 &buf_scan_perm); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5014 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5015 // 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
|
5016 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
|
5017 // We need to treat the discovered reference lists of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5018 // concurrent mark ref processor as roots and keep entries |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5019 // (which are added by the marking threads) on them live |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5020 // until they can be processed at the end of marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5021 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
|
5022 } |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5023 |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5024 // Finish up any enqueued closure apps (attributed as object copy time). |
| 342 | 5025 buf_scan_non_heap_roots.done(); |
| 5026 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
|
5027 |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5028 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
|
5029 buf_scan_non_heap_roots.closure_app_seconds(); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5030 g1_policy()->phase_times()->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
|
5031 |
| 342 | 5032 double ext_root_time_ms = |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5033 ((os::elapsedTime() - 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
|
5034 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5035 g1_policy()->phase_times()->record_ext_root_scan_time(worker_i, ext_root_time_ms); |
| 342 | 5036 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5037 // 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
|
5038 // 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
|
5039 // as implicitly live). |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5040 double satb_filtering_ms = 0.0; |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5041 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
|
5042 if (mark_in_progress()) { |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5043 double satb_filter_start = os::elapsedTime(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5044 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5045 JavaThread::satb_mark_queue_set().filter_thread_buffers(); |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5046 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5047 satb_filtering_ms = (os::elapsedTime() - satb_filter_start) * 1000.0; |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5048 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5049 } |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5050 g1_policy()->phase_times()->record_satb_filtering_time(worker_i, satb_filtering_ms); |
| 342 | 5051 |
| 5052 // Now scan the complement of the collection set. | |
| 5053 if (scan_rs != NULL) { | |
| 5054 g1_rem_set()->oops_into_collection_set_do(scan_rs, worker_i); | |
| 5055 } | |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5056 |
| 342 | 5057 _process_strong_tasks->all_tasks_completed(); |
| 5058 } | |
| 5059 | |
| 5060 void | |
| 5061 G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure, | |
| 5062 OopClosure* non_root_closure) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5063 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
|
5064 SharedHeap::process_weak_roots(root_closure, &roots_in_blobs, non_root_closure); |
| 342 | 5065 } |
| 5066 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5067 // Weak Reference Processing support |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5068 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5069 // An always "is_alive" closure that is used to preserve referents. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5070 // 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
|
5071 // of referent objects that are pointed to by reference objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5072 // discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5073 class G1AlwaysAliveClosure: public BoolObjectClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5074 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5075 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5076 G1AlwaysAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5077 void do_object(oop p) { assert(false, "Do not call."); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5078 bool do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5079 if (p != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5080 return true; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5081 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5082 return false; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5083 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5084 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5085 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5086 bool G1STWIsAliveClosure::do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5087 // An object is reachable if it is outside the collection set, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5088 // or is inside and copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5089 return !_g1->obj_in_cs(p) || p->is_forwarded(); |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5092 // Non Copying Keep Alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5093 class G1KeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5094 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5095 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5096 G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5097 void do_oop(narrowOop* p) { guarantee(false, "Not needed"); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5098 void do_oop( oop* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5099 oop obj = *p; |
|
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 if (_g1->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5102 assert( obj->is_forwarded(), "invariant" ); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5103 *p = obj->forwardee(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5104 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5105 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5106 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5107 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5108 // Copying Keep Alive closure - can be called from both |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5109 // serial and parallel code as long as different worker |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5110 // threads utilize different G1ParScanThreadState instances |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5111 // and different queues. |
|
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 class G1CopyingKeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5114 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5115 OopClosure* _copy_non_heap_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5116 OopsInHeapRegionClosure* _copy_perm_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5117 G1ParScanThreadState* _par_scan_state; |
|
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 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5120 G1CopyingKeepAliveClosure(G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5121 OopClosure* non_heap_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5122 OopsInHeapRegionClosure* perm_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5123 G1ParScanThreadState* pss): |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5124 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5125 _copy_non_heap_obj_cl(non_heap_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5126 _copy_perm_obj_cl(perm_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5127 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5128 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5129 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5130 virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5131 virtual void do_oop( oop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5132 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5133 template <class T> void do_oop_work(T* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5134 oop obj = oopDesc::load_decode_heap_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5135 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5136 if (_g1h->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5137 // If the referent object has been forwarded (either copied |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5138 // 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
|
5139 // evacuation failure) then we need to update the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5140 // field and, if both reference and referent are in the G1 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5141 // heap, update the RSet for the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5142 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5143 // 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
|
5144 // it alive by policy. Therefore we have copy the referent. |
|
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 // 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
|
5147 // on the PSS queue. When the queue is drained (after each |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5148 // phase of reference processing) the object and it's followers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5149 // will be copied, the reference field set to point to the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5150 // new location, and the RSet updated. Otherwise we need to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5151 // use the the non-heap or perm closures directly to copy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5152 // the refernt object and update the pointer, while avoiding |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5153 // updating the RSet. |
|
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 if (_g1h->is_in_g1_reserved(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5156 _par_scan_state->push_on_queue(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5157 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5158 // The reference field is not in the G1 heap. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5159 if (_g1h->perm_gen()->is_in(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5160 _copy_perm_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5161 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5162 _copy_non_heap_obj_cl->do_oop(p); |
|
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 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5165 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5166 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5167 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5168 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5169 // Serial drain queue closure. Called as the 'complete_gc' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5170 // closure for each discovered list in some of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5171 // reference processing phases. |
|
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 class G1STWDrainQueueClosure: public VoidClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5174 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5175 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5176 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5177 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5178 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5179 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5180 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5181 G1STWDrainQueueClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5182 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5183 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5184 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5185 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5186 void do_void() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5187 G1ParScanThreadState* const pss = par_scan_state(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5188 pss->trim_queue(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5189 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5190 }; |
|
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 // Parallel Reference Processing closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5193 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5194 // Implementation of AbstractRefProcTaskExecutor for parallel reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5195 // processing during G1 evacuation pauses. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5196 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5197 class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5198 private: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5199 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5200 RefToScanQueueSet* _queues; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5201 FlexibleWorkGang* _workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5202 int _active_workers; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5203 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5204 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5205 G1STWRefProcTaskExecutor(G1CollectedHeap* g1h, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5206 FlexibleWorkGang* workers, |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5207 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5208 int n_workers) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5209 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5210 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5211 _workers(workers), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5212 _active_workers(n_workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5213 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5214 assert(n_workers > 0, "shouldn't call this otherwise"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5215 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5216 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5217 // Executes the given task using concurrent marking worker threads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5218 virtual void execute(ProcessTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5219 virtual void execute(EnqueueTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5220 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5221 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5222 // Gang task for possibly parallel reference processing |
|
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 class G1STWRefProcTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5225 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5226 ProcessTask& _proc_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5227 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5228 RefToScanQueueSet *_task_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5229 ParallelTaskTerminator* _terminator; |
|
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 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5232 G1STWRefProcTaskProxy(ProcessTask& proc_task, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5233 G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5234 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5235 ParallelTaskTerminator* terminator) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5236 AbstractGangTask("Process reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5237 _proc_task(proc_task), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5238 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5239 _task_queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5240 _terminator(terminator) |
|
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 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5243 virtual void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5244 // The reference processing task executed by a single worker. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5245 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5246 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5247 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5248 G1STWIsAliveClosure is_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5249 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5250 G1ParScanThreadState pss(_g1h, worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5251 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5252 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5253 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5254 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5255 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5256 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5257 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5258 pss.set_partial_scan_closure(&partial_scan_cl); |
|
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 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5261 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5262 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5263 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5264 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5265 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5266 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5267 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
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 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5270 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5271 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5272 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5273 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5274 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5275 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5276 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
|
5277 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5278 // Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5279 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator); |
|
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 // 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
|
5282 _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
|
5283 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5284 // 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
|
5285 // of the processing tasks (specifically phase2 - pp2_work) execute |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5286 // the complete_gc closure (which ordinarily would drain the queue) so |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5287 // the queue may not be empty. |
|
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 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5290 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5291 // Driver routine for parallel reference processing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5292 // Creates an instance of the ref processing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5293 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5294 void G1STWRefProcTaskExecutor::execute(ProcessTask& proc_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5295 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5296 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5297 ParallelTaskTerminator terminator(_active_workers, _queues); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5298 G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5299 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5300 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5301 _workers->run_task(&proc_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5302 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5303 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5304 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5305 // Gang task for parallel reference enqueueing. |
|
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 class G1STWRefEnqueueTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5308 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5309 EnqueueTask& _enq_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5310 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5311 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5312 G1STWRefEnqueueTaskProxy(EnqueueTask& enq_task) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5313 AbstractGangTask("Enqueue reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5314 _enq_task(enq_task) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5315 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5316 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5317 virtual void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5318 _enq_task.work(worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5319 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5320 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5321 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5322 // Driver routine for parallel reference enqueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5323 // Creates an instance of the ref enqueueing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5324 // task and has the worker threads execute it. |
|
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 void G1STWRefProcTaskExecutor::execute(EnqueueTask& enq_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5327 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5328 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5329 G1STWRefEnqueueTaskProxy enq_task_proxy(enq_task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5330 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5331 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5332 _workers->run_task(&enq_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5333 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5334 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5335 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5336 // End of weak reference support closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5337 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5338 // Abstract task used to preserve (i.e. copy) any referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5339 // 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
|
5340 // objects discovered by the CM ref processor. |
|
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 class G1ParPreserveCMReferentsTask: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5343 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5344 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5345 RefToScanQueueSet *_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5346 ParallelTaskTerminator _terminator; |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5347 uint _n_workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5348 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5349 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5350 G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5351 AbstractGangTask("ParPreserveCMReferents"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5352 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5353 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5354 _terminator(workers, _queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5355 _n_workers(workers) |
|
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 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5358 void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5359 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5360 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5361 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5362 G1ParScanThreadState pss(_g1h, worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5363 G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5364 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5365 G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5366 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5367 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5368 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5369 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5370 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5371 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
|
5372 |
|
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 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5375 G1ParScanPermClosure only_copy_perm_cl(_g1h, &pss, NULL); |
|
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 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5378 G1ParScanAndMarkPermClosure copy_mark_perm_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5379 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5380 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5381 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5382 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5383 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5384 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5385 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5386 copy_perm_cl = ©_mark_perm_cl; |
|
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 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5389 // Is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5390 G1AlwaysAliveClosure always_alive(_g1h); |
|
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 // Copying keep alive closure. Applied to referent objects that need |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5393 // to be copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5394 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
|
5395 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5396 ReferenceProcessor* rp = _g1h->ref_processor_cm(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5397 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5398 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
|
5399 uint stride = MIN2(MAX2(_n_workers, 1U), limit); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5400 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5401 // 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
|
5402 // 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
|
5403 // change the worker ids. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5404 assert(0 <= worker_id && worker_id < limit, "sanity"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5405 assert(!rp->discovery_is_atomic(), "check this code"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5406 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5407 // 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
|
5408 for (uint idx = worker_id; idx < limit; idx += stride) { |
|
4014
bf2d2b8b1726
7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents:
4013
diff
changeset
|
5409 DiscoveredList& ref_list = rp->discovered_refs()[idx]; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5410 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5411 DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5412 while (iter.has_next()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5413 // Since discovery is not atomic for the CM ref processor, we |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5414 // can see some null referent objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5415 iter.load_ptrs(DEBUG_ONLY(true)); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5416 oop ref = iter.obj(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5417 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5418 // This will filter nulls. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5419 if (iter.is_referent_alive()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5420 iter.make_referent_alive(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5421 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5422 iter.move_to_next(); |
|
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 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5425 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5426 // Drain the queue - which may cause stealing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5427 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5428 drain_queue.do_void(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5429 // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5430 assert(pss.refs()->is_empty(), "should be"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5431 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5432 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5433 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5434 // Weak Reference processing during an evacuation pause (part 1). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5435 void G1CollectedHeap::process_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5436 double ref_proc_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5437 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5438 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5439 assert(rp->discovery_enabled(), "should have been enabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5440 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5441 // Any reference objects, in the collection set, that were 'discovered' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5442 // 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
|
5443 // applying the external root copy closure to the discovered lists, or |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5444 // by following an RSet entry). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5445 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5446 // 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
|
5447 // 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
|
5448 // processor would have seen that the reference object had already |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5449 // been 'discovered' and would have skipped discovering the reference, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5450 // 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
|
5451 // 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
|
5452 // referent object. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5453 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5454 // We need to explicitly copy these referent objects - the references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5455 // will be processed at the end of remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5456 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5457 // 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
|
5458 // 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
|
5459 // referents points to another object which is also referenced by an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5460 // object discovered by the STW ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5461 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5462 uint active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5463 workers()->active_workers() : 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5464 |
| 4711 | 5465 assert(!G1CollectedHeap::use_parallel_gc_threads() || |
| 5466 active_workers == workers()->active_workers(), | |
| 5467 "Need to reset active_workers"); | |
| 5468 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5469 set_par_threads(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5470 G1ParPreserveCMReferentsTask keep_cm_referents(this, active_workers, _task_queues); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5471 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5472 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5473 workers()->run_task(&keep_cm_referents); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5474 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5475 keep_cm_referents.work(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5476 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5477 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5478 set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5479 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5480 // Closure to test whether a referent is alive. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5481 G1STWIsAliveClosure is_alive(this); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5482 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5483 // Even when parallel reference processing is enabled, the processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5484 // 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
|
5485 // 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
|
5486 // JNI refs. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5487 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5488 // Use only a single queue for this PSS. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5489 G1ParScanThreadState pss(this, 0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5490 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5491 // We do not embed a reference processor in the copying/scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5492 // closures while we're actually processing the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5493 // reference objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5494 G1ParScanHeapEvacClosure scan_evac_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5495 G1ParScanHeapEvacFailureClosure evac_failure_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5496 G1ParScanPartialArrayClosure partial_scan_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5497 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5498 pss.set_evac_closure(&scan_evac_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5499 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5500 pss.set_partial_scan_closure(&partial_scan_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5501 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5502 assert(pss.refs()->is_empty(), "pre-condition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5503 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5504 G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5505 G1ParScanPermClosure only_copy_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5506 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5507 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5508 G1ParScanAndMarkPermClosure copy_mark_perm_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5509 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5510 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5511 OopsInHeapRegionClosure* copy_perm_cl = &only_copy_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5512 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5513 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5514 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5515 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5516 copy_perm_cl = ©_mark_perm_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5517 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5518 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5519 // Keep alive closure. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5520 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
|
5521 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5522 // Serial Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5523 G1STWDrainQueueClosure drain_queue(this, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5524 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5525 // Setup the soft refs policy... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5526 rp->setup_policy(false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5527 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5528 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5529 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5530 rp->process_discovered_references(&is_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5531 &keep_alive, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5532 &drain_queue, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5533 NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5534 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5535 // Parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5536 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5537 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5538 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5539 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5540 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
|
5541 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5542 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5543 // We have completed copying any necessary live referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5544 // (that were not copied during the actual pause) so we can |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5545 // retire any active alloc buffers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5546 pss.retire_alloc_buffers(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5547 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
|
5548 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5549 double ref_proc_time = os::elapsedTime() - ref_proc_start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5550 g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5551 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5552 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5553 // Weak Reference processing during an evacuation pause (part 2). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5554 void G1CollectedHeap::enqueue_discovered_references() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5555 double ref_enq_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5556 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5557 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5558 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
|
5559 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5560 // Now enqueue any remaining on the discovered lists on to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5561 // the pending list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5562 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5563 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5564 rp->enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5565 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5566 // Parallel reference enqueuing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5567 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5568 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
|
5569 assert(active_workers == workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5570 "Need to reset active_workers"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5571 assert(rp->num_q() == active_workers, "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5572 assert(active_workers <= rp->max_num_q(), "sanity"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5573 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5574 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5575 rp->enqueue_discovered_references(&par_task_executor); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5576 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5577 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5578 rp->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5579 assert(!rp->discovery_enabled(), "should have been disabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5580 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5581 // FIXME |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5582 // 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
|
5583 // 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
|
5584 // and could signicantly increase the pause time. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5585 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5586 double ref_enq_time = os::elapsedTime() - ref_enq_start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5587 g1_policy()->phase_times()->record_ref_enq_time(ref_enq_time * 1000.0); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5588 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5589 |
| 342 | 5590 void G1CollectedHeap::evacuate_collection_set() { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
5591 _expand_heap_after_alloc_failure = true; |
| 342 | 5592 set_evacuation_failed(false); |
| 5593 | |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5594 // Should G1EvacuationFailureALot be in effect for this GC? |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5595 NOT_PRODUCT(set_evacuation_failure_alot_for_current_gc();) |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5596 |
| 342 | 5597 g1_rem_set()->prepare_for_oops_into_collection_set_do(); |
| 5598 concurrent_g1_refine()->set_use_cache(false); | |
| 889 | 5599 concurrent_g1_refine()->clear_hot_cache_claimed_index(); |
| 5600 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5601 uint n_workers; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5602 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5603 n_workers = |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5604 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5605 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5606 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5607 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5608 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5609 "If not dynamic should be using all the workers"); |
| 4711 | 5610 workers()->set_active_workers(n_workers); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5611 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5612 } else { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5613 assert(n_par_threads() == 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5614 "Should be the original non-parallel value"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5615 n_workers = 1; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5616 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5617 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5618 G1ParTask g1_par_task(this, _task_queues); |
| 342 | 5619 |
| 5620 init_for_evac_failure(NULL); | |
| 5621 | |
| 5622 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
|
5623 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5624 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
|
5625 double start_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5626 double end_par_time_sec; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5627 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5628 { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
5629 StrongRootsScope srs(this); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5630 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5631 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5632 // 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
|
5633 if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5634 // These tasks use ShareHeap::_process_strong_tasks |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5635 assert(UseDynamicNumberOfGCThreads || |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5636 workers()->active_workers() == workers()->total_workers(), |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5637 "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
|
5638 workers()->run_task(&g1_par_task); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5639 } else { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5640 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
|
5641 g1_par_task.work(0); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5642 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5643 end_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5644 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5645 // 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
|
5646 // 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
|
5647 // 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
|
5648 // 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
|
5649 // reported parallel time. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5650 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5651 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5652 double par_time_ms = (end_par_time_sec - start_par_time_sec) * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5653 g1_policy()->phase_times()->record_par_time(par_time_ms); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5654 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5655 double code_root_fixup_time_ms = |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5656 (os::elapsedTime() - end_par_time_sec) * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5657 g1_policy()->phase_times()->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
|
5658 |
| 342 | 5659 set_par_threads(0); |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5660 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5661 // Process any discovered reference objects - we have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5662 // to do this _before_ we retire the GC alloc regions |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5663 // as we may have to copy some 'reachable' referent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5664 // objects (and their reachable sub-graphs) that were |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5665 // not copied during the pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5666 process_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5667 |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5668 // Weak root processing. |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
5669 // 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
|
5670 // 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
|
5671 // here too. |
| 342 | 5672 { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5673 G1STWIsAliveClosure is_alive(this); |
| 342 | 5674 G1KeepAliveClosure keep_alive(this); |
| 5675 JNIHandles::weak_oops_do(&is_alive, &keep_alive); | |
| 5676 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5677 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5678 release_gc_alloc_regions(); |
| 342 | 5679 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
|
5680 |
| 889 | 5681 concurrent_g1_refine()->clear_hot_cache(); |
| 342 | 5682 concurrent_g1_refine()->set_use_cache(true); |
| 5683 | |
| 5684 finalize_for_evac_failure(); | |
| 5685 | |
| 5686 if (evacuation_failed()) { | |
| 5687 remove_self_forwarding_pointers(); | |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5688 |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5689 // Reset the G1EvacuationFailureALot counters and flags |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5690 // Note: the values are reset only when an actual |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5691 // evacuation failure occurs. |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5692 NOT_PRODUCT(reset_evacuation_should_fail();) |
| 342 | 5693 } |
| 5694 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5695 // Enqueue any remaining references remaining on the STW |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5696 // reference processor's discovered lists. We need to do |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5697 // this after the card table is cleaned (and verified) as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5698 // the act of enqueuing entries on to the pending list |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5699 // will log these updates (and dirty their associated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5700 // cards). We need these updates logged to update any |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5701 // RSets. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5702 enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5703 |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5704 if (G1DeferredRSUpdate) { |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5705 RedirtyLoggedCardTableEntryFastClosure redirty; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5706 dirty_card_queue_set().set_closure(&redirty); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5707 dirty_card_queue_set().apply_closure_to_all_completed_buffers(); |
| 1111 | 5708 |
| 5709 DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set(); | |
| 5710 dcq.merge_bufferlists(&dirty_card_queue_set()); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5711 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
|
5712 } |
| 342 | 5713 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
| 5714 } | |
| 5715 | |
| 2173 | 5716 void G1CollectedHeap::free_region_if_empty(HeapRegion* hr, |
| 2152 | 5717 size_t* pre_used, |
| 5718 FreeRegionList* free_list, | |
| 4072 | 5719 OldRegionSet* old_proxy_set, |
| 2152 | 5720 HumongousRegionSet* humongous_proxy_set, |
| 2173 | 5721 HRRSCleanupTask* hrrs_cleanup_task, |
| 2152 | 5722 bool par) { |
| 5723 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) { | |
| 5724 if (hr->isHumongous()) { | |
| 5725 assert(hr->startsHumongous(), "we should only see starts humongous"); | |
| 5726 free_humongous_region(hr, pre_used, free_list, humongous_proxy_set, par); | |
| 5727 } else { | |
| 4072 | 5728 _old_set.remove_with_proxy(hr, old_proxy_set); |
| 2152 | 5729 free_region(hr, pre_used, free_list, par); |
| 342 | 5730 } |
| 2173 | 5731 } else { |
| 5732 hr->rem_set()->do_cleanup_work(hrrs_cleanup_task); | |
| 342 | 5733 } |
| 5734 } | |
| 5735 | |
| 2152 | 5736 void G1CollectedHeap::free_region(HeapRegion* hr, |
| 5737 size_t* pre_used, | |
| 5738 FreeRegionList* free_list, | |
| 5739 bool par) { | |
| 5740 assert(!hr->isHumongous(), "this is only for non-humongous regions"); | |
| 5741 assert(!hr->is_empty(), "the region should not be empty"); | |
| 5742 assert(free_list != NULL, "pre-condition"); | |
| 5743 | |
| 5744 *pre_used += hr->used(); | |
| 5745 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
|
5746 free_list->add_as_head(hr); |
| 2152 | 5747 } |
| 5748 | |
| 5749 void G1CollectedHeap::free_humongous_region(HeapRegion* hr, | |
| 5750 size_t* pre_used, | |
| 5751 FreeRegionList* free_list, | |
| 5752 HumongousRegionSet* humongous_proxy_set, | |
| 5753 bool par) { | |
| 5754 assert(hr->startsHumongous(), "this is only for starts humongous regions"); | |
| 5755 assert(free_list != NULL, "pre-condition"); | |
| 5756 assert(humongous_proxy_set != NULL, "pre-condition"); | |
| 5757 | |
| 5758 size_t hr_used = hr->used(); | |
| 5759 size_t hr_capacity = hr->capacity(); | |
| 5760 size_t hr_pre_used = 0; | |
| 5761 _humongous_set.remove_with_proxy(hr, humongous_proxy_set); | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
5762 // We need to read this before we make the region non-humongous, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
5763 // otherwise the information will be gone. |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
5764 uint last_index = hr->last_hc_index(); |
| 2152 | 5765 hr->set_notHumongous(); |
| 5766 free_region(hr, &hr_pre_used, free_list, par); | |
| 5767 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
5768 uint i = hr->hrs_index() + 1; |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
5769 while (i < last_index) { |
| 3766 | 5770 HeapRegion* curr_hr = region_at(i); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
5771 assert(curr_hr->continuesHumongous(), "invariant"); |
| 2152 | 5772 curr_hr->set_notHumongous(); |
| 5773 free_region(curr_hr, &hr_pre_used, free_list, par); | |
| 5774 i += 1; | |
| 5775 } | |
| 5776 assert(hr_pre_used == hr_used, | |
| 5777 err_msg("hr_pre_used: "SIZE_FORMAT" and hr_used: "SIZE_FORMAT" " | |
| 5778 "should be the same", hr_pre_used, hr_used)); | |
| 5779 *pre_used += hr_pre_used; | |
| 5780 } | |
| 5781 | |
| 5782 void G1CollectedHeap::update_sets_after_freeing_regions(size_t pre_used, | |
| 5783 FreeRegionList* free_list, | |
| 4072 | 5784 OldRegionSet* old_proxy_set, |
| 2152 | 5785 HumongousRegionSet* humongous_proxy_set, |
| 5786 bool par) { | |
| 5787 if (pre_used > 0) { | |
| 5788 Mutex* lock = (par) ? ParGCRareEvent_lock : NULL; | |
| 342 | 5789 MutexLockerEx x(lock, Mutex::_no_safepoint_check_flag); |
| 2152 | 5790 assert(_summary_bytes_used >= pre_used, |
| 5791 err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" " | |
| 5792 "should be >= pre_used: "SIZE_FORMAT, | |
| 5793 _summary_bytes_used, pre_used)); | |
| 342 | 5794 _summary_bytes_used -= pre_used; |
| 2152 | 5795 } |
| 5796 if (free_list != NULL && !free_list->is_empty()) { | |
| 5797 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
|
5798 _free_list.add_as_head(free_list); |
| 2152 | 5799 } |
| 4072 | 5800 if (old_proxy_set != NULL && !old_proxy_set->is_empty()) { |
| 5801 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5802 _old_set.update_from_proxy(old_proxy_set); | |
| 5803 } | |
| 2152 | 5804 if (humongous_proxy_set != NULL && !humongous_proxy_set->is_empty()) { |
| 5805 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); | |
| 5806 _humongous_set.update_from_proxy(humongous_proxy_set); | |
| 342 | 5807 } |
| 5808 } | |
| 5809 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5810 class G1ParCleanupCTTask : public AbstractGangTask { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5811 CardTableModRefBS* _ct_bs; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5812 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5813 HeapRegion* volatile _su_head; |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5814 public: |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5815 G1ParCleanupCTTask(CardTableModRefBS* ct_bs, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
5816 G1CollectedHeap* g1h) : |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5817 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
|
5818 _ct_bs(ct_bs), _g1h(g1h) { } |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5819 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5820 void work(uint worker_id) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5821 HeapRegion* r; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5822 while (r = _g1h->pop_dirty_cards_region()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5823 clear_cards(r); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5824 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5825 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5826 |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5827 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
|
5828 // 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
|
5829 if (!r->is_survivor()) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5830 _ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5831 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5832 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5833 }; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5834 |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5835 #ifndef PRODUCT |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5836 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
|
5837 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5838 CardTableModRefBS* _ct_bs; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5839 public: |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5840 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
|
5841 : _g1h(g1h), _ct_bs(ct_bs) { } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5842 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
|
5843 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
|
5844 _g1h->verify_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5845 } else { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5846 _g1h->verify_not_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5847 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5848 return false; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5849 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5850 }; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5851 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5852 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
|
5853 // 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
|
5854 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
|
5855 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
|
5856 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
|
5857 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5858 |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5859 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
|
5860 // 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
|
5861 // 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
|
5862 // 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
|
5863 // 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
|
5864 // 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
|
5865 // 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
|
5866 // is dirty. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5867 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
|
5868 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
|
5869 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
|
5870 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
5871 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5872 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
|
5873 CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5874 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
|
5875 verify_dirty_region(hr); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5876 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5877 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5878 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5879 void G1CollectedHeap::verify_dirty_young_regions() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5880 verify_dirty_young_list(_young_list->first_region()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
5881 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5882 #endif |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5883 |
| 342 | 5884 void G1CollectedHeap::cleanUpCardTable() { |
| 5885 CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set()); | |
| 5886 double start = os::elapsedTime(); | |
| 5887 | |
| 4023 | 5888 { |
| 5889 // Iterate over the dirty cards region list. | |
| 5890 G1ParCleanupCTTask cleanup_task(ct_bs, this); | |
| 5891 | |
| 4711 | 5892 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 5893 set_par_threads(); | |
| 4023 | 5894 workers()->run_task(&cleanup_task); |
| 5895 set_par_threads(0); | |
| 5896 } else { | |
| 5897 while (_dirty_cards_region_list) { | |
| 5898 HeapRegion* r = _dirty_cards_region_list; | |
| 5899 cleanup_task.clear_cards(r); | |
| 5900 _dirty_cards_region_list = r->get_next_dirty_cards_region(); | |
| 5901 if (_dirty_cards_region_list == r) { | |
| 5902 // The last region. | |
| 5903 _dirty_cards_region_list = NULL; | |
| 5904 } | |
| 5905 r->set_next_dirty_cards_region(NULL); | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5906 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
5907 } |
| 4023 | 5908 #ifndef PRODUCT |
| 5909 if (G1VerifyCTCleanup || VerifyAfterGC) { | |
| 5910 G1VerifyCardTableCleanup cleanup_verifier(this, ct_bs); | |
| 5911 heap_region_iterate(&cleanup_verifier); | |
| 5912 } | |
| 5913 #endif | |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
5914 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5915 |
| 342 | 5916 double elapsed = os::elapsedTime() - start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5917 g1_policy()->phase_times()->record_clear_ct_time(elapsed * 1000.0); |
| 342 | 5918 } |
| 5919 | |
| 5920 void G1CollectedHeap::free_collection_set(HeapRegion* cs_head) { | |
| 2152 | 5921 size_t pre_used = 0; |
| 5922 FreeRegionList local_free_list("Local List for CSet Freeing"); | |
| 5923 | |
| 342 | 5924 double young_time_ms = 0.0; |
| 5925 double non_young_time_ms = 0.0; | |
| 5926 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5927 // 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
|
5928 // 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
|
5929 // 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
|
5930 _young_list->clear(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5931 |
| 342 | 5932 G1CollectorPolicy* policy = g1_policy(); |
| 5933 | |
| 5934 double start_sec = os::elapsedTime(); | |
| 5935 bool non_young = true; | |
| 5936 | |
| 5937 HeapRegion* cur = cs_head; | |
| 5938 int age_bound = -1; | |
| 5939 size_t rs_lengths = 0; | |
| 5940 | |
| 5941 while (cur != NULL) { | |
| 2361 | 5942 assert(!is_on_master_free_list(cur), "sanity"); |
| 342 | 5943 if (non_young) { |
| 5944 if (cur->is_young()) { | |
| 5945 double end_sec = os::elapsedTime(); | |
| 5946 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
| 5947 non_young_time_ms += elapsed_ms; | |
| 5948 | |
| 5949 start_sec = os::elapsedTime(); | |
| 5950 non_young = false; | |
| 5951 } | |
| 5952 } else { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5953 if (!cur->is_young()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5954 double end_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5955 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
|
5956 young_time_ms += elapsed_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5957 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5958 start_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5959 non_young = true; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5960 } |
| 342 | 5961 } |
| 5962 | |
| 5963 rs_lengths += cur->rem_set()->occupied(); | |
| 5964 | |
| 5965 HeapRegion* next = cur->next_in_collection_set(); | |
| 5966 assert(cur->in_collection_set(), "bad CS"); | |
| 5967 cur->set_next_in_collection_set(NULL); | |
| 5968 cur->set_in_collection_set(false); | |
| 5969 | |
| 5970 if (cur->is_young()) { | |
| 5971 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
|
5972 assert(index != -1, "invariant"); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
5973 assert((uint) index < policy->young_cset_region_length(), "invariant"); |
| 342 | 5974 size_t words_survived = _surviving_young_words[index]; |
| 5975 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
|
5976 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5977 // 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
|
5978 // (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
|
5979 // 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
|
5980 // _next_young_region field. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
5981 cur->set_next_young_region(NULL); |
| 342 | 5982 } else { |
| 5983 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
|
5984 assert(index == -1, "invariant"); |
| 342 | 5985 } |
| 5986 | |
| 5987 assert( (cur->is_young() && cur->young_index_in_cset() > -1) || | |
| 5988 (!cur->is_young() && cur->young_index_in_cset() == -1), | |
| 5989 "invariant" ); | |
| 5990 | |
| 5991 if (!cur->evacuation_failed()) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5992 MemRegion used_mr = cur->used_region(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5993 |
| 342 | 5994 // And the region is empty. |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
5995 assert(!used_mr.is_empty(), "Should not have empty regions in a CS."); |
| 2152 | 5996 free_region(cur, &pre_used, &local_free_list, false /* par */); |
| 342 | 5997 } else { |
| 5998 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
|
5999 if (cur->is_young()) { |
| 342 | 6000 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
|
6001 } |
| 342 | 6002 cur->set_not_young(); |
| 6003 cur->set_evacuation_failed(false); | |
| 4072 | 6004 // The region is now considered to be old. |
| 6005 _old_set.add(cur); | |
| 342 | 6006 } |
| 6007 cur = next; | |
| 6008 } | |
| 6009 | |
| 6010 policy->record_max_rs_lengths(rs_lengths); | |
| 6011 policy->cset_regions_freed(); | |
| 6012 | |
| 6013 double end_sec = os::elapsedTime(); | |
| 6014 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
|
6015 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6016 if (non_young) { |
| 342 | 6017 non_young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6018 } else { |
| 342 | 6019 young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6020 } |
| 342 | 6021 |
| 2152 | 6022 update_sets_after_freeing_regions(pre_used, &local_free_list, |
| 4072 | 6023 NULL /* old_proxy_set */, |
| 2152 | 6024 NULL /* humongous_proxy_set */, |
| 6025 false /* par */); | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6026 policy->phase_times()->record_young_free_cset_time_ms(young_time_ms); |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6027 policy->phase_times()->record_non_young_free_cset_time_ms(non_young_time_ms); |
| 342 | 6028 } |
| 6029 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6030 // 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
|
6031 // 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
|
6032 // 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
|
6033 // 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
|
6034 // 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
|
6035 // 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
|
6036 // 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
|
6037 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6038 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
|
6039 HeapRegion* cur = cs_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6040 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6041 while (cur != NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6042 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
|
6043 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
|
6044 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
|
6045 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
|
6046 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
|
6047 cur = next; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6048 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6049 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6050 |
| 2152 | 6051 void G1CollectedHeap::set_free_regions_coming() { |
| 6052 if (G1ConcRegionFreeingVerbose) { | |
| 6053 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 6054 "setting free regions coming"); | |
| 6055 } | |
| 6056 | |
| 6057 assert(!free_regions_coming(), "pre-condition"); | |
| 6058 _free_regions_coming = true; | |
| 342 | 6059 } |
| 6060 | |
| 2152 | 6061 void G1CollectedHeap::reset_free_regions_coming() { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
6062 assert(free_regions_coming(), "pre-condition"); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
6063 |
| 2152 | 6064 { |
| 6065 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 6066 _free_regions_coming = false; | |
| 6067 SecondaryFreeList_lock->notify_all(); | |
| 6068 } | |
| 6069 | |
| 6070 if (G1ConcRegionFreeingVerbose) { | |
| 6071 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 6072 "reset free regions coming"); | |
| 342 | 6073 } |
| 6074 } | |
| 6075 | |
| 2152 | 6076 void G1CollectedHeap::wait_while_free_regions_coming() { |
| 6077 // Most of the time we won't have to wait, so let's do a quick test | |
| 6078 // first before we take the lock. | |
| 6079 if (!free_regions_coming()) { | |
| 6080 return; | |
| 6081 } | |
| 6082 | |
| 6083 if (G1ConcRegionFreeingVerbose) { | |
| 6084 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 6085 "waiting for free regions"); | |
| 342 | 6086 } |
| 6087 | |
| 6088 { | |
| 2152 | 6089 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 6090 while (free_regions_coming()) { | |
| 6091 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 342 | 6092 } |
| 2152 | 6093 } |
| 6094 | |
| 6095 if (G1ConcRegionFreeingVerbose) { | |
| 6096 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 6097 "done waiting for free regions"); | |
| 6098 } | |
| 342 | 6099 } |
| 6100 | |
| 6101 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) { | |
| 6102 assert(heap_lock_held_for_gc(), | |
| 6103 "the heap lock should already be held by or for this thread"); | |
| 6104 _young_list->push_region(hr); | |
| 6105 } | |
| 6106 | |
| 6107 class NoYoungRegionsClosure: public HeapRegionClosure { | |
| 6108 private: | |
| 6109 bool _success; | |
| 6110 public: | |
| 6111 NoYoungRegionsClosure() : _success(true) { } | |
| 6112 bool doHeapRegion(HeapRegion* r) { | |
| 6113 if (r->is_young()) { | |
| 6114 gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", | |
| 6115 r->bottom(), r->end()); | |
| 6116 _success = false; | |
| 6117 } | |
| 6118 return false; | |
| 6119 } | |
| 6120 bool success() { return _success; } | |
| 6121 }; | |
| 6122 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6123 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
|
6124 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
|
6125 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6126 if (check_heap) { |
| 342 | 6127 NoYoungRegionsClosure closure; |
| 6128 heap_region_iterate(&closure); | |
| 6129 ret = ret && closure.success(); | |
| 6130 } | |
| 6131 | |
| 6132 return ret; | |
| 6133 } | |
| 6134 | |
| 4072 | 6135 class TearDownRegionSetsClosure : public HeapRegionClosure { |
| 6136 private: | |
| 6137 OldRegionSet *_old_set; | |
| 2152 | 6138 |
| 342 | 6139 public: |
| 4072 | 6140 TearDownRegionSetsClosure(OldRegionSet* old_set) : _old_set(old_set) { } |
| 2152 | 6141 |
| 342 | 6142 bool doHeapRegion(HeapRegion* r) { |
| 4072 | 6143 if (r->is_empty()) { |
| 6144 // We ignore empty regions, we'll empty the free list afterwards | |
| 6145 } else if (r->is_young()) { | |
| 6146 // We ignore young regions, we'll empty the young list afterwards | |
| 6147 } else if (r->isHumongous()) { | |
| 6148 // We ignore humongous regions, we're not tearing down the | |
| 6149 // humongous region set | |
| 342 | 6150 } else { |
| 4072 | 6151 // The rest should be old |
| 6152 _old_set->remove(r); | |
| 342 | 6153 } |
| 6154 return false; | |
| 6155 } | |
| 6156 | |
| 4072 | 6157 ~TearDownRegionSetsClosure() { |
| 6158 assert(_old_set->is_empty(), "post-condition"); | |
| 2152 | 6159 } |
| 342 | 6160 }; |
| 6161 | |
| 4072 | 6162 void G1CollectedHeap::tear_down_region_sets(bool free_list_only) { |
| 6163 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6164 | |
| 6165 if (!free_list_only) { | |
| 6166 TearDownRegionSetsClosure cl(&_old_set); | |
| 6167 heap_region_iterate(&cl); | |
| 6168 | |
| 6169 // Need to do this after the heap iteration to be able to | |
| 6170 // recognize the young regions and ignore them during the iteration. | |
| 6171 _young_list->empty_list(); | |
| 6172 } | |
| 6173 _free_list.remove_all(); | |
| 6174 } | |
| 6175 | |
| 6176 class RebuildRegionSetsClosure : public HeapRegionClosure { | |
| 6177 private: | |
| 6178 bool _free_list_only; | |
| 6179 OldRegionSet* _old_set; | |
| 6180 FreeRegionList* _free_list; | |
| 6181 size_t _total_used; | |
| 6182 | |
| 6183 public: | |
| 6184 RebuildRegionSetsClosure(bool free_list_only, | |
| 6185 OldRegionSet* old_set, FreeRegionList* free_list) : | |
| 6186 _free_list_only(free_list_only), | |
| 6187 _old_set(old_set), _free_list(free_list), _total_used(0) { | |
| 6188 assert(_free_list->is_empty(), "pre-condition"); | |
| 6189 if (!free_list_only) { | |
| 6190 assert(_old_set->is_empty(), "pre-condition"); | |
| 6191 } | |
| 6192 } | |
| 6193 | |
| 6194 bool doHeapRegion(HeapRegion* r) { | |
| 6195 if (r->continuesHumongous()) { | |
| 6196 return false; | |
| 6197 } | |
| 6198 | |
| 6199 if (r->is_empty()) { | |
| 6200 // Add free regions to the free list | |
| 6201 _free_list->add_as_tail(r); | |
| 6202 } else if (!_free_list_only) { | |
| 6203 assert(!r->is_young(), "we should not come across young regions"); | |
| 6204 | |
| 6205 if (r->isHumongous()) { | |
| 6206 // We ignore humongous regions, we left the humongous set unchanged | |
| 6207 } else { | |
| 6208 // The rest should be old, add them to the old set | |
| 6209 _old_set->add(r); | |
| 6210 } | |
| 6211 _total_used += r->used(); | |
| 6212 } | |
| 6213 | |
| 6214 return false; | |
| 6215 } | |
| 6216 | |
| 6217 size_t total_used() { | |
| 6218 return _total_used; | |
| 6219 } | |
| 6220 }; | |
| 6221 | |
| 6222 void G1CollectedHeap::rebuild_region_sets(bool free_list_only) { | |
| 6223 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6224 | |
| 6225 RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list); | |
| 6226 heap_region_iterate(&cl); | |
| 6227 | |
| 6228 if (!free_list_only) { | |
| 6229 _summary_bytes_used = cl.total_used(); | |
| 6230 } | |
| 6231 assert(_summary_bytes_used == recalculate_used(), | |
| 6232 err_msg("inconsistent _summary_bytes_used, " | |
| 6233 "value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, | |
| 6234 _summary_bytes_used, recalculate_used())); | |
| 342 | 6235 } |
| 6236 | |
| 6237 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) { | |
| 6238 _refine_cte_cl->set_concurrent(concurrent); | |
| 6239 } | |
| 6240 | |
| 6241 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { | |
| 6242 HeapRegion* hr = heap_region_containing(p); | |
| 6243 if (hr == NULL) { | |
| 6244 return is_in_permanent(p); | |
| 6245 } else { | |
| 6246 return hr->is_in(p); | |
| 6247 } | |
| 6248 } | |
| 2152 | 6249 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6250 // 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
|
6251 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6252 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
|
6253 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6254 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
|
6255 assert(!force || g1_policy()->can_expand_young_list(), |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6256 "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
|
6257 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
|
6258 if (force || !young_list_full) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6259 HeapRegion* new_alloc_region = new_region(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6260 false /* do_expand */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6261 if (new_alloc_region != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6262 set_region_short_lived_locked(new_alloc_region); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6263 _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
|
6264 return new_alloc_region; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6265 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6266 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6267 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6268 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6269 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6270 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
|
6271 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6272 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
|
6273 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
|
6274 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6275 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
|
6276 _summary_bytes_used += allocated_bytes; |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6277 _hr_printer.retire(alloc_region); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6278 // 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
|
6279 // 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
|
6280 // used space has been recored in _summary_bytes_used. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6281 g1mm()->update_eden_size(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6282 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6283 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6284 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
|
6285 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6286 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
|
6287 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6288 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6289 void G1CollectedHeap::set_par_threads() { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6290 // 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
|
6291 // in the workgroup. |
| 4711 | 6292 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
|
6293 uint n_workers = workers()->active_workers(); |
| 4711 | 6294 assert(UseDynamicNumberOfGCThreads || |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6295 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6296 "Otherwise should be using the total number of workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6297 if (n_workers == 0) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6298 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
|
6299 n_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6300 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6301 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6302 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6303 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6304 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6305 void MutatorAllocRegion::retire_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6306 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6307 _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
|
6308 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6309 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6310 // 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
|
6311 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6312 HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size, |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6313 uint count, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6314 GCAllocPurpose ap) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6315 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
|
6316 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6317 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
|
6318 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
|
6319 true /* do_expand */); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6320 if (new_alloc_region != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6321 // 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
|
6322 // 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
|
6323 // for survivors too. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6324 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
|
6325 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6326 new_alloc_region->set_survivor(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6327 _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
|
6328 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6329 _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
|
6330 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6331 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
|
6332 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
|
6333 return new_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6334 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6335 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
|
6336 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6337 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6338 return NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6339 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6340 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6341 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
|
6342 size_t allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6343 GCAllocPurpose ap) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6344 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
|
6345 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
|
6346 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
|
6347 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6348 young_list()->add_survivor_region(alloc_region); |
| 4072 | 6349 } else { |
| 6350 _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
|
6351 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6352 _hr_printer.retire(alloc_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6353 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6354 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6355 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
|
6356 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6357 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
|
6358 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
|
6359 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6360 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6361 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
|
6362 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6363 _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
|
6364 GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6365 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6366 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6367 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
|
6368 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6369 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
|
6370 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
|
6371 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6372 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6373 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
|
6374 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6375 _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
|
6376 GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6377 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6378 // Heap region set verification |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6379 |
| 2152 | 6380 class VerifyRegionListsClosure : public HeapRegionClosure { |
| 6381 private: | |
| 4072 | 6382 FreeRegionList* _free_list; |
| 6383 OldRegionSet* _old_set; | |
| 2152 | 6384 HumongousRegionSet* _humongous_set; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6385 uint _region_count; |
| 2152 | 6386 |
| 6387 public: | |
| 4072 | 6388 VerifyRegionListsClosure(OldRegionSet* old_set, |
| 6389 HumongousRegionSet* humongous_set, | |
| 2152 | 6390 FreeRegionList* free_list) : |
| 4072 | 6391 _old_set(old_set), _humongous_set(humongous_set), |
| 6392 _free_list(free_list), _region_count(0) { } | |
| 2152 | 6393 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6394 uint region_count() { return _region_count; } |
| 2152 | 6395 |
| 6396 bool doHeapRegion(HeapRegion* hr) { | |
| 6397 _region_count += 1; | |
| 6398 | |
| 6399 if (hr->continuesHumongous()) { | |
| 6400 return false; | |
| 6401 } | |
| 6402 | |
| 6403 if (hr->is_young()) { | |
| 6404 // TODO | |
| 6405 } else if (hr->startsHumongous()) { | |
| 6406 _humongous_set->verify_next_region(hr); | |
| 6407 } else if (hr->is_empty()) { | |
| 6408 _free_list->verify_next_region(hr); | |
| 4072 | 6409 } else { |
| 6410 _old_set->verify_next_region(hr); | |
| 2152 | 6411 } |
| 6412 return false; | |
| 6413 } | |
| 6414 }; | |
| 6415 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6416 HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index, |
| 3766 | 6417 HeapWord* bottom) { |
| 6418 HeapWord* end = bottom + HeapRegion::GrainWords; | |
| 6419 MemRegion mr(bottom, end); | |
| 6420 assert(_g1_reserved.contains(mr), "invariant"); | |
| 6421 // This might return NULL if the allocation fails | |
| 6422 return new HeapRegion(hrs_index, _bot_shared, mr, true /* is_zeroed */); | |
| 6423 } | |
| 6424 | |
| 2152 | 6425 void G1CollectedHeap::verify_region_sets() { |
| 6426 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); | |
| 6427 | |
| 6428 // First, check the explicit lists. | |
| 6429 _free_list.verify(); | |
| 6430 { | |
| 6431 // Given that a concurrent operation might be adding regions to | |
| 6432 // the secondary free list we have to take the lock before | |
| 6433 // verifying it. | |
| 6434 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 6435 _secondary_free_list.verify(); | |
| 6436 } | |
| 4072 | 6437 _old_set.verify(); |
| 2152 | 6438 _humongous_set.verify(); |
| 6439 | |
| 6440 // If a concurrent region freeing operation is in progress it will | |
| 6441 // be difficult to correctly attributed any free regions we come | |
| 6442 // across to the correct free list given that they might belong to | |
| 6443 // one of several (free_list, secondary_free_list, any local lists, | |
| 6444 // etc.). So, if that's the case we will skip the rest of the | |
| 6445 // verification operation. Alternatively, waiting for the concurrent | |
| 6446 // operation to complete will have a non-trivial effect on the GC's | |
| 6447 // operation (no concurrent operation will last longer than the | |
| 6448 // interval between two calls to verification) and it might hide | |
| 6449 // any issues that we would like to catch during testing. | |
| 6450 if (free_regions_coming()) { | |
| 6451 return; | |
| 6452 } | |
| 6453 | |
| 2361 | 6454 // Make sure we append the secondary_free_list on the free_list so |
| 6455 // that all free regions we will come across can be safely | |
| 6456 // attributed to the free_list. | |
| 6457 append_secondary_free_list_if_not_empty_with_lock(); | |
| 2152 | 6458 |
| 6459 // Finally, make sure that the region accounting in the lists is | |
| 6460 // consistent with what we see in the heap. | |
| 4072 | 6461 _old_set.verify_start(); |
| 2152 | 6462 _humongous_set.verify_start(); |
| 6463 _free_list.verify_start(); | |
| 6464 | |
| 4072 | 6465 VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list); |
| 2152 | 6466 heap_region_iterate(&cl); |
| 6467 | |
| 4072 | 6468 _old_set.verify_end(); |
| 2152 | 6469 _humongous_set.verify_end(); |
| 6470 _free_list.verify_end(); | |
| 342 | 6471 } |