author | jwilhelm |
Thu, 03 Oct 2013 21:36:29 +0200 | |
changeset 20398 | b206c580c45f |
parent 20310 | 903b398490d9 |
child 21560 | b3ae3ba25ebb |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
2 |
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 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" |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
32 |
#include "gc_implementation/g1/g1HotCardCache.hpp" |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
11586
diff
changeset
|
33 |
#include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
7397 | 34 |
#include "gc_implementation/g1/g1OopClosures.inline.hpp" |
35 |
#include "gc_implementation/g1/g1RemSet.inline.hpp" |
|
36 |
#include "gc_implementation/g1/heapRegionSeq.inline.hpp" |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
37 |
#include "gc_implementation/g1/heapRegionRemSet.hpp" |
7397 | 38 |
#include "memory/iterator.hpp" |
39 |
#include "oops/oop.inline.hpp" |
|
40 |
#include "utilities/intHisto.hpp" |
|
1374 | 41 |
|
42 |
#define CARD_REPEAT_HISTO 0 |
|
43 |
||
44 |
#if CARD_REPEAT_HISTO |
|
45 |
static size_t ct_freq_sz; |
|
46 |
static jbyte* ct_freq = NULL; |
|
47 |
||
48 |
void init_ct_freq_table(size_t heap_sz_bytes) { |
|
49 |
if (ct_freq == NULL) { |
|
50 |
ct_freq_sz = heap_sz_bytes/CardTableModRefBS::card_size; |
|
51 |
ct_freq = new jbyte[ct_freq_sz]; |
|
52 |
for (size_t j = 0; j < ct_freq_sz; j++) ct_freq[j] = 0; |
|
53 |
} |
|
54 |
} |
|
55 |
||
56 |
void ct_freq_note_card(size_t index) { |
|
57 |
assert(0 <= index && index < ct_freq_sz, "Bounds error."); |
|
58 |
if (ct_freq[index] < 100) { ct_freq[index]++; } |
|
59 |
} |
|
60 |
||
61 |
static IntHistogram card_repeat_count(10, 10); |
|
62 |
||
63 |
void ct_freq_update_histo_and_reset() { |
|
64 |
for (size_t j = 0; j < ct_freq_sz; j++) { |
|
65 |
card_repeat_count.add_entry(ct_freq[j]); |
|
66 |
ct_freq[j] = 0; |
|
67 |
} |
|
68 |
||
69 |
} |
|
70 |
#endif |
|
71 |
||
6958 | 72 |
G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) |
73 |
: _g1(g1), _conc_refine_cards(0), |
|
74 |
_ct_bs(ct_bs), _g1p(_g1->g1_policy()), |
|
1374 | 75 |
_cg1r(g1->concurrent_g1_refine()), |
6247 | 76 |
_cset_rs_update_cl(NULL), |
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
77 |
_cards_scanned(NULL), _total_cards_scanned(0), |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
78 |
_prev_period_summary() |
1374 | 79 |
{ |
80 |
_seq_task = new SubTasksDone(NumSeqTasks); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
81 |
guarantee(n_workers() > 0, "There should be some workers"); |
13195 | 82 |
_cset_rs_update_cl = NEW_C_HEAP_ARRAY(OopsInHeapRegionClosure*, n_workers(), mtGC); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
83 |
for (uint i = 0; i < n_workers(); i++) { |
6247 | 84 |
_cset_rs_update_cl[i] = NULL; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
85 |
} |
20310
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
86 |
if (G1SummarizeRSetStats) { |
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
87 |
_prev_period_summary.initialize(this); |
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
88 |
} |
1374 | 89 |
} |
90 |
||
6958 | 91 |
G1RemSet::~G1RemSet() { |
1374 | 92 |
delete _seq_task; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
93 |
for (uint i = 0; i < n_workers(); i++) { |
6247 | 94 |
assert(_cset_rs_update_cl[i] == NULL, "it should be"); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
95 |
} |
13195 | 96 |
FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl, mtGC); |
1374 | 97 |
} |
98 |
||
99 |
void CountNonCleanMemRegionClosure::do_MemRegion(MemRegion mr) { |
|
100 |
if (_g1->is_in_g1_reserved(mr.start())) { |
|
101 |
_n += (int) ((mr.byte_size() / CardTableModRefBS::card_size)); |
|
102 |
if (_start_first == NULL) _start_first = mr.start(); |
|
103 |
} |
|
104 |
} |
|
105 |
||
106 |
class ScanRSClosure : public HeapRegionClosure { |
|
107 |
size_t _cards_done, _cards; |
|
108 |
G1CollectedHeap* _g1h; |
|
19339 | 109 |
|
1374 | 110 |
OopsInHeapRegionClosure* _oc; |
19339 | 111 |
CodeBlobToOopClosure* _code_root_cl; |
112 |
||
1374 | 113 |
G1BlockOffsetSharedArray* _bot_shared; |
20309 | 114 |
G1SATBCardTableModRefBS *_ct_bs; |
19339 | 115 |
|
116 |
double _strong_code_root_scan_time_sec; |
|
117 |
int _worker_i; |
|
118 |
int _block_size; |
|
119 |
bool _try_claimed; |
|
120 |
||
1374 | 121 |
public: |
19339 | 122 |
ScanRSClosure(OopsInHeapRegionClosure* oc, |
123 |
CodeBlobToOopClosure* code_root_cl, |
|
124 |
int worker_i) : |
|
1374 | 125 |
_oc(oc), |
19339 | 126 |
_code_root_cl(code_root_cl), |
127 |
_strong_code_root_scan_time_sec(0.0), |
|
1374 | 128 |
_cards(0), |
129 |
_cards_done(0), |
|
130 |
_worker_i(worker_i), |
|
131 |
_try_claimed(false) |
|
132 |
{ |
|
133 |
_g1h = G1CollectedHeap::heap(); |
|
134 |
_bot_shared = _g1h->bot_shared(); |
|
20309 | 135 |
_ct_bs = _g1h->g1_barrier_set(); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
136 |
_block_size = MAX2<int>(G1RSetScanBlockSize, 1); |
1374 | 137 |
} |
138 |
||
139 |
void set_try_claimed() { _try_claimed = true; } |
|
140 |
||
141 |
void scanCard(size_t index, HeapRegion *r) { |
|
10770 | 142 |
// Stack allocate the DirtyCardToOopClosure instance |
143 |
HeapRegionDCTOC cl(_g1h, r, _oc, |
|
144 |
CardTableModRefBS::Precise, |
|
145 |
HeapRegionDCTOC::IntoCSFilterKind); |
|
1374 | 146 |
|
147 |
// Set the "from" region in the closure. |
|
148 |
_oc->set_region(r); |
|
149 |
HeapWord* card_start = _bot_shared->address_for_index(index); |
|
150 |
HeapWord* card_end = card_start + G1BlockOffsetSharedArray::N_words; |
|
151 |
Space *sp = SharedHeap::heap()->space_containing(card_start); |
|
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
152 |
MemRegion sm_region = sp->used_region_at_save_marks(); |
1374 | 153 |
MemRegion mr = sm_region.intersection(MemRegion(card_start,card_end)); |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
154 |
if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) { |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
155 |
// We make the card as "claimed" lazily (so races are possible |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
156 |
// but they're benign), which reduces the number of duplicate |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
157 |
// scans (the rsets of the regions in the cset can intersect). |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
158 |
_ct_bs->set_card_claimed(index); |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
159 |
_cards_done++; |
10770 | 160 |
cl.do_MemRegion(mr); |
1374 | 161 |
} |
162 |
} |
|
163 |
||
164 |
void printCard(HeapRegion* card_region, size_t card_index, |
|
165 |
HeapWord* card_start) { |
|
166 |
gclog_or_tty->print_cr("T %d Region [" PTR_FORMAT ", " PTR_FORMAT ") " |
|
167 |
"RS names card %p: " |
|
168 |
"[" PTR_FORMAT ", " PTR_FORMAT ")", |
|
169 |
_worker_i, |
|
170 |
card_region->bottom(), card_region->end(), |
|
171 |
card_index, |
|
172 |
card_start, card_start + G1BlockOffsetSharedArray::N_words); |
|
173 |
} |
|
174 |
||
19339 | 175 |
void scan_strong_code_roots(HeapRegion* r) { |
176 |
double scan_start = os::elapsedTime(); |
|
177 |
r->strong_code_roots_do(_code_root_cl); |
|
178 |
_strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start); |
|
179 |
} |
|
180 |
||
1374 | 181 |
bool doHeapRegion(HeapRegion* r) { |
182 |
assert(r->in_collection_set(), "should only be called on elements of CS."); |
|
183 |
HeapRegionRemSet* hrrs = r->rem_set(); |
|
184 |
if (hrrs->iter_is_complete()) return false; // All done. |
|
185 |
if (!_try_claimed && !hrrs->claim_iter()) return false; |
|
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
186 |
// If we ever free the collection set concurrently, we should also |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
187 |
// clear the card table concurrently therefore we won't need to |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
188 |
// add regions of the collection set to the dirty cards region. |
2883
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
189 |
_g1h->push_dirty_cards_region(r); |
1374 | 190 |
// If we didn't return above, then |
191 |
// _try_claimed || r->claim_iter() |
|
192 |
// is true: either we're supposed to work on claimed-but-not-complete |
|
193 |
// regions, or we successfully claimed the region. |
|
19339 | 194 |
|
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13728
diff
changeset
|
195 |
HeapRegionRemSetIterator iter(hrrs); |
1374 | 196 |
size_t card_index; |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
197 |
|
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
198 |
// We claim cards in block so as to recude the contention. The block size is determined by |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
199 |
// the G1RSetScanBlockSize parameter. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
200 |
size_t jump_to_card = hrrs->iter_claimed_next(_block_size); |
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13728
diff
changeset
|
201 |
for (size_t current_card = 0; iter.has_next(card_index); current_card++) { |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
202 |
if (current_card >= jump_to_card + _block_size) { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
203 |
jump_to_card = hrrs->iter_claimed_next(_block_size); |
2737 | 204 |
} |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
205 |
if (current_card < jump_to_card) continue; |
1374 | 206 |
HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index); |
207 |
#if 0 |
|
208 |
gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n", |
|
209 |
card_start, card_start + CardTableModRefBS::card_size_in_words); |
|
210 |
#endif |
|
211 |
||
212 |
HeapRegion* card_region = _g1h->heap_region_containing(card_start); |
|
213 |
assert(card_region != NULL, "Yielding cards not in the heap?"); |
|
214 |
_cards++; |
|
215 |
||
2883
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
216 |
if (!card_region->is_on_dirty_cards_region_list()) { |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
217 |
_g1h->push_dirty_cards_region(card_region); |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
218 |
} |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
219 |
|
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
220 |
// If the card is dirty, then we will scan it during updateRS. |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
221 |
if (!card_region->in_collection_set() && |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
222 |
!_ct_bs->is_card_dirty(card_index)) { |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
223 |
scanCard(card_index, card_region); |
1374 | 224 |
} |
225 |
} |
|
2737 | 226 |
if (!_try_claimed) { |
19339 | 227 |
// Scan the strong code root list attached to the current region |
228 |
scan_strong_code_roots(r); |
|
229 |
||
2737 | 230 |
hrrs->set_iter_complete(); |
231 |
} |
|
1374 | 232 |
return false; |
233 |
} |
|
19339 | 234 |
|
235 |
double strong_code_root_scan_time_sec() { |
|
236 |
return _strong_code_root_scan_time_sec; |
|
237 |
} |
|
238 |
||
1374 | 239 |
size_t cards_done() { return _cards_done;} |
240 |
size_t cards_looked_up() { return _cards;} |
|
241 |
}; |
|
242 |
||
19339 | 243 |
void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, |
244 |
CodeBlobToOopClosure* code_root_cl, |
|
245 |
int worker_i) { |
|
1374 | 246 |
double rs_time_start = os::elapsedTime(); |
11176
9bb1ddd8da51
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
11174
diff
changeset
|
247 |
HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i); |
1374 | 248 |
|
19339 | 249 |
ScanRSClosure scanRScl(oc, code_root_cl, worker_i); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
250 |
|
1374 | 251 |
_g1->collection_set_iterate_from(startRegion, &scanRScl); |
252 |
scanRScl.set_try_claimed(); |
|
253 |
_g1->collection_set_iterate_from(startRegion, &scanRScl); |
|
254 |
||
19339 | 255 |
double scan_rs_time_sec = (os::elapsedTime() - rs_time_start) |
256 |
- scanRScl.strong_code_root_scan_time_sec(); |
|
1374 | 257 |
|
19339 | 258 |
assert(_cards_scanned != NULL, "invariant"); |
1374 | 259 |
_cards_scanned[worker_i] = scanRScl.cards_done(); |
260 |
||
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
11586
diff
changeset
|
261 |
_g1p->phase_times()->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); |
19339 | 262 |
_g1p->phase_times()->record_strong_code_root_scan_time(worker_i, |
263 |
scanRScl.strong_code_root_scan_time_sec() * 1000.0); |
|
1374 | 264 |
} |
265 |
||
6247 | 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 |
{} |
|
278 |
bool do_card_ptr(jbyte* card_ptr, int worker_i) { |
|
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"); |
|
8683
9d31cebc0f6e
7023747: G1: too strict assert in RefineRecordRefsIntoCSCardTableEntryClosure::do_card_ptr in g1RemSet.cpp
brutisso
parents:
8680
diff
changeset
|
284 |
assert(worker_i < (int) (ParallelGCThreads == 0 ? 1 : ParallelGCThreads), "should be a GC worker"); |
1374 | 285 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
286 |
if (_g1rs->refine_card(card_ptr, worker_i, true)) { |
6247 | 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 |
||
6958 | 299 |
void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) { |
1374 | 300 |
double start = os::elapsedTime(); |
6247 | 301 |
// Apply the given closure to all remaining log entries. |
302 |
RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq); |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
303 |
|
6247 | 304 |
_g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i); |
305 |
||
2881 | 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."); |
|
1374 | 313 |
} |
2881 | 314 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
11586
diff
changeset
|
315 |
_g1p->phase_times()->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); |
1374 | 316 |
} |
317 |
||
6958 | 318 |
void G1RemSet::cleanupHRRS() { |
1374 | 319 |
HeapRegionRemSet::cleanup(); |
320 |
} |
|
321 |
||
6958 | 322 |
void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, |
19339 | 323 |
CodeBlobToOopClosure* code_root_cl, |
324 |
int worker_i) { |
|
1374 | 325 |
#if CARD_REPEAT_HISTO |
326 |
ct_freq_update_histo_and_reset(); |
|
327 |
#endif |
|
328 |
||
6247 | 329 |
// We cache the value of 'oc' closure into the appropriate slot in the |
330 |
// _cset_rs_update_cl for this worker |
|
331 |
assert(worker_i < (int)n_workers(), "sanity"); |
|
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 |
|
341 |
// failure the cards/buffers in this queue set are: |
|
342 |
// * passed to the DirtyCardQueueSet that is used to manage deferred |
|
343 |
// RSet updates, or |
|
344 |
// * scanned for references that point into the collection set |
|
345 |
// and the RSet of the corresponding region in the collection set |
|
346 |
// is updated immediately. |
|
347 |
DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); |
|
348 |
||
6250
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
349 |
assert((ParallelGCThreads > 0) || worker_i == 0, "invariant"); |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
350 |
|
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
351 |
// The two flags below were introduced temporarily to serialize |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
352 |
// the updating and scanning of remembered sets. There are some |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
353 |
// race conditions when these two operations are done in parallel |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
354 |
// and they are causing failures. When we resolve said race |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
355 |
// conditions, we'll revert back to parallel remembered set |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
356 |
// updating and scanning. See CRs 6677707 and 6677708. |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
357 |
if (G1UseParallelRSetUpdating || (worker_i == 0)) { |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
358 |
updateRS(&into_cset_dcq, worker_i); |
1374 | 359 |
} else { |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13336
diff
changeset
|
360 |
_g1p->phase_times()->record_update_rs_processed_buffers(worker_i, 0); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
11586
diff
changeset
|
361 |
_g1p->phase_times()->record_update_rs_time(worker_i, 0.0); |
6250
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
362 |
} |
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
363 |
if (G1UseParallelRSetScanning || (worker_i == 0)) { |
19339 | 364 |
scanRS(oc, code_root_cl, worker_i); |
6250
5680f968c721
6930581: G1: assert(ParallelGCThreads > 1 || n_yielded() == _hrrs->occupied(),"Should have yielded all the ..
johnc
parents:
6247
diff
changeset
|
365 |
} else { |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
11586
diff
changeset
|
366 |
_g1p->phase_times()->record_scan_rs_time(worker_i, 0.0); |
1374 | 367 |
} |
6247 | 368 |
|
369 |
// We now clear the cached values of _cset_rs_update_cl for this worker |
|
370 |
_cset_rs_update_cl[worker_i] = NULL; |
|
1374 | 371 |
} |
372 |
||
6958 | 373 |
void G1RemSet::prepare_for_oops_into_collection_set_do() { |
1374 | 374 |
cleanupHRRS(); |
375 |
ConcurrentG1Refine* cg1r = _g1->concurrent_g1_refine(); |
|
376 |
_g1->set_refine_cte_cl_concurrency(false); |
|
377 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
378 |
dcqs.concatenate_logs(); |
|
379 |
||
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
380 |
if (G1CollectedHeap::use_parallel_gc_threads()) { |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
381 |
// Don't set the number of workers here. It will be set |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
382 |
// when the task is run |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
383 |
// _seq_task->set_n_termination((int)n_workers()); |
1374 | 384 |
} |
385 |
guarantee( _cards_scanned == NULL, "invariant" ); |
|
13195 | 386 |
_cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers(), mtGC); |
2009 | 387 |
for (uint i = 0; i < n_workers(); ++i) { |
388 |
_cards_scanned[i] = 0; |
|
389 |
} |
|
1374 | 390 |
_total_cards_scanned = 0; |
391 |
} |
|
392 |
||
393 |
||
6247 | 394 |
// This closure, applied to a DirtyCardQueueSet, is used to immediately |
395 |
// update the RSets for the regions in the CSet. For each card it iterates |
|
396 |
// through the oops which coincide with that card. It scans the reference |
|
397 |
// fields in each oop; when it finds an oop that points into the collection |
|
398 |
// set, the RSet for the region containing the referenced object is updated. |
|
399 |
class UpdateRSetCardTableEntryIntoCSetClosure: public CardTableEntryClosure { |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
400 |
G1CollectedHeap* _g1; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
401 |
CardTableModRefBS* _ct_bs; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
402 |
public: |
6247 | 403 |
UpdateRSetCardTableEntryIntoCSetClosure(G1CollectedHeap* g1, |
404 |
CardTableModRefBS* bs): |
|
405 |
_g1(g1), _ct_bs(bs) |
|
406 |
{ } |
|
407 |
||
408 |
bool do_card_ptr(jbyte* card_ptr, int worker_i) { |
|
409 |
// Construct the region representing the card. |
|
410 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
|
411 |
// And find the region containing it. |
|
412 |
HeapRegion* r = _g1->heap_region_containing(start); |
|
413 |
assert(r != NULL, "unexpected null"); |
|
414 |
||
415 |
// Scan oops in the card looking for references into the collection set |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
416 |
// Don't use addr_for(card_ptr + 1) which can ask for |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
417 |
// a card beyond the heap. This is not safe without a perm |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
418 |
// gen. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
419 |
HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
6247 | 420 |
MemRegion scanRegion(start, end); |
421 |
||
422 |
UpdateRSetImmediate update_rs_cl(_g1->g1_rem_set()); |
|
10674
09e6f8d20337
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
10670
diff
changeset
|
423 |
FilterIntoCSClosure update_rs_cset_oop_cl(NULL, _g1, &update_rs_cl); |
6247 | 424 |
FilterOutOfRegionClosure filter_then_update_rs_cset_oop_cl(r, &update_rs_cset_oop_cl); |
425 |
||
426 |
// We can pass false as the "filter_young" parameter here as: |
|
427 |
// * we should be in a STW pause, |
|
428 |
// * the DCQS to which this closure is applied is used to hold |
|
429 |
// references that point into the collection set from the prior |
|
430 |
// RSet updating, |
|
431 |
// * the post-write barrier shouldn't be logging updates to young |
|
432 |
// regions (but there is a situation where this can happen - see |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
433 |
// the comment in G1RemSet::refine_card() below - |
6247 | 434 |
// that should not be applicable here), and |
435 |
// * during actual RSet updating, the filtering of cards in young |
|
436 |
// regions in HeapRegion::oops_on_card_seq_iterate_careful is |
|
437 |
// employed. |
|
438 |
// As a result, when this closure is applied to "refs into cset" |
|
439 |
// DCQS, we shouldn't see any cards in young regions. |
|
440 |
update_rs_cl.set_region(r); |
|
441 |
HeapWord* stop_point = |
|
442 |
r->oops_on_card_seq_iterate_careful(scanRegion, |
|
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
443 |
&filter_then_update_rs_cset_oop_cl, |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
444 |
false /* filter_young */, |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
445 |
NULL /* card_ptr */); |
6247 | 446 |
|
447 |
// Since this is performed in the event of an evacuation failure, we |
|
448 |
// we shouldn't see a non-null stop point |
|
449 |
assert(stop_point == NULL, "saw an unallocated region"); |
|
450 |
return true; |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
451 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
452 |
}; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
453 |
|
6958 | 454 |
void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
1374 | 455 |
guarantee( _cards_scanned != NULL, "invariant" ); |
456 |
_total_cards_scanned = 0; |
|
10000
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
9988
diff
changeset
|
457 |
for (uint i = 0; i < n_workers(); ++i) { |
1374 | 458 |
_total_cards_scanned += _cards_scanned[i]; |
10000
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
9988
diff
changeset
|
459 |
} |
13195 | 460 |
FREE_C_HEAP_ARRAY(size_t, _cards_scanned, mtGC); |
1374 | 461 |
_cards_scanned = NULL; |
462 |
// Cleanup after copy |
|
463 |
_g1->set_refine_cte_cl_concurrency(true); |
|
464 |
// Set all cards back to clean. |
|
465 |
_g1->cleanUpCardTable(); |
|
2881 | 466 |
|
6247 | 467 |
DirtyCardQueueSet& into_cset_dcqs = _g1->into_cset_dirty_card_queue_set(); |
468 |
int into_cset_n_buffers = into_cset_dcqs.completed_buffers_num(); |
|
469 |
||
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
470 |
if (_g1->evacuation_failed()) { |
6247 | 471 |
// Restore remembered sets for the regions pointing into the collection set. |
472 |
||
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
473 |
if (G1DeferredRSUpdate) { |
6247 | 474 |
// If deferred RS updates are enabled then we just need to transfer |
475 |
// the completed buffers from (a) the DirtyCardQueueSet used to hold |
|
476 |
// cards that contain references that point into the collection set |
|
477 |
// to (b) the DCQS used to hold the deferred RS updates |
|
478 |
_g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
479 |
} else { |
6247 | 480 |
|
481 |
CardTableModRefBS* bs = (CardTableModRefBS*)_g1->barrier_set(); |
|
482 |
UpdateRSetCardTableEntryIntoCSetClosure update_rs_cset_immediate(_g1, bs); |
|
483 |
||
484 |
int n_completed_buffers = 0; |
|
485 |
while (into_cset_dcqs.apply_closure_to_completed_buffer(&update_rs_cset_immediate, |
|
486 |
0, 0, true)) { |
|
487 |
n_completed_buffers++; |
|
488 |
} |
|
489 |
assert(n_completed_buffers == into_cset_n_buffers, "missed some buffers"); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
490 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
491 |
} |
6247 | 492 |
|
493 |
// Free any completed buffers in the DirtyCardQueueSet used to hold cards |
|
494 |
// which contain references that point into the collection. |
|
495 |
_g1->into_cset_dirty_card_queue_set().clear(); |
|
496 |
assert(_g1->into_cset_dirty_card_queue_set().completed_buffers_num() == 0, |
|
497 |
"all buffers should be freed"); |
|
498 |
_g1->into_cset_dirty_card_queue_set().clear_n_completed_buffers(); |
|
1374 | 499 |
} |
500 |
||
501 |
class ScrubRSClosure: public HeapRegionClosure { |
|
502 |
G1CollectedHeap* _g1h; |
|
503 |
BitMap* _region_bm; |
|
504 |
BitMap* _card_bm; |
|
505 |
CardTableModRefBS* _ctbs; |
|
506 |
public: |
|
507 |
ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) : |
|
508 |
_g1h(G1CollectedHeap::heap()), |
|
509 |
_region_bm(region_bm), _card_bm(card_bm), |
|
20309 | 510 |
_ctbs(_g1h->g1_barrier_set()) {} |
1374 | 511 |
|
512 |
bool doHeapRegion(HeapRegion* r) { |
|
513 |
if (!r->continuesHumongous()) { |
|
514 |
r->rem_set()->scrub(_ctbs, _region_bm, _card_bm); |
|
515 |
} |
|
516 |
return false; |
|
517 |
} |
|
518 |
}; |
|
519 |
||
6958 | 520 |
void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) { |
1374 | 521 |
ScrubRSClosure scrub_cl(region_bm, card_bm); |
522 |
_g1->heap_region_iterate(&scrub_cl); |
|
523 |
} |
|
524 |
||
6958 | 525 |
void G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm, |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11176
diff
changeset
|
526 |
uint worker_num, int claim_val) { |
1374 | 527 |
ScrubRSClosure scrub_cl(region_bm, card_bm); |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
528 |
_g1->heap_region_par_iterate_chunked(&scrub_cl, |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
529 |
worker_num, |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11176
diff
changeset
|
530 |
n_workers(), |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
531 |
claim_val); |
1374 | 532 |
} |
533 |
||
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
534 |
G1TriggerClosure::G1TriggerClosure() : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
535 |
_triggered(false) { } |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
536 |
|
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
537 |
G1InvokeIfNotTriggeredClosure::G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t_cl, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
538 |
OopClosure* oop_cl) : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
539 |
_trigger_cl(t_cl), _oop_cl(oop_cl) { } |
6247 | 540 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
541 |
G1Mux2Closure::G1Mux2Closure(OopClosure *c1, OopClosure *c2) : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
542 |
_c1(c1), _c2(c2) { } |
6247 | 543 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
544 |
G1UpdateRSOrPushRefOopClosure:: |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
545 |
G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
546 |
G1RemSet* rs, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
547 |
OopsInHeapRegionClosure* push_ref_cl, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
548 |
bool record_refs_into_cset, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
549 |
int worker_i) : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
550 |
_g1(g1h), _g1_rem_set(rs), _from(NULL), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
551 |
_record_refs_into_cset(record_refs_into_cset), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
552 |
_push_ref_cl(push_ref_cl), _worker_i(worker_i) { } |
6247 | 553 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
554 |
// Returns true if the given card contains references that point |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
555 |
// into the collection set, if we're checking for such references; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
556 |
// false otherwise. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
557 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
558 |
bool G1RemSet::refine_card(jbyte* card_ptr, int worker_i, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
559 |
bool check_for_refs_into_cset) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
560 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
561 |
// If the card is no longer dirty, nothing to do. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
562 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
563 |
// No need to return that this card contains refs that point |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
564 |
// into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
565 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
566 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
567 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
568 |
// Construct the region representing the card. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
569 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
570 |
// And find the region containing it. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
571 |
HeapRegion* r = _g1->heap_region_containing(start); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
572 |
if (r == NULL) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
573 |
// Again no need to return that this card contains refs that |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
574 |
// point into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
575 |
return false; // Not in the G1 heap (might be in perm, for example.) |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
576 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
577 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
578 |
// Why do we have to check here whether a card is on a young region, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
579 |
// given that we dirty young regions and, as a result, the |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
580 |
// post-barrier is supposed to filter them out and never to enqueue |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
581 |
// them? When we allocate a new region as the "allocation region" we |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
582 |
// actually dirty its cards after we release the lock, since card |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
583 |
// dirtying while holding the lock was a performance bottleneck. So, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
584 |
// as a result, it is possible for other threads to actually |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
585 |
// allocate objects in the region (after the acquire the lock) |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
586 |
// before all the cards on the region are dirtied. This is unlikely, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
587 |
// and it doesn't happen often, but it can happen. So, the extra |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
588 |
// check below filters out those cards. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
589 |
if (r->is_young()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
590 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
591 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
592 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
593 |
// While we are processing RSet buffers during the collection, we |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
594 |
// actually don't want to scan any cards on the collection set, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
595 |
// since we don't want to update remebered sets with entries that |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
596 |
// point into the collection set, given that live objects from the |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
597 |
// collection set are about to move and such entries will be stale |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
598 |
// very soon. This change also deals with a reliability issue which |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
599 |
// involves scanning a card in the collection set and coming across |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
600 |
// an array that was being chunked and looking malformed. Note, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
601 |
// however, that if evacuation fails, we have to scan any objects |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
602 |
// that were not moved and create any missing entries. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
603 |
if (r->in_collection_set()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
604 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
605 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
606 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
607 |
// The result from the hot card cache insert call is either: |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
608 |
// * pointer to the current card |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
609 |
// (implying that the current card is not 'hot'), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
610 |
// * null |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
611 |
// (meaning we had inserted the card ptr into the "hot" card cache, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
612 |
// which had some headroom), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
613 |
// * a pointer to a "hot" card that was evicted from the "hot" cache. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
614 |
// |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
615 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
616 |
G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
617 |
if (hot_card_cache->use_cache()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
618 |
assert(!check_for_refs_into_cset, "sanity"); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
619 |
assert(!SafepointSynchronize::is_at_safepoint(), "sanity"); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
620 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
621 |
card_ptr = hot_card_cache->insert(card_ptr); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
622 |
if (card_ptr == NULL) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
623 |
// There was no eviction. Nothing to do. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
624 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
625 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
626 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
627 |
start = _ct_bs->addr_for(card_ptr); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
628 |
r = _g1->heap_region_containing(start); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
629 |
if (r == NULL) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
630 |
// Not in the G1 heap |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
631 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
632 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
633 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
634 |
// Checking whether the region we got back from the cache |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
635 |
// is young here is inappropriate. The region could have been |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
636 |
// freed, reallocated and tagged as young while in the cache. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
637 |
// Hence we could see its young type change at any time. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
638 |
} |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
639 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
640 |
// Don't use addr_for(card_ptr + 1) which can ask for |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
641 |
// a card beyond the heap. This is not safe without a perm |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
642 |
// gen at the upper end of the heap. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
643 |
HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
644 |
MemRegion dirtyRegion(start, end); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
645 |
|
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
646 |
#if CARD_REPEAT_HISTO |
8103
65eafe3fb3c7
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
7397
diff
changeset
|
647 |
init_ct_freq_table(_g1->max_capacity()); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
648 |
ct_freq_note_card(_ct_bs->index_for(start)); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
649 |
#endif |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
650 |
|
10995
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
651 |
OopsInHeapRegionClosure* oops_in_heap_closure = NULL; |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
652 |
if (check_for_refs_into_cset) { |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
653 |
// ConcurrentG1RefineThreads have worker numbers larger than what |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
654 |
// _cset_rs_update_cl[] is set up to handle. But those threads should |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
655 |
// only be active outside of a collection which means that when they |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
656 |
// reach here they should have check_for_refs_into_cset == false. |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
657 |
assert((size_t)worker_i < n_workers(), "index of worker larger than _cset_rs_update_cl[].length"); |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
658 |
oops_in_heap_closure = _cset_rs_update_cl[worker_i]; |
b3b2d17ff45d
7106751: G1: gc/gctests/nativeGC03 crashes VM with SIGSEGV
brutisso
parents:
10770
diff
changeset
|
659 |
} |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
660 |
G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
661 |
_g1->g1_rem_set(), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
662 |
oops_in_heap_closure, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
663 |
check_for_refs_into_cset, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
664 |
worker_i); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
665 |
update_rs_oop_cl.set_from(r); |
6247 | 666 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
667 |
G1TriggerClosure trigger_cl; |
10674
09e6f8d20337
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
10670
diff
changeset
|
668 |
FilterIntoCSClosure into_cs_cl(NULL, _g1, &trigger_cl); |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
669 |
G1InvokeIfNotTriggeredClosure invoke_cl(&trigger_cl, &into_cs_cl); |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
670 |
G1Mux2Closure mux(&invoke_cl, &update_rs_oop_cl); |
6247 | 671 |
|
672 |
FilterOutOfRegionClosure filter_then_update_rs_oop_cl(r, |
|
673 |
(check_for_refs_into_cset ? |
|
674 |
(OopClosure*)&mux : |
|
675 |
(OopClosure*)&update_rs_oop_cl)); |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
676 |
|
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
677 |
// The region for the current card may be a young region. The |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
678 |
// current card may have been a card that was evicted from the |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
679 |
// card cache. When the card was inserted into the cache, we had |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
680 |
// determined that its region was non-young. While in the cache, |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
681 |
// the region may have been freed during a cleanup pause, reallocated |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
682 |
// and tagged as young. |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
683 |
// |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
684 |
// We wish to filter out cards for such a region but the current |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
685 |
// thread, if we're running concurrently, may "see" the young type |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
686 |
// change at any time (so an earlier "is_young" check may pass or |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
687 |
// fail arbitrarily). We tell the iteration code to perform this |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
688 |
// filtering when it has been determined that there has been an actual |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
689 |
// allocation in this region and making it safe to check the young type. |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
690 |
bool filter_young = true; |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
691 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
692 |
HeapWord* stop_point = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
693 |
r->oops_on_card_seq_iterate_careful(dirtyRegion, |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
694 |
&filter_then_update_rs_oop_cl, |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
695 |
filter_young, |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
696 |
card_ptr); |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
697 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
698 |
// If stop_point is non-null, then we encountered an unallocated region |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
699 |
// (perhaps the unfilled portion of a TLAB.) For now, we'll dirty the |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
700 |
// card and re-enqueue: if we put off the card until a GC pause, then the |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
701 |
// unallocated portion will be filled in. Alternatively, we might try |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
702 |
// the full complexity of the technique used in "regular" precleaning. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
703 |
if (stop_point != NULL) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
704 |
// The card might have gotten re-dirtied and re-enqueued while we |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
705 |
// worked. (In fact, it's pretty likely.) |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
706 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
707 |
*card_ptr = CardTableModRefBS::dirty_card_val(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
708 |
MutexLockerEx x(Shared_DirtyCardQ_lock, |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
709 |
Mutex::_no_safepoint_check_flag); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
710 |
DirtyCardQueue* sdcq = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
711 |
JavaThread::dirty_card_queue_set().shared_dirty_card_queue(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
712 |
sdcq->enqueue(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
713 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
714 |
} else { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
715 |
_conc_refine_cards++; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
716 |
} |
6247 | 717 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
718 |
// This gets set to true if the card being refined has |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
719 |
// references that point into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
720 |
bool has_refs_into_cset = trigger_cl.triggered(); |
1374 | 721 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
722 |
// We should only be detecting that the card contains references |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
723 |
// that point into the collection set if the current thread is |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
724 |
// a GC worker thread. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
725 |
assert(!has_refs_into_cset || SafepointSynchronize::is_at_safepoint(), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
726 |
"invalid result at non safepoint"); |
6247 | 727 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
728 |
return has_refs_into_cset; |
1374 | 729 |
} |
730 |
||
20305
af013cf4a5e6
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
19339
diff
changeset
|
731 |
void G1RemSet::print_periodic_summary_info(const char* header) { |
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
732 |
G1RemSetSummary current; |
20310
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
733 |
current.initialize(this); |
1374 | 734 |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
735 |
_prev_period_summary.subtract_from(¤t); |
20305
af013cf4a5e6
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
19339
diff
changeset
|
736 |
print_summary_info(&_prev_period_summary, header); |
1374 | 737 |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
738 |
_prev_period_summary.set(¤t); |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
739 |
} |
2881 | 740 |
|
6958 | 741 |
void G1RemSet::print_summary_info() { |
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
742 |
G1RemSetSummary current; |
20310
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
743 |
current.initialize(this); |
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
744 |
|
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
745 |
print_summary_info(¤t, " Cumulative RS summary"); |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
746 |
} |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
747 |
|
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
748 |
void G1RemSet::print_summary_info(G1RemSetSummary * summary, const char * header) { |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
749 |
assert(summary != NULL, "just checking"); |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
750 |
|
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
751 |
if (header != NULL) { |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
752 |
gclog_or_tty->print_cr("%s", header); |
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
753 |
} |
1374 | 754 |
|
755 |
#if CARD_REPEAT_HISTO |
|
756 |
gclog_or_tty->print_cr("\nG1 card_repeat count histogram: "); |
|
757 |
gclog_or_tty->print_cr(" # of repeats --> # of cards with that number."); |
|
758 |
card_repeat_count.print_on(gclog_or_tty); |
|
759 |
#endif |
|
760 |
||
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
761 |
summary->print_on(gclog_or_tty); |
1374 | 762 |
} |
6247 | 763 |
|
6958 | 764 |
void G1RemSet::prepare_for_verify() { |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
765 |
if (G1HRRSFlushLogBuffersOnVerify && |
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
766 |
(VerifyBeforeGC || VerifyAfterGC) |
17855
9d0719d7bb85
8015244: G1: Verification after a full GC is incorrectly placed.
johnc
parents:
17854
diff
changeset
|
767 |
&& (!_g1->full_collection() || G1VerifyRSetsDuringFullGC)) { |
1374 | 768 |
cleanupHRRS(); |
769 |
_g1->set_refine_cte_cl_concurrency(false); |
|
770 |
if (SafepointSynchronize::is_at_safepoint()) { |
|
771 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
772 |
dcqs.concatenate_logs(); |
|
773 |
} |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
774 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
775 |
G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
776 |
bool use_hot_card_cache = hot_card_cache->use_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
777 |
hot_card_cache->set_use_cache(false); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
778 |
|
6247 | 779 |
DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); |
780 |
updateRS(&into_cset_dcq, 0); |
|
781 |
_g1->into_cset_dirty_card_queue_set().clear(); |
|
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
782 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
783 |
hot_card_cache->set_use_cache(use_hot_card_cache); |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
784 |
assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
1374 | 785 |
} |
786 |
} |