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