Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1RemSet.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | da91efe96a93 |
| children | 5c93c1f61226 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 4839 | 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:
1282
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1282
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:
1282
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "gc_implementation/g1/bufferingOopClosure.hpp" | |
| 27 #include "gc_implementation/g1/concurrentG1Refine.hpp" | |
| 28 #include "gc_implementation/g1/concurrentG1RefineThread.hpp" | |
| 29 #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp" | |
| 30 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 31 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
32 #include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
| 1972 | 33 #include "gc_implementation/g1/g1OopClosures.inline.hpp" |
| 34 #include "gc_implementation/g1/g1RemSet.inline.hpp" | |
| 35 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 36 #include "memory/iterator.hpp" | |
| 37 #include "oops/oop.inline.hpp" | |
| 38 #include "utilities/intHisto.hpp" | |
| 342 | 39 |
| 40 #define CARD_REPEAT_HISTO 0 | |
| 41 | |
| 42 #if CARD_REPEAT_HISTO | |
| 43 static size_t ct_freq_sz; | |
| 44 static jbyte* ct_freq = NULL; | |
| 45 | |
| 46 void init_ct_freq_table(size_t heap_sz_bytes) { | |
| 47 if (ct_freq == NULL) { | |
| 48 ct_freq_sz = heap_sz_bytes/CardTableModRefBS::card_size; | |
| 49 ct_freq = new jbyte[ct_freq_sz]; | |
| 50 for (size_t j = 0; j < ct_freq_sz; j++) ct_freq[j] = 0; | |
| 51 } | |
| 52 } | |
| 53 | |
| 54 void ct_freq_note_card(size_t index) { | |
| 55 assert(0 <= index && index < ct_freq_sz, "Bounds error."); | |
| 56 if (ct_freq[index] < 100) { ct_freq[index]++; } | |
| 57 } | |
| 58 | |
| 59 static IntHistogram card_repeat_count(10, 10); | |
| 60 | |
| 61 void ct_freq_update_histo_and_reset() { | |
| 62 for (size_t j = 0; j < ct_freq_sz; j++) { | |
| 63 card_repeat_count.add_entry(ct_freq[j]); | |
| 64 ct_freq[j] = 0; | |
| 65 } | |
| 66 | |
| 67 } | |
| 68 #endif | |
| 69 | |
| 1861 | 70 G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) |
| 71 : _g1(g1), _conc_refine_cards(0), | |
| 72 _ct_bs(ct_bs), _g1p(_g1->g1_policy()), | |
| 342 | 73 _cg1r(g1->concurrent_g1_refine()), |
| 1705 | 74 _cset_rs_update_cl(NULL), |
| 342 | 75 _cards_scanned(NULL), _total_cards_scanned(0) |
| 76 { | |
| 77 _seq_task = new SubTasksDone(NumSeqTasks); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
78 guarantee(n_workers() > 0, "There should be some workers"); |
| 6197 | 79 _cset_rs_update_cl = NEW_C_HEAP_ARRAY(OopsInHeapRegionClosure*, n_workers(), mtGC); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
80 for (uint i = 0; i < n_workers(); i++) { |
| 1705 | 81 _cset_rs_update_cl[i] = NULL; |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
82 } |
| 342 | 83 } |
| 84 | |
| 1861 | 85 G1RemSet::~G1RemSet() { |
| 342 | 86 delete _seq_task; |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
87 for (uint i = 0; i < n_workers(); i++) { |
| 1705 | 88 assert(_cset_rs_update_cl[i] == NULL, "it should be"); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
89 } |
| 6197 | 90 FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl, mtGC); |
| 342 | 91 } |
| 92 | |
| 93 void CountNonCleanMemRegionClosure::do_MemRegion(MemRegion mr) { | |
| 94 if (_g1->is_in_g1_reserved(mr.start())) { | |
| 95 _n += (int) ((mr.byte_size() / CardTableModRefBS::card_size)); | |
| 96 if (_start_first == NULL) _start_first = mr.start(); | |
| 97 } | |
| 98 } | |
| 99 | |
| 100 class ScanRSClosure : public HeapRegionClosure { | |
| 101 size_t _cards_done, _cards; | |
| 102 G1CollectedHeap* _g1h; | |
| 103 OopsInHeapRegionClosure* _oc; | |
| 104 G1BlockOffsetSharedArray* _bot_shared; | |
| 105 CardTableModRefBS *_ct_bs; | |
| 106 int _worker_i; | |
| 1261 | 107 int _block_size; |
| 342 | 108 bool _try_claimed; |
| 109 public: | |
| 110 ScanRSClosure(OopsInHeapRegionClosure* oc, int worker_i) : | |
| 111 _oc(oc), | |
| 112 _cards(0), | |
| 113 _cards_done(0), | |
| 114 _worker_i(worker_i), | |
| 115 _try_claimed(false) | |
| 116 { | |
| 117 _g1h = G1CollectedHeap::heap(); | |
| 118 _bot_shared = _g1h->bot_shared(); | |
| 119 _ct_bs = (CardTableModRefBS*) (_g1h->barrier_set()); | |
| 1261 | 120 _block_size = MAX2<int>(G1RSetScanBlockSize, 1); |
| 342 | 121 } |
| 122 | |
| 123 void set_try_claimed() { _try_claimed = true; } | |
| 124 | |
| 125 void scanCard(size_t index, HeapRegion *r) { | |
| 4023 | 126 // Stack allocate the DirtyCardToOopClosure instance |
| 127 HeapRegionDCTOC cl(_g1h, r, _oc, | |
| 128 CardTableModRefBS::Precise, | |
| 129 HeapRegionDCTOC::IntoCSFilterKind); | |
| 342 | 130 |
| 131 // Set the "from" region in the closure. | |
| 132 _oc->set_region(r); | |
| 133 HeapWord* card_start = _bot_shared->address_for_index(index); | |
| 134 HeapWord* card_end = card_start + G1BlockOffsetSharedArray::N_words; | |
| 135 Space *sp = SharedHeap::heap()->space_containing(card_start); | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
136 MemRegion sm_region = sp->used_region_at_save_marks(); |
| 342 | 137 MemRegion mr = sm_region.intersection(MemRegion(card_start,card_end)); |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
138 if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
139 // We make the card as "claimed" lazily (so races are possible |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
140 // but they're benign), which reduces the number of duplicate |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
141 // scans (the rsets of the regions in the cset can intersect). |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
142 _ct_bs->set_card_claimed(index); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
143 _cards_done++; |
| 4023 | 144 cl.do_MemRegion(mr); |
| 342 | 145 } |
| 146 } | |
| 147 | |
| 148 void printCard(HeapRegion* card_region, size_t card_index, | |
| 149 HeapWord* card_start) { | |
| 150 gclog_or_tty->print_cr("T %d Region [" PTR_FORMAT ", " PTR_FORMAT ") " | |
| 151 "RS names card %p: " | |
| 152 "[" PTR_FORMAT ", " PTR_FORMAT ")", | |
| 153 _worker_i, | |
| 154 card_region->bottom(), card_region->end(), | |
| 155 card_index, | |
| 156 card_start, card_start + G1BlockOffsetSharedArray::N_words); | |
| 157 } | |
| 158 | |
| 159 bool doHeapRegion(HeapRegion* r) { | |
| 160 assert(r->in_collection_set(), "should only be called on elements of CS."); | |
| 161 HeapRegionRemSet* hrrs = r->rem_set(); | |
| 162 if (hrrs->iter_is_complete()) return false; // All done. | |
| 163 if (!_try_claimed && !hrrs->claim_iter()) return false; | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
164 // If we ever free the collection set concurrently, we should also |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
165 // clear the card table concurrently therefore we won't need to |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
166 // add regions of the collection set to the dirty cards region. |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
167 _g1h->push_dirty_cards_region(r); |
| 342 | 168 // If we didn't return above, then |
| 169 // _try_claimed || r->claim_iter() | |
| 170 // is true: either we're supposed to work on claimed-but-not-complete | |
| 171 // regions, or we successfully claimed the region. | |
| 172 HeapRegionRemSetIterator* iter = _g1h->rem_set_iterator(_worker_i); | |
| 173 hrrs->init_iterator(iter); | |
| 174 size_t card_index; | |
| 1261 | 175 |
| 176 // We claim cards in block so as to recude the contention. The block size is determined by | |
| 177 // the G1RSetScanBlockSize parameter. | |
| 178 size_t jump_to_card = hrrs->iter_claimed_next(_block_size); | |
| 179 for (size_t current_card = 0; iter->has_next(card_index); current_card++) { | |
| 180 if (current_card >= jump_to_card + _block_size) { | |
| 181 jump_to_card = hrrs->iter_claimed_next(_block_size); | |
| 747 | 182 } |
| 1261 | 183 if (current_card < jump_to_card) continue; |
| 342 | 184 HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index); |
| 185 #if 0 | |
| 186 gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n", | |
| 187 card_start, card_start + CardTableModRefBS::card_size_in_words); | |
| 188 #endif | |
| 189 | |
| 190 HeapRegion* card_region = _g1h->heap_region_containing(card_start); | |
| 191 assert(card_region != NULL, "Yielding cards not in the heap?"); | |
| 192 _cards++; | |
| 193 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
194 if (!card_region->is_on_dirty_cards_region_list()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
195 _g1h->push_dirty_cards_region(card_region); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
196 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
197 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
198 // If the card is dirty, then we will scan it during updateRS. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
199 if (!card_region->in_collection_set() && |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
200 !_ct_bs->is_card_dirty(card_index)) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
201 scanCard(card_index, card_region); |
| 342 | 202 } |
| 203 } | |
| 747 | 204 if (!_try_claimed) { |
| 205 hrrs->set_iter_complete(); | |
| 206 } | |
| 342 | 207 return false; |
| 208 } | |
| 209 size_t cards_done() { return _cards_done;} | |
| 210 size_t cards_looked_up() { return _cards;} | |
| 211 }; | |
| 212 | |
| 1861 | 213 void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) { |
| 342 | 214 double rs_time_start = os::elapsedTime(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
215 HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i); |
| 342 | 216 |
| 1261 | 217 ScanRSClosure scanRScl(oc, worker_i); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3777
diff
changeset
|
218 |
| 342 | 219 _g1->collection_set_iterate_from(startRegion, &scanRScl); |
| 220 scanRScl.set_try_claimed(); | |
| 221 _g1->collection_set_iterate_from(startRegion, &scanRScl); | |
| 222 | |
| 1261 | 223 double scan_rs_time_sec = os::elapsedTime() - rs_time_start; |
| 342 | 224 |
| 225 assert( _cards_scanned != NULL, "invariant" ); | |
| 226 _cards_scanned[worker_i] = scanRScl.cards_done(); | |
| 227 | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
228 _g1p->phase_times()->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); |
| 342 | 229 } |
| 230 | |
| 1705 | 231 // Closure used for updating RSets and recording references that |
| 232 // point into the collection set. Only called during an | |
| 233 // evacuation pause. | |
| 234 | |
| 235 class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure { | |
| 236 G1RemSet* _g1rs; | |
| 237 DirtyCardQueue* _into_cset_dcq; | |
| 238 public: | |
| 239 RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h, | |
| 240 DirtyCardQueue* into_cset_dcq) : | |
| 241 _g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq) | |
| 242 {} | |
| 243 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 244 // The only time we care about recording cards that | |
| 245 // contain references that point into the collection set | |
| 246 // is during RSet updating within an evacuation pause. | |
| 247 // In this case worker_i should be the id of a GC worker thread. | |
| 248 assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause"); | |
|
2364
04d1138b4cce
7023747: G1: too strict assert in RefineRecordRefsIntoCSCardTableEntryClosure::do_card_ptr in g1RemSet.cpp
brutisso
parents:
2361
diff
changeset
|
249 assert(worker_i < (int) (ParallelGCThreads == 0 ? 1 : ParallelGCThreads), "should be a GC worker"); |
| 342 | 250 |
| 1705 | 251 if (_g1rs->concurrentRefineOneCard(card_ptr, worker_i, true)) { |
| 252 // 'card_ptr' contains references that point into the collection | |
| 253 // set. We need to record the card in the DCQS | |
| 254 // (G1CollectedHeap::into_cset_dirty_card_queue_set()) | |
| 255 // that's used for that purpose. | |
| 256 // | |
| 257 // Enqueue the card | |
| 258 _into_cset_dcq->enqueue(card_ptr); | |
| 259 } | |
| 260 return true; | |
| 261 } | |
| 262 }; | |
| 263 | |
| 1861 | 264 void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) { |
| 342 | 265 double start = os::elapsedTime(); |
| 1705 | 266 // Apply the given closure to all remaining log entries. |
| 267 RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3777
diff
changeset
|
268 |
| 1705 | 269 _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i); |
| 270 | |
| 794 | 271 // Now there should be no dirty cards. |
| 272 if (G1RSLogCheckCardTable) { | |
| 273 CountNonCleanMemRegionClosure cl(_g1); | |
| 274 _ct_bs->mod_card_iterate(&cl); | |
| 275 // XXX This isn't true any more: keeping cards of young regions | |
| 276 // marked dirty broke it. Need some reasonable fix. | |
| 277 guarantee(cl.n() == 0, "Card table should be clean."); | |
| 342 | 278 } |
| 794 | 279 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
280 _g1p->phase_times()->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); |
| 342 | 281 } |
| 282 | |
| 1861 | 283 void G1RemSet::cleanupHRRS() { |
| 342 | 284 HeapRegionRemSet::cleanup(); |
| 285 } | |
| 286 | |
| 1861 | 287 void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, |
| 342 | 288 int worker_i) { |
| 289 #if CARD_REPEAT_HISTO | |
| 290 ct_freq_update_histo_and_reset(); | |
| 291 #endif | |
| 292 if (worker_i == 0) { | |
| 293 _cg1r->clear_and_record_card_counts(); | |
| 294 } | |
| 295 | |
| 1705 | 296 // We cache the value of 'oc' closure into the appropriate slot in the |
| 297 // _cset_rs_update_cl for this worker | |
| 298 assert(worker_i < (int)n_workers(), "sanity"); | |
| 299 _cset_rs_update_cl[worker_i] = oc; | |
| 300 | |
| 301 // A DirtyCardQueue that is used to hold cards containing references | |
| 302 // that point into the collection set. This DCQ is associated with a | |
| 303 // special DirtyCardQueueSet (see g1CollectedHeap.hpp). Under normal | |
| 304 // circumstances (i.e. the pause successfully completes), these cards | |
| 305 // are just discarded (there's no need to update the RSets of regions | |
| 306 // that were in the collection set - after the pause these regions | |
| 307 // are wholly 'free' of live objects. In the event of an evacuation | |
| 308 // failure the cards/buffers in this queue set are: | |
| 309 // * passed to the DirtyCardQueueSet that is used to manage deferred | |
| 310 // RSet updates, or | |
| 311 // * scanned for references that point into the collection set | |
| 312 // and the RSet of the corresponding region in the collection set | |
| 313 // is updated immediately. | |
| 314 DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); | |
| 315 | |
|
1708
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
316 assert((ParallelGCThreads > 0) || worker_i == 0, "invariant"); |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
317 |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
318 // The two flags below were introduced temporarily to serialize |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
319 // the updating and scanning of remembered sets. There are some |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
320 // race conditions when these two operations are done in parallel |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
321 // and they are causing failures. When we resolve said race |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
322 // conditions, we'll revert back to parallel remembered set |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
323 // updating and scanning. See CRs 6677707 and 6677708. |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
324 if (G1UseParallelRSetUpdating || (worker_i == 0)) { |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
325 updateRS(&into_cset_dcq, worker_i); |
| 342 | 326 } else { |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6254
diff
changeset
|
327 _g1p->phase_times()->record_update_rs_processed_buffers(worker_i, 0); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
328 _g1p->phase_times()->record_update_rs_time(worker_i, 0.0); |
|
1708
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
329 } |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
330 if (G1UseParallelRSetScanning || (worker_i == 0)) { |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
331 scanRS(oc, worker_i); |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
332 } else { |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
333 _g1p->phase_times()->record_scan_rs_time(worker_i, 0.0); |
| 342 | 334 } |
| 1705 | 335 |
| 336 // We now clear the cached values of _cset_rs_update_cl for this worker | |
| 337 _cset_rs_update_cl[worker_i] = NULL; | |
| 342 | 338 } |
| 339 | |
| 1861 | 340 void G1RemSet::prepare_for_oops_into_collection_set_do() { |
| 342 | 341 cleanupHRRS(); |
| 342 ConcurrentG1Refine* cg1r = _g1->concurrent_g1_refine(); | |
| 343 _g1->set_refine_cte_cl_concurrency(false); | |
| 344 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 345 dcqs.concatenate_logs(); | |
| 346 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
347 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
348 // Don't set the number of workers here. It will be set |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
349 // when the task is run |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
350 // _seq_task->set_n_termination((int)n_workers()); |
| 342 | 351 } |
| 352 guarantee( _cards_scanned == NULL, "invariant" ); | |
| 6197 | 353 _cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers(), mtGC); |
| 545 | 354 for (uint i = 0; i < n_workers(); ++i) { |
| 355 _cards_scanned[i] = 0; | |
| 356 } | |
| 342 | 357 _total_cards_scanned = 0; |
| 358 } | |
| 359 | |
| 360 | |
| 1705 | 361 // This closure, applied to a DirtyCardQueueSet, is used to immediately |
| 362 // update the RSets for the regions in the CSet. For each card it iterates | |
| 363 // through the oops which coincide with that card. It scans the reference | |
| 364 // fields in each oop; when it finds an oop that points into the collection | |
| 365 // set, the RSet for the region containing the referenced object is updated. | |
| 366 class UpdateRSetCardTableEntryIntoCSetClosure: public CardTableEntryClosure { | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
367 G1CollectedHeap* _g1; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
368 CardTableModRefBS* _ct_bs; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
369 public: |
| 1705 | 370 UpdateRSetCardTableEntryIntoCSetClosure(G1CollectedHeap* g1, |
| 371 CardTableModRefBS* bs): | |
| 372 _g1(g1), _ct_bs(bs) | |
| 373 { } | |
| 374 | |
| 375 bool do_card_ptr(jbyte* card_ptr, int worker_i) { | |
| 376 // Construct the region representing the card. | |
| 377 HeapWord* start = _ct_bs->addr_for(card_ptr); | |
| 378 // And find the region containing it. | |
| 379 HeapRegion* r = _g1->heap_region_containing(start); | |
| 380 assert(r != NULL, "unexpected null"); | |
| 381 | |
| 382 // Scan oops in the card looking for references into the collection set | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
383 // Don't use addr_for(card_ptr + 1) which can ask for |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
384 // a card beyond the heap. This is not safe without a perm |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
385 // gen. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
386 HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
| 1705 | 387 MemRegion scanRegion(start, end); |
| 388 | |
| 389 UpdateRSetImmediate update_rs_cl(_g1->g1_rem_set()); | |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
390 FilterIntoCSClosure update_rs_cset_oop_cl(NULL, _g1, &update_rs_cl); |
| 1705 | 391 FilterOutOfRegionClosure filter_then_update_rs_cset_oop_cl(r, &update_rs_cset_oop_cl); |
| 392 | |
| 393 // We can pass false as the "filter_young" parameter here as: | |
| 394 // * we should be in a STW pause, | |
| 395 // * the DCQS to which this closure is applied is used to hold | |
| 396 // references that point into the collection set from the prior | |
| 397 // RSet updating, | |
| 398 // * the post-write barrier shouldn't be logging updates to young | |
| 399 // regions (but there is a situation where this can happen - see | |
| 1861 | 400 // the comment in G1RemSet::concurrentRefineOneCard below - |
| 1705 | 401 // that should not be applicable here), and |
| 402 // * during actual RSet updating, the filtering of cards in young | |
| 403 // regions in HeapRegion::oops_on_card_seq_iterate_careful is | |
| 404 // employed. | |
| 405 // As a result, when this closure is applied to "refs into cset" | |
| 406 // DCQS, we shouldn't see any cards in young regions. | |
| 407 update_rs_cl.set_region(r); | |
| 408 HeapWord* stop_point = | |
| 409 r->oops_on_card_seq_iterate_careful(scanRegion, | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
410 &filter_then_update_rs_cset_oop_cl, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
411 false /* filter_young */, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
412 NULL /* card_ptr */); |
| 1705 | 413 |
| 414 // Since this is performed in the event of an evacuation failure, we | |
| 415 // we shouldn't see a non-null stop point | |
| 416 assert(stop_point == NULL, "saw an unallocated region"); | |
| 417 return true; | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
418 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
419 }; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
420 |
| 1861 | 421 void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
| 342 | 422 guarantee( _cards_scanned != NULL, "invariant" ); |
| 423 _total_cards_scanned = 0; | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3765
diff
changeset
|
424 for (uint i = 0; i < n_workers(); ++i) { |
| 342 | 425 _total_cards_scanned += _cards_scanned[i]; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3765
diff
changeset
|
426 } |
| 6197 | 427 FREE_C_HEAP_ARRAY(size_t, _cards_scanned, mtGC); |
| 342 | 428 _cards_scanned = NULL; |
| 429 // Cleanup after copy | |
| 430 _g1->set_refine_cte_cl_concurrency(true); | |
| 431 // Set all cards back to clean. | |
| 432 _g1->cleanUpCardTable(); | |
| 794 | 433 |
| 1705 | 434 DirtyCardQueueSet& into_cset_dcqs = _g1->into_cset_dirty_card_queue_set(); |
| 435 int into_cset_n_buffers = into_cset_dcqs.completed_buffers_num(); | |
| 436 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
437 if (_g1->evacuation_failed()) { |
| 1705 | 438 // Restore remembered sets for the regions pointing into the collection set. |
| 439 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
440 if (G1DeferredRSUpdate) { |
| 1705 | 441 // If deferred RS updates are enabled then we just need to transfer |
| 442 // the completed buffers from (a) the DirtyCardQueueSet used to hold | |
| 443 // cards that contain references that point into the collection set | |
| 444 // to (b) the DCQS used to hold the deferred RS updates | |
| 445 _g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
446 } else { |
| 1705 | 447 |
| 448 CardTableModRefBS* bs = (CardTableModRefBS*)_g1->barrier_set(); | |
| 449 UpdateRSetCardTableEntryIntoCSetClosure update_rs_cset_immediate(_g1, bs); | |
| 450 | |
| 451 int n_completed_buffers = 0; | |
| 452 while (into_cset_dcqs.apply_closure_to_completed_buffer(&update_rs_cset_immediate, | |
| 453 0, 0, true)) { | |
| 454 n_completed_buffers++; | |
| 455 } | |
| 456 assert(n_completed_buffers == into_cset_n_buffers, "missed some buffers"); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
457 } |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
458 } |
| 1705 | 459 |
| 460 // Free any completed buffers in the DirtyCardQueueSet used to hold cards | |
| 461 // which contain references that point into the collection. | |
| 462 _g1->into_cset_dirty_card_queue_set().clear(); | |
| 463 assert(_g1->into_cset_dirty_card_queue_set().completed_buffers_num() == 0, | |
| 464 "all buffers should be freed"); | |
| 465 _g1->into_cset_dirty_card_queue_set().clear_n_completed_buffers(); | |
| 342 | 466 } |
| 467 | |
| 468 class ScrubRSClosure: public HeapRegionClosure { | |
| 469 G1CollectedHeap* _g1h; | |
| 470 BitMap* _region_bm; | |
| 471 BitMap* _card_bm; | |
| 472 CardTableModRefBS* _ctbs; | |
| 473 public: | |
| 474 ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) : | |
| 475 _g1h(G1CollectedHeap::heap()), | |
| 476 _region_bm(region_bm), _card_bm(card_bm), | |
| 477 _ctbs(NULL) | |
| 478 { | |
| 479 ModRefBarrierSet* bs = _g1h->mr_bs(); | |
| 480 guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition"); | |
| 481 _ctbs = (CardTableModRefBS*)bs; | |
| 482 } | |
| 483 | |
| 484 bool doHeapRegion(HeapRegion* r) { | |
| 485 if (!r->continuesHumongous()) { | |
| 486 r->rem_set()->scrub(_ctbs, _region_bm, _card_bm); | |
| 487 } | |
| 488 return false; | |
| 489 } | |
| 490 }; | |
| 491 | |
| 1861 | 492 void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) { |
| 342 | 493 ScrubRSClosure scrub_cl(region_bm, card_bm); |
| 494 _g1->heap_region_iterate(&scrub_cl); | |
| 495 } | |
| 496 | |
| 1861 | 497 void G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4097
diff
changeset
|
498 uint worker_num, int claim_val) { |
| 342 | 499 ScrubRSClosure scrub_cl(region_bm, card_bm); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
500 _g1->heap_region_par_iterate_chunked(&scrub_cl, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
501 worker_num, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4097
diff
changeset
|
502 n_workers(), |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
503 claim_val); |
| 342 | 504 } |
| 505 | |
| 506 | |
| 4839 | 507 |
| 508 G1TriggerClosure::G1TriggerClosure() : | |
| 509 _triggered(false) { } | |
| 510 | |
| 511 G1InvokeIfNotTriggeredClosure::G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t_cl, | |
| 512 OopClosure* oop_cl) : | |
| 513 _trigger_cl(t_cl), _oop_cl(oop_cl) { } | |
| 1705 | 514 |
| 4839 | 515 G1Mux2Closure::G1Mux2Closure(OopClosure *c1, OopClosure *c2) : |
| 516 _c1(c1), _c2(c2) { } | |
| 1705 | 517 |
| 4839 | 518 G1UpdateRSOrPushRefOopClosure:: |
| 519 G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, | |
| 520 G1RemSet* rs, | |
| 521 OopsInHeapRegionClosure* push_ref_cl, | |
| 522 bool record_refs_into_cset, | |
| 523 int worker_i) : | |
| 524 _g1(g1h), _g1_rem_set(rs), _from(NULL), | |
| 525 _record_refs_into_cset(record_refs_into_cset), | |
| 526 _push_ref_cl(push_ref_cl), _worker_i(worker_i) { } | |
| 1705 | 527 |
| 1861 | 528 bool G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i, |
| 1705 | 529 bool check_for_refs_into_cset) { |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
530 // Construct the region representing the card. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
531 HeapWord* start = _ct_bs->addr_for(card_ptr); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
532 // And find the region containing it. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
533 HeapRegion* r = _g1->heap_region_containing(start); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
534 assert(r != NULL, "unexpected null"); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
535 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
536 // Don't use addr_for(card_ptr + 1) which can ask for |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
537 // a card beyond the heap. This is not safe without a perm |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
538 // gen at the upper end of the heap. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
539 HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
540 MemRegion dirtyRegion(start, end); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
541 |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
542 #if CARD_REPEAT_HISTO |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
1972
diff
changeset
|
543 init_ct_freq_table(_g1->max_capacity()); |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
544 ct_freq_note_card(_ct_bs->index_for(start)); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
545 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
546 |
|
4071
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
547 OopsInHeapRegionClosure* oops_in_heap_closure = NULL; |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
548 if (check_for_refs_into_cset) { |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
549 // ConcurrentG1RefineThreads have worker numbers larger than what |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
550 // _cset_rs_update_cl[] is set up to handle. But those threads should |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
551 // only be active outside of a collection which means that when they |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
552 // reach here they should have check_for_refs_into_cset == false. |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
553 assert((size_t)worker_i < n_workers(), "index of worker larger than _cset_rs_update_cl[].length"); |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
554 oops_in_heap_closure = _cset_rs_update_cl[worker_i]; |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
555 } |
| 4839 | 556 G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1, |
| 557 _g1->g1_rem_set(), | |
| 558 oops_in_heap_closure, | |
| 559 check_for_refs_into_cset, | |
| 560 worker_i); | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
561 update_rs_oop_cl.set_from(r); |
| 1705 | 562 |
| 4839 | 563 G1TriggerClosure trigger_cl; |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
564 FilterIntoCSClosure into_cs_cl(NULL, _g1, &trigger_cl); |
| 4839 | 565 G1InvokeIfNotTriggeredClosure invoke_cl(&trigger_cl, &into_cs_cl); |
| 566 G1Mux2Closure mux(&invoke_cl, &update_rs_oop_cl); | |
| 1705 | 567 |
| 568 FilterOutOfRegionClosure filter_then_update_rs_oop_cl(r, | |
| 569 (check_for_refs_into_cset ? | |
| 570 (OopClosure*)&mux : | |
| 571 (OopClosure*)&update_rs_oop_cl)); | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
572 |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
573 // The region for the current card may be a young region. The |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
574 // current card may have been a card that was evicted from the |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
575 // card cache. When the card was inserted into the cache, we had |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
576 // determined that its region was non-young. While in the cache, |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
577 // the region may have been freed during a cleanup pause, reallocated |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
578 // and tagged as young. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
579 // |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
580 // We wish to filter out cards for such a region but the current |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
581 // thread, if we're running concurrently, may "see" the young type |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
582 // change at any time (so an earlier "is_young" check may pass or |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
583 // fail arbitrarily). We tell the iteration code to perform this |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
584 // filtering when it has been determined that there has been an actual |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
585 // allocation in this region and making it safe to check the young type. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
586 bool filter_young = true; |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
587 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
588 HeapWord* stop_point = |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
589 r->oops_on_card_seq_iterate_careful(dirtyRegion, |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
590 &filter_then_update_rs_oop_cl, |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
591 filter_young, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
592 card_ptr); |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
593 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
594 // If stop_point is non-null, then we encountered an unallocated region |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
595 // (perhaps the unfilled portion of a TLAB.) For now, we'll dirty the |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
596 // card and re-enqueue: if we put off the card until a GC pause, then the |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
597 // unallocated portion will be filled in. Alternatively, we might try |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
598 // the full complexity of the technique used in "regular" precleaning. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
599 if (stop_point != NULL) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
600 // The card might have gotten re-dirtied and re-enqueued while we |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
601 // worked. (In fact, it's pretty likely.) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
602 if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
603 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
604 MutexLockerEx x(Shared_DirtyCardQ_lock, |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
605 Mutex::_no_safepoint_check_flag); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
606 DirtyCardQueue* sdcq = |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
607 JavaThread::dirty_card_queue_set().shared_dirty_card_queue(); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
608 sdcq->enqueue(card_ptr); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
609 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
610 } else { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
611 _conc_refine_cards++; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
612 } |
| 1705 | 613 |
| 4839 | 614 return trigger_cl.triggered(); |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
615 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
616 |
| 1861 | 617 bool G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i, |
| 1705 | 618 bool check_for_refs_into_cset) { |
| 342 | 619 // If the card is no longer dirty, nothing to do. |
| 1705 | 620 if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
| 621 // No need to return that this card contains refs that point | |
| 622 // into the collection set. | |
| 623 return false; | |
| 624 } | |
| 342 | 625 |
| 626 // Construct the region representing the card. | |
| 627 HeapWord* start = _ct_bs->addr_for(card_ptr); | |
| 628 // And find the region containing it. | |
| 629 HeapRegion* r = _g1->heap_region_containing(start); | |
| 630 if (r == NULL) { | |
| 1705 | 631 // Again no need to return that this card contains refs that |
| 632 // point into the collection set. | |
| 633 return false; // Not in the G1 heap (might be in perm, for example.) | |
| 342 | 634 } |
| 635 // Why do we have to check here whether a card is on a young region, | |
| 636 // given that we dirty young regions and, as a result, the | |
| 637 // post-barrier is supposed to filter them out and never to enqueue | |
| 638 // them? When we allocate a new region as the "allocation region" we | |
| 639 // actually dirty its cards after we release the lock, since card | |
| 640 // dirtying while holding the lock was a performance bottleneck. So, | |
| 641 // as a result, it is possible for other threads to actually | |
| 642 // allocate objects in the region (after the acquire the lock) | |
| 643 // before all the cards on the region are dirtied. This is unlikely, | |
| 644 // and it doesn't happen often, but it can happen. So, the extra | |
| 645 // check below filters out those cards. | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
646 if (r->is_young()) { |
| 1705 | 647 return false; |
| 342 | 648 } |
| 649 // While we are processing RSet buffers during the collection, we | |
| 650 // actually don't want to scan any cards on the collection set, | |
| 651 // since we don't want to update remebered sets with entries that | |
| 652 // point into the collection set, given that live objects from the | |
| 653 // collection set are about to move and such entries will be stale | |
| 654 // very soon. This change also deals with a reliability issue which | |
| 655 // involves scanning a card in the collection set and coming across | |
| 656 // an array that was being chunked and looking malformed. Note, | |
| 657 // however, that if evacuation fails, we have to scan any objects | |
| 658 // that were not moved and create any missing entries. | |
| 659 if (r->in_collection_set()) { | |
| 1705 | 660 return false; |
| 342 | 661 } |
| 662 | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
663 // Should we defer processing the card? |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
664 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
665 // Previously the result from the insert_cache call would be |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
666 // either card_ptr (implying that card_ptr was currently "cold"), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
667 // null (meaning we had inserted the card ptr into the "hot" |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
668 // cache, which had some headroom), or a "hot" card ptr |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
669 // extracted from the "hot" cache. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
670 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
671 // Now that the _card_counts cache in the ConcurrentG1Refine |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
672 // instance is an evicting hash table, the result we get back |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
673 // could be from evicting the card ptr in an already occupied |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
674 // bucket (in which case we have replaced the card ptr in the |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
675 // bucket with card_ptr and "defer" is set to false). To avoid |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
676 // having a data structure (updates to which would need a lock) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
677 // to hold these unprocessed dirty cards, we need to immediately |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
678 // process card_ptr. The actions needed to be taken on return |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
679 // from cache_insert are summarized in the following table: |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
680 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
681 // res defer action |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
682 // -------------------------------------------------------------- |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
683 // null false card evicted from _card_counts & replaced with |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
684 // card_ptr; evicted ptr added to hot cache. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
685 // No need to process res; immediately process card_ptr |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
686 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
687 // null true card not evicted from _card_counts; card_ptr added |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
688 // to hot cache. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
689 // Nothing to do. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
690 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
691 // non-null false card evicted from _card_counts & replaced with |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
692 // card_ptr; evicted ptr is currently "cold" or |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
693 // caused an eviction from the hot cache. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
694 // Immediately process res; process card_ptr. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
695 // |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
696 // non-null true card not evicted from _card_counts; card_ptr is |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
697 // currently cold, or caused an eviction from hot |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
698 // cache. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
699 // Immediately process res; no need to process card_ptr. |
| 342 | 700 |
| 1705 | 701 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
702 jbyte* res = card_ptr; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
703 bool defer = false; |
| 1705 | 704 |
| 705 // This gets set to true if the card being refined has references | |
| 706 // that point into the collection set. | |
| 707 bool oops_into_cset = false; | |
| 708 | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
709 if (_cg1r->use_cache()) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
710 jbyte* res = _cg1r->cache_insert(card_ptr, &defer); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
711 if (res != NULL && (res != card_ptr || defer)) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
712 start = _ct_bs->addr_for(res); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
713 r = _g1->heap_region_containing(start); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
714 if (r != NULL) { |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
715 // Checking whether the region we got back from the cache |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
716 // is young here is inappropriate. The region could have been |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
717 // freed, reallocated and tagged as young while in the cache. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
718 // Hence we could see its young type change at any time. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
719 // |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
720 // Process card pointer we get back from the hot card cache. This |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
721 // will check whether the region containing the card is young |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
722 // _after_ checking that the region has been allocated from. |
| 1705 | 723 oops_into_cset = concurrentRefineOneCard_impl(res, worker_i, |
| 724 false /* check_for_refs_into_cset */); | |
| 725 // The above call to concurrentRefineOneCard_impl is only | |
| 726 // performed if the hot card cache is enabled. This cache is | |
| 727 // disabled during an evacuation pause - which is the only | |
| 728 // time when we need know if the card contains references | |
| 729 // that point into the collection set. Also when the hot card | |
| 730 // cache is enabled, this code is executed by the concurrent | |
| 731 // refine threads - rather than the GC worker threads - and | |
| 732 // concurrentRefineOneCard_impl will return false. | |
| 733 assert(!oops_into_cset, "should not see true here"); | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
734 } |
| 342 | 735 } |
| 736 } | |
| 737 | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
738 if (!defer) { |
| 1705 | 739 oops_into_cset = |
| 740 concurrentRefineOneCard_impl(card_ptr, worker_i, check_for_refs_into_cset); | |
| 741 // We should only be detecting that the card contains references | |
| 742 // that point into the collection set if the current thread is | |
| 743 // a GC worker thread. | |
| 744 assert(!oops_into_cset || SafepointSynchronize::is_at_safepoint(), | |
| 745 "invalid result at non safepoint"); | |
| 342 | 746 } |
| 1705 | 747 return oops_into_cset; |
| 342 | 748 } |
| 749 | |
| 750 class HRRSStatsIter: public HeapRegionClosure { | |
| 751 size_t _occupied; | |
| 752 size_t _total_mem_sz; | |
| 753 size_t _max_mem_sz; | |
| 754 HeapRegion* _max_mem_sz_region; | |
| 755 public: | |
| 756 HRRSStatsIter() : | |
| 757 _occupied(0), | |
| 758 _total_mem_sz(0), | |
| 759 _max_mem_sz(0), | |
| 760 _max_mem_sz_region(NULL) | |
| 761 {} | |
| 762 | |
| 763 bool doHeapRegion(HeapRegion* r) { | |
| 764 if (r->continuesHumongous()) return false; | |
| 765 size_t mem_sz = r->rem_set()->mem_size(); | |
| 766 if (mem_sz > _max_mem_sz) { | |
| 767 _max_mem_sz = mem_sz; | |
| 768 _max_mem_sz_region = r; | |
| 769 } | |
| 770 _total_mem_sz += mem_sz; | |
| 771 size_t occ = r->rem_set()->occupied(); | |
| 772 _occupied += occ; | |
| 773 return false; | |
| 774 } | |
| 775 size_t total_mem_sz() { return _total_mem_sz; } | |
| 776 size_t max_mem_sz() { return _max_mem_sz; } | |
| 777 size_t occupied() { return _occupied; } | |
| 778 HeapRegion* max_mem_sz_region() { return _max_mem_sz_region; } | |
| 779 }; | |
| 780 | |
| 794 | 781 class PrintRSThreadVTimeClosure : public ThreadClosure { |
| 782 public: | |
| 783 virtual void do_thread(Thread *t) { | |
| 784 ConcurrentG1RefineThread* crt = (ConcurrentG1RefineThread*) t; | |
| 785 gclog_or_tty->print(" %5.2f", crt->vtime_accum()); | |
| 786 } | |
| 787 }; | |
| 788 | |
| 1861 | 789 void G1RemSet::print_summary_info() { |
| 342 | 790 G1CollectedHeap* g1 = G1CollectedHeap::heap(); |
| 791 | |
| 792 #if CARD_REPEAT_HISTO | |
| 793 gclog_or_tty->print_cr("\nG1 card_repeat count histogram: "); | |
| 794 gclog_or_tty->print_cr(" # of repeats --> # of cards with that number."); | |
| 795 card_repeat_count.print_on(gclog_or_tty); | |
| 796 #endif | |
| 797 | |
| 794 | 798 gclog_or_tty->print_cr("\n Concurrent RS processed %d cards", |
| 799 _conc_refine_cards); | |
| 342 | 800 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
| 801 jint tot_processed_buffers = | |
| 802 dcqs.processed_buffers_mut() + dcqs.processed_buffers_rs_thread(); | |
| 803 gclog_or_tty->print_cr(" Of %d completed buffers:", tot_processed_buffers); | |
| 794 | 804 gclog_or_tty->print_cr(" %8d (%5.1f%%) by conc RS threads.", |
| 342 | 805 dcqs.processed_buffers_rs_thread(), |
| 806 100.0*(float)dcqs.processed_buffers_rs_thread()/ | |
| 807 (float)tot_processed_buffers); | |
| 808 gclog_or_tty->print_cr(" %8d (%5.1f%%) by mutator threads.", | |
| 809 dcqs.processed_buffers_mut(), | |
| 810 100.0*(float)dcqs.processed_buffers_mut()/ | |
| 811 (float)tot_processed_buffers); | |
| 794 | 812 gclog_or_tty->print_cr(" Conc RS threads times(s)"); |
| 813 PrintRSThreadVTimeClosure p; | |
| 814 gclog_or_tty->print(" "); | |
| 815 g1->concurrent_g1_refine()->threads_do(&p); | |
| 342 | 816 gclog_or_tty->print_cr(""); |
| 794 | 817 |
| 1861 | 818 HRRSStatsIter blk; |
| 819 g1->heap_region_iterate(&blk); | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
820 gclog_or_tty->print_cr(" Total heap region rem set sizes = "SIZE_FORMAT"K." |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
821 " Max = "SIZE_FORMAT"K.", |
| 1861 | 822 blk.total_mem_sz()/K, blk.max_mem_sz()/K); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
823 gclog_or_tty->print_cr(" Static structures = "SIZE_FORMAT"K," |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
824 " free_lists = "SIZE_FORMAT"K.", |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
825 HeapRegionRemSet::static_mem_size() / K, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
826 HeapRegionRemSet::fl_mem_size() / K); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
827 gclog_or_tty->print_cr(" "SIZE_FORMAT" occupied cards represented.", |
| 1861 | 828 blk.occupied()); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
829 HeapRegion* max_mem_sz_region = blk.max_mem_sz_region(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
830 HeapRegionRemSet* rem_set = max_mem_sz_region->rem_set(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
831 gclog_or_tty->print_cr(" Max size region = "HR_FORMAT", " |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
832 "size = "SIZE_FORMAT "K, occupied = "SIZE_FORMAT"K.", |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
833 HR_FORMAT_PARAMS(max_mem_sz_region), |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
834 (rem_set->mem_size() + K - 1)/K, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
835 (rem_set->occupied() + K - 1)/K); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
836 gclog_or_tty->print_cr(" Did %d coarsenings.", |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
837 HeapRegionRemSet::n_coarsenings()); |
| 342 | 838 } |
| 1705 | 839 |
| 1861 | 840 void G1RemSet::prepare_for_verify() { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
841 if (G1HRRSFlushLogBuffersOnVerify && |
|
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
842 (VerifyBeforeGC || VerifyAfterGC) |
|
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
843 && !_g1->full_collection()) { |
| 342 | 844 cleanupHRRS(); |
| 845 _g1->set_refine_cte_cl_concurrency(false); | |
| 846 if (SafepointSynchronize::is_at_safepoint()) { | |
| 847 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 848 dcqs.concatenate_logs(); | |
| 849 } | |
| 850 bool cg1r_use_cache = _cg1r->use_cache(); | |
| 851 _cg1r->set_use_cache(false); | |
| 1705 | 852 DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); |
| 853 updateRS(&into_cset_dcq, 0); | |
| 854 _g1->into_cset_dirty_card_queue_set().clear(); | |
| 342 | 855 _cg1r->set_use_cache(cg1r_use_cache); |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
856 |
|
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
857 assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
| 342 | 858 } |
| 859 } |