author | tschatzl |
Fri, 02 Jun 2017 13:45:21 +0200 | |
changeset 46518 | 69f8479862a2 |
parent 46517 | 14de3e5151a9 |
child 46519 | 40c9c132f961 |
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" |
24098
48f07e2c74de
8039957: Replace the last few %p usages with PTR_FORMAT in the GC code
stefank
parents:
23858
diff
changeset
|
43 |
#include "utilities/globalDefinitions.hpp" |
7397 | 44 |
#include "utilities/intHisto.hpp" |
30175 | 45 |
#include "utilities/stack.inline.hpp" |
1374 | 46 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
47 |
// 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
|
48 |
class G1RemSetScanState : public CHeapObj<mtGC> { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
49 |
private: |
38154 | 50 |
class G1ClearCardTableTask : public AbstractGangTask { |
51 |
G1CollectedHeap* _g1h; |
|
52 |
uint* _dirty_region_list; |
|
53 |
size_t _num_dirty_regions; |
|
54 |
size_t _chunk_length; |
|
55 |
||
56 |
size_t volatile _cur_dirty_regions; |
|
57 |
public: |
|
58 |
G1ClearCardTableTask(G1CollectedHeap* g1h, |
|
59 |
uint* dirty_region_list, |
|
60 |
size_t num_dirty_regions, |
|
61 |
size_t chunk_length) : |
|
62 |
AbstractGangTask("G1 Clear Card Table Task"), |
|
63 |
_g1h(g1h), |
|
64 |
_dirty_region_list(dirty_region_list), |
|
65 |
_num_dirty_regions(num_dirty_regions), |
|
66 |
_chunk_length(chunk_length), |
|
67 |
_cur_dirty_regions(0) { |
|
68 |
||
69 |
assert(chunk_length > 0, "must be"); |
|
70 |
} |
|
71 |
||
72 |
static size_t chunk_size() { return M; } |
|
73 |
||
74 |
void work(uint worker_id) { |
|
75 |
G1SATBCardTableModRefBS* ct_bs = _g1h->g1_barrier_set(); |
|
76 |
||
77 |
while (_cur_dirty_regions < _num_dirty_regions) { |
|
78 |
size_t next = Atomic::add(_chunk_length, &_cur_dirty_regions) - _chunk_length; |
|
79 |
size_t max = MIN2(next + _chunk_length, _num_dirty_regions); |
|
80 |
||
81 |
for (size_t i = next; i < max; i++) { |
|
82 |
HeapRegion* r = _g1h->region_at(_dirty_region_list[i]); |
|
83 |
if (!r->is_survivor()) { |
|
84 |
ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
85 |
} |
|
86 |
} |
|
87 |
} |
|
88 |
} |
|
89 |
}; |
|
90 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
91 |
size_t _max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
92 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
93 |
// 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
|
94 |
// Unclaimed -> Claimed -> Complete. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
95 |
// 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
|
96 |
// 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
|
97 |
typedef jint G1RemsetIterState; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
98 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
99 |
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
|
100 |
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
|
101 |
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
|
102 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
103 |
G1RemsetIterState volatile* _iter_states; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
104 |
// 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
|
105 |
// remembered set. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
106 |
size_t volatile* _iter_claims; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
107 |
|
38154 | 108 |
// Temporary buffer holding the regions we used to store remembered set scan duplicate |
109 |
// information. These are also called "dirty". Valid entries are from [0.._cur_dirty_region) |
|
110 |
uint* _dirty_region_buffer; |
|
111 |
||
112 |
typedef jbyte IsDirtyRegionState; |
|
113 |
static const IsDirtyRegionState Clean = 0; |
|
114 |
static const IsDirtyRegionState Dirty = 1; |
|
115 |
// Holds a flag for every region whether it is in the _dirty_region_buffer already |
|
116 |
// to avoid duplicates. Uses jbyte since there are no atomic instructions for bools. |
|
117 |
IsDirtyRegionState* _in_dirty_region_buffer; |
|
118 |
size_t _cur_dirty_region; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
119 |
public: |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
120 |
G1RemSetScanState() : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
121 |
_max_regions(0), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
122 |
_iter_states(NULL), |
38154 | 123 |
_iter_claims(NULL), |
124 |
_dirty_region_buffer(NULL), |
|
125 |
_in_dirty_region_buffer(NULL), |
|
126 |
_cur_dirty_region(0) { |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
127 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
128 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
129 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
130 |
~G1RemSetScanState() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
131 |
if (_iter_states != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
132 |
FREE_C_HEAP_ARRAY(G1RemsetIterState, _iter_states); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
133 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
134 |
if (_iter_claims != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
135 |
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
|
136 |
} |
38154 | 137 |
if (_dirty_region_buffer != NULL) { |
138 |
FREE_C_HEAP_ARRAY(uint, _dirty_region_buffer); |
|
139 |
} |
|
140 |
if (_in_dirty_region_buffer != NULL) { |
|
141 |
FREE_C_HEAP_ARRAY(IsDirtyRegionState, _in_dirty_region_buffer); |
|
142 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
143 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
144 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
145 |
void initialize(uint max_regions) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
146 |
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
|
147 |
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
|
148 |
_max_regions = max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
149 |
_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
|
150 |
_iter_claims = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC); |
38154 | 151 |
_dirty_region_buffer = NEW_C_HEAP_ARRAY(uint, max_regions, mtGC); |
152 |
_in_dirty_region_buffer = NEW_C_HEAP_ARRAY(IsDirtyRegionState, max_regions, mtGC); |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
153 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
154 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
155 |
void reset() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
156 |
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
|
157 |
_iter_states[i] = Unclaimed; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
158 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
159 |
memset((void*)_iter_claims, 0, _max_regions * sizeof(size_t)); |
38154 | 160 |
memset(_in_dirty_region_buffer, Clean, _max_regions * sizeof(IsDirtyRegionState)); |
161 |
_cur_dirty_region = 0; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
162 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
163 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
164 |
// 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
|
165 |
// 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
|
166 |
inline bool claim_iter(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
167 |
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
|
168 |
if (_iter_states[region] != Unclaimed) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
169 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
170 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
171 |
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
|
172 |
return (res == Unclaimed); |
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 |
// 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
|
176 |
// thread that caused the transition. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
177 |
inline bool set_iter_complete(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
178 |
if (iter_is_complete(region)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
179 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
180 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
181 |
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
|
182 |
return (res == Claimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
183 |
} |
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 |
// 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
|
186 |
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
|
187 |
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
|
188 |
return _iter_states[region] == Complete; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
189 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
190 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
191 |
// 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
|
192 |
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
|
193 |
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
|
194 |
return _iter_claims[region]; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
195 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
196 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
197 |
// 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
|
198 |
// step size. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
199 |
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
|
200 |
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
|
201 |
} |
38154 | 202 |
|
203 |
void add_dirty_region(uint region) { |
|
204 |
if (_in_dirty_region_buffer[region] == Dirty) { |
|
205 |
return; |
|
206 |
} |
|
207 |
||
208 |
bool marked_as_dirty = Atomic::cmpxchg(Dirty, &_in_dirty_region_buffer[region], Clean) == Clean; |
|
209 |
if (marked_as_dirty) { |
|
210 |
size_t allocated = Atomic::add(1, &_cur_dirty_region) - 1; |
|
211 |
_dirty_region_buffer[allocated] = region; |
|
212 |
} |
|
213 |
} |
|
214 |
||
215 |
// Clear the card table of "dirty" regions. |
|
216 |
void clear_card_table(WorkGang* workers) { |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
217 |
if (_cur_dirty_region == 0) { |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
218 |
return; |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
219 |
} |
38154 | 220 |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
221 |
size_t const num_chunks = align_size_up(_cur_dirty_region * HeapRegion::CardsPerRegion, G1ClearCardTableTask::chunk_size()) / G1ClearCardTableTask::chunk_size(); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
222 |
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
|
223 |
size_t const chunk_length = G1ClearCardTableTask::chunk_size() / HeapRegion::CardsPerRegion; |
38154 | 224 |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
225 |
// Iterate over the dirty cards region list. |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
226 |
G1ClearCardTableTask cl(G1CollectedHeap::heap(), _dirty_region_buffer, _cur_dirty_region, chunk_length); |
38154 | 227 |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
228 |
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
|
229 |
"units of work for " SIZE_FORMAT " regions.", |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
230 |
cl.name(), num_workers, num_chunks, _cur_dirty_region); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
231 |
workers->run_task(&cl, num_workers); |
38154 | 232 |
|
233 |
#ifndef PRODUCT |
|
38160
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
234 |
// Need to synchronize with concurrent cleanup since it needs to |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
235 |
// finish its card table clearing before we can verify. |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
236 |
G1CollectedHeap::heap()->wait_while_free_regions_coming(); |
13a14d5777b0
8155813: Fix indentation in G1RemSetScanState::clear_card_table()
tschatzl
parents:
38154
diff
changeset
|
237 |
G1CollectedHeap::heap()->verifier()->verify_card_table_cleanup(); |
38154 | 238 |
#endif |
239 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
240 |
}; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
241 |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
242 |
G1RemSet::G1RemSet(G1CollectedHeap* g1, |
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
243 |
CardTableModRefBS* ct_bs, |
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
244 |
G1HotCardCache* hot_card_cache) : |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
245 |
_g1(g1), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
246 |
_scan_state(new G1RemSetScanState()), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
247 |
_conc_refine_cards(0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
248 |
_ct_bs(ct_bs), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
249 |
_g1p(_g1->g1_policy()), |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
250 |
_hot_card_cache(hot_card_cache), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
251 |
_prev_period_summary(), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
252 |
_into_cset_dirty_card_queue_set(false) |
1374 | 253 |
{ |
35061 | 254 |
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
|
255 |
_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
|
256 |
} |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
257 |
// 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
|
258 |
// references into the collection set. |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
259 |
_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
|
260 |
DirtyCardQ_CBL_mon, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
261 |
DirtyCardQ_FL_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
262 |
-1, // never trigger processing |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
263 |
-1, // no limit on length |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
264 |
Shared_DirtyCardQ_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
265 |
&JavaThread::dirty_card_queue_set()); |
1374 | 266 |
} |
267 |
||
6958 | 268 |
G1RemSet::~G1RemSet() { |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
269 |
if (_scan_state != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
270 |
delete _scan_state; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
271 |
} |
1374 | 272 |
} |
273 |
||
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
274 |
uint G1RemSet::num_par_rem_sets() { |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
275 |
return MAX2(DirtyCardQueueSet::num_par_ids() + ConcurrentG1Refine::thread_num(), ParallelGCThreads); |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
276 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
277 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
278 |
void G1RemSet::initialize(size_t capacity, uint max_regions) { |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
279 |
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
|
280 |
_scan_state->initialize(max_regions); |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
281 |
{ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
282 |
GCTraceTime(Debug, gc, marking)("Initialize Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
283 |
_card_live_data.initialize(capacity, max_regions); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
284 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
285 |
if (G1PretouchAuxiliaryMemory) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
286 |
GCTraceTime(Debug, gc, marking)("Pre-Touch Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
287 |
_card_live_data.pretouch(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
288 |
} |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
289 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
290 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
291 |
G1ScanRSClosure::G1ScanRSClosure(G1RemSetScanState* scan_state, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
292 |
G1ParPushHeapRSClosure* push_heap_cl, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
293 |
CodeBlobClosure* code_root_cl, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
294 |
uint worker_i) : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
295 |
_scan_state(scan_state), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
296 |
_push_heap_cl(push_heap_cl), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
297 |
_code_root_cl(code_root_cl), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
298 |
_strong_code_root_scan_time_sec(0.0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
299 |
_cards(0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
300 |
_cards_done(0), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
301 |
_worker_i(worker_i) { |
34246 | 302 |
_g1h = G1CollectedHeap::heap(); |
35461 | 303 |
_bot = _g1h->bot(); |
34246 | 304 |
_ct_bs = _g1h->g1_barrier_set(); |
305 |
_block_size = MAX2<size_t>(G1RSetScanBlockSize, 1); |
|
306 |
} |
|
307 |
||
46518
69f8479862a2
8162928: Micro-optimizations in scanning the remembered sets
tschatzl
parents:
46517
diff
changeset
|
308 |
void G1ScanRSClosure::scan_card(size_t index, HeapWord* card_start, HeapRegion *r) { |
69f8479862a2
8162928: Micro-optimizations in scanning the remembered sets
tschatzl
parents:
46517
diff
changeset
|
309 |
MemRegion card_region(card_start, BOTConstants::N_words); |
34246 | 310 |
MemRegion pre_gc_allocated(r->bottom(), r->scan_top()); |
311 |
MemRegion mr = pre_gc_allocated.intersection(card_region); |
|
312 |
if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) { |
|
313 |
// We make the card as "claimed" lazily (so races are possible |
|
314 |
// but they're benign), which reduces the number of duplicate |
|
315 |
// scans (the rsets of the regions in the cset can intersect). |
|
316 |
_ct_bs->set_card_claimed(index); |
|
46518
69f8479862a2
8162928: Micro-optimizations in scanning the remembered sets
tschatzl
parents:
46517
diff
changeset
|
317 |
_push_heap_cl->set_region(r); |
69f8479862a2
8162928: Micro-optimizations in scanning the remembered sets
tschatzl
parents:
46517
diff
changeset
|
318 |
r->oops_on_card_seq_iterate_careful<true>(mr, _push_heap_cl); |
34246 | 319 |
_cards_done++; |
1374 | 320 |
} |
34246 | 321 |
} |
1374 | 322 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
323 |
void G1ScanRSClosure::scan_strong_code_roots(HeapRegion* r) { |
34246 | 324 |
double scan_start = os::elapsedTime(); |
325 |
r->strong_code_roots_do(_code_root_cl); |
|
326 |
_strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start); |
|
327 |
} |
|
328 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
329 |
bool G1ScanRSClosure::doHeapRegion(HeapRegion* r) { |
34246 | 330 |
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
|
331 |
uint region_idx = r->hrm_index(); |
34246 | 332 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
333 |
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
|
334 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
335 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
336 |
if (_scan_state->claim_iter(region_idx)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
337 |
// 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
|
338 |
// 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
|
339 |
// add regions of the collection set to the dirty cards region. |
38154 | 340 |
_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
|
341 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
342 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
343 |
HeapRegionRemSetIterator iter(r->rem_set()); |
34246 | 344 |
size_t card_index; |
1374 | 345 |
|
34246 | 346 |
// We claim cards in block so as to reduce the contention. The block size is determined by |
347 |
// the G1RSetScanBlockSize parameter. |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
348 |
size_t claimed_card_block = _scan_state->iter_claimed_next(region_idx, _block_size); |
34246 | 349 |
for (size_t current_card = 0; iter.has_next(card_index); current_card++) { |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
350 |
if (current_card >= claimed_card_block + _block_size) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
351 |
claimed_card_block = _scan_state->iter_claimed_next(region_idx, _block_size); |
34246 | 352 |
} |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
353 |
if (current_card < claimed_card_block) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
354 |
continue; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
355 |
} |
35461 | 356 |
HeapWord* card_start = _g1h->bot()->address_for_index(card_index); |
34246 | 357 |
|
358 |
HeapRegion* card_region = _g1h->heap_region_containing(card_start); |
|
359 |
_cards++; |
|
360 |
||
38154 | 361 |
_scan_state->add_dirty_region(card_region->hrm_index()); |
34246 | 362 |
|
363 |
// If the card is dirty, then we will scan it during updateRS. |
|
364 |
if (!card_region->in_collection_set() && |
|
365 |
!_ct_bs->is_card_dirty(card_index)) { |
|
46518
69f8479862a2
8162928: Micro-optimizations in scanning the remembered sets
tschatzl
parents:
46517
diff
changeset
|
366 |
scan_card(card_index, card_start, card_region); |
1374 | 367 |
} |
368 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
369 |
if (_scan_state->set_iter_complete(region_idx)) { |
34246 | 370 |
// Scan the strong code root list attached to the current region |
371 |
scan_strong_code_roots(r); |
|
1374 | 372 |
} |
34246 | 373 |
return false; |
374 |
} |
|
1374 | 375 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
376 |
size_t G1RemSet::scan_rem_set(G1ParPushHeapRSClosure* oops_in_heap_closure, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
377 |
CodeBlobClosure* heap_region_codeblobs, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
378 |
uint worker_i) { |
1374 | 379 |
double rs_time_start = os::elapsedTime(); |
32617
a59435e1fecc
8135012: Don't use G1RootProcessor when scanning remembered sets
mgerdin
parents:
31592
diff
changeset
|
380 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
381 |
G1ScanRSClosure cl(_scan_state, oops_in_heap_closure, 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
|
382 |
_g1->collection_set_iterate_from(&cl, worker_i); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
383 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
384 |
double scan_rs_time_sec = (os::elapsedTime() - rs_time_start) - |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
385 |
cl.strong_code_root_scan_time_sec(); |
1374 | 386 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28207
diff
changeset
|
387 |
_g1p->phase_times()->record_time_secs(G1GCPhaseTimes::ScanRS, worker_i, scan_rs_time_sec); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
388 |
_g1p->phase_times()->record_time_secs(G1GCPhaseTimes::CodeRoots, worker_i, cl.strong_code_root_scan_time_sec()); |
32737
f02118695c2f
8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents:
32617
diff
changeset
|
389 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
390 |
return cl.cards_done(); |
1374 | 391 |
} |
392 |
||
6247 | 393 |
// Closure used for updating RSets and recording references that |
394 |
// point into the collection set. Only called during an |
|
395 |
// evacuation pause. |
|
396 |
||
397 |
class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure { |
|
398 |
G1RemSet* _g1rs; |
|
399 |
DirtyCardQueue* _into_cset_dcq; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
400 |
G1ParPushHeapRSClosure* _cl; |
6247 | 401 |
public: |
402 |
RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h, |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
403 |
DirtyCardQueue* into_cset_dcq, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
404 |
G1ParPushHeapRSClosure* cl) : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
405 |
_g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq), _cl(cl) |
6247 | 406 |
{} |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
407 |
|
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23455
diff
changeset
|
408 |
bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
6247 | 409 |
// The only time we care about recording cards that |
410 |
// contain references that point into the collection set |
|
411 |
// is during RSet updating within an evacuation pause. |
|
412 |
// In this case worker_i should be the id of a GC worker thread. |
|
413 |
assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause"); |
|
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27009
diff
changeset
|
414 |
assert(worker_i < ParallelGCThreads, "should be a GC worker"); |
1374 | 415 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
416 |
if (_g1rs->refine_card(card_ptr, worker_i, _cl)) { |
6247 | 417 |
// 'card_ptr' contains references that point into the collection |
418 |
// 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
|
419 |
// (_into_cset_dirty_card_queue_set) |
6247 | 420 |
// that's used for that purpose. |
421 |
// |
|
422 |
// Enqueue the card |
|
423 |
_into_cset_dcq->enqueue(card_ptr); |
|
424 |
} |
|
425 |
return true; |
|
426 |
} |
|
427 |
}; |
|
428 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
429 |
void G1RemSet::update_rem_set(DirtyCardQueue* into_cset_dcq, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
430 |
G1ParPushHeapRSClosure* oops_in_heap_closure, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
431 |
uint worker_i) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
432 |
RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq, oops_in_heap_closure); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
433 |
|
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
434 |
G1GCParPhaseTimesTracker x(_g1p->phase_times(), G1GCPhaseTimes::UpdateRS, worker_i); |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
435 |
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
|
436 |
// 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
|
437 |
G1GCParPhaseTimesTracker y(_g1p->phase_times(), G1GCPhaseTimes::ScanHCC, worker_i); |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
438 |
_g1->iterate_hcc_closure(&into_cset_update_rs_cl, worker_i); |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
439 |
} |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
440 |
// Apply the closure to all remaining log entries. |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
441 |
_g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, worker_i); |
1374 | 442 |
} |
443 |
||
6958 | 444 |
void G1RemSet::cleanupHRRS() { |
1374 | 445 |
HeapRegionRemSet::cleanup(); |
446 |
} |
|
447 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
448 |
size_t G1RemSet::oops_into_collection_set_do(G1ParPushHeapRSClosure* cl, |
33213
b937f634f56e
8138762: Refactor setup of evacuation closures in G1
mgerdin
parents:
33204
diff
changeset
|
449 |
CodeBlobClosure* heap_region_codeblobs, |
32737
f02118695c2f
8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents:
32617
diff
changeset
|
450 |
uint worker_i) { |
6247 | 451 |
// A DirtyCardQueue that is used to hold cards containing references |
452 |
// that point into the collection set. This DCQ is associated with a |
|
453 |
// special DirtyCardQueueSet (see g1CollectedHeap.hpp). Under normal |
|
454 |
// circumstances (i.e. the pause successfully completes), these cards |
|
455 |
// are just discarded (there's no need to update the RSets of regions |
|
456 |
// that were in the collection set - after the pause these regions |
|
457 |
// 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
|
458 |
// 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
|
459 |
// 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
|
460 |
DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set); |
6247 | 461 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
462 |
update_rem_set(&into_cset_dcq, cl, worker_i); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
463 |
return scan_rem_set(cl, heap_region_codeblobs, worker_i);; |
1374 | 464 |
} |
465 |
||
6958 | 466 |
void G1RemSet::prepare_for_oops_into_collection_set_do() { |
1374 | 467 |
_g1->set_refine_cte_cl_concurrency(false); |
468 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
469 |
dcqs.concatenate_logs(); |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
470 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
471 |
_scan_state->reset(); |
1374 | 472 |
} |
473 |
||
6958 | 474 |
void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
38154 | 475 |
G1GCPhaseTimes* phase_times = _g1->g1_policy()->phase_times(); |
1374 | 476 |
// Cleanup after copy |
477 |
_g1->set_refine_cte_cl_concurrency(true); |
|
38154 | 478 |
|
1374 | 479 |
// Set all cards back to clean. |
38154 | 480 |
double start = os::elapsedTime(); |
481 |
_scan_state->clear_card_table(_g1->workers()); |
|
482 |
phase_times->record_clear_ct_time((os::elapsedTime() - start) * 1000.0); |
|
2881 | 483 |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
484 |
DirtyCardQueueSet& into_cset_dcqs = _into_cset_dirty_card_queue_set; |
6247 | 485 |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
486 |
if (_g1->evacuation_failed()) { |
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
487 |
double restore_remembered_set_start = os::elapsedTime(); |
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
488 |
|
6247 | 489 |
// 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
|
490 |
// 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
|
491 |
// 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
|
492 |
// 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
|
493 |
_g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); |
38154 | 494 |
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
|
495 |
} |
6247 | 496 |
|
497 |
// Free any completed buffers in the DirtyCardQueueSet used to hold cards |
|
498 |
// 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
|
499 |
_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
|
500 |
assert(_into_cset_dirty_card_queue_set.completed_buffers_num() == 0, |
6247 | 501 |
"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
|
502 |
_into_cset_dirty_card_queue_set.clear_n_completed_buffers(); |
1374 | 503 |
} |
504 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
505 |
class G1ScrubRSClosure: public HeapRegionClosure { |
1374 | 506 |
G1CollectedHeap* _g1h; |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
507 |
G1CardLiveData* _live_data; |
1374 | 508 |
public: |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
509 |
G1ScrubRSClosure(G1CardLiveData* live_data) : |
1374 | 510 |
_g1h(G1CollectedHeap::heap()), |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
511 |
_live_data(live_data) { } |
1374 | 512 |
|
513 |
bool doHeapRegion(HeapRegion* r) { |
|
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26701
diff
changeset
|
514 |
if (!r->is_continues_humongous()) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
515 |
r->rem_set()->scrub(_live_data); |
1374 | 516 |
} |
517 |
return false; |
|
518 |
} |
|
519 |
}; |
|
520 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
521 |
void G1RemSet::scrub(uint worker_num, HeapRegionClaimer *hrclaimer) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
522 |
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
|
523 |
_g1->heap_region_par_iterate(&scrub_cl, worker_num, hrclaimer); |
1374 | 524 |
} |
525 |
||
46307
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
526 |
G1UpdateRSOrPushRefOopClosure::G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
527 |
G1ParPushHeapRSClosure* push_ref_cl, |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
528 |
bool record_refs_into_cset, |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
529 |
uint worker_i) : |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
530 |
_g1(g1h), |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
531 |
_from(NULL), |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
532 |
_record_refs_into_cset(record_refs_into_cset), |
46307
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
533 |
_has_refs_into_cset(false), |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
534 |
_push_ref_cl(push_ref_cl), |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
535 |
_worker_i(worker_i) { } |
6247 | 536 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
537 |
// Returns true if the given card contains references that point |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
538 |
// into the collection set, if we're checking for such references; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
539 |
// false otherwise. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
540 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
541 |
bool G1RemSet::refine_card(jbyte* card_ptr, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
542 |
uint worker_i, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
543 |
G1ParPushHeapRSClosure* oops_in_heap_closure) { |
26160 | 544 |
assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
545 |
"Card at " PTR_FORMAT " index " SIZE_FORMAT " representing heap at " PTR_FORMAT " (%u) must be in committed heap", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
546 |
p2i(card_ptr), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
547 |
_ct_bs->index_for(_ct_bs->addr_for(card_ptr)), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
548 |
p2i(_ct_bs->addr_for(card_ptr)), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
549 |
_g1->addr_to_region(_ct_bs->addr_for(card_ptr))); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
550 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
551 |
bool check_for_refs_into_cset = oops_in_heap_closure != NULL; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
552 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
553 |
// 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
|
554 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
555 |
// 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
|
556 |
// into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
557 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
558 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
559 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
560 |
// Construct the region representing the card. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
561 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
562 |
// And find the region containing it. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
563 |
HeapRegion* r = _g1->heap_region_containing(start); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
564 |
|
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
565 |
// This check is needed for some uncommon cases where we should |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
566 |
// ignore the card. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
567 |
// |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
568 |
// The region could be young. Cards for young regions are |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
569 |
// distinctly marked (set to g1_young_gen), so the post-barrier will |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
570 |
// filter them out. However, that marking is performed |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
571 |
// concurrently. A write to a young object could occur before the |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
572 |
// card has been marked young, slipping past the filter. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
573 |
// |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
574 |
// The card could be stale, because the region has been freed since |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
575 |
// the card was recorded. In this case the region type could be |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
576 |
// anything. If (still) free or (reallocated) young, just ignore |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
577 |
// it. If (reallocated) old or humongous, the later card trimming |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
578 |
// and additional checks in iteration may detect staleness. At |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
579 |
// worst, we end up processing a stale card unnecessarily. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
580 |
// |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
581 |
// In the normal (non-stale) case, the synchronization between the |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
582 |
// enqueueing of the card and processing it here will have ensured |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
583 |
// we see the up-to-date region type here. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
584 |
if (!r->is_old_or_humongous()) { |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
585 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
586 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
587 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
588 |
// While we are processing RSet buffers during the collection, we |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
589 |
// actually don't want to scan any cards on the collection set, |
22551 | 590 |
// since we don't want to update remembered sets with entries that |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
591 |
// point into the collection set, given that live objects from the |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
592 |
// collection set are about to move and such entries will be stale |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
593 |
// very soon. This change also deals with a reliability issue which |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
594 |
// involves scanning a card in the collection set and coming across |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
595 |
// an array that was being chunked and looking malformed. Note, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
596 |
// however, that if evacuation fails, we have to scan any objects |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
597 |
// that were not moved and create any missing entries. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
598 |
if (r->in_collection_set()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
599 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
600 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
601 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
602 |
// The result from the hot card cache insert call is either: |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
603 |
// * pointer to the current card |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
604 |
// (implying that the current card is not 'hot'), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
605 |
// * null |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
606 |
// (meaning we had inserted the card ptr into the "hot" card cache, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
607 |
// which had some headroom), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
608 |
// * a pointer to a "hot" card that was evicted from the "hot" cache. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
609 |
// |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
610 |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
611 |
if (_hot_card_cache->use_cache()) { |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
612 |
assert(!check_for_refs_into_cset, "sanity"); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
613 |
assert(!SafepointSynchronize::is_at_safepoint(), "sanity"); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
614 |
|
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
615 |
const jbyte* orig_card_ptr = card_ptr; |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
616 |
card_ptr = _hot_card_cache->insert(card_ptr); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
617 |
if (card_ptr == NULL) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
618 |
// There was no eviction. Nothing to do. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
619 |
return false; |
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
620 |
} else if (card_ptr != orig_card_ptr) { |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
621 |
// Original card was inserted and an old card was evicted. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
622 |
start = _ct_bs->addr_for(card_ptr); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
623 |
r = _g1->heap_region_containing(start); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
624 |
|
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
625 |
// Check whether the region formerly in the cache should be |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
626 |
// ignored, as discussed earlier for the original card. The |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
627 |
// region could have been freed while in the cache. The cset is |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
628 |
// not relevant here, since we're in concurrent phase. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
629 |
if (!r->is_old_or_humongous()) { |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
630 |
return false; |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
631 |
} |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
632 |
} // Else we still have the original card. |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
633 |
} |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
634 |
|
42589
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
635 |
// Trim the region designated by the card to what's been allocated |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
636 |
// in the region. The card could be stale, or the card could cover |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
637 |
// (part of) an object at the end of the allocated space and extend |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
638 |
// beyond the end of allocation. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
639 |
HeapWord* scan_limit; |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
640 |
if (_g1->is_gc_active()) { |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
641 |
// If we're in a STW GC, then a card might be in a GC alloc region |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
642 |
// and extend onto a GC LAB, which may not be parsable. Stop such |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
643 |
// at the "scan_top" of the region. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
644 |
scan_limit = r->scan_top(); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
645 |
} else { |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
646 |
// Non-humongous objects are only allocated in the old-gen during |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
647 |
// GC, so if region is old then top is stable. Humongous object |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
648 |
// allocation sets top last; if top has not yet been set, this is |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
649 |
// a stale card and we'll end up with an empty intersection. If |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
650 |
// this is not a stale card, the synchronization between the |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
651 |
// enqueuing of the card and processing it here will have ensured |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
652 |
// we see the up-to-date top here. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
653 |
scan_limit = r->top(); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
654 |
} |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
655 |
if (scan_limit <= start) { |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
656 |
// If the trimmed region is empty, the card must be stale. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
657 |
return false; |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
658 |
} |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
659 |
|
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
660 |
// Okay to clean and process the card now. There are still some |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
661 |
// stale card cases that may be detected by iteration and dealt with |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
662 |
// as iteration failure. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
663 |
*const_cast<volatile jbyte*>(card_ptr) = CardTableModRefBS::clean_card_val(); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
664 |
|
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
665 |
// This fence serves two purposes. First, the card must be cleaned |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
666 |
// before processing the contents. Second, we can't proceed with |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
667 |
// processing until after the read of top, for synchronization with |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
668 |
// possibly concurrent humongous object allocation. It's okay that |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
669 |
// reading top and reading type were racy wrto each other. We need |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
670 |
// both set, in any order, to proceed. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
671 |
OrderAccess::fence(); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
672 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
673 |
// 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
|
674 |
// a card beyond the heap. |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
675 |
HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
676 |
MemRegion dirty_region(start, MIN2(scan_limit, end)); |
037b433e8069
8166811: Missing memory fences between memory allocation and refinement
kbarrett
parents:
42588
diff
changeset
|
677 |
assert(!dirty_region.is_empty(), "sanity"); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
678 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
679 |
G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
680 |
oops_in_heap_closure, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
681 |
check_for_refs_into_cset, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
682 |
worker_i); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
683 |
update_rs_oop_cl.set_from(r); |
6247 | 684 |
|
46517
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
685 |
bool card_processed; |
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
686 |
if (_g1->is_gc_active()) { |
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
687 |
card_processed = r->oops_on_card_seq_iterate_careful<true>(dirty_region, &update_rs_oop_cl); |
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
688 |
} else { |
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
689 |
card_processed = r->oops_on_card_seq_iterate_careful<false>(dirty_region, &update_rs_oop_cl); |
14de3e5151a9
8071280: Specialize HeapRegion::oops_on_card_seq_iterate_careful() for use during concurrent refinement and updating the rset
tschatzl
parents:
46307
diff
changeset
|
690 |
} |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
691 |
|
41313
6593aed45a67
8166663: Simplify oops_on_card_seq_iterate_careful
kbarrett
parents:
39698
diff
changeset
|
692 |
// If unable to process the card then we encountered an unparsable |
42588 | 693 |
// part of the heap (e.g. a partially allocated object) while |
694 |
// processing a stale card. Despite the card being stale, redirty |
|
695 |
// and re-enqueue, because we've already cleaned the card. Without |
|
696 |
// this we could incorrectly discard a non-stale card. |
|
41313
6593aed45a67
8166663: Simplify oops_on_card_seq_iterate_careful
kbarrett
parents:
39698
diff
changeset
|
697 |
if (!card_processed) { |
6593aed45a67
8166663: Simplify oops_on_card_seq_iterate_careful
kbarrett
parents:
39698
diff
changeset
|
698 |
assert(!_g1->is_gc_active(), "Unparsable heap during GC"); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
699 |
// The card might have gotten re-dirtied and re-enqueued while we |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
700 |
// worked. (In fact, it's pretty likely.) |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
701 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
702 |
*card_ptr = CardTableModRefBS::dirty_card_val(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
703 |
MutexLockerEx x(Shared_DirtyCardQ_lock, |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
704 |
Mutex::_no_safepoint_check_flag); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
705 |
DirtyCardQueue* sdcq = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
706 |
JavaThread::dirty_card_queue_set().shared_dirty_card_queue(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
707 |
sdcq->enqueue(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
708 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
709 |
} else { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
710 |
_conc_refine_cards++; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
711 |
} |
6247 | 712 |
|
46307
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
713 |
// This gets set to true if the card being refined has references that point |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
714 |
// into the collection set. |
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
715 |
bool has_refs_into_cset = update_rs_oop_cl.has_refs_into_cset(); |
1374 | 716 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
717 |
// We should only be detecting that the card contains references |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
718 |
// that point into the collection set if the current thread is |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
719 |
// a GC worker thread. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
720 |
assert(!has_refs_into_cset || SafepointSynchronize::is_at_safepoint(), |
46307
686d50172bfd
8071278: Fix the closure mess in G1RemSet::refine_card()
tschatzl
parents:
42589
diff
changeset
|
721 |
"invalid result at non safepoint"); |
6247 | 722 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
723 |
return has_refs_into_cset; |
1374 | 724 |
} |
725 |
||
35061 | 726 |
void G1RemSet::print_periodic_summary_info(const char* header, uint period_count) { |
727 |
if ((G1SummarizeRSetStatsPeriod > 0) && log_is_enabled(Trace, gc, remset) && |
|
728 |
(period_count % G1SummarizeRSetStatsPeriod == 0)) { |
|
729 |
||
730 |
if (!_prev_period_summary.initialized()) { |
|
731 |
_prev_period_summary.initialize(this); |
|
732 |
} |
|
1374 | 733 |
|
35061 | 734 |
G1RemSetSummary current; |
735 |
current.initialize(this); |
|
736 |
_prev_period_summary.subtract_from(¤t); |
|
1374 | 737 |
|
37242 | 738 |
Log(gc, remset) log; |
35061 | 739 |
log.trace("%s", header); |
740 |
ResourceMark rm; |
|
741 |
_prev_period_summary.print_on(log.trace_stream()); |
|
742 |
||
743 |
_prev_period_summary.set(¤t); |
|
744 |
} |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
745 |
} |
2881 | 746 |
|
6958 | 747 |
void G1RemSet::print_summary_info() { |
37242 | 748 |
Log(gc, remset, exit) log; |
35061 | 749 |
if (log.is_trace()) { |
750 |
log.trace(" Cumulative RS summary"); |
|
751 |
G1RemSetSummary current; |
|
752 |
current.initialize(this); |
|
753 |
ResourceMark rm; |
|
754 |
current.print_on(log.trace_stream()); |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
755 |
} |
1374 | 756 |
} |
6247 | 757 |
|
6958 | 758 |
void G1RemSet::prepare_for_verify() { |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
759 |
if (G1HRRSFlushLogBuffersOnVerify && |
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
760 |
(VerifyBeforeGC || VerifyAfterGC) |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30764
diff
changeset
|
761 |
&& (!_g1->collector_state()->full_collection() || G1VerifyRSetsDuringFullGC)) { |
1374 | 762 |
cleanupHRRS(); |
763 |
_g1->set_refine_cte_cl_concurrency(false); |
|
764 |
if (SafepointSynchronize::is_at_safepoint()) { |
|
765 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
766 |
dcqs.concatenate_logs(); |
|
767 |
} |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
768 |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
769 |
bool use_hot_card_cache = _hot_card_cache->use_cache(); |
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
770 |
_hot_card_cache->set_use_cache(false); |
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
771 |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
772 |
DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set); |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
773 |
update_rem_set(&into_cset_dcq, NULL, 0); |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
774 |
_into_cset_dirty_card_queue_set.clear(); |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
775 |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
38160
diff
changeset
|
776 |
_hot_card_cache->set_use_cache(use_hot_card_cache); |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
777 |
assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
1374 | 778 |
} |
779 |
} |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
780 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
781 |
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
|
782 |
_card_live_data.create(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
783 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
784 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
785 |
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
|
786 |
_card_live_data.finalize(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
787 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
788 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
789 |
void G1RemSet::verify_card_live_data(WorkGang* workers, G1CMBitMap* bitmap) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
790 |
_card_live_data.verify(workers, bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
791 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
792 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
793 |
void G1RemSet::clear_card_live_data(WorkGang* workers) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
794 |
_card_live_data.clear(workers); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
795 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
796 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
797 |
#ifdef ASSERT |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
798 |
void G1RemSet::verify_card_live_data_is_clear() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
799 |
_card_live_data.verify_is_clear(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
800 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
801 |
#endif |