author | tschatzl |
Thu, 06 Jul 2017 12:11:20 +0200 | |
changeset 46635 | ef7cac5de811 |
parent 46625 | edefffab74e2 |
child 46652 | ab8716d193bb |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
46307
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
2 |
* Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved. |
1374 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5033
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
30764 | 26 |
#include "gc/g1/concurrentG1Refine.hpp" |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
27 |
#include "gc/g1/dirtyCardQueue.hpp" |
30764 | 28 |
#include "gc/g1/g1BlockOffsetTable.inline.hpp" |
29 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
|
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
30 |
#include "gc/g1/g1FromCardCache.hpp" |
30764 | 31 |
#include "gc/g1/g1GCPhaseTimes.hpp" |
32 |
#include "gc/g1/g1HotCardCache.hpp" |
|
33 |
#include "gc/g1/g1OopClosures.inline.hpp" |
|
34 |
#include "gc/g1/g1RemSet.inline.hpp" |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35469
diff
changeset
|
35 |
#include "gc/g1/g1SATBCardTableModRefBS.inline.hpp" |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
36 |
#include "gc/g1/heapRegion.inline.hpp" |
30764 | 37 |
#include "gc/g1/heapRegionManager.inline.hpp" |
38 |
#include "gc/g1/heapRegionRemSet.hpp" |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
39 |
#include "gc/shared/gcTraceTime.inline.hpp" |
7397 | 40 |
#include "memory/iterator.hpp" |
37248 | 41 |
#include "memory/resourceArea.hpp" |
7397 | 42 |
#include "oops/oop.inline.hpp" |
46625 | 43 |
#include "utilities/align.hpp" |
24098
48f07e2c74de
8039957: Replace the last few %p usages with PTR_FORMAT in the GC code
stefank
parents:
23858
diff
changeset
|
44 |
#include "utilities/globalDefinitions.hpp" |
7397 | 45 |
#include "utilities/intHisto.hpp" |
30175 | 46 |
#include "utilities/stack.inline.hpp" |
1374 | 47 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
48 |
// Collects information about the overall remembered set scan progress during an evacuation. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
49 |
class G1RemSetScanState : public CHeapObj<mtGC> { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
50 |
private: |
38154 | 51 |
class G1ClearCardTableTask : public AbstractGangTask { |
52 |
G1CollectedHeap* _g1h; |
|
53 |
uint* _dirty_region_list; |
|
54 |
size_t _num_dirty_regions; |
|
55 |
size_t _chunk_length; |
|
56 |
||
57 |
size_t volatile _cur_dirty_regions; |
|
58 |
public: |
|
59 |
G1ClearCardTableTask(G1CollectedHeap* g1h, |
|
60 |
uint* dirty_region_list, |
|
61 |
size_t num_dirty_regions, |
|
62 |
size_t chunk_length) : |
|
63 |
AbstractGangTask("G1 Clear Card Table Task"), |
|
64 |
_g1h(g1h), |
|
65 |
_dirty_region_list(dirty_region_list), |
|
66 |
_num_dirty_regions(num_dirty_regions), |
|
67 |
_chunk_length(chunk_length), |
|
68 |
_cur_dirty_regions(0) { |
|
69 |
||
70 |
assert(chunk_length > 0, "must be"); |
|
71 |
} |
|
72 |
||
73 |
static size_t chunk_size() { return M; } |
|
74 |
||
75 |
void work(uint worker_id) { |
|
76 |
G1SATBCardTableModRefBS* ct_bs = _g1h->g1_barrier_set(); |
|
77 |
||
78 |
while (_cur_dirty_regions < _num_dirty_regions) { |
|
79 |
size_t next = Atomic::add(_chunk_length, &_cur_dirty_regions) - _chunk_length; |
|
80 |
size_t max = MIN2(next + _chunk_length, _num_dirty_regions); |
|
81 |
||
82 |
for (size_t i = next; i < max; i++) { |
|
83 |
HeapRegion* r = _g1h->region_at(_dirty_region_list[i]); |
|
84 |
if (!r->is_survivor()) { |
|
85 |
ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
86 |
} |
|
87 |
} |
|
88 |
} |
|
89 |
} |
|
90 |
}; |
|
91 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
92 |
size_t _max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
93 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
94 |
// Scan progress for the remembered set of a single region. Transitions from |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
95 |
// Unclaimed -> Claimed -> Complete. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
96 |
// At each of the transitions the thread that does the transition needs to perform |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
97 |
// some special action once. This is the reason for the extra "Claimed" state. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
98 |
typedef jint G1RemsetIterState; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
99 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
100 |
static const G1RemsetIterState Unclaimed = 0; // The remembered set has not been scanned yet. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
101 |
static const G1RemsetIterState Claimed = 1; // The remembered set is currently being scanned. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
102 |
static const G1RemsetIterState Complete = 2; // The remembered set has been completely scanned. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
103 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
104 |
G1RemsetIterState volatile* _iter_states; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
105 |
// The current location where the next thread should continue scanning in a region's |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
106 |
// remembered set. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
107 |
size_t volatile* _iter_claims; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
108 |
|
38154 | 109 |
// Temporary buffer holding the regions we used to store remembered set scan duplicate |
110 |
// information. These are also called "dirty". Valid entries are from [0.._cur_dirty_region) |
|
111 |
uint* _dirty_region_buffer; |
|
112 |
||
113 |
typedef jbyte IsDirtyRegionState; |
|
114 |
static const IsDirtyRegionState Clean = 0; |
|
115 |
static const IsDirtyRegionState Dirty = 1; |
|
116 |
// Holds a flag for every region whether it is in the _dirty_region_buffer already |
|
117 |
// to avoid duplicates. Uses jbyte since there are no atomic instructions for bools. |
|
118 |
IsDirtyRegionState* _in_dirty_region_buffer; |
|
119 |
size_t _cur_dirty_region; |
|
46520 | 120 |
|
121 |
// Creates a snapshot of the current _top values at the start of collection to |
|
122 |
// filter out card marks that we do not want to scan. |
|
123 |
class G1ResetScanTopClosure : public HeapRegionClosure { |
|
124 |
private: |
|
125 |
HeapWord** _scan_top; |
|
126 |
public: |
|
127 |
G1ResetScanTopClosure(HeapWord** scan_top) : _scan_top(scan_top) { } |
|
128 |
||
129 |
virtual bool doHeapRegion(HeapRegion* r) { |
|
130 |
uint hrm_index = r->hrm_index(); |
|
131 |
if (!r->in_collection_set() && r->is_old_or_humongous()) { |
|
132 |
_scan_top[hrm_index] = r->top(); |
|
133 |
} else { |
|
134 |
_scan_top[hrm_index] = r->bottom(); |
|
135 |
} |
|
136 |
return false; |
|
137 |
} |
|
138 |
}; |
|
139 |
||
140 |
// For each region, contains the maximum top() value to be used during this garbage |
|
141 |
// collection. Subsumes common checks like filtering out everything but old and |
|
142 |
// humongous regions outside the collection set. |
|
143 |
// This is valid because we are not interested in scanning stray remembered set |
|
144 |
// entries from free or archive regions. |
|
145 |
HeapWord** _scan_top; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
146 |
public: |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
147 |
G1RemSetScanState() : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
148 |
_max_regions(0), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
149 |
_iter_states(NULL), |
38154 | 150 |
_iter_claims(NULL), |
151 |
_dirty_region_buffer(NULL), |
|
152 |
_in_dirty_region_buffer(NULL), |
|
46520 | 153 |
_cur_dirty_region(0), |
154 |
_scan_top(NULL) { |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
155 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
156 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
157 |
~G1RemSetScanState() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
158 |
if (_iter_states != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
159 |
FREE_C_HEAP_ARRAY(G1RemsetIterState, _iter_states); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
160 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
161 |
if (_iter_claims != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
162 |
FREE_C_HEAP_ARRAY(size_t, _iter_claims); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
163 |
} |
38154 | 164 |
if (_dirty_region_buffer != NULL) { |
165 |
FREE_C_HEAP_ARRAY(uint, _dirty_region_buffer); |
|
166 |
} |
|
167 |
if (_in_dirty_region_buffer != NULL) { |
|
168 |
FREE_C_HEAP_ARRAY(IsDirtyRegionState, _in_dirty_region_buffer); |
|
169 |
} |
|
46520 | 170 |
if (_scan_top != NULL) { |
171 |
FREE_C_HEAP_ARRAY(HeapWord*, _scan_top); |
|
172 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
173 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
174 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
175 |
void initialize(uint max_regions) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
176 |
assert(_iter_states == NULL, "Must not be initialized twice"); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
177 |
assert(_iter_claims == NULL, "Must not be initialized twice"); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
178 |
_max_regions = max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
179 |
_iter_states = NEW_C_HEAP_ARRAY(G1RemsetIterState, max_regions, mtGC); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
180 |
_iter_claims = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC); |
38154 | 181 |
_dirty_region_buffer = NEW_C_HEAP_ARRAY(uint, max_regions, mtGC); |
182 |
_in_dirty_region_buffer = NEW_C_HEAP_ARRAY(IsDirtyRegionState, max_regions, mtGC); |
|
46520 | 183 |
_scan_top = NEW_C_HEAP_ARRAY(HeapWord*, max_regions, mtGC); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
184 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
185 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
186 |
void reset() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
187 |
for (uint i = 0; i < _max_regions; i++) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
188 |
_iter_states[i] = Unclaimed; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
189 |
} |
46520 | 190 |
|
191 |
G1ResetScanTopClosure cl(_scan_top); |
|
192 |
G1CollectedHeap::heap()->heap_region_iterate(&cl); |
|
193 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
194 |
memset((void*)_iter_claims, 0, _max_regions * sizeof(size_t)); |
38154 | 195 |
memset(_in_dirty_region_buffer, Clean, _max_regions * sizeof(IsDirtyRegionState)); |
196 |
_cur_dirty_region = 0; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
197 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
198 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
199 |
// Attempt to claim the remembered set of the region for iteration. Returns true |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
200 |
// if this call caused the transition from Unclaimed to Claimed. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
201 |
inline bool claim_iter(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
202 |
assert(region < _max_regions, "Tried to access invalid region %u", region); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
203 |
if (_iter_states[region] != Unclaimed) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
204 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
205 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
206 |
jint res = Atomic::cmpxchg(Claimed, (jint*)(&_iter_states[region]), Unclaimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
207 |
return (res == Unclaimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
208 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
209 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
210 |
// Try to atomically sets the iteration state to "complete". Returns true for the |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
211 |
// thread that caused the transition. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
212 |
inline bool set_iter_complete(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
213 |
if (iter_is_complete(region)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
214 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
215 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
216 |
jint res = Atomic::cmpxchg(Complete, (jint*)(&_iter_states[region]), Claimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
217 |
return (res == Claimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
218 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
219 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
220 |
// Returns true if the region's iteration is complete. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
221 |
inline bool iter_is_complete(uint region) const { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
222 |
assert(region < _max_regions, "Tried to access invalid region %u", region); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
223 |
return _iter_states[region] == Complete; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
224 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
225 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
226 |
// The current position within the remembered set of the given region. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
227 |
inline size_t iter_claimed(uint region) const { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
228 |
assert(region < _max_regions, "Tried to access invalid region %u", region); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
229 |
return _iter_claims[region]; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
230 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
231 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
232 |
// Claim the next block of cards within the remembered set of the region with |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
233 |
// step size. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
234 |
inline size_t iter_claimed_next(uint region, size_t step) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
235 |
return Atomic::add(step, &_iter_claims[region]) - step; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
236 |
} |
38154 | 237 |
|
238 |
void add_dirty_region(uint region) { |
|
239 |
if (_in_dirty_region_buffer[region] == Dirty) { |
|
240 |
return; |
|
241 |
} |
|
242 |
||
243 |
bool marked_as_dirty = Atomic::cmpxchg(Dirty, &_in_dirty_region_buffer[region], Clean) == Clean; |
|
244 |
if (marked_as_dirty) { |
|
245 |
size_t allocated = Atomic::add(1, &_cur_dirty_region) - 1; |
|
246 |
_dirty_region_buffer[allocated] = region; |
|
247 |
} |
|
248 |
} |
|
249 |
||
46520 | 250 |
HeapWord* scan_top(uint region_idx) const { |
251 |
return _scan_top[region_idx]; |
|
252 |
} |
|
253 |
||
38154 | 254 |
// Clear the card table of "dirty" regions. |
255 |
void clear_card_table(WorkGang* workers) { |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
256 |
if (_cur_dirty_region == 0) { |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
257 |
return; |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
258 |
} |
38154 | 259 |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46614
diff
changeset
|
260 |
size_t const num_chunks = align_up(_cur_dirty_region * HeapRegion::CardsPerRegion, G1ClearCardTableTask::chunk_size()) / G1ClearCardTableTask::chunk_size(); |
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
261 |
uint const num_workers = (uint)MIN2(num_chunks, (size_t)workers->active_workers()); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
262 |
size_t const chunk_length = G1ClearCardTableTask::chunk_size() / HeapRegion::CardsPerRegion; |
38154 | 263 |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
264 |
// Iterate over the dirty cards region list. |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
265 |
G1ClearCardTableTask cl(G1CollectedHeap::heap(), _dirty_region_buffer, _cur_dirty_region, chunk_length); |
38154 | 266 |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
267 |
log_debug(gc, ergo)("Running %s using %u workers for " SIZE_FORMAT " " |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
268 |
"units of work for " SIZE_FORMAT " regions.", |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
269 |
cl.name(), num_workers, num_chunks, _cur_dirty_region); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
270 |
workers->run_task(&cl, num_workers); |
38154 | 271 |
|
272 |
#ifndef PRODUCT |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
273 |
// Need to synchronize with concurrent cleanup since it needs to |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
274 |
// finish its card table clearing before we can verify. |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
275 |
G1CollectedHeap::heap()->wait_while_free_regions_coming(); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
276 |
G1CollectedHeap::heap()->verifier()->verify_card_table_cleanup(); |
38154 | 277 |
#endif |
278 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
279 |
}; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
280 |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
281 |
G1RemSet::G1RemSet(G1CollectedHeap* g1, |
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
282 |
CardTableModRefBS* ct_bs, |
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
283 |
G1HotCardCache* hot_card_cache) : |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
284 |
_g1(g1), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
285 |
_scan_state(new G1RemSetScanState()), |
46614
ae1105fff9e4
8179677: Let G1Remset::_conc_refined_cards only count number of cards concurrently refined
tschatzl
parents:
46611
diff
changeset
|
286 |
_num_conc_refined_cards(0), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
287 |
_ct_bs(ct_bs), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
288 |
_g1p(_g1->g1_policy()), |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
289 |
_hot_card_cache(hot_card_cache), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
290 |
_prev_period_summary(), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
291 |
_into_cset_dirty_card_queue_set(false) |
1374 | 292 |
{ |
35061 | 293 |
if (log_is_enabled(Trace, gc, remset)) { |
20310
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
294 |
_prev_period_summary.initialize(this); |
903b398490d9
8025441: G1: assert "assert(thread < _num_vtimes) failed: just checking" fails when G1ConcRefinementThreads > ParallelGCThreads
tschatzl
parents:
20309
diff
changeset
|
295 |
} |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
296 |
// Initialize the card queue set used to hold cards containing |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
297 |
// references into the collection set. |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
298 |
_into_cset_dirty_card_queue_set.initialize(NULL, // Should never be called by the Java code |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
299 |
DirtyCardQ_CBL_mon, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
300 |
DirtyCardQ_FL_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
301 |
-1, // never trigger processing |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
302 |
-1, // no limit on length |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
303 |
Shared_DirtyCardQ_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
304 |
&JavaThread::dirty_card_queue_set()); |
1374 | 305 |
} |
306 |
||
6958 | 307 |
G1RemSet::~G1RemSet() { |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
308 |
if (_scan_state != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
309 |
delete _scan_state; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
310 |
} |
1374 | 311 |
} |
312 |
||
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
313 |
uint G1RemSet::num_par_rem_sets() { |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
314 |
return MAX2(DirtyCardQueueSet::num_par_ids() + ConcurrentG1Refine::thread_num(), ParallelGCThreads); |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
315 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
316 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
317 |
void G1RemSet::initialize(size_t capacity, uint max_regions) { |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
318 |
G1FromCardCache::initialize(num_par_rem_sets(), max_regions); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
319 |
_scan_state->initialize(max_regions); |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
320 |
{ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
321 |
GCTraceTime(Debug, gc, marking)("Initialize Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
322 |
_card_live_data.initialize(capacity, max_regions); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
323 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
324 |
if (G1PretouchAuxiliaryMemory) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
325 |
GCTraceTime(Debug, gc, marking)("Pre-Touch Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
326 |
_card_live_data.pretouch(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
327 |
} |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
328 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
329 |
|
46575 | 330 |
G1ScanRSForRegionClosure::G1ScanRSForRegionClosure(G1RemSetScanState* scan_state, |
331 |
G1ScanObjsDuringScanRSClosure* scan_obj_on_card, |
|
332 |
CodeBlobClosure* code_root_cl, |
|
333 |
uint worker_i) : |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
334 |
_scan_state(scan_state), |
46572 | 335 |
_scan_objs_on_card_cl(scan_obj_on_card), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
336 |
_code_root_cl(code_root_cl), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
337 |
_strong_code_root_scan_time_sec(0.0), |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
338 |
_cards_claimed(0), |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
339 |
_cards_scanned(0), |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
340 |
_cards_skipped(0), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
341 |
_worker_i(worker_i) { |
34246 | 342 |
_g1h = G1CollectedHeap::heap(); |
35461 | 343 |
_bot = _g1h->bot(); |
34246 | 344 |
_ct_bs = _g1h->g1_barrier_set(); |
345 |
} |
|
346 |
||
46635 | 347 |
void G1ScanRSForRegionClosure::scan_card(MemRegion mr, uint region_idx_for_card) { |
348 |
HeapRegion* const card_region = _g1h->region_at(region_idx_for_card); |
|
349 |
_scan_objs_on_card_cl->set_region(card_region); |
|
350 |
card_region->oops_on_card_seq_iterate_careful<true>(mr, _scan_objs_on_card_cl); |
|
351 |
_cards_scanned++; |
|
34246 | 352 |
} |
1374 | 353 |
|
46575 | 354 |
void G1ScanRSForRegionClosure::scan_strong_code_roots(HeapRegion* r) { |
34246 | 355 |
double scan_start = os::elapsedTime(); |
356 |
r->strong_code_roots_do(_code_root_cl); |
|
357 |
_strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start); |
|
358 |
} |
|
359 |
||
46635 | 360 |
void G1ScanRSForRegionClosure::claim_card(size_t card_index, const uint region_idx_for_card){ |
361 |
_ct_bs->set_card_claimed(card_index); |
|
362 |
_scan_state->add_dirty_region(region_idx_for_card); |
|
363 |
} |
|
364 |
||
46575 | 365 |
bool G1ScanRSForRegionClosure::doHeapRegion(HeapRegion* r) { |
34246 | 366 |
assert(r->in_collection_set(), "should only be called on elements of CS."); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
367 |
uint region_idx = r->hrm_index(); |
34246 | 368 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
369 |
if (_scan_state->iter_is_complete(region_idx)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
370 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
371 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
372 |
if (_scan_state->claim_iter(region_idx)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
373 |
// If we ever free the collection set concurrently, we should also |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
374 |
// clear the card table concurrently therefore we won't need to |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
375 |
// add regions of the collection set to the dirty cards region. |
38154 | 376 |
_scan_state->add_dirty_region(region_idx); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
377 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
378 |
|
46575 | 379 |
// We claim cards in blocks so as to reduce the contention. |
380 |
size_t const block_size = G1RSetScanBlockSize; |
|
381 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
382 |
HeapRegionRemSetIterator iter(r->rem_set()); |
34246 | 383 |
size_t card_index; |
1374 | 384 |
|
46575 | 385 |
size_t claimed_card_block = _scan_state->iter_claimed_next(region_idx, block_size); |
34246 | 386 |
for (size_t current_card = 0; iter.has_next(card_index); current_card++) { |
46575 | 387 |
if (current_card >= claimed_card_block + block_size) { |
388 |
claimed_card_block = _scan_state->iter_claimed_next(region_idx, block_size); |
|
34246 | 389 |
} |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
390 |
if (current_card < claimed_card_block) { |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
391 |
_cards_skipped++; |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
392 |
continue; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
393 |
} |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
394 |
_cards_claimed++; |
34246 | 395 |
|
46635 | 396 |
// If the card is dirty, then G1 will scan it during Update RS. |
397 |
if (_ct_bs->is_card_claimed(card_index) || _ct_bs->is_card_dirty(card_index)) { |
|
398 |
continue; |
|
399 |
} |
|
400 |
||
401 |
HeapWord* const card_start = _g1h->bot()->address_for_index(card_index); |
|
402 |
uint const region_idx_for_card = _g1h->addr_to_region(card_start); |
|
34246 | 403 |
|
46635 | 404 |
assert(_g1h->region_at(region_idx_for_card)->is_in_reserved(card_start), |
405 |
"Card start " PTR_FORMAT " to scan outside of region %u", p2i(card_start), _g1h->region_at(region_idx_for_card)->hrm_index()); |
|
406 |
HeapWord* const top = _scan_state->scan_top(region_idx_for_card); |
|
407 |
if (card_start >= top) { |
|
408 |
continue; |
|
1374 | 409 |
} |
46635 | 410 |
|
411 |
// We claim lazily (so races are possible but they're benign), which reduces the |
|
412 |
// number of duplicate scans (the rsets of the regions in the cset can intersect). |
|
413 |
// Claim the card after checking bounds above: the remembered set may contain |
|
414 |
// random cards into current survivor, and we would then have an incorrectly |
|
415 |
// claimed card in survivor space. Card table clear does not reset the card table |
|
416 |
// of survivor space regions. |
|
417 |
claim_card(card_index, region_idx_for_card); |
|
418 |
||
419 |
MemRegion const mr(card_start, MIN2(card_start + BOTConstants::N_words, top)); |
|
420 |
||
421 |
scan_card(mr, region_idx_for_card); |
|
1374 | 422 |
} |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
423 |
if (_scan_state->set_iter_complete(region_idx)) { |
34246 | 424 |
// Scan the strong code root list attached to the current region |
425 |
scan_strong_code_roots(r); |
|
1374 | 426 |
} |
34246 | 427 |
return false; |
428 |
} |
|
1374 | 429 |
|
46572 | 430 |
void G1RemSet::scan_rem_set(G1ParScanThreadState* pss, |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
431 |
CodeBlobClosure* heap_region_codeblobs, |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
432 |
uint worker_i) { |
1374 | 433 |
double rs_time_start = os::elapsedTime(); |
32617
a59435e1fecc
8135012: Don't use G1RootProcessor when scanning remembered sets
mgerdin
parents:
31592
diff
changeset
|
434 |
|
46572 | 435 |
G1ScanObjsDuringScanRSClosure scan_cl(_g1, pss); |
46575 | 436 |
G1ScanRSForRegionClosure cl(_scan_state, &scan_cl, heap_region_codeblobs, worker_i); |
39698
4016de4e596b
8159978: Use an array to store the collection set regions instead of linking through regions
tschatzl
parents:
38172
diff
changeset
|
437 |
_g1->collection_set_iterate_from(&cl, worker_i); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
438 |
|
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
439 |
double scan_rs_time_sec = (os::elapsedTime() - rs_time_start) - |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
440 |
cl.strong_code_root_scan_time_sec(); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
441 |
|
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
442 |
G1GCPhaseTimes* p = _g1p->phase_times(); |
1374 | 443 |
|
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
444 |
p->record_time_secs(G1GCPhaseTimes::ScanRS, worker_i, scan_rs_time_sec); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
445 |
p->record_thread_work_item(G1GCPhaseTimes::ScanRS, worker_i, cl.cards_scanned(), G1GCPhaseTimes::ScannedCards); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
446 |
p->record_thread_work_item(G1GCPhaseTimes::ScanRS, worker_i, cl.cards_claimed(), G1GCPhaseTimes::ClaimedCards); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
447 |
p->record_thread_work_item(G1GCPhaseTimes::ScanRS, worker_i, cl.cards_skipped(), G1GCPhaseTimes::SkippedCards); |
32737
f02118695c2f
8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents:
32617
diff
changeset
|
448 |
|
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
449 |
p->record_time_secs(G1GCPhaseTimes::CodeRoots, worker_i, cl.strong_code_root_scan_time_sec()); |
1374 | 450 |
} |
451 |
||
6247 | 452 |
// Closure used for updating RSets and recording references that |
453 |
// point into the collection set. Only called during an |
|
454 |
// evacuation pause. |
|
46580
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
455 |
class G1RefineCardClosure: public CardTableEntryClosure { |
6247 | 456 |
G1RemSet* _g1rs; |
457 |
DirtyCardQueue* _into_cset_dcq; |
|
46572 | 458 |
G1ScanObjsDuringUpdateRSClosure* _update_rs_cl; |
6247 | 459 |
public: |
46580
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
460 |
G1RefineCardClosure(G1CollectedHeap* g1h, |
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
461 |
DirtyCardQueue* into_cset_dcq, |
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
462 |
G1ScanObjsDuringUpdateRSClosure* update_rs_cl) : |
46572 | 463 |
_g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq), _update_rs_cl(update_rs_cl) |
6247 | 464 |
{} |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
465 |
|
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23455
diff
changeset
|
466 |
bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
6247 | 467 |
// The only time we care about recording cards that |
468 |
// contain references that point into the collection set |
|
469 |
// is during RSet updating within an evacuation pause. |
|
470 |
// In this case worker_i should be the id of a GC worker thread. |
|
471 |
assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause"); |
|
1374 | 472 |
|
46572 | 473 |
if (_g1rs->refine_card_during_gc(card_ptr, _update_rs_cl)) { |
6247 | 474 |
// 'card_ptr' contains references that point into the collection |
475 |
// set. We need to record the card in the DCQS |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
476 |
// (_into_cset_dirty_card_queue_set) |
6247 | 477 |
// that's used for that purpose. |
478 |
// |
|
479 |
// Enqueue the card |
|
480 |
_into_cset_dcq->enqueue(card_ptr); |
|
481 |
} |
|
482 |
return true; |
|
483 |
} |
|
484 |
}; |
|
485 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
486 |
void G1RemSet::update_rem_set(DirtyCardQueue* into_cset_dcq, |
46572 | 487 |
G1ParScanThreadState* pss, |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
488 |
uint worker_i) { |
46572 | 489 |
G1ScanObjsDuringUpdateRSClosure update_rs_cl(_g1, pss, worker_i); |
46580
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
490 |
G1RefineCardClosure refine_card_cl(_g1, into_cset_dcq, &update_rs_cl); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
491 |
|
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
492 |
G1GCParPhaseTimesTracker x(_g1p->phase_times(), G1GCPhaseTimes::UpdateRS, worker_i); |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
493 |
if (G1HotCardCache::default_use_cache()) { |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
494 |
// Apply the closure to the entries of the hot card cache. |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
495 |
G1GCParPhaseTimesTracker y(_g1p->phase_times(), G1GCPhaseTimes::ScanHCC, worker_i); |
46580
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
496 |
_g1->iterate_hcc_closure(&refine_card_cl, worker_i); |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
497 |
} |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
498 |
// Apply the closure to all remaining log entries. |
46580
130fde4acb34
8183122: Rename RefineRecordRefsIntoCSCardTableEntryClosure to G1RefineCardClosure
ehelin
parents:
46575
diff
changeset
|
499 |
_g1->iterate_dirty_card_closure(&refine_card_cl, worker_i); |
1374 | 500 |
} |
501 |
||
6958 | 502 |
void G1RemSet::cleanupHRRS() { |
1374 | 503 |
HeapRegionRemSet::cleanup(); |
504 |
} |
|
505 |
||
46572 | 506 |
void G1RemSet::oops_into_collection_set_do(G1ParScanThreadState* pss, |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
507 |
CodeBlobClosure* heap_region_codeblobs, |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46520
diff
changeset
|
508 |
uint worker_i) { |
6247 | 509 |
// A DirtyCardQueue that is used to hold cards containing references |
510 |
// that point into the collection set. This DCQ is associated with a |
|
511 |
// special DirtyCardQueueSet (see g1CollectedHeap.hpp). Under normal |
|
512 |
// circumstances (i.e. the pause successfully completes), these cards |
|
513 |
// are just discarded (there's no need to update the RSets of regions |
|
514 |
// that were in the collection set - after the pause these regions |
|
515 |
// are wholly 'free' of live objects. In the event of an evacuation |
|
26701
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
516 |
// failure the cards/buffers in this queue set are passed to the |
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
517 |
// DirtyCardQueueSet that is used to manage RSet updates |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
518 |
DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set); |
6247 | 519 |
|
46572 | 520 |
update_rem_set(&into_cset_dcq, pss, worker_i); |
521 |
scan_rem_set(pss, heap_region_codeblobs, worker_i);; |
|
1374 | 522 |
} |
523 |
||
6958 | 524 |
void G1RemSet::prepare_for_oops_into_collection_set_do() { |
1374 | 525 |
_g1->set_refine_cte_cl_concurrency(false); |
526 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
527 |
dcqs.concatenate_logs(); |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
528 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
529 |
_scan_state->reset(); |
1374 | 530 |
} |
531 |
||
6958 | 532 |
void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
38154 | 533 |
G1GCPhaseTimes* phase_times = _g1->g1_policy()->phase_times(); |
1374 | 534 |
// Cleanup after copy |
535 |
_g1->set_refine_cte_cl_concurrency(true); |
|
38154 | 536 |
|
1374 | 537 |
// Set all cards back to clean. |
38154 | 538 |
double start = os::elapsedTime(); |
539 |
_scan_state->clear_card_table(_g1->workers()); |
|
540 |
phase_times->record_clear_ct_time((os::elapsedTime() - start) * 1000.0); |
|
2881 | 541 |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
542 |
DirtyCardQueueSet& into_cset_dcqs = _into_cset_dirty_card_queue_set; |
6247 | 543 |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
544 |
if (_g1->evacuation_failed()) { |
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
545 |
double restore_remembered_set_start = os::elapsedTime(); |
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
546 |
|
6247 | 547 |
// Restore remembered sets for the regions pointing into the collection set. |
26701
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
548 |
// We just need to transfer the completed buffers from the DirtyCardQueueSet |
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
549 |
// used to hold cards that contain references that point into the collection set |
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
550 |
// to the DCQS used to hold the deferred RS updates. |
f8ff74a6c058
8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set
tschatzl
parents:
26422
diff
changeset
|
551 |
_g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); |
38154 | 552 |
phase_times->record_evac_fail_restore_remsets((os::elapsedTime() - restore_remembered_set_start) * 1000.0); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
553 |
} |
6247 | 554 |
|
555 |
// Free any completed buffers in the DirtyCardQueueSet used to hold cards |
|
556 |
// which contain references that point into the collection. |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
557 |
_into_cset_dirty_card_queue_set.clear(); |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
558 |
assert(_into_cset_dirty_card_queue_set.completed_buffers_num() == 0, |
6247 | 559 |
"all buffers should be freed"); |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
560 |
_into_cset_dirty_card_queue_set.clear_n_completed_buffers(); |
1374 | 561 |
} |
562 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
563 |
class G1ScrubRSClosure: public HeapRegionClosure { |
1374 | 564 |
G1CollectedHeap* _g1h; |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
565 |
G1CardLiveData* _live_data; |
1374 | 566 |
public: |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
567 |
G1ScrubRSClosure(G1CardLiveData* live_data) : |
1374 | 568 |
_g1h(G1CollectedHeap::heap()), |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
569 |
_live_data(live_data) { } |
1374 | 570 |
|
571 |
bool doHeapRegion(HeapRegion* r) { |
|
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26701
diff
changeset
|
572 |
if (!r->is_continues_humongous()) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
573 |
r->rem_set()->scrub(_live_data); |
1374 | 574 |
} |
575 |
return false; |
|
576 |
} |
|
577 |
}; |
|
578 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
579 |
void G1RemSet::scrub(uint worker_num, HeapRegionClaimer *hrclaimer) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
580 |
G1ScrubRSClosure scrub_cl(&_card_live_data); |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26846
diff
changeset
|
581 |
_g1->heap_region_par_iterate(&scrub_cl, worker_num, hrclaimer); |
1374 | 582 |
} |
583 |
||
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
584 |
inline void check_card_ptr(jbyte* card_ptr, CardTableModRefBS* ct_bs) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
585 |
#ifdef ASSERT |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
586 |
G1CollectedHeap* g1 = G1CollectedHeap::heap(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
587 |
assert(g1->is_in_exact(ct_bs->addr_for(card_ptr)), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
588 |
"Card at " PTR_FORMAT " index " SIZE_FORMAT " representing heap at " PTR_FORMAT " (%u) must be in committed heap", |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
589 |
p2i(card_ptr), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
590 |
ct_bs->index_for(ct_bs->addr_for(card_ptr)), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
591 |
p2i(ct_bs->addr_for(card_ptr)), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
592 |
g1->addr_to_region(ct_bs->addr_for(card_ptr))); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
593 |
#endif |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
594 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
595 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
596 |
void G1RemSet::refine_card_concurrently(jbyte* card_ptr, |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
597 |
uint worker_i) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
598 |
assert(!_g1->is_gc_active(), "Only call concurrently"); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
599 |
|
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
600 |
check_card_ptr(card_ptr, _ct_bs); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
601 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
602 |
// If the card is no longer dirty, nothing to do. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
603 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
604 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
605 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
606 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
607 |
// Construct the region representing the card. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
608 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
609 |
// And find the region containing it. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
610 |
HeapRegion* r = _g1->heap_region_containing(start); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
611 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
612 |
// This check is needed for some uncommon cases where we should |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
613 |
// ignore the card. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
614 |
// |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
615 |
// The region could be young. Cards for young regions are |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
616 |
// distinctly marked (set to g1_young_gen), so the post-barrier will |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
617 |
// filter them out. However, that marking is performed |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
618 |
// concurrently. A write to a young object could occur before the |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
619 |
// card has been marked young, slipping past the filter. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
620 |
// |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
621 |
// The card could be stale, because the region has been freed since |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
622 |
// the card was recorded. In this case the region type could be |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
623 |
// anything. If (still) free or (reallocated) young, just ignore |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
624 |
// it. If (reallocated) old or humongous, the later card trimming |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
625 |
// and additional checks in iteration may detect staleness. At |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
626 |
// worst, we end up processing a stale card unnecessarily. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
627 |
// |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
628 |
// In the normal (non-stale) case, the synchronization between the |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
629 |
// enqueueing of the card and processing it here will have ensured |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
630 |
// we see the up-to-date region type here. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
631 |
if (!r->is_old_or_humongous()) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
632 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
633 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
634 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
635 |
// While we are processing RSet buffers during the collection, we |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
636 |
// actually don't want to scan any cards on the collection set, |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
637 |
// since we don't want to update remembered sets with entries that |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
638 |
// point into the collection set, given that live objects from the |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
639 |
// collection set are about to move and such entries will be stale |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
640 |
// very soon. This change also deals with a reliability issue which |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
641 |
// involves scanning a card in the collection set and coming across |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
642 |
// an array that was being chunked and looking malformed. Note, |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
643 |
// however, that if evacuation fails, we have to scan any objects |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
644 |
// that were not moved and create any missing entries. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
645 |
if (r->in_collection_set()) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
646 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
647 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
648 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
649 |
// The result from the hot card cache insert call is either: |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
650 |
// * pointer to the current card |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
651 |
// (implying that the current card is not 'hot'), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
652 |
// * null |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
653 |
// (meaning we had inserted the card ptr into the "hot" card cache, |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
654 |
// which had some headroom), |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
655 |
// * a pointer to a "hot" card that was evicted from the "hot" cache. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
656 |
// |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
657 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
658 |
if (_hot_card_cache->use_cache()) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
659 |
assert(!SafepointSynchronize::is_at_safepoint(), "sanity"); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
660 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
661 |
const jbyte* orig_card_ptr = card_ptr; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
662 |
card_ptr = _hot_card_cache->insert(card_ptr); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
663 |
if (card_ptr == NULL) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
664 |
// There was no eviction. Nothing to do. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
665 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
666 |
} else if (card_ptr != orig_card_ptr) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
667 |
// Original card was inserted and an old card was evicted. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
668 |
start = _ct_bs->addr_for(card_ptr); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
669 |
r = _g1->heap_region_containing(start); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
670 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
671 |
// Check whether the region formerly in the cache should be |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
672 |
// ignored, as discussed earlier for the original card. The |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
673 |
// region could have been freed while in the cache. The cset is |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
674 |
// not relevant here, since we're in concurrent phase. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
675 |
if (!r->is_old_or_humongous()) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
676 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
677 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
678 |
} // Else we still have the original card. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
679 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
680 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
681 |
// Trim the region designated by the card to what's been allocated |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
682 |
// in the region. The card could be stale, or the card could cover |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
683 |
// (part of) an object at the end of the allocated space and extend |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
684 |
// beyond the end of allocation. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
685 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
686 |
// Non-humongous objects are only allocated in the old-gen during |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
687 |
// GC, so if region is old then top is stable. Humongous object |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
688 |
// allocation sets top last; if top has not yet been set, this is |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
689 |
// a stale card and we'll end up with an empty intersection. If |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
690 |
// this is not a stale card, the synchronization between the |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
691 |
// enqueuing of the card and processing it here will have ensured |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
692 |
// we see the up-to-date top here. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
693 |
HeapWord* scan_limit = r->top(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
694 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
695 |
if (scan_limit <= start) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
696 |
// If the trimmed region is empty, the card must be stale. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
697 |
return; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
698 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
699 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
700 |
// Okay to clean and process the card now. There are still some |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
701 |
// stale card cases that may be detected by iteration and dealt with |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
702 |
// as iteration failure. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
703 |
*const_cast<volatile jbyte*>(card_ptr) = CardTableModRefBS::clean_card_val(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
704 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
705 |
// This fence serves two purposes. First, the card must be cleaned |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
706 |
// before processing the contents. Second, we can't proceed with |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
707 |
// processing until after the read of top, for synchronization with |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
708 |
// possibly concurrent humongous object allocation. It's okay that |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
709 |
// reading top and reading type were racy wrto each other. We need |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
710 |
// both set, in any order, to proceed. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
711 |
OrderAccess::fence(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
712 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
713 |
// Don't use addr_for(card_ptr + 1) which can ask for |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
714 |
// a card beyond the heap. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
715 |
HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
716 |
MemRegion dirty_region(start, MIN2(scan_limit, end)); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
717 |
assert(!dirty_region.is_empty(), "sanity"); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
718 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
719 |
G1ConcurrentRefineOopClosure conc_refine_cl(_g1, worker_i); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
720 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
721 |
bool card_processed = |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
722 |
r->oops_on_card_seq_iterate_careful<false>(dirty_region, &conc_refine_cl); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
723 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
724 |
// If unable to process the card then we encountered an unparsable |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
725 |
// part of the heap (e.g. a partially allocated object) while |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
726 |
// processing a stale card. Despite the card being stale, redirty |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
727 |
// and re-enqueue, because we've already cleaned the card. Without |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
728 |
// this we could incorrectly discard a non-stale card. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
729 |
if (!card_processed) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
730 |
// The card might have gotten re-dirtied and re-enqueued while we |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
731 |
// worked. (In fact, it's pretty likely.) |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
732 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
733 |
*card_ptr = CardTableModRefBS::dirty_card_val(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
734 |
MutexLockerEx x(Shared_DirtyCardQ_lock, |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
735 |
Mutex::_no_safepoint_check_flag); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
736 |
DirtyCardQueue* sdcq = |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
737 |
JavaThread::dirty_card_queue_set().shared_dirty_card_queue(); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
738 |
sdcq->enqueue(card_ptr); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
739 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
740 |
} else { |
46614
ae1105fff9e4
8179677: Let G1Remset::_conc_refined_cards only count number of cards concurrently refined
tschatzl
parents:
46611
diff
changeset
|
741 |
_num_conc_refined_cards++; // Unsynchronized update, only used for logging. |
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
742 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
743 |
} |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
744 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
745 |
bool G1RemSet::refine_card_during_gc(jbyte* card_ptr, |
46572 | 746 |
G1ScanObjsDuringUpdateRSClosure* update_rs_cl) { |
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
747 |
assert(_g1->is_gc_active(), "Only call during GC"); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
748 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
749 |
check_card_ptr(card_ptr, _ct_bs); |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
750 |
|
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
751 |
// If the card is no longer dirty, nothing to do. This covers cards that were already |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
752 |
// scanned as parts of the remembered sets. |
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
753 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
754 |
// No need to return that this card contains refs that point |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
755 |
// into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
756 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
757 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
758 |
|
46520 | 759 |
// During GC we can immediately clean the card since we will not re-enqueue stale |
760 |
// cards as we know they can be disregarded. |
|
761 |
*card_ptr = CardTableModRefBS::clean_card_val(); |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
762 |
|
46520 | 763 |
// Construct the region representing the card. |
764 |
HeapWord* card_start = _ct_bs->addr_for(card_ptr); |
|
765 |
// And find the region containing it. |
|
766 |
HeapRegion* r = _g1->heap_region_containing(card_start); |
|
767 |
||
768 |
HeapWord* scan_limit = _scan_state->scan_top(r->hrm_index()); |
|
769 |
if (scan_limit <= card_start) { |
|
770 |
// If the card starts above the area in the region containing objects to scan, skip it. |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
771 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
772 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
773 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
774 |
// Don't use addr_for(card_ptr + 1) which can ask for |
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
775 |
// a card beyond the heap. |
46520 | 776 |
HeapWord* card_end = card_start + CardTableModRefBS::card_size_in_words; |
777 |
MemRegion dirty_region(card_start, MIN2(scan_limit, card_end)); |
|
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
778 |
assert(!dirty_region.is_empty(), "sanity"); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
779 |
|
46572 | 780 |
update_rs_cl->set_region(r); |
781 |
update_rs_cl->reset_has_refs_into_cset(); |
|
6247 | 782 |
|
46572 | 783 |
bool card_processed = r->oops_on_card_seq_iterate_careful<true>(dirty_region, update_rs_cl); |
46519
40c9c132f961
8177707: Specialize G1RemSet::refine_card for concurrent/during safepoint refinement
tschatzl
parents:
46518
diff
changeset
|
784 |
assert(card_processed, "must be"); |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
785 |
|
46572 | 786 |
return update_rs_cl->has_refs_into_cset(); |
1374 | 787 |
} |
788 |
||
35061 | 789 |
void G1RemSet::print_periodic_summary_info(const char* header, uint period_count) { |
790 |
if ((G1SummarizeRSetStatsPeriod > 0) && log_is_enabled(Trace, gc, remset) && |
|
791 |
(period_count % G1SummarizeRSetStatsPeriod == 0)) { |
|
792 |
||
793 |
if (!_prev_period_summary.initialized()) { |
|
794 |
_prev_period_summary.initialize(this); |
|
795 |
} |
|
1374 | 796 |
|
35061 | 797 |
G1RemSetSummary current; |
798 |
current.initialize(this); |
|
799 |
_prev_period_summary.subtract_from(¤t); |
|
1374 | 800 |
|
37242 | 801 |
Log(gc, remset) log; |
35061 | 802 |
log.trace("%s", header); |
803 |
ResourceMark rm; |
|
804 |
_prev_period_summary.print_on(log.trace_stream()); |
|
805 |
||
806 |
_prev_period_summary.set(¤t); |
|
807 |
} |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
808 |
} |
2881 | 809 |
|
6958 | 810 |
void G1RemSet::print_summary_info() { |
37242 | 811 |
Log(gc, remset, exit) log; |
35061 | 812 |
if (log.is_trace()) { |
813 |
log.trace(" Cumulative RS summary"); |
|
814 |
G1RemSetSummary current; |
|
815 |
current.initialize(this); |
|
816 |
ResourceMark rm; |
|
817 |
current.print_on(log.trace_stream()); |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
818 |
} |
1374 | 819 |
} |
6247 | 820 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
821 |
void G1RemSet::create_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
822 |
_card_live_data.create(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
823 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
824 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
825 |
void G1RemSet::finalize_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
826 |
_card_live_data.finalize(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
827 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
828 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
829 |
void G1RemSet::verify_card_live_data(WorkGang* workers, G1CMBitMap* bitmap) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
830 |
_card_live_data.verify(workers, bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
831 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
832 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
833 |
void G1RemSet::clear_card_live_data(WorkGang* workers) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
834 |
_card_live_data.clear(workers); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
835 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
836 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
837 |
#ifdef ASSERT |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
838 |
void G1RemSet::verify_card_live_data_is_clear() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
839 |
_card_live_data.verify_is_clear(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
840 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
841 |
#endif |