annotate src/share/vm/gc_implementation/g1/g1RemSet.cpp @ 6611:7383557659bd

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