author | iveresov |
Thu, 11 Feb 2010 15:52:19 -0800 | |
changeset 4902 | 991aaddb5165 |
parent 3590 | a268fa66d7fb |
child 5033 | 55f476a32544 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
2105 | 2 |
* Copyright 2001-2009 Sun Microsystems, Inc. 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 |
* |
|
19 |
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 |
* have any questions. |
|
22 |
* |
|
23 |
*/ |
|
24 |
||
25 |
#include "incls/_precompiled.incl" |
|
26 |
#include "incls/_g1RemSet.cpp.incl" |
|
27 |
||
28 |
#define CARD_REPEAT_HISTO 0 |
|
29 |
||
30 |
#if CARD_REPEAT_HISTO |
|
31 |
static size_t ct_freq_sz; |
|
32 |
static jbyte* ct_freq = NULL; |
|
33 |
||
34 |
void init_ct_freq_table(size_t heap_sz_bytes) { |
|
35 |
if (ct_freq == NULL) { |
|
36 |
ct_freq_sz = heap_sz_bytes/CardTableModRefBS::card_size; |
|
37 |
ct_freq = new jbyte[ct_freq_sz]; |
|
38 |
for (size_t j = 0; j < ct_freq_sz; j++) ct_freq[j] = 0; |
|
39 |
} |
|
40 |
} |
|
41 |
||
42 |
void ct_freq_note_card(size_t index) { |
|
43 |
assert(0 <= index && index < ct_freq_sz, "Bounds error."); |
|
44 |
if (ct_freq[index] < 100) { ct_freq[index]++; } |
|
45 |
} |
|
46 |
||
47 |
static IntHistogram card_repeat_count(10, 10); |
|
48 |
||
49 |
void ct_freq_update_histo_and_reset() { |
|
50 |
for (size_t j = 0; j < ct_freq_sz; j++) { |
|
51 |
card_repeat_count.add_entry(ct_freq[j]); |
|
52 |
ct_freq[j] = 0; |
|
53 |
} |
|
54 |
||
55 |
} |
|
56 |
#endif |
|
57 |
||
58 |
||
59 |
class IntoCSOopClosure: public OopsInHeapRegionClosure { |
|
60 |
OopsInHeapRegionClosure* _blk; |
|
61 |
G1CollectedHeap* _g1; |
|
62 |
public: |
|
63 |
IntoCSOopClosure(G1CollectedHeap* g1, OopsInHeapRegionClosure* blk) : |
|
64 |
_g1(g1), _blk(blk) {} |
|
65 |
void set_region(HeapRegion* from) { |
|
66 |
_blk->set_region(from); |
|
67 |
} |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
68 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
69 |
virtual void do_oop( oop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
70 |
template <class T> void do_oop_work(T* p) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
71 |
oop obj = oopDesc::load_decode_heap_oop(p); |
1374 | 72 |
if (_g1->obj_in_cs(obj)) _blk->do_oop(p); |
73 |
} |
|
74 |
bool apply_to_weak_ref_discovered_field() { return true; } |
|
75 |
bool idempotent() { return true; } |
|
76 |
}; |
|
77 |
||
78 |
class IntoCSRegionClosure: public HeapRegionClosure { |
|
79 |
IntoCSOopClosure _blk; |
|
80 |
G1CollectedHeap* _g1; |
|
81 |
public: |
|
82 |
IntoCSRegionClosure(G1CollectedHeap* g1, OopsInHeapRegionClosure* blk) : |
|
83 |
_g1(g1), _blk(g1, blk) {} |
|
84 |
bool doHeapRegion(HeapRegion* r) { |
|
85 |
if (!r->in_collection_set()) { |
|
86 |
_blk.set_region(r); |
|
87 |
if (r->isHumongous()) { |
|
88 |
if (r->startsHumongous()) { |
|
89 |
oop obj = oop(r->bottom()); |
|
90 |
obj->oop_iterate(&_blk); |
|
91 |
} |
|
92 |
} else { |
|
93 |
r->oop_before_save_marks_iterate(&_blk); |
|
94 |
} |
|
95 |
} |
|
96 |
return false; |
|
97 |
} |
|
98 |
}; |
|
99 |
||
100 |
void |
|
101 |
StupidG1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, |
|
102 |
int worker_i) { |
|
103 |
IntoCSRegionClosure rc(_g1, oc); |
|
104 |
_g1->heap_region_iterate(&rc); |
|
105 |
} |
|
106 |
||
107 |
class VerifyRSCleanCardOopClosure: public OopClosure { |
|
108 |
G1CollectedHeap* _g1; |
|
109 |
public: |
|
110 |
VerifyRSCleanCardOopClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
111 |
||
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
112 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
113 |
virtual void do_oop( oop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
114 |
template <class T> void do_oop_work(T* p) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
115 |
oop obj = oopDesc::load_decode_heap_oop(p); |
1374 | 116 |
HeapRegion* to = _g1->heap_region_containing(obj); |
117 |
guarantee(to == NULL || !to->in_collection_set(), |
|
118 |
"Missed a rem set member."); |
|
119 |
} |
|
120 |
}; |
|
121 |
||
122 |
HRInto_G1RemSet::HRInto_G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) |
|
123 |
: G1RemSet(g1), _ct_bs(ct_bs), _g1p(_g1->g1_policy()), |
|
124 |
_cg1r(g1->concurrent_g1_refine()), |
|
125 |
_par_traversal_in_progress(false), _new_refs(NULL), |
|
126 |
_cards_scanned(NULL), _total_cards_scanned(0) |
|
127 |
{ |
|
128 |
_seq_task = new SubTasksDone(NumSeqTasks); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
129 |
guarantee(n_workers() > 0, "There should be some workers"); |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
130 |
_new_refs = NEW_C_HEAP_ARRAY(GrowableArray<OopOrNarrowOopStar>*, n_workers()); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
131 |
for (uint i = 0; i < n_workers(); i++) { |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
132 |
_new_refs[i] = new (ResourceObj::C_HEAP) GrowableArray<OopOrNarrowOopStar>(8192,true); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
133 |
} |
1374 | 134 |
} |
135 |
||
136 |
HRInto_G1RemSet::~HRInto_G1RemSet() { |
|
137 |
delete _seq_task; |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
138 |
for (uint i = 0; i < n_workers(); i++) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
139 |
delete _new_refs[i]; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
140 |
} |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
141 |
FREE_C_HEAP_ARRAY(GrowableArray<OopOrNarrowOopStar>*, _new_refs); |
1374 | 142 |
} |
143 |
||
144 |
void CountNonCleanMemRegionClosure::do_MemRegion(MemRegion mr) { |
|
145 |
if (_g1->is_in_g1_reserved(mr.start())) { |
|
146 |
_n += (int) ((mr.byte_size() / CardTableModRefBS::card_size)); |
|
147 |
if (_start_first == NULL) _start_first = mr.start(); |
|
148 |
} |
|
149 |
} |
|
150 |
||
151 |
class ScanRSClosure : public HeapRegionClosure { |
|
152 |
size_t _cards_done, _cards; |
|
153 |
G1CollectedHeap* _g1h; |
|
154 |
OopsInHeapRegionClosure* _oc; |
|
155 |
G1BlockOffsetSharedArray* _bot_shared; |
|
156 |
CardTableModRefBS *_ct_bs; |
|
157 |
int _worker_i; |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
158 |
int _block_size; |
1374 | 159 |
bool _try_claimed; |
160 |
public: |
|
161 |
ScanRSClosure(OopsInHeapRegionClosure* oc, int worker_i) : |
|
162 |
_oc(oc), |
|
163 |
_cards(0), |
|
164 |
_cards_done(0), |
|
165 |
_worker_i(worker_i), |
|
166 |
_try_claimed(false) |
|
167 |
{ |
|
168 |
_g1h = G1CollectedHeap::heap(); |
|
169 |
_bot_shared = _g1h->bot_shared(); |
|
170 |
_ct_bs = (CardTableModRefBS*) (_g1h->barrier_set()); |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
171 |
_block_size = MAX2<int>(G1RSetScanBlockSize, 1); |
1374 | 172 |
} |
173 |
||
174 |
void set_try_claimed() { _try_claimed = true; } |
|
175 |
||
176 |
void scanCard(size_t index, HeapRegion *r) { |
|
177 |
_cards_done++; |
|
178 |
DirtyCardToOopClosure* cl = |
|
179 |
r->new_dcto_closure(_oc, |
|
180 |
CardTableModRefBS::Precise, |
|
181 |
HeapRegionDCTOC::IntoCSFilterKind); |
|
182 |
||
183 |
// Set the "from" region in the closure. |
|
184 |
_oc->set_region(r); |
|
185 |
HeapWord* card_start = _bot_shared->address_for_index(index); |
|
186 |
HeapWord* card_end = card_start + G1BlockOffsetSharedArray::N_words; |
|
187 |
Space *sp = SharedHeap::heap()->space_containing(card_start); |
|
188 |
MemRegion sm_region; |
|
189 |
if (ParallelGCThreads > 0) { |
|
190 |
// first find the used area |
|
191 |
sm_region = sp->used_region_at_save_marks(); |
|
192 |
} else { |
|
193 |
// The closure is not idempotent. We shouldn't look at objects |
|
194 |
// allocated during the GC. |
|
195 |
sm_region = sp->used_region_at_save_marks(); |
|
196 |
} |
|
197 |
MemRegion mr = sm_region.intersection(MemRegion(card_start,card_end)); |
|
198 |
if (!mr.is_empty()) { |
|
199 |
cl->do_MemRegion(mr); |
|
200 |
} |
|
201 |
} |
|
202 |
||
203 |
void printCard(HeapRegion* card_region, size_t card_index, |
|
204 |
HeapWord* card_start) { |
|
205 |
gclog_or_tty->print_cr("T %d Region [" PTR_FORMAT ", " PTR_FORMAT ") " |
|
206 |
"RS names card %p: " |
|
207 |
"[" PTR_FORMAT ", " PTR_FORMAT ")", |
|
208 |
_worker_i, |
|
209 |
card_region->bottom(), card_region->end(), |
|
210 |
card_index, |
|
211 |
card_start, card_start + G1BlockOffsetSharedArray::N_words); |
|
212 |
} |
|
213 |
||
214 |
bool doHeapRegion(HeapRegion* r) { |
|
215 |
assert(r->in_collection_set(), "should only be called on elements of CS."); |
|
216 |
HeapRegionRemSet* hrrs = r->rem_set(); |
|
217 |
if (hrrs->iter_is_complete()) return false; // All done. |
|
218 |
if (!_try_claimed && !hrrs->claim_iter()) return false; |
|
2883
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
219 |
_g1h->push_dirty_cards_region(r); |
1374 | 220 |
// If we didn't return above, then |
221 |
// _try_claimed || r->claim_iter() |
|
222 |
// is true: either we're supposed to work on claimed-but-not-complete |
|
223 |
// regions, or we successfully claimed the region. |
|
224 |
HeapRegionRemSetIterator* iter = _g1h->rem_set_iterator(_worker_i); |
|
225 |
hrrs->init_iterator(iter); |
|
226 |
size_t card_index; |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
227 |
|
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
228 |
// 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
|
229 |
// the G1RSetScanBlockSize parameter. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
230 |
size_t jump_to_card = hrrs->iter_claimed_next(_block_size); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
231 |
for (size_t current_card = 0; iter->has_next(card_index); current_card++) { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
232 |
if (current_card >= jump_to_card + _block_size) { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
233 |
jump_to_card = hrrs->iter_claimed_next(_block_size); |
2737 | 234 |
} |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
235 |
if (current_card < jump_to_card) continue; |
1374 | 236 |
HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index); |
237 |
#if 0 |
|
238 |
gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n", |
|
239 |
card_start, card_start + CardTableModRefBS::card_size_in_words); |
|
240 |
#endif |
|
241 |
||
242 |
HeapRegion* card_region = _g1h->heap_region_containing(card_start); |
|
243 |
assert(card_region != NULL, "Yielding cards not in the heap?"); |
|
244 |
_cards++; |
|
245 |
||
2883
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
246 |
if (!card_region->is_on_dirty_cards_region_list()) { |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
247 |
_g1h->push_dirty_cards_region(card_region); |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
248 |
} |
406d1e6d1aa1
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
2881
diff
changeset
|
249 |
|
2737 | 250 |
// If the card is dirty, then we will scan it during updateRS. |
251 |
if (!card_region->in_collection_set() && !_ct_bs->is_card_dirty(card_index)) { |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
252 |
// We make the card as "claimed" lazily (so races are possible but they're benign), |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
253 |
// which reduces the number of duplicate scans (the rsets of the regions in the cset |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
254 |
// can intersect). |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
255 |
if (!_ct_bs->is_card_claimed(card_index)) { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
256 |
_ct_bs->set_card_claimed(card_index); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
257 |
scanCard(card_index, card_region); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
258 |
} |
1374 | 259 |
} |
260 |
} |
|
2737 | 261 |
if (!_try_claimed) { |
262 |
hrrs->set_iter_complete(); |
|
263 |
} |
|
1374 | 264 |
return false; |
265 |
} |
|
266 |
// Set all cards back to clean. |
|
267 |
void cleanup() {_g1h->cleanUpCardTable();} |
|
268 |
size_t cards_done() { return _cards_done;} |
|
269 |
size_t cards_looked_up() { return _cards;} |
|
270 |
}; |
|
271 |
||
272 |
// We want the parallel threads to start their scanning at |
|
273 |
// different collection set regions to avoid contention. |
|
274 |
// If we have: |
|
275 |
// n collection set regions |
|
276 |
// p threads |
|
277 |
// Then thread t will start at region t * floor (n/p) |
|
278 |
||
279 |
HeapRegion* HRInto_G1RemSet::calculateStartRegion(int worker_i) { |
|
280 |
HeapRegion* result = _g1p->collection_set(); |
|
281 |
if (ParallelGCThreads > 0) { |
|
282 |
size_t cs_size = _g1p->collection_set_size(); |
|
283 |
int n_workers = _g1->workers()->total_workers(); |
|
284 |
size_t cs_spans = cs_size / n_workers; |
|
285 |
size_t ind = cs_spans * worker_i; |
|
286 |
for (size_t i = 0; i < ind; i++) |
|
287 |
result = result->next_in_collection_set(); |
|
288 |
} |
|
289 |
return result; |
|
290 |
} |
|
291 |
||
292 |
void HRInto_G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) { |
|
293 |
double rs_time_start = os::elapsedTime(); |
|
294 |
HeapRegion *startRegion = calculateStartRegion(worker_i); |
|
295 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
296 |
ScanRSClosure scanRScl(oc, worker_i); |
1374 | 297 |
_g1->collection_set_iterate_from(startRegion, &scanRScl); |
298 |
scanRScl.set_try_claimed(); |
|
299 |
_g1->collection_set_iterate_from(startRegion, &scanRScl); |
|
300 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
301 |
double scan_rs_time_sec = os::elapsedTime() - rs_time_start; |
1374 | 302 |
|
303 |
assert( _cards_scanned != NULL, "invariant" ); |
|
304 |
_cards_scanned[worker_i] = scanRScl.cards_done(); |
|
305 |
||
306 |
_g1p->record_scan_rs_start_time(worker_i, rs_time_start * 1000.0); |
|
307 |
_g1p->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); |
|
308 |
} |
|
309 |
||
310 |
void HRInto_G1RemSet::updateRS(int worker_i) { |
|
311 |
ConcurrentG1Refine* cg1r = _g1->concurrent_g1_refine(); |
|
312 |
||
313 |
double start = os::elapsedTime(); |
|
314 |
_g1p->record_update_rs_start_time(worker_i, start * 1000.0); |
|
315 |
||
2881 | 316 |
// Apply the appropriate closure to all remaining log entries. |
317 |
_g1->iterate_dirty_card_closure(false, worker_i); |
|
318 |
// Now there should be no dirty cards. |
|
319 |
if (G1RSLogCheckCardTable) { |
|
320 |
CountNonCleanMemRegionClosure cl(_g1); |
|
321 |
_ct_bs->mod_card_iterate(&cl); |
|
322 |
// XXX This isn't true any more: keeping cards of young regions |
|
323 |
// marked dirty broke it. Need some reasonable fix. |
|
324 |
guarantee(cl.n() == 0, "Card table should be clean."); |
|
1374 | 325 |
} |
2881 | 326 |
|
1374 | 327 |
_g1p->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); |
328 |
} |
|
329 |
||
330 |
#ifndef PRODUCT |
|
331 |
class PrintRSClosure : public HeapRegionClosure { |
|
332 |
int _count; |
|
333 |
public: |
|
334 |
PrintRSClosure() : _count(0) {} |
|
335 |
bool doHeapRegion(HeapRegion* r) { |
|
336 |
HeapRegionRemSet* hrrs = r->rem_set(); |
|
337 |
_count += (int) hrrs->occupied(); |
|
338 |
if (hrrs->occupied() == 0) { |
|
339 |
gclog_or_tty->print("Heap Region [" PTR_FORMAT ", " PTR_FORMAT ") " |
|
340 |
"has no remset entries\n", |
|
341 |
r->bottom(), r->end()); |
|
342 |
} else { |
|
343 |
gclog_or_tty->print("Printing rem set for heap region [" PTR_FORMAT ", " PTR_FORMAT ")\n", |
|
344 |
r->bottom(), r->end()); |
|
345 |
r->print(); |
|
346 |
hrrs->print(); |
|
347 |
gclog_or_tty->print("\nDone printing rem set\n"); |
|
348 |
} |
|
349 |
return false; |
|
350 |
} |
|
351 |
int occupied() {return _count;} |
|
352 |
}; |
|
353 |
#endif |
|
354 |
||
355 |
class CountRSSizeClosure: public HeapRegionClosure { |
|
356 |
size_t _n; |
|
357 |
size_t _tot; |
|
358 |
size_t _max; |
|
359 |
HeapRegion* _max_r; |
|
360 |
enum { |
|
361 |
N = 20, |
|
362 |
MIN = 6 |
|
363 |
}; |
|
364 |
int _histo[N]; |
|
365 |
public: |
|
366 |
CountRSSizeClosure() : _n(0), _tot(0), _max(0), _max_r(NULL) { |
|
367 |
for (int i = 0; i < N; i++) _histo[i] = 0; |
|
368 |
} |
|
369 |
bool doHeapRegion(HeapRegion* r) { |
|
370 |
if (!r->continuesHumongous()) { |
|
371 |
size_t occ = r->rem_set()->occupied(); |
|
372 |
_n++; |
|
373 |
_tot += occ; |
|
374 |
if (occ > _max) { |
|
375 |
_max = occ; |
|
376 |
_max_r = r; |
|
377 |
} |
|
378 |
// Fit it into a histo bin. |
|
379 |
int s = 1 << MIN; |
|
380 |
int i = 0; |
|
381 |
while (occ > (size_t) s && i < (N-1)) { |
|
382 |
s = s << 1; |
|
383 |
i++; |
|
384 |
} |
|
385 |
_histo[i]++; |
|
386 |
} |
|
387 |
return false; |
|
388 |
} |
|
389 |
size_t n() { return _n; } |
|
390 |
size_t tot() { return _tot; } |
|
391 |
size_t mx() { return _max; } |
|
392 |
HeapRegion* mxr() { return _max_r; } |
|
393 |
void print_histo() { |
|
394 |
int mx = N; |
|
395 |
while (mx >= 0) { |
|
396 |
if (_histo[mx-1] > 0) break; |
|
397 |
mx--; |
|
398 |
} |
|
399 |
gclog_or_tty->print_cr("Number of regions with given RS sizes:"); |
|
400 |
gclog_or_tty->print_cr(" <= %8d %8d", 1 << MIN, _histo[0]); |
|
401 |
for (int i = 1; i < mx-1; i++) { |
|
402 |
gclog_or_tty->print_cr(" %8d - %8d %8d", |
|
403 |
(1 << (MIN + i - 1)) + 1, |
|
404 |
1 << (MIN + i), |
|
405 |
_histo[i]); |
|
406 |
} |
|
407 |
gclog_or_tty->print_cr(" > %8d %8d", (1 << (MIN+mx-2))+1, _histo[mx-1]); |
|
408 |
} |
|
409 |
}; |
|
410 |
||
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
411 |
template <class T> void |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
412 |
HRInto_G1RemSet::scanNewRefsRS_work(OopsInHeapRegionClosure* oc, |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
413 |
int worker_i) { |
1374 | 414 |
double scan_new_refs_start_sec = os::elapsedTime(); |
415 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
416 |
CardTableModRefBS* ct_bs = (CardTableModRefBS*) (g1h->barrier_set()); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
417 |
for (int i = 0; i < _new_refs[worker_i]->length(); i++) { |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
418 |
T* p = (T*) _new_refs[worker_i]->at(i); |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
419 |
oop obj = oopDesc::load_decode_heap_oop(p); |
1374 | 420 |
// *p was in the collection set when p was pushed on "_new_refs", but |
421 |
// another thread may have processed this location from an RS, so it |
|
422 |
// might not point into the CS any longer. If so, it's obviously been |
|
423 |
// processed, and we don't need to do anything further. |
|
424 |
if (g1h->obj_in_cs(obj)) { |
|
425 |
HeapRegion* r = g1h->heap_region_containing(p); |
|
426 |
||
427 |
DEBUG_ONLY(HeapRegion* to = g1h->heap_region_containing(obj)); |
|
428 |
oc->set_region(r); |
|
429 |
// If "p" has already been processed concurrently, this is |
|
430 |
// idempotent. |
|
431 |
oc->do_oop(p); |
|
432 |
} |
|
433 |
} |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
434 |
double scan_new_refs_time_ms = (os::elapsedTime() - scan_new_refs_start_sec) * 1000.0; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3590
diff
changeset
|
435 |
_g1p->record_scan_new_refs_time(worker_i, scan_new_refs_time_ms); |
1374 | 436 |
} |
437 |
||
438 |
void HRInto_G1RemSet::cleanupHRRS() { |
|
439 |
HeapRegionRemSet::cleanup(); |
|
440 |
} |
|
441 |
||
442 |
void |
|
443 |
HRInto_G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, |
|
444 |
int worker_i) { |
|
445 |
#if CARD_REPEAT_HISTO |
|
446 |
ct_freq_update_histo_and_reset(); |
|
447 |
#endif |
|
448 |
if (worker_i == 0) { |
|
449 |
_cg1r->clear_and_record_card_counts(); |
|
450 |
} |
|
451 |
||
452 |
// Make this into a command-line flag... |
|
453 |
if (G1RSCountHisto && (ParallelGCThreads == 0 || worker_i == 0)) { |
|
454 |
CountRSSizeClosure count_cl; |
|
455 |
_g1->heap_region_iterate(&count_cl); |
|
456 |
gclog_or_tty->print_cr("Avg of %d RS counts is %f, max is %d, " |
|
457 |
"max region is " PTR_FORMAT, |
|
458 |
count_cl.n(), (float)count_cl.tot()/(float)count_cl.n(), |
|
459 |
count_cl.mx(), count_cl.mxr()); |
|
460 |
count_cl.print_histo(); |
|
461 |
} |
|
462 |
||
463 |
if (ParallelGCThreads > 0) { |
|
2250
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
464 |
// The two flags below were introduced temporarily to serialize |
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
465 |
// the updating and scanning of remembered sets. There are some |
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
466 |
// race conditions when these two operations are done in parallel |
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
467 |
// and they are causing failures. When we resolve said race |
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
468 |
// conditions, we'll revert back to parallel remembered set |
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
469 |
// updating and scanning. See CRs 6677707 and 6677708. |
2741 | 470 |
if (G1ParallelRSetUpdatingEnabled || (worker_i == 0)) { |
1374 | 471 |
updateRS(worker_i); |
472 |
scanNewRefsRS(oc, worker_i); |
|
2260
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
473 |
} else { |
2881 | 474 |
_g1p->record_update_rs_start_time(worker_i, os::elapsedTime() * 1000.0); |
2260
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
475 |
_g1p->record_update_rs_processed_buffers(worker_i, 0.0); |
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
476 |
_g1p->record_update_rs_time(worker_i, 0.0); |
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
477 |
_g1p->record_scan_new_refs_time(worker_i, 0.0); |
2250
36d1eb1bb075
6816154: G1: introduce flags to enable/disable RSet updating and scanning
tonyp
parents:
2249
diff
changeset
|
478 |
} |
2741 | 479 |
if (G1ParallelRSetScanningEnabled || (worker_i == 0)) { |
1374 | 480 |
scanRS(oc, worker_i); |
2260
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
481 |
} else { |
2881 | 482 |
_g1p->record_scan_rs_start_time(worker_i, os::elapsedTime() * 1000.0); |
2260
219013f6a311
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
2252
diff
changeset
|
483 |
_g1p->record_scan_rs_time(worker_i, 0.0); |
1374 | 484 |
} |
485 |
} else { |
|
486 |
assert(worker_i == 0, "invariant"); |
|
487 |
updateRS(0); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
488 |
scanNewRefsRS(oc, 0); |
1374 | 489 |
scanRS(oc, 0); |
490 |
} |
|
491 |
} |
|
492 |
||
493 |
void HRInto_G1RemSet:: |
|
494 |
prepare_for_oops_into_collection_set_do() { |
|
495 |
#if G1_REM_SET_LOGGING |
|
496 |
PrintRSClosure cl; |
|
497 |
_g1->collection_set_iterate(&cl); |
|
498 |
#endif |
|
499 |
cleanupHRRS(); |
|
500 |
ConcurrentG1Refine* cg1r = _g1->concurrent_g1_refine(); |
|
501 |
_g1->set_refine_cte_cl_concurrency(false); |
|
502 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
503 |
dcqs.concatenate_logs(); |
|
504 |
||
505 |
assert(!_par_traversal_in_progress, "Invariant between iterations."); |
|
506 |
if (ParallelGCThreads > 0) { |
|
507 |
set_par_traversal(true); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
508 |
_seq_task->set_par_threads((int)n_workers()); |
1374 | 509 |
} |
510 |
guarantee( _cards_scanned == NULL, "invariant" ); |
|
511 |
_cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers()); |
|
2009 | 512 |
for (uint i = 0; i < n_workers(); ++i) { |
513 |
_cards_scanned[i] = 0; |
|
514 |
} |
|
1374 | 515 |
_total_cards_scanned = 0; |
516 |
} |
|
517 |
||
518 |
||
519 |
class cleanUpIteratorsClosure : public HeapRegionClosure { |
|
520 |
bool doHeapRegion(HeapRegion *r) { |
|
521 |
HeapRegionRemSet* hrrs = r->rem_set(); |
|
522 |
hrrs->init_for_par_iteration(); |
|
523 |
return false; |
|
524 |
} |
|
525 |
}; |
|
526 |
||
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
527 |
class UpdateRSetOopsIntoCSImmediate : public OopClosure { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
528 |
G1CollectedHeap* _g1; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
529 |
public: |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
530 |
UpdateRSetOopsIntoCSImmediate(G1CollectedHeap* g1) : _g1(g1) { } |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
531 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
532 |
virtual void do_oop( oop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
533 |
template <class T> void do_oop_work(T* p) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
534 |
HeapRegion* to = _g1->heap_region_containing(oopDesc::load_decode_heap_oop(p)); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
535 |
if (to->in_collection_set()) { |
2344 | 536 |
to->rem_set()->add_reference(p, 0); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
537 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
538 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
539 |
}; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
540 |
|
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
541 |
class UpdateRSetOopsIntoCSDeferred : public OopClosure { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
542 |
G1CollectedHeap* _g1; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
543 |
CardTableModRefBS* _ct_bs; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
544 |
DirtyCardQueue* _dcq; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
545 |
public: |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
546 |
UpdateRSetOopsIntoCSDeferred(G1CollectedHeap* g1, DirtyCardQueue* dcq) : |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
547 |
_g1(g1), _ct_bs((CardTableModRefBS*)_g1->barrier_set()), _dcq(dcq) { } |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
548 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
549 |
virtual void do_oop( oop* p) { do_oop_work(p); } |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
550 |
template <class T> void do_oop_work(T* p) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
551 |
oop obj = oopDesc::load_decode_heap_oop(p); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
552 |
if (_g1->obj_in_cs(obj)) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
553 |
size_t card_index = _ct_bs->index_for(p); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
554 |
if (_ct_bs->mark_card_deferred(card_index)) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
555 |
_dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index)); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
556 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
557 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
558 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
559 |
}; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
560 |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
561 |
template <class T> void HRInto_G1RemSet::new_refs_iterate_work(OopClosure* cl) { |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
562 |
for (size_t i = 0; i < n_workers(); i++) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
563 |
for (int j = 0; j < _new_refs[i]->length(); j++) { |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2883
diff
changeset
|
564 |
T* p = (T*) _new_refs[i]->at(j); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
565 |
cl->do_oop(p); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
566 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
567 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
568 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
569 |
|
1374 | 570 |
void HRInto_G1RemSet::cleanup_after_oops_into_collection_set_do() { |
571 |
guarantee( _cards_scanned != NULL, "invariant" ); |
|
572 |
_total_cards_scanned = 0; |
|
573 |
for (uint i = 0; i < n_workers(); ++i) |
|
574 |
_total_cards_scanned += _cards_scanned[i]; |
|
575 |
FREE_C_HEAP_ARRAY(size_t, _cards_scanned); |
|
576 |
_cards_scanned = NULL; |
|
577 |
// Cleanup after copy |
|
578 |
#if G1_REM_SET_LOGGING |
|
579 |
PrintRSClosure cl; |
|
580 |
_g1->heap_region_iterate(&cl); |
|
581 |
#endif |
|
582 |
_g1->set_refine_cte_cl_concurrency(true); |
|
583 |
cleanUpIteratorsClosure iterClosure; |
|
584 |
_g1->collection_set_iterate(&iterClosure); |
|
585 |
// Set all cards back to clean. |
|
586 |
_g1->cleanUpCardTable(); |
|
2881 | 587 |
|
1374 | 588 |
if (ParallelGCThreads > 0) { |
589 |
set_par_traversal(false); |
|
590 |
} |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
591 |
|
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
592 |
if (_g1->evacuation_failed()) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
593 |
// Restore remembered sets for the regions pointing into |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
594 |
// the collection set. |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
595 |
if (G1DeferredRSUpdate) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
596 |
DirtyCardQueue dcq(&_g1->dirty_card_queue_set()); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
597 |
UpdateRSetOopsIntoCSDeferred deferred_update(_g1, &dcq); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
598 |
new_refs_iterate(&deferred_update); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
599 |
} else { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
600 |
UpdateRSetOopsIntoCSImmediate immediate_update(_g1); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
601 |
new_refs_iterate(&immediate_update); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
602 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
603 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
604 |
for (uint i = 0; i < n_workers(); i++) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
605 |
_new_refs[i]->clear(); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
606 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
607 |
|
1374 | 608 |
assert(!_par_traversal_in_progress, "Invariant between iterations."); |
609 |
} |
|
610 |
||
611 |
class UpdateRSObjectClosure: public ObjectClosure { |
|
612 |
UpdateRSOopClosure* _update_rs_oop_cl; |
|
613 |
public: |
|
614 |
UpdateRSObjectClosure(UpdateRSOopClosure* update_rs_oop_cl) : |
|
615 |
_update_rs_oop_cl(update_rs_oop_cl) {} |
|
616 |
void do_object(oop obj) { |
|
617 |
obj->oop_iterate(_update_rs_oop_cl); |
|
618 |
} |
|
619 |
||
620 |
}; |
|
621 |
||
622 |
class ScrubRSClosure: public HeapRegionClosure { |
|
623 |
G1CollectedHeap* _g1h; |
|
624 |
BitMap* _region_bm; |
|
625 |
BitMap* _card_bm; |
|
626 |
CardTableModRefBS* _ctbs; |
|
627 |
public: |
|
628 |
ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) : |
|
629 |
_g1h(G1CollectedHeap::heap()), |
|
630 |
_region_bm(region_bm), _card_bm(card_bm), |
|
631 |
_ctbs(NULL) |
|
632 |
{ |
|
633 |
ModRefBarrierSet* bs = _g1h->mr_bs(); |
|
634 |
guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition"); |
|
635 |
_ctbs = (CardTableModRefBS*)bs; |
|
636 |
} |
|
637 |
||
638 |
bool doHeapRegion(HeapRegion* r) { |
|
639 |
if (!r->continuesHumongous()) { |
|
640 |
r->rem_set()->scrub(_ctbs, _region_bm, _card_bm); |
|
641 |
} |
|
642 |
return false; |
|
643 |
} |
|
644 |
}; |
|
645 |
||
646 |
void HRInto_G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) { |
|
647 |
ScrubRSClosure scrub_cl(region_bm, card_bm); |
|
648 |
_g1->heap_region_iterate(&scrub_cl); |
|
649 |
} |
|
650 |
||
651 |
void HRInto_G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm, |
|
652 |
int worker_num, int claim_val) { |
|
653 |
ScrubRSClosure scrub_cl(region_bm, card_bm); |
|
654 |
_g1->heap_region_par_iterate_chunked(&scrub_cl, worker_num, claim_val); |
|
655 |
} |
|
656 |
||
657 |
||
658 |
static IntHistogram out_of_histo(50, 50); |
|
659 |
||
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
660 |
void HRInto_G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
661 |
// Construct the region representing the card. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
662 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
663 |
// And find the region containing it. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
664 |
HeapRegion* r = _g1->heap_region_containing(start); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
665 |
assert(r != NULL, "unexpected null"); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
666 |
|
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
667 |
HeapWord* end = _ct_bs->addr_for(card_ptr + 1); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
668 |
MemRegion dirtyRegion(start, end); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
669 |
|
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
670 |
#if CARD_REPEAT_HISTO |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
671 |
init_ct_freq_table(_g1->g1_reserved_obj_bytes()); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
672 |
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
|
673 |
#endif |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
674 |
|
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
675 |
UpdateRSOopClosure update_rs_oop_cl(this, worker_i); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
676 |
update_rs_oop_cl.set_from(r); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
677 |
FilterOutOfRegionClosure filter_then_update_rs_oop_cl(r, &update_rs_oop_cl); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
678 |
|
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
679 |
// Undirty the card. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
680 |
*card_ptr = CardTableModRefBS::clean_card_val(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
681 |
// We must complete this write before we do any of the reads below. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
682 |
OrderAccess::storeload(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
683 |
// And process it, being careful of unallocated portions of TLAB's. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
684 |
HeapWord* stop_point = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
685 |
r->oops_on_card_seq_iterate_careful(dirtyRegion, |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
686 |
&filter_then_update_rs_oop_cl); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
687 |
// 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
|
688 |
// (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
|
689 |
// 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
|
690 |
// 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
|
691 |
// 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
|
692 |
if (stop_point != NULL) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
693 |
// 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
|
694 |
// worked. (In fact, it's pretty likely.) |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
695 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
696 |
*card_ptr = CardTableModRefBS::dirty_card_val(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
697 |
MutexLockerEx x(Shared_DirtyCardQ_lock, |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
698 |
Mutex::_no_safepoint_check_flag); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
699 |
DirtyCardQueue* sdcq = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
700 |
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
|
701 |
sdcq->enqueue(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
702 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
703 |
} else { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
704 |
out_of_histo.add_entry(filter_then_update_rs_oop_cl.out_of_region()); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
705 |
_conc_refine_cards++; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
706 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
707 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
708 |
|
1374 | 709 |
void HRInto_G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i) { |
710 |
// If the card is no longer dirty, nothing to do. |
|
711 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) return; |
|
712 |
||
713 |
// Construct the region representing the card. |
|
714 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
|
715 |
// And find the region containing it. |
|
716 |
HeapRegion* r = _g1->heap_region_containing(start); |
|
717 |
if (r == NULL) { |
|
718 |
guarantee(_g1->is_in_permanent(start), "Or else where?"); |
|
719 |
return; // Not in the G1 heap (might be in perm, for example.) |
|
720 |
} |
|
721 |
// Why do we have to check here whether a card is on a young region, |
|
722 |
// given that we dirty young regions and, as a result, the |
|
723 |
// post-barrier is supposed to filter them out and never to enqueue |
|
724 |
// them? When we allocate a new region as the "allocation region" we |
|
725 |
// actually dirty its cards after we release the lock, since card |
|
726 |
// dirtying while holding the lock was a performance bottleneck. So, |
|
727 |
// as a result, it is possible for other threads to actually |
|
728 |
// allocate objects in the region (after the acquire the lock) |
|
729 |
// before all the cards on the region are dirtied. This is unlikely, |
|
730 |
// and it doesn't happen often, but it can happen. So, the extra |
|
731 |
// check below filters out those cards. |
|
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
732 |
if (r->is_young()) { |
1374 | 733 |
return; |
734 |
} |
|
735 |
// While we are processing RSet buffers during the collection, we |
|
736 |
// actually don't want to scan any cards on the collection set, |
|
737 |
// since we don't want to update remebered sets with entries that |
|
738 |
// point into the collection set, given that live objects from the |
|
739 |
// collection set are about to move and such entries will be stale |
|
740 |
// very soon. This change also deals with a reliability issue which |
|
741 |
// involves scanning a card in the collection set and coming across |
|
742 |
// an array that was being chunked and looking malformed. Note, |
|
743 |
// however, that if evacuation fails, we have to scan any objects |
|
744 |
// that were not moved and create any missing entries. |
|
745 |
if (r->in_collection_set()) { |
|
746 |
return; |
|
747 |
} |
|
748 |
||
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
749 |
// Should we defer processing the card? |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
750 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
751 |
// Previously the result from the insert_cache call would be |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
752 |
// either card_ptr (implying that card_ptr was currently "cold"), |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
753 |
// null (meaning we had inserted the card ptr into the "hot" |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
754 |
// cache, which had some headroom), or a "hot" card ptr |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
755 |
// extracted from the "hot" cache. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
756 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
757 |
// Now that the _card_counts cache in the ConcurrentG1Refine |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
758 |
// instance is an evicting hash table, the result we get back |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
759 |
// could be from evicting the card ptr in an already occupied |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
760 |
// bucket (in which case we have replaced the card ptr in the |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
761 |
// bucket with card_ptr and "defer" is set to false). To avoid |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
762 |
// having a data structure (updates to which would need a lock) |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
763 |
// to hold these unprocessed dirty cards, we need to immediately |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
764 |
// process card_ptr. The actions needed to be taken on return |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
765 |
// from cache_insert are summarized in the following table: |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
766 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
767 |
// res defer action |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
768 |
// -------------------------------------------------------------- |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
769 |
// null false card evicted from _card_counts & replaced with |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
770 |
// card_ptr; evicted ptr added to hot cache. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
771 |
// No need to process res; immediately process card_ptr |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
772 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
773 |
// null true card not evicted from _card_counts; card_ptr added |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
774 |
// to hot cache. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
775 |
// Nothing to do. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
776 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
777 |
// non-null false card evicted from _card_counts & replaced with |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
778 |
// card_ptr; evicted ptr is currently "cold" or |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
779 |
// caused an eviction from the hot cache. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
780 |
// Immediately process res; process card_ptr. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
781 |
// |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
782 |
// non-null true card not evicted from _card_counts; card_ptr is |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
783 |
// currently cold, or caused an eviction from hot |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
784 |
// cache. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
785 |
// Immediately process res; no need to process card_ptr. |
1374 | 786 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
787 |
jbyte* res = card_ptr; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
788 |
bool defer = false; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
789 |
if (_cg1r->use_cache()) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
790 |
jbyte* res = _cg1r->cache_insert(card_ptr, &defer); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
791 |
if (res != NULL && (res != card_ptr || defer)) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
792 |
start = _ct_bs->addr_for(res); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
793 |
r = _g1->heap_region_containing(start); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
794 |
if (r == NULL) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
795 |
assert(_g1->is_in_permanent(start), "Or else where?"); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
796 |
} else { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
797 |
guarantee(!r->is_young(), "It was evicted in the current minor cycle."); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
798 |
// Process card pointer we get back from the hot card cache |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
799 |
concurrentRefineOneCard_impl(res, worker_i); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
800 |
} |
1374 | 801 |
} |
802 |
} |
|
803 |
||
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
804 |
if (!defer) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
805 |
concurrentRefineOneCard_impl(card_ptr, worker_i); |
1374 | 806 |
} |
807 |
} |
|
808 |
||
809 |
class HRRSStatsIter: public HeapRegionClosure { |
|
810 |
size_t _occupied; |
|
811 |
size_t _total_mem_sz; |
|
812 |
size_t _max_mem_sz; |
|
813 |
HeapRegion* _max_mem_sz_region; |
|
814 |
public: |
|
815 |
HRRSStatsIter() : |
|
816 |
_occupied(0), |
|
817 |
_total_mem_sz(0), |
|
818 |
_max_mem_sz(0), |
|
819 |
_max_mem_sz_region(NULL) |
|
820 |
{} |
|
821 |
||
822 |
bool doHeapRegion(HeapRegion* r) { |
|
823 |
if (r->continuesHumongous()) return false; |
|
824 |
size_t mem_sz = r->rem_set()->mem_size(); |
|
825 |
if (mem_sz > _max_mem_sz) { |
|
826 |
_max_mem_sz = mem_sz; |
|
827 |
_max_mem_sz_region = r; |
|
828 |
} |
|
829 |
_total_mem_sz += mem_sz; |
|
830 |
size_t occ = r->rem_set()->occupied(); |
|
831 |
_occupied += occ; |
|
832 |
return false; |
|
833 |
} |
|
834 |
size_t total_mem_sz() { return _total_mem_sz; } |
|
835 |
size_t max_mem_sz() { return _max_mem_sz; } |
|
836 |
size_t occupied() { return _occupied; } |
|
837 |
HeapRegion* max_mem_sz_region() { return _max_mem_sz_region; } |
|
838 |
}; |
|
839 |
||
2881 | 840 |
class PrintRSThreadVTimeClosure : public ThreadClosure { |
841 |
public: |
|
842 |
virtual void do_thread(Thread *t) { |
|
843 |
ConcurrentG1RefineThread* crt = (ConcurrentG1RefineThread*) t; |
|
844 |
gclog_or_tty->print(" %5.2f", crt->vtime_accum()); |
|
845 |
} |
|
846 |
}; |
|
847 |
||
1374 | 848 |
void HRInto_G1RemSet::print_summary_info() { |
849 |
G1CollectedHeap* g1 = G1CollectedHeap::heap(); |
|
850 |
||
851 |
#if CARD_REPEAT_HISTO |
|
852 |
gclog_or_tty->print_cr("\nG1 card_repeat count histogram: "); |
|
853 |
gclog_or_tty->print_cr(" # of repeats --> # of cards with that number."); |
|
854 |
card_repeat_count.print_on(gclog_or_tty); |
|
855 |
#endif |
|
856 |
||
857 |
if (FILTEROUTOFREGIONCLOSURE_DOHISTOGRAMCOUNT) { |
|
858 |
gclog_or_tty->print_cr("\nG1 rem-set out-of-region histogram: "); |
|
859 |
gclog_or_tty->print_cr(" # of CS ptrs --> # of cards with that number."); |
|
860 |
out_of_histo.print_on(gclog_or_tty); |
|
861 |
} |
|
2881 | 862 |
gclog_or_tty->print_cr("\n Concurrent RS processed %d cards", |
863 |
_conc_refine_cards); |
|
1374 | 864 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
865 |
jint tot_processed_buffers = |
|
866 |
dcqs.processed_buffers_mut() + dcqs.processed_buffers_rs_thread(); |
|
867 |
gclog_or_tty->print_cr(" Of %d completed buffers:", tot_processed_buffers); |
|
2881 | 868 |
gclog_or_tty->print_cr(" %8d (%5.1f%%) by conc RS threads.", |
1374 | 869 |
dcqs.processed_buffers_rs_thread(), |
870 |
100.0*(float)dcqs.processed_buffers_rs_thread()/ |
|
871 |
(float)tot_processed_buffers); |
|
872 |
gclog_or_tty->print_cr(" %8d (%5.1f%%) by mutator threads.", |
|
873 |
dcqs.processed_buffers_mut(), |
|
874 |
100.0*(float)dcqs.processed_buffers_mut()/ |
|
875 |
(float)tot_processed_buffers); |
|
2881 | 876 |
gclog_or_tty->print_cr(" Conc RS threads times(s)"); |
877 |
PrintRSThreadVTimeClosure p; |
|
878 |
gclog_or_tty->print(" "); |
|
879 |
g1->concurrent_g1_refine()->threads_do(&p); |
|
1374 | 880 |
gclog_or_tty->print_cr(""); |
2881 | 881 |
|
1374 | 882 |
if (G1UseHRIntoRS) { |
883 |
HRRSStatsIter blk; |
|
884 |
g1->heap_region_iterate(&blk); |
|
885 |
gclog_or_tty->print_cr(" Total heap region rem set sizes = " SIZE_FORMAT "K." |
|
886 |
" Max = " SIZE_FORMAT "K.", |
|
887 |
blk.total_mem_sz()/K, blk.max_mem_sz()/K); |
|
888 |
gclog_or_tty->print_cr(" Static structures = " SIZE_FORMAT "K," |
|
889 |
" free_lists = " SIZE_FORMAT "K.", |
|
890 |
HeapRegionRemSet::static_mem_size()/K, |
|
891 |
HeapRegionRemSet::fl_mem_size()/K); |
|
892 |
gclog_or_tty->print_cr(" %d occupied cards represented.", |
|
893 |
blk.occupied()); |
|
894 |
gclog_or_tty->print_cr(" Max sz region = [" PTR_FORMAT ", " PTR_FORMAT " )" |
|
2344 | 895 |
", cap = " SIZE_FORMAT "K, occ = " SIZE_FORMAT "K.", |
1374 | 896 |
blk.max_mem_sz_region()->bottom(), blk.max_mem_sz_region()->end(), |
897 |
(blk.max_mem_sz_region()->rem_set()->mem_size() + K - 1)/K, |
|
898 |
(blk.max_mem_sz_region()->rem_set()->occupied() + K - 1)/K); |
|
899 |
gclog_or_tty->print_cr(" Did %d coarsenings.", |
|
900 |
HeapRegionRemSet::n_coarsenings()); |
|
901 |
||
902 |
} |
|
903 |
} |
|
904 |
void HRInto_G1RemSet::prepare_for_verify() { |
|
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
905 |
if (G1HRRSFlushLogBuffersOnVerify && |
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
906 |
(VerifyBeforeGC || VerifyAfterGC) |
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
907 |
&& !_g1->full_collection()) { |
1374 | 908 |
cleanupHRRS(); |
909 |
_g1->set_refine_cte_cl_concurrency(false); |
|
910 |
if (SafepointSynchronize::is_at_safepoint()) { |
|
911 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
912 |
dcqs.concatenate_logs(); |
|
913 |
} |
|
914 |
bool cg1r_use_cache = _cg1r->use_cache(); |
|
915 |
_cg1r->set_use_cache(false); |
|
916 |
updateRS(0); |
|
917 |
_cg1r->set_use_cache(cg1r_use_cache); |
|
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
918 |
|
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
919 |
assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
1374 | 920 |
} |
921 |
} |