Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1RemSet.cpp @ 20504:6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
Summary: Remove -XX:-G1DeferredRSUpdate functionality as it is racy. During evacuation failure handling, threads where evacuation failure handling occurred may try to add remembered sets to regions which remembered sets are currently being scanned. The iterator to handle the remembered set scan does not support addition of entries during scan and so may skip valid references.
Reviewed-by: iveresov, brutisso, mgerdin
| author | tschatzl |
|---|---|
| date | Tue, 30 Sep 2014 09:44:36 +0200 |
| parents | 7baf47cb97cb |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
2 * Copyright (c) 2001, 2014, 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/concurrentG1Refine.hpp" | |
| 27 #include "gc_implementation/g1/concurrentG1RefineThread.hpp" | |
| 28 #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp" | |
| 29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 30 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
31 #include "gc_implementation/g1/g1HotCardCache.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" | |
|
20377
a8ea2f110d87
8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents:
20337
diff
changeset
|
35 #include "gc_implementation/g1/heapRegionManager.inline.hpp" |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
36 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
| 1972 | 37 #include "memory/iterator.hpp" |
| 38 #include "oops/oop.inline.hpp" | |
| 39 #include "utilities/intHisto.hpp" | |
| 342 | 40 |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
41 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
42 |
| 342 | 43 #define CARD_REPEAT_HISTO 0 |
| 44 | |
| 45 #if CARD_REPEAT_HISTO | |
| 46 static size_t ct_freq_sz; | |
| 47 static jbyte* ct_freq = NULL; | |
| 48 | |
| 49 void init_ct_freq_table(size_t heap_sz_bytes) { | |
| 50 if (ct_freq == NULL) { | |
| 51 ct_freq_sz = heap_sz_bytes/CardTableModRefBS::card_size; | |
| 52 ct_freq = new jbyte[ct_freq_sz]; | |
| 53 for (size_t j = 0; j < ct_freq_sz; j++) ct_freq[j] = 0; | |
| 54 } | |
| 55 } | |
| 56 | |
| 57 void ct_freq_note_card(size_t index) { | |
| 58 assert(0 <= index && index < ct_freq_sz, "Bounds error."); | |
| 59 if (ct_freq[index] < 100) { ct_freq[index]++; } | |
| 60 } | |
| 61 | |
| 62 static IntHistogram card_repeat_count(10, 10); | |
| 63 | |
| 64 void ct_freq_update_histo_and_reset() { | |
| 65 for (size_t j = 0; j < ct_freq_sz; j++) { | |
| 66 card_repeat_count.add_entry(ct_freq[j]); | |
| 67 ct_freq[j] = 0; | |
| 68 } | |
| 69 | |
| 70 } | |
| 71 #endif | |
| 72 | |
| 1861 | 73 G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) |
| 74 : _g1(g1), _conc_refine_cards(0), | |
| 75 _ct_bs(ct_bs), _g1p(_g1->g1_policy()), | |
| 342 | 76 _cg1r(g1->concurrent_g1_refine()), |
| 1705 | 77 _cset_rs_update_cl(NULL), |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
78 _cards_scanned(NULL), _total_cards_scanned(0), |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
79 _prev_period_summary() |
| 342 | 80 { |
| 81 _seq_task = new SubTasksDone(NumSeqTasks); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
82 guarantee(n_workers() > 0, "There should be some workers"); |
| 6197 | 83 _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
|
84 for (uint i = 0; i < n_workers(); i++) { |
| 1705 | 85 _cset_rs_update_cl[i] = NULL; |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
86 } |
|
12344
7ec10139bf37
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
12343
diff
changeset
|
87 if (G1SummarizeRSetStats) { |
|
7ec10139bf37
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
12343
diff
changeset
|
88 _prev_period_summary.initialize(this); |
|
7ec10139bf37
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
12343
diff
changeset
|
89 } |
| 342 | 90 } |
| 91 | |
| 1861 | 92 G1RemSet::~G1RemSet() { |
| 342 | 93 delete _seq_task; |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
94 for (uint i = 0; i < n_workers(); i++) { |
| 1705 | 95 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
|
96 } |
| 6197 | 97 FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl, mtGC); |
| 342 | 98 } |
| 99 | |
| 100 void CountNonCleanMemRegionClosure::do_MemRegion(MemRegion mr) { | |
| 101 if (_g1->is_in_g1_reserved(mr.start())) { | |
| 102 _n += (int) ((mr.byte_size() / CardTableModRefBS::card_size)); | |
| 103 if (_start_first == NULL) _start_first = mr.start(); | |
| 104 } | |
| 105 } | |
| 106 | |
| 107 class ScanRSClosure : public HeapRegionClosure { | |
| 108 size_t _cards_done, _cards; | |
| 109 G1CollectedHeap* _g1h; | |
| 12080 | 110 |
| 342 | 111 OopsInHeapRegionClosure* _oc; |
| 20494 | 112 CodeBlobClosure* _code_root_cl; |
| 12080 | 113 |
| 342 | 114 G1BlockOffsetSharedArray* _bot_shared; |
| 12343 | 115 G1SATBCardTableModRefBS *_ct_bs; |
| 12080 | 116 |
| 117 double _strong_code_root_scan_time_sec; | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
118 uint _worker_i; |
| 12080 | 119 int _block_size; |
| 120 bool _try_claimed; | |
| 121 | |
| 342 | 122 public: |
| 12080 | 123 ScanRSClosure(OopsInHeapRegionClosure* oc, |
| 20494 | 124 CodeBlobClosure* code_root_cl, |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
125 uint worker_i) : |
| 342 | 126 _oc(oc), |
| 12080 | 127 _code_root_cl(code_root_cl), |
| 128 _strong_code_root_scan_time_sec(0.0), | |
| 342 | 129 _cards(0), |
| 130 _cards_done(0), | |
| 131 _worker_i(worker_i), | |
| 132 _try_claimed(false) | |
| 133 { | |
| 134 _g1h = G1CollectedHeap::heap(); | |
| 135 _bot_shared = _g1h->bot_shared(); | |
| 12343 | 136 _ct_bs = _g1h->g1_barrier_set(); |
| 1261 | 137 _block_size = MAX2<int>(G1RSetScanBlockSize, 1); |
| 342 | 138 } |
| 139 | |
| 140 void set_try_claimed() { _try_claimed = true; } | |
| 141 | |
| 142 void scanCard(size_t index, HeapRegion *r) { | |
| 4023 | 143 // Stack allocate the DirtyCardToOopClosure instance |
| 144 HeapRegionDCTOC cl(_g1h, r, _oc, | |
| 145 CardTableModRefBS::Precise, | |
| 146 HeapRegionDCTOC::IntoCSFilterKind); | |
| 342 | 147 |
| 148 // Set the "from" region in the closure. | |
| 149 _oc->set_region(r); | |
| 150 HeapWord* card_start = _bot_shared->address_for_index(index); | |
| 151 HeapWord* card_end = card_start + G1BlockOffsetSharedArray::N_words; | |
| 152 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
|
153 MemRegion sm_region = sp->used_region_at_save_marks(); |
| 342 | 154 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
|
155 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
|
156 // 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
|
157 // 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
|
158 // 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
|
159 _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
|
160 _cards_done++; |
| 4023 | 161 cl.do_MemRegion(mr); |
| 342 | 162 } |
| 163 } | |
| 164 | |
| 165 void printCard(HeapRegion* card_region, size_t card_index, | |
| 166 HeapWord* card_start) { | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
167 gclog_or_tty->print_cr("T " UINT32_FORMAT " Region [" PTR_FORMAT ", " PTR_FORMAT ") " |
| 342 | 168 "RS names card %p: " |
| 169 "[" PTR_FORMAT ", " PTR_FORMAT ")", | |
| 170 _worker_i, | |
| 171 card_region->bottom(), card_region->end(), | |
| 172 card_index, | |
| 173 card_start, card_start + G1BlockOffsetSharedArray::N_words); | |
| 174 } | |
| 175 | |
| 12080 | 176 void scan_strong_code_roots(HeapRegion* r) { |
| 177 double scan_start = os::elapsedTime(); | |
| 178 r->strong_code_roots_do(_code_root_cl); | |
| 179 _strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start); | |
| 180 } | |
| 181 | |
| 342 | 182 bool doHeapRegion(HeapRegion* r) { |
| 183 assert(r->in_collection_set(), "should only be called on elements of CS."); | |
| 184 HeapRegionRemSet* hrrs = r->rem_set(); | |
| 185 if (hrrs->iter_is_complete()) return false; // All done. | |
| 186 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
|
187 // 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
|
188 // 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
|
189 // 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
|
190 _g1h->push_dirty_cards_region(r); |
| 342 | 191 // If we didn't return above, then |
| 192 // _try_claimed || r->claim_iter() | |
| 193 // is true: either we're supposed to work on claimed-but-not-complete | |
| 194 // regions, or we successfully claimed the region. | |
| 12080 | 195 |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6725
diff
changeset
|
196 HeapRegionRemSetIterator iter(hrrs); |
| 342 | 197 size_t card_index; |
| 1261 | 198 |
| 199 // We claim cards in block so as to recude the contention. The block size is determined by | |
| 200 // the G1RSetScanBlockSize parameter. | |
| 201 size_t jump_to_card = hrrs->iter_claimed_next(_block_size); | |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6725
diff
changeset
|
202 for (size_t current_card = 0; iter.has_next(card_index); current_card++) { |
| 1261 | 203 if (current_card >= jump_to_card + _block_size) { |
| 204 jump_to_card = hrrs->iter_claimed_next(_block_size); | |
| 747 | 205 } |
| 1261 | 206 if (current_card < jump_to_card) continue; |
| 342 | 207 HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index); |
| 208 #if 0 | |
| 209 gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n", | |
| 210 card_start, card_start + CardTableModRefBS::card_size_in_words); | |
| 211 #endif | |
| 212 | |
| 213 HeapRegion* card_region = _g1h->heap_region_containing(card_start); | |
| 214 _cards++; | |
| 215 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
216 if (!card_region->is_on_dirty_cards_region_list()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
217 _g1h->push_dirty_cards_region(card_region); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
218 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
219 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
220 // 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
|
221 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
|
222 !_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
|
223 scanCard(card_index, card_region); |
| 342 | 224 } |
| 225 } | |
| 747 | 226 if (!_try_claimed) { |
| 12080 | 227 // Scan the strong code root list attached to the current region |
| 228 scan_strong_code_roots(r); | |
| 229 | |
| 747 | 230 hrrs->set_iter_complete(); |
| 231 } | |
| 342 | 232 return false; |
| 233 } | |
| 12080 | 234 |
| 235 double strong_code_root_scan_time_sec() { | |
| 236 return _strong_code_root_scan_time_sec; | |
| 237 } | |
| 238 | |
| 342 | 239 size_t cards_done() { return _cards_done;} |
| 240 size_t cards_looked_up() { return _cards;} | |
| 241 }; | |
| 242 | |
| 12080 | 243 void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, |
| 20494 | 244 CodeBlobClosure* code_root_cl, |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
245 uint worker_i) { |
| 342 | 246 double rs_time_start = os::elapsedTime(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
247 HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i); |
| 342 | 248 |
| 12080 | 249 ScanRSClosure scanRScl(oc, code_root_cl, worker_i); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3777
diff
changeset
|
250 |
| 342 | 251 _g1->collection_set_iterate_from(startRegion, &scanRScl); |
| 252 scanRScl.set_try_claimed(); | |
| 253 _g1->collection_set_iterate_from(startRegion, &scanRScl); | |
| 254 | |
| 12080 | 255 double scan_rs_time_sec = (os::elapsedTime() - rs_time_start) |
| 256 - scanRScl.strong_code_root_scan_time_sec(); | |
| 342 | 257 |
| 12080 | 258 assert(_cards_scanned != NULL, "invariant"); |
| 342 | 259 _cards_scanned[worker_i] = scanRScl.cards_done(); |
| 260 | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
261 _g1p->phase_times()->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); |
| 12080 | 262 _g1p->phase_times()->record_strong_code_root_scan_time(worker_i, |
| 263 scanRScl.strong_code_root_scan_time_sec() * 1000.0); | |
| 342 | 264 } |
| 265 | |
| 1705 | 266 // Closure used for updating RSets and recording references that |
| 267 // point into the collection set. Only called during an | |
| 268 // evacuation pause. | |
| 269 | |
| 270 class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure { | |
| 271 G1RemSet* _g1rs; | |
| 272 DirtyCardQueue* _into_cset_dcq; | |
| 273 public: | |
| 274 RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h, | |
| 275 DirtyCardQueue* into_cset_dcq) : | |
| 276 _g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq) | |
| 277 {} | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
278 bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
| 1705 | 279 // The only time we care about recording cards that |
| 280 // contain references that point into the collection set | |
| 281 // is during RSet updating within an evacuation pause. | |
| 282 // In this case worker_i should be the id of a GC worker thread. | |
| 283 assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause"); | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
284 assert(worker_i < (ParallelGCThreads == 0 ? 1 : ParallelGCThreads), "should be a GC worker"); |
| 342 | 285 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
286 if (_g1rs->refine_card(card_ptr, worker_i, true)) { |
| 1705 | 287 // 'card_ptr' contains references that point into the collection |
| 288 // set. We need to record the card in the DCQS | |
| 289 // (G1CollectedHeap::into_cset_dirty_card_queue_set()) | |
| 290 // that's used for that purpose. | |
| 291 // | |
| 292 // Enqueue the card | |
| 293 _into_cset_dcq->enqueue(card_ptr); | |
| 294 } | |
| 295 return true; | |
| 296 } | |
| 297 }; | |
| 298 | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
299 void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, uint worker_i) { |
| 342 | 300 double start = os::elapsedTime(); |
| 1705 | 301 // Apply the given closure to all remaining log entries. |
| 302 RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3777
diff
changeset
|
303 |
| 1705 | 304 _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i); |
| 305 | |
| 794 | 306 // Now there should be no dirty cards. |
| 307 if (G1RSLogCheckCardTable) { | |
| 308 CountNonCleanMemRegionClosure cl(_g1); | |
| 309 _ct_bs->mod_card_iterate(&cl); | |
| 310 // XXX This isn't true any more: keeping cards of young regions | |
| 311 // marked dirty broke it. Need some reasonable fix. | |
| 312 guarantee(cl.n() == 0, "Card table should be clean."); | |
| 342 | 313 } |
| 794 | 314 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
315 _g1p->phase_times()->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); |
| 342 | 316 } |
| 317 | |
| 1861 | 318 void G1RemSet::cleanupHRRS() { |
| 342 | 319 HeapRegionRemSet::cleanup(); |
| 320 } | |
| 321 | |
| 1861 | 322 void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, |
| 20494 | 323 CodeBlobClosure* code_root_cl, |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
324 uint worker_i) { |
| 342 | 325 #if CARD_REPEAT_HISTO |
| 326 ct_freq_update_histo_and_reset(); | |
| 327 #endif | |
| 328 | |
| 1705 | 329 // We cache the value of 'oc' closure into the appropriate slot in the |
| 330 // _cset_rs_update_cl for this worker | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
331 assert(worker_i < n_workers(), "sanity"); |
| 1705 | 332 _cset_rs_update_cl[worker_i] = oc; |
| 333 | |
| 334 // A DirtyCardQueue that is used to hold cards containing references | |
| 335 // that point into the collection set. This DCQ is associated with a | |
| 336 // special DirtyCardQueueSet (see g1CollectedHeap.hpp). Under normal | |
| 337 // circumstances (i.e. the pause successfully completes), these cards | |
| 338 // are just discarded (there's no need to update the RSets of regions | |
| 339 // that were in the collection set - after the pause these regions | |
| 340 // are wholly 'free' of live objects. In the event of an evacuation | |
|
20504
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
341 // failure the cards/buffers in this queue set are passed to the |
|
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
342 // DirtyCardQueueSet that is used to manage RSet updates |
| 1705 | 343 DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); |
| 344 | |
|
1708
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
345 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
|
346 |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
347 // 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
|
348 // 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
|
349 // 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
|
350 // 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
|
351 // 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
|
352 // 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
|
353 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
|
354 updateRS(&into_cset_dcq, worker_i); |
| 342 | 355 } 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
|
356 _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
|
357 _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
|
358 } |
|
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
359 if (G1UseParallelRSetScanning || (worker_i == 0)) { |
| 12080 | 360 scanRS(oc, code_root_cl, worker_i); |
|
1708
a03ae377b2e8
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
1705
diff
changeset
|
361 } else { |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
4839
diff
changeset
|
362 _g1p->phase_times()->record_scan_rs_time(worker_i, 0.0); |
| 342 | 363 } |
| 1705 | 364 |
| 365 // We now clear the cached values of _cset_rs_update_cl for this worker | |
| 366 _cset_rs_update_cl[worker_i] = NULL; | |
| 342 | 367 } |
| 368 | |
| 1861 | 369 void G1RemSet::prepare_for_oops_into_collection_set_do() { |
| 342 | 370 cleanupHRRS(); |
| 371 _g1->set_refine_cte_cl_concurrency(false); | |
| 372 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 373 dcqs.concatenate_logs(); | |
| 374 | |
| 375 guarantee( _cards_scanned == NULL, "invariant" ); | |
| 6197 | 376 _cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers(), mtGC); |
| 545 | 377 for (uint i = 0; i < n_workers(); ++i) { |
| 378 _cards_scanned[i] = 0; | |
| 379 } | |
| 342 | 380 _total_cards_scanned = 0; |
| 381 } | |
| 382 | |
| 1861 | 383 void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
| 342 | 384 guarantee( _cards_scanned != NULL, "invariant" ); |
| 385 _total_cards_scanned = 0; | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3765
diff
changeset
|
386 for (uint i = 0; i < n_workers(); ++i) { |
| 342 | 387 _total_cards_scanned += _cards_scanned[i]; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3765
diff
changeset
|
388 } |
| 6197 | 389 FREE_C_HEAP_ARRAY(size_t, _cards_scanned, mtGC); |
| 342 | 390 _cards_scanned = NULL; |
| 391 // Cleanup after copy | |
| 392 _g1->set_refine_cte_cl_concurrency(true); | |
| 393 // Set all cards back to clean. | |
| 394 _g1->cleanUpCardTable(); | |
| 794 | 395 |
| 1705 | 396 DirtyCardQueueSet& into_cset_dcqs = _g1->into_cset_dirty_card_queue_set(); |
| 397 int into_cset_n_buffers = into_cset_dcqs.completed_buffers_num(); | |
| 398 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
399 if (_g1->evacuation_failed()) { |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
13059
diff
changeset
|
400 double restore_remembered_set_start = os::elapsedTime(); |
|
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
13059
diff
changeset
|
401 |
| 1705 | 402 // Restore remembered sets for the regions pointing into the collection set. |
|
20504
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
403 // We just need to transfer the completed buffers from the DirtyCardQueueSet |
|
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
404 // used to hold cards that contain references that point into the collection set |
|
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
405 // to the DCQS used to hold the deferred RS updates. |
|
6948da6d7c13
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
20494
diff
changeset
|
406 _g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
13059
diff
changeset
|
407 _g1->g1_policy()->phase_times()->record_evac_fail_restore_remsets((os::elapsedTime() - restore_remembered_set_start) * 1000.0); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
545
diff
changeset
|
408 } |
| 1705 | 409 |
| 410 // Free any completed buffers in the DirtyCardQueueSet used to hold cards | |
| 411 // which contain references that point into the collection. | |
| 412 _g1->into_cset_dirty_card_queue_set().clear(); | |
| 413 assert(_g1->into_cset_dirty_card_queue_set().completed_buffers_num() == 0, | |
| 414 "all buffers should be freed"); | |
| 415 _g1->into_cset_dirty_card_queue_set().clear_n_completed_buffers(); | |
| 342 | 416 } |
| 417 | |
| 418 class ScrubRSClosure: public HeapRegionClosure { | |
| 419 G1CollectedHeap* _g1h; | |
| 420 BitMap* _region_bm; | |
| 421 BitMap* _card_bm; | |
| 422 CardTableModRefBS* _ctbs; | |
| 423 public: | |
| 424 ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) : | |
| 425 _g1h(G1CollectedHeap::heap()), | |
| 426 _region_bm(region_bm), _card_bm(card_bm), | |
| 12343 | 427 _ctbs(_g1h->g1_barrier_set()) {} |
| 342 | 428 |
| 429 bool doHeapRegion(HeapRegion* r) { | |
| 430 if (!r->continuesHumongous()) { | |
| 431 r->rem_set()->scrub(_ctbs, _region_bm, _card_bm); | |
| 432 } | |
| 433 return false; | |
| 434 } | |
| 435 }; | |
| 436 | |
| 1861 | 437 void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) { |
| 342 | 438 ScrubRSClosure scrub_cl(region_bm, card_bm); |
| 439 _g1->heap_region_iterate(&scrub_cl); | |
| 440 } | |
| 441 | |
| 1861 | 442 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
|
443 uint worker_num, int claim_val) { |
| 342 | 444 ScrubRSClosure scrub_cl(region_bm, card_bm); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
445 _g1->heap_region_par_iterate_chunked(&scrub_cl, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
446 worker_num, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4097
diff
changeset
|
447 n_workers(), |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
448 claim_val); |
| 342 | 449 } |
| 450 | |
| 4839 | 451 G1TriggerClosure::G1TriggerClosure() : |
| 452 _triggered(false) { } | |
| 453 | |
| 454 G1InvokeIfNotTriggeredClosure::G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t_cl, | |
| 455 OopClosure* oop_cl) : | |
| 456 _trigger_cl(t_cl), _oop_cl(oop_cl) { } | |
| 1705 | 457 |
| 4839 | 458 G1Mux2Closure::G1Mux2Closure(OopClosure *c1, OopClosure *c2) : |
| 459 _c1(c1), _c2(c2) { } | |
| 1705 | 460 |
| 4839 | 461 G1UpdateRSOrPushRefOopClosure:: |
| 462 G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, | |
| 463 G1RemSet* rs, | |
| 464 OopsInHeapRegionClosure* push_ref_cl, | |
| 465 bool record_refs_into_cset, | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
466 uint worker_i) : |
| 4839 | 467 _g1(g1h), _g1_rem_set(rs), _from(NULL), |
| 468 _record_refs_into_cset(record_refs_into_cset), | |
| 469 _push_ref_cl(push_ref_cl), _worker_i(worker_i) { } | |
| 1705 | 470 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
471 // Returns true if the given card contains references that point |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
472 // into the collection set, if we're checking for such references; |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
473 // false otherwise. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
474 |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17757
diff
changeset
|
475 bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
476 bool check_for_refs_into_cset) { |
| 20337 | 477 assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)), |
| 478 err_msg("Card at "PTR_FORMAT" index "SIZE_FORMAT" representing heap at "PTR_FORMAT" (%u) must be in committed heap", | |
| 479 p2i(card_ptr), | |
| 480 _ct_bs->index_for(_ct_bs->addr_for(card_ptr)), | |
| 481 _ct_bs->addr_for(card_ptr), | |
| 482 _g1->addr_to_region(_ct_bs->addr_for(card_ptr)))); | |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
483 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
484 // If the card is no longer dirty, nothing to do. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
485 if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
486 // No need to return that this card contains refs that point |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
487 // into the collection set. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
488 return false; |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
489 } |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
490 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
491 // Construct the region representing the card. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
492 HeapWord* start = _ct_bs->addr_for(card_ptr); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
493 // And find the region containing it. |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
494 HeapRegion* r = _g1->heap_region_containing(start); |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
495 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
496 // Why do we have to check here whether a card is on a young region, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
497 // given that we dirty young regions and, as a result, the |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
498 // post-barrier is supposed to filter them out and never to enqueue |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
499 // them? When we allocate a new region as the "allocation region" we |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
500 // actually dirty its cards after we release the lock, since card |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
501 // dirtying while holding the lock was a performance bottleneck. So, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
502 // as a result, it is possible for other threads to actually |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
503 // allocate objects in the region (after the acquire the lock) |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
504 // before all the cards on the region are dirtied. This is unlikely, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
505 // and it doesn't happen often, but it can happen. So, the extra |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
506 // check below filters out those cards. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
507 if (r->is_young()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
508 return false; |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
509 } |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
510 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
511 // While we are processing RSet buffers during the collection, we |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
512 // actually don't want to scan any cards on the collection set, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
513 // since we don't want to update remebered sets with entries that |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
514 // point into the collection set, given that live objects from the |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
515 // collection set are about to move and such entries will be stale |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
516 // very soon. This change also deals with a reliability issue which |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
517 // involves scanning a card in the collection set and coming across |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
518 // an array that was being chunked and looking malformed. Note, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
519 // however, that if evacuation fails, we have to scan any objects |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
520 // that were not moved and create any missing entries. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
521 if (r->in_collection_set()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
522 return false; |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
523 } |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
524 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
525 // The result from the hot card cache insert call is either: |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
526 // * pointer to the current card |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
527 // (implying that the current card is not 'hot'), |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
528 // * null |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
529 // (meaning we had inserted the card ptr into the "hot" card cache, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
530 // which had some headroom), |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
531 // * a pointer to a "hot" card that was evicted from the "hot" cache. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
532 // |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
533 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
534 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
535 if (hot_card_cache->use_cache()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
536 assert(!check_for_refs_into_cset, "sanity"); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
537 assert(!SafepointSynchronize::is_at_safepoint(), "sanity"); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
538 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
539 card_ptr = hot_card_cache->insert(card_ptr); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
540 if (card_ptr == NULL) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
541 // There was no eviction. Nothing to do. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
542 return false; |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
543 } |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
544 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
545 start = _ct_bs->addr_for(card_ptr); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
546 r = _g1->heap_region_containing(start); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
547 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
548 // Checking whether the region we got back from the cache |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
549 // is young here is inappropriate. The region could have been |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
550 // freed, reallocated and tagged as young while in the cache. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
551 // Hence we could see its young type change at any time. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
552 } |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
553 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
554 // 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
|
555 // 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
|
556 // gen at the upper end of the heap. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
557 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
|
558 MemRegion dirtyRegion(start, end); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
559 |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
560 #if CARD_REPEAT_HISTO |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
1972
diff
changeset
|
561 init_ct_freq_table(_g1->max_capacity()); |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
562 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
|
563 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
564 |
|
4071
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
565 OopsInHeapRegionClosure* oops_in_heap_closure = NULL; |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
566 if (check_for_refs_into_cset) { |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
567 // ConcurrentG1RefineThreads have worker numbers larger than what |
|
ed80554efa25
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
4023
diff
changeset
|
568 // _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
|
569 // 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
|
570 // 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
|
571 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
|
572 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
|
573 } |
| 4839 | 574 G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1, |
| 575 _g1->g1_rem_set(), | |
| 576 oops_in_heap_closure, | |
| 577 check_for_refs_into_cset, | |
| 578 worker_i); | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
579 update_rs_oop_cl.set_from(r); |
| 1705 | 580 |
| 4839 | 581 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
|
582 FilterIntoCSClosure into_cs_cl(NULL, _g1, &trigger_cl); |
| 4839 | 583 G1InvokeIfNotTriggeredClosure invoke_cl(&trigger_cl, &into_cs_cl); |
| 584 G1Mux2Closure mux(&invoke_cl, &update_rs_oop_cl); | |
| 1705 | 585 |
| 586 FilterOutOfRegionClosure filter_then_update_rs_oop_cl(r, | |
| 587 (check_for_refs_into_cset ? | |
| 588 (OopClosure*)&mux : | |
| 589 (OopClosure*)&update_rs_oop_cl)); | |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
590 |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
591 // 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
|
592 // 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
|
593 // 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
|
594 // 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
|
595 // 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
|
596 // and tagged as young. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
597 // |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
598 // 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
|
599 // 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
|
600 // 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
|
601 // 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
|
602 // 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
|
603 // 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
|
604 bool filter_young = true; |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
605 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
606 HeapWord* stop_point = |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
607 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
|
608 &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
|
609 filter_young, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2364
diff
changeset
|
610 card_ptr); |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1611
diff
changeset
|
611 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
612 // 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
|
613 // (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
|
614 // 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
|
615 // 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
|
616 // 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
|
617 if (stop_point != NULL) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
618 // 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
|
619 // worked. (In fact, it's pretty likely.) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
620 if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
621 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
622 MutexLockerEx x(Shared_DirtyCardQ_lock, |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
623 Mutex::_no_safepoint_check_flag); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
624 DirtyCardQueue* sdcq = |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
625 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
|
626 sdcq->enqueue(card_ptr); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
627 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
628 } else { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
629 _conc_refine_cards++; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
630 } |
| 1705 | 631 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
632 // This gets set to true if the card being refined has |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
633 // references that point into the collection set. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
634 bool has_refs_into_cset = trigger_cl.triggered(); |
| 342 | 635 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
636 // We should only be detecting that the card contains references |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
637 // that point into the collection set if the current thread is |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
638 // a GC worker thread. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
639 assert(!has_refs_into_cset || SafepointSynchronize::is_at_safepoint(), |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
640 "invalid result at non safepoint"); |
| 1705 | 641 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
642 return has_refs_into_cset; |
| 342 | 643 } |
| 644 | |
|
12339
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12080
diff
changeset
|
645 void G1RemSet::print_periodic_summary_info(const char* header) { |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
646 G1RemSetSummary current; |
|
12344
7ec10139bf37
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
12343
diff
changeset
|
647 current.initialize(this); |
| 342 | 648 |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
649 _prev_period_summary.subtract_from(¤t); |
|
12339
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12080
diff
changeset
|
650 print_summary_info(&_prev_period_summary, header); |
| 342 | 651 |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
652 _prev_period_summary.set(¤t); |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
653 } |
| 794 | 654 |
| 1861 | 655 void G1RemSet::print_summary_info() { |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
656 G1RemSetSummary current; |
|
12344
7ec10139bf37
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
12343
diff
changeset
|
657 current.initialize(this); |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
658 |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
659 print_summary_info(¤t, " Cumulative RS summary"); |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
660 } |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
661 |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
662 void G1RemSet::print_summary_info(G1RemSetSummary * summary, const char * header) { |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
663 assert(summary != NULL, "just checking"); |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
664 |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
665 if (header != NULL) { |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
666 gclog_or_tty->print_cr("%s", header); |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
667 } |
| 342 | 668 |
| 669 #if CARD_REPEAT_HISTO | |
| 670 gclog_or_tty->print_cr("\nG1 card_repeat count histogram: "); | |
| 671 gclog_or_tty->print_cr(" # of repeats --> # of cards with that number."); | |
| 672 card_repeat_count.print_on(gclog_or_tty); | |
| 673 #endif | |
| 674 | |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10246
diff
changeset
|
675 summary->print_on(gclog_or_tty); |
| 342 | 676 } |
| 1705 | 677 |
| 1861 | 678 void G1RemSet::prepare_for_verify() { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
679 if (G1HRRSFlushLogBuffersOnVerify && |
|
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
680 (VerifyBeforeGC || VerifyAfterGC) |
|
10373
3a4805ad0005
8015244: G1: Verification after a full GC is incorrectly placed.
johnc
parents:
10372
diff
changeset
|
681 && (!_g1->full_collection() || G1VerifyRSetsDuringFullGC)) { |
| 342 | 682 cleanupHRRS(); |
| 683 _g1->set_refine_cte_cl_concurrency(false); | |
| 684 if (SafepointSynchronize::is_at_safepoint()) { | |
| 685 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 686 dcqs.concatenate_logs(); | |
| 687 } | |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
688 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
689 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
690 bool use_hot_card_cache = hot_card_cache->use_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
691 hot_card_cache->set_use_cache(false); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
692 |
| 1705 | 693 DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); |
| 694 updateRS(&into_cset_dcq, 0); | |
| 695 _g1->into_cset_dirty_card_queue_set().clear(); | |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
696 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10182
diff
changeset
|
697 hot_card_cache->set_use_cache(use_hot_card_cache); |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
626
diff
changeset
|
698 assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
| 342 | 699 } |
| 700 } |