author | tschatzl |
Mon, 18 Apr 2016 16:51:14 +0200 | |
changeset 37988 | bf4018edea5e |
parent 37985 | 539c597ee0fa |
child 38154 | 4c30333c304e |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
35469
17ea1b453dd5
8146694: Break out shared constants and static BOT functions.
david
parents:
35461
diff
changeset
|
2 |
* Copyright (c) 2001, 2016, 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" |
27 |
#include "gc/g1/concurrentG1RefineThread.hpp" |
|
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
28 |
#include "gc/g1/dirtyCardQueue.hpp" |
30764 | 29 |
#include "gc/g1/g1BlockOffsetTable.inline.hpp" |
30 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
|
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
31 |
#include "gc/g1/g1FromCardCache.hpp" |
30764 | 32 |
#include "gc/g1/g1GCPhaseTimes.hpp" |
33 |
#include "gc/g1/g1HotCardCache.hpp" |
|
34 |
#include "gc/g1/g1OopClosures.inline.hpp" |
|
35 |
#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
|
36 |
#include "gc/g1/g1SATBCardTableModRefBS.inline.hpp" |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
37 |
#include "gc/g1/heapRegion.inline.hpp" |
30764 | 38 |
#include "gc/g1/heapRegionManager.inline.hpp" |
39 |
#include "gc/g1/heapRegionRemSet.hpp" |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
40 |
#include "gc/shared/gcTraceTime.inline.hpp" |
7397 | 41 |
#include "memory/iterator.hpp" |
37248 | 42 |
#include "memory/resourceArea.hpp" |
7397 | 43 |
#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
|
44 |
#include "utilities/globalDefinitions.hpp" |
7397 | 45 |
#include "utilities/intHisto.hpp" |
30175 | 46 |
#include "utilities/stack.inline.hpp" |
1374 | 47 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
48 |
// Collects information about the overall remembered set scan progress during an evacuation. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
49 |
class G1RemSetScanState : public CHeapObj<mtGC> { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
50 |
private: |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
51 |
size_t _max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
52 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
53 |
// 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
|
54 |
// Unclaimed -> Claimed -> Complete. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
55 |
// 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
|
56 |
// 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
|
57 |
typedef jint G1RemsetIterState; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
58 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
59 |
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
|
60 |
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
|
61 |
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
|
62 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
63 |
G1RemsetIterState volatile* _iter_states; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
64 |
// 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
|
65 |
// remembered set. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
66 |
size_t volatile* _iter_claims; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
67 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
68 |
public: |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
69 |
G1RemSetScanState() : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
70 |
_max_regions(0), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
71 |
_iter_states(NULL), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
72 |
_iter_claims(NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
73 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
74 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
75 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
76 |
~G1RemSetScanState() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
77 |
if (_iter_states != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
78 |
FREE_C_HEAP_ARRAY(G1RemsetIterState, _iter_states); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
79 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
80 |
if (_iter_claims != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
81 |
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
|
82 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
83 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
84 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
85 |
void initialize(uint max_regions) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
86 |
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
|
87 |
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
|
88 |
_max_regions = max_regions; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
89 |
_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
|
90 |
_iter_claims = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
91 |
} |
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 |
void reset() { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
94 |
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
|
95 |
_iter_states[i] = Unclaimed; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
96 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
97 |
memset((void*)_iter_claims, 0, _max_regions * sizeof(size_t)); |
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 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
100 |
// 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
|
101 |
// 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
|
102 |
inline bool claim_iter(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
103 |
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
|
104 |
if (_iter_states[region] != Unclaimed) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
105 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
106 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
107 |
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
|
108 |
return (res == Unclaimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
109 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
110 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
111 |
// 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
|
112 |
// thread that caused the transition. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
113 |
inline bool set_iter_complete(uint region) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
114 |
if (iter_is_complete(region)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
115 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
116 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
117 |
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
|
118 |
return (res == Claimed); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
119 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
120 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
121 |
// 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
|
122 |
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
|
123 |
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
|
124 |
return _iter_states[region] == Complete; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
125 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
126 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
127 |
// 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
|
128 |
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
|
129 |
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
|
130 |
return _iter_claims[region]; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
131 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
132 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
133 |
// 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
|
134 |
// step size. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
135 |
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
|
136 |
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
|
137 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
138 |
}; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
139 |
|
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
140 |
G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) : |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
141 |
_g1(g1), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
142 |
_scan_state(new G1RemSetScanState()), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
143 |
_conc_refine_cards(0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
144 |
_ct_bs(ct_bs), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
145 |
_g1p(_g1->g1_policy()), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
146 |
_cg1r(g1->concurrent_g1_refine()), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
147 |
_prev_period_summary(), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
148 |
_into_cset_dirty_card_queue_set(false) |
1374 | 149 |
{ |
35061 | 150 |
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
|
151 |
_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
|
152 |
} |
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
153 |
// 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
|
154 |
// references into the collection set. |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
155 |
_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
|
156 |
DirtyCardQ_CBL_mon, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
157 |
DirtyCardQ_FL_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
158 |
-1, // never trigger processing |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
159 |
-1, // no limit on length |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
160 |
Shared_DirtyCardQ_lock, |
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
161 |
&JavaThread::dirty_card_queue_set()); |
1374 | 162 |
} |
163 |
||
6958 | 164 |
G1RemSet::~G1RemSet() { |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
165 |
if (_scan_state != NULL) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
166 |
delete _scan_state; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
167 |
} |
1374 | 168 |
} |
169 |
||
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
170 |
uint G1RemSet::num_par_rem_sets() { |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
171 |
return MAX2(DirtyCardQueueSet::num_par_ids() + ConcurrentG1Refine::thread_num(), ParallelGCThreads); |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
172 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
173 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
174 |
void G1RemSet::initialize(size_t capacity, uint max_regions) { |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
175 |
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
|
176 |
_scan_state->initialize(max_regions); |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
177 |
{ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
178 |
GCTraceTime(Debug, gc, marking)("Initialize Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
179 |
_card_live_data.initialize(capacity, max_regions); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
180 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
181 |
if (G1PretouchAuxiliaryMemory) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
182 |
GCTraceTime(Debug, gc, marking)("Pre-Touch Card Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
183 |
_card_live_data.pretouch(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
184 |
} |
35210
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
185 |
} |
eb1d5c68bf64
8145672: Remove dependency of G1FromCardCache to HeapRegionRemSet
tschatzl
parents:
35198
diff
changeset
|
186 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
187 |
G1ScanRSClosure::G1ScanRSClosure(G1RemSetScanState* scan_state, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
188 |
G1ParPushHeapRSClosure* push_heap_cl, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
189 |
CodeBlobClosure* code_root_cl, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
190 |
uint worker_i) : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
191 |
_scan_state(scan_state), |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
192 |
_push_heap_cl(push_heap_cl), |
35198
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
193 |
_code_root_cl(code_root_cl), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
194 |
_strong_code_root_scan_time_sec(0.0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
195 |
_cards(0), |
1365be812a7d
8145674: Fix includes and forward declarations in g1Remset files
tschatzl
parents:
35068
diff
changeset
|
196 |
_cards_done(0), |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
197 |
_worker_i(worker_i) { |
34246 | 198 |
_g1h = G1CollectedHeap::heap(); |
35461 | 199 |
_bot = _g1h->bot(); |
34246 | 200 |
_ct_bs = _g1h->g1_barrier_set(); |
201 |
_block_size = MAX2<size_t>(G1RSetScanBlockSize, 1); |
|
202 |
} |
|
203 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
204 |
void G1ScanRSClosure::scan_card(size_t index, HeapRegion *r) { |
34246 | 205 |
// Stack allocate the DirtyCardToOopClosure instance |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
206 |
HeapRegionDCTOC cl(_g1h, r, _push_heap_cl, CardTableModRefBS::Precise); |
34246 | 207 |
|
208 |
// Set the "from" region in the closure. |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
209 |
_push_heap_cl->set_region(r); |
35469
17ea1b453dd5
8146694: Break out shared constants and static BOT functions.
david
parents:
35461
diff
changeset
|
210 |
MemRegion card_region(_bot->address_for_index(index), BOTConstants::N_words); |
34246 | 211 |
MemRegion pre_gc_allocated(r->bottom(), r->scan_top()); |
212 |
MemRegion mr = pre_gc_allocated.intersection(card_region); |
|
213 |
if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) { |
|
214 |
// We make the card as "claimed" lazily (so races are possible |
|
215 |
// but they're benign), which reduces the number of duplicate |
|
216 |
// scans (the rsets of the regions in the cset can intersect). |
|
217 |
_ct_bs->set_card_claimed(index); |
|
218 |
_cards_done++; |
|
219 |
cl.do_MemRegion(mr); |
|
1374 | 220 |
} |
34246 | 221 |
} |
1374 | 222 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
223 |
void G1ScanRSClosure::scan_strong_code_roots(HeapRegion* r) { |
34246 | 224 |
double scan_start = os::elapsedTime(); |
225 |
r->strong_code_roots_do(_code_root_cl); |
|
226 |
_strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start); |
|
227 |
} |
|
228 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
229 |
bool G1ScanRSClosure::doHeapRegion(HeapRegion* r) { |
34246 | 230 |
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
|
231 |
uint region_idx = r->hrm_index(); |
34246 | 232 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
233 |
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
|
234 |
return false; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
235 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
236 |
if (_scan_state->claim_iter(region_idx)) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
237 |
// 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
|
238 |
// 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
|
239 |
// add regions of the collection set to the dirty cards region. |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
240 |
_g1h->push_dirty_cards_region(r); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
241 |
} |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
242 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
243 |
HeapRegionRemSetIterator iter(r->rem_set()); |
34246 | 244 |
size_t card_index; |
1374 | 245 |
|
34246 | 246 |
// We claim cards in block so as to reduce the contention. The block size is determined by |
247 |
// the G1RSetScanBlockSize parameter. |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
248 |
size_t claimed_card_block = _scan_state->iter_claimed_next(region_idx, _block_size); |
34246 | 249 |
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
|
250 |
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
|
251 |
claimed_card_block = _scan_state->iter_claimed_next(region_idx, _block_size); |
34246 | 252 |
} |
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
253 |
if (current_card < claimed_card_block) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
254 |
continue; |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
255 |
} |
35461 | 256 |
HeapWord* card_start = _g1h->bot()->address_for_index(card_index); |
34246 | 257 |
|
258 |
HeapRegion* card_region = _g1h->heap_region_containing(card_start); |
|
259 |
_cards++; |
|
260 |
||
261 |
if (!card_region->is_on_dirty_cards_region_list()) { |
|
262 |
_g1h->push_dirty_cards_region(card_region); |
|
263 |
} |
|
264 |
||
265 |
// If the card is dirty, then we will scan it during updateRS. |
|
266 |
if (!card_region->in_collection_set() && |
|
267 |
!_ct_bs->is_card_dirty(card_index)) { |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
268 |
scan_card(card_index, card_region); |
1374 | 269 |
} |
270 |
} |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
271 |
if (_scan_state->set_iter_complete(region_idx)) { |
34246 | 272 |
// Scan the strong code root list attached to the current region |
273 |
scan_strong_code_roots(r); |
|
1374 | 274 |
} |
34246 | 275 |
return false; |
276 |
} |
|
1374 | 277 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
278 |
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
|
279 |
CodeBlobClosure* heap_region_codeblobs, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
280 |
uint worker_i) { |
1374 | 281 |
double rs_time_start = os::elapsedTime(); |
32617
a59435e1fecc
8135012: Don't use G1RootProcessor when scanning remembered sets
mgerdin
parents:
31592
diff
changeset
|
282 |
|
11176
9bb1ddd8da51
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
11174
diff
changeset
|
283 |
HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i); |
1374 | 284 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
285 |
G1ScanRSClosure cl(_scan_state, oops_in_heap_closure, heap_region_codeblobs, worker_i); |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
286 |
_g1->collection_set_iterate_from(startRegion, &cl); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10000
diff
changeset
|
287 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
288 |
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
|
289 |
cl.strong_code_root_scan_time_sec(); |
1374 | 290 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28207
diff
changeset
|
291 |
_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
|
292 |
_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
|
293 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
294 |
return cl.cards_done(); |
1374 | 295 |
} |
296 |
||
6247 | 297 |
// Closure used for updating RSets and recording references that |
298 |
// point into the collection set. Only called during an |
|
299 |
// evacuation pause. |
|
300 |
||
301 |
class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure { |
|
302 |
G1RemSet* _g1rs; |
|
303 |
DirtyCardQueue* _into_cset_dcq; |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
304 |
G1ParPushHeapRSClosure* _cl; |
6247 | 305 |
public: |
306 |
RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h, |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
307 |
DirtyCardQueue* into_cset_dcq, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
308 |
G1ParPushHeapRSClosure* cl) : |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
309 |
_g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq), _cl(cl) |
6247 | 310 |
{} |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
311 |
|
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23455
diff
changeset
|
312 |
bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
6247 | 313 |
// The only time we care about recording cards that |
314 |
// contain references that point into the collection set |
|
315 |
// is during RSet updating within an evacuation pause. |
|
316 |
// In this case worker_i should be the id of a GC worker thread. |
|
317 |
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
|
318 |
assert(worker_i < ParallelGCThreads, "should be a GC worker"); |
1374 | 319 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
320 |
if (_g1rs->refine_card(card_ptr, worker_i, _cl)) { |
6247 | 321 |
// 'card_ptr' contains references that point into the collection |
322 |
// 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
|
323 |
// (_into_cset_dirty_card_queue_set) |
6247 | 324 |
// that's used for that purpose. |
325 |
// |
|
326 |
// Enqueue the card |
|
327 |
_into_cset_dcq->enqueue(card_ptr); |
|
328 |
} |
|
329 |
return true; |
|
330 |
} |
|
331 |
}; |
|
332 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
333 |
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
|
334 |
G1ParPushHeapRSClosure* oops_in_heap_closure, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
335 |
uint worker_i) { |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
336 |
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
|
337 |
|
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
338 |
G1GCParPhaseTimesTracker x(_g1p->phase_times(), G1GCPhaseTimes::UpdateRS, worker_i); |
36374 | 339 |
if (ConcurrentG1Refine::hot_card_cache_enabled()) { |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
340 |
// 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
|
341 |
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
|
342 |
_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
|
343 |
} |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33105
diff
changeset
|
344 |
// 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
|
345 |
_g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, worker_i); |
1374 | 346 |
} |
347 |
||
6958 | 348 |
void G1RemSet::cleanupHRRS() { |
1374 | 349 |
HeapRegionRemSet::cleanup(); |
350 |
} |
|
351 |
||
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
352 |
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
|
353 |
CodeBlobClosure* heap_region_codeblobs, |
32737
f02118695c2f
8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents:
32617
diff
changeset
|
354 |
uint worker_i) { |
6247 | 355 |
// A DirtyCardQueue that is used to hold cards containing references |
356 |
// that point into the collection set. This DCQ is associated with a |
|
357 |
// special DirtyCardQueueSet (see g1CollectedHeap.hpp). Under normal |
|
358 |
// circumstances (i.e. the pause successfully completes), these cards |
|
359 |
// are just discarded (there's no need to update the RSets of regions |
|
360 |
// that were in the collection set - after the pause these regions |
|
361 |
// 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
|
362 |
// 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
|
363 |
// 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
|
364 |
DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set); |
6247 | 365 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
366 |
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
|
367 |
return scan_rem_set(cl, heap_region_codeblobs, worker_i);; |
1374 | 368 |
} |
369 |
||
6958 | 370 |
void G1RemSet::prepare_for_oops_into_collection_set_do() { |
1374 | 371 |
_g1->set_refine_cte_cl_concurrency(false); |
372 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
373 |
dcqs.concatenate_logs(); |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
374 |
|
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
375 |
_scan_state->reset(); |
1374 | 376 |
} |
377 |
||
6958 | 378 |
void G1RemSet::cleanup_after_oops_into_collection_set_do() { |
1374 | 379 |
// Cleanup after copy |
380 |
_g1->set_refine_cte_cl_concurrency(true); |
|
381 |
// Set all cards back to clean. |
|
382 |
_g1->cleanUpCardTable(); |
|
2881 | 383 |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
384 |
DirtyCardQueueSet& into_cset_dcqs = _into_cset_dirty_card_queue_set; |
6247 | 385 |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
2009
diff
changeset
|
386 |
if (_g1->evacuation_failed()) { |
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
387 |
double restore_remembered_set_start = os::elapsedTime(); |
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
388 |
|
6247 | 389 |
// 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
|
390 |
// 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
|
391 |
// 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
|
392 |
// 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
|
393 |
_g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs); |
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
22772
diff
changeset
|
394 |
_g1->g1_policy()->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
|
395 |
} |
6247 | 396 |
|
397 |
// Free any completed buffers in the DirtyCardQueueSet used to hold cards |
|
398 |
// 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
|
399 |
_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
|
400 |
assert(_into_cset_dirty_card_queue_set.completed_buffers_num() == 0, |
6247 | 401 |
"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
|
402 |
_into_cset_dirty_card_queue_set.clear_n_completed_buffers(); |
1374 | 403 |
} |
404 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
405 |
class G1ScrubRSClosure: public HeapRegionClosure { |
1374 | 406 |
G1CollectedHeap* _g1h; |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
407 |
G1CardLiveData* _live_data; |
1374 | 408 |
public: |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
409 |
G1ScrubRSClosure(G1CardLiveData* live_data) : |
1374 | 410 |
_g1h(G1CollectedHeap::heap()), |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
411 |
_live_data(live_data) { } |
1374 | 412 |
|
413 |
bool doHeapRegion(HeapRegion* r) { |
|
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26701
diff
changeset
|
414 |
if (!r->is_continues_humongous()) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
415 |
r->rem_set()->scrub(_live_data); |
1374 | 416 |
} |
417 |
return false; |
|
418 |
} |
|
419 |
}; |
|
420 |
||
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
421 |
void G1RemSet::scrub(uint worker_num, HeapRegionClaimer *hrclaimer) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
422 |
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
|
423 |
_g1->heap_region_par_iterate(&scrub_cl, worker_num, hrclaimer); |
1374 | 424 |
} |
425 |
||
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
426 |
G1TriggerClosure::G1TriggerClosure() : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
427 |
_triggered(false) { } |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
428 |
|
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
429 |
G1InvokeIfNotTriggeredClosure::G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t_cl, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
430 |
OopClosure* oop_cl) : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
431 |
_trigger_cl(t_cl), _oop_cl(oop_cl) { } |
6247 | 432 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
433 |
G1Mux2Closure::G1Mux2Closure(OopClosure *c1, OopClosure *c2) : |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
434 |
_c1(c1), _c2(c2) { } |
6247 | 435 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
436 |
G1UpdateRSOrPushRefOopClosure:: |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
437 |
G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
438 |
G1RemSet* rs, |
28207
6ad23566cbef
8067655: Clean up G1 remembered set oop iteration
mgerdin
parents:
27905
diff
changeset
|
439 |
G1ParPushHeapRSClosure* push_ref_cl, |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
440 |
bool record_refs_into_cset, |
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23455
diff
changeset
|
441 |
uint worker_i) : |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
442 |
_g1(g1h), _g1_rem_set(rs), _from(NULL), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
443 |
_record_refs_into_cset(record_refs_into_cset), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
444 |
_push_ref_cl(push_ref_cl), _worker_i(worker_i) { } |
6247 | 445 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
446 |
// 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
|
447 |
// 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
|
448 |
// false otherwise. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
449 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
450 |
bool G1RemSet::refine_card(jbyte* card_ptr, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
451 |
uint worker_i, |
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
452 |
G1ParPushHeapRSClosure* oops_in_heap_closure) { |
26160 | 453 |
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
|
454 |
"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
|
455 |
p2i(card_ptr), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
456 |
_ct_bs->index_for(_ct_bs->addr_for(card_ptr)), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
457 |
p2i(_ct_bs->addr_for(card_ptr)), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32737
diff
changeset
|
458 |
_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
|
459 |
|
37988
bf4018edea5e
8153503: Move remset scan iteration claim to remset local data structure
tschatzl
parents:
37985
diff
changeset
|
460 |
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
|
461 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
462 |
// 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
|
463 |
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
|
464 |
// 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
|
465 |
// into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
466 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
467 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
468 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
469 |
// Construct the region representing the card. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
470 |
HeapWord* start = _ct_bs->addr_for(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
471 |
// And find the region containing it. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
472 |
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
|
473 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
474 |
// Why do we have to check here whether a card is on a young region, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
475 |
// given that we dirty young regions and, as a result, the |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
476 |
// post-barrier is supposed to filter them out and never to enqueue |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
477 |
// them? When we allocate a new region as the "allocation region" we |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
478 |
// actually dirty its cards after we release the lock, since card |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
479 |
// dirtying while holding the lock was a performance bottleneck. So, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
480 |
// as a result, it is possible for other threads to actually |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
481 |
// allocate objects in the region (after the acquire the lock) |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
482 |
// before all the cards on the region are dirtied. This is unlikely, |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
483 |
// and it doesn't happen often, but it can happen. So, the extra |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
484 |
// check below filters out those cards. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
485 |
if (r->is_young()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
486 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
487 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
488 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
489 |
// 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
|
490 |
// actually don't want to scan any cards on the collection set, |
22551 | 491 |
// 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
|
492 |
// 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
|
493 |
// 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
|
494 |
// 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
|
495 |
// 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
|
496 |
// 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
|
497 |
// 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
|
498 |
// 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
|
499 |
if (r->in_collection_set()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
500 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
501 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
502 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
503 |
// 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
|
504 |
// * pointer to the current card |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
505 |
// (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
|
506 |
// * null |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
507 |
// (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
|
508 |
// which had some headroom), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
509 |
// * 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
|
510 |
// |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
511 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
512 |
G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
513 |
if (hot_card_cache->use_cache()) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
514 |
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
|
515 |
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
|
516 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
517 |
card_ptr = hot_card_cache->insert(card_ptr); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
518 |
if (card_ptr == NULL) { |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
519 |
// 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
|
520 |
return false; |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
521 |
} |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
522 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
523 |
start = _ct_bs->addr_for(card_ptr); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
524 |
r = _g1->heap_region_containing(start); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
525 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
526 |
// Checking whether the region we got back from the cache |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
527 |
// is young here is inappropriate. The region could have been |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
528 |
// freed, reallocated and tagged as young while in the cache. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
529 |
// Hence we could see its young type change at any time. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
530 |
} |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
531 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
532 |
// Don't use addr_for(card_ptr + 1) which can ask for |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
533 |
// a card beyond the heap. This is not safe without a perm |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
534 |
// gen at the upper end of the heap. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13516
diff
changeset
|
535 |
HeapWord* end = start + CardTableModRefBS::card_size_in_words; |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
536 |
MemRegion dirtyRegion(start, end); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
537 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
538 |
G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
539 |
_g1->g1_rem_set(), |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
540 |
oops_in_heap_closure, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
541 |
check_for_refs_into_cset, |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
542 |
worker_i); |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
543 |
update_rs_oop_cl.set_from(r); |
6247 | 544 |
|
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
545 |
G1TriggerClosure trigger_cl; |
35068
b0d5016aecc7
8144584: Change FilterIntoCSClosure to inherit OopClosure
sjohanss
parents:
35061
diff
changeset
|
546 |
FilterIntoCSClosure into_cs_cl(_g1, &trigger_cl); |
11586
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
547 |
G1InvokeIfNotTriggeredClosure invoke_cl(&trigger_cl, &into_cs_cl); |
ccc217c177ee
7133038: G1: Some small profile based optimizations
johnc
parents:
11396
diff
changeset
|
548 |
G1Mux2Closure mux(&invoke_cl, &update_rs_oop_cl); |
6247 | 549 |
|
550 |
FilterOutOfRegionClosure filter_then_update_rs_oop_cl(r, |
|
551 |
(check_for_refs_into_cset ? |
|
552 |
(OopClosure*)&mux : |
|
553 |
(OopClosure*)&update_rs_oop_cl)); |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
554 |
|
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
555 |
// The region for the current card may be a young region. The |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
556 |
// current card may have been a card that was evicted from the |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
557 |
// card cache. When the card was inserted into the cache, we had |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
558 |
// determined that its region was non-young. While in the cache, |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
559 |
// the region may have been freed during a cleanup pause, reallocated |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
560 |
// and tagged as young. |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
561 |
// |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
562 |
// We wish to filter out cards for such a region but the current |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
563 |
// thread, if we're running concurrently, may "see" the young type |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
564 |
// change at any time (so an earlier "is_young" check may pass or |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
565 |
// fail arbitrarily). We tell the iteration code to perform this |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
566 |
// filtering when it has been determined that there has been an actual |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
567 |
// allocation in this region and making it safe to check the young type. |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
568 |
bool filter_young = true; |
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
569 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
570 |
HeapWord* stop_point = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
571 |
r->oops_on_card_seq_iterate_careful(dirtyRegion, |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
572 |
&filter_then_update_rs_oop_cl, |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
573 |
filter_young, |
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
8683
diff
changeset
|
574 |
card_ptr); |
6068
80ef41e75a2d
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
5891
diff
changeset
|
575 |
|
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
576 |
// If stop_point is non-null, then we encountered an unallocated region |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
577 |
// (perhaps the unfilled portion of a TLAB.) For now, we'll dirty the |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
578 |
// card and re-enqueue: if we put off the card until a GC pause, then the |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
579 |
// unallocated portion will be filled in. Alternatively, we might try |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
580 |
// the full complexity of the technique used in "regular" precleaning. |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
581 |
if (stop_point != NULL) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
582 |
// 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
|
583 |
// worked. (In fact, it's pretty likely.) |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
584 |
if (*card_ptr != CardTableModRefBS::dirty_card_val()) { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
585 |
*card_ptr = CardTableModRefBS::dirty_card_val(); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
586 |
MutexLockerEx x(Shared_DirtyCardQ_lock, |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
587 |
Mutex::_no_safepoint_check_flag); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
588 |
DirtyCardQueue* sdcq = |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
589 |
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
|
590 |
sdcq->enqueue(card_ptr); |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
591 |
} |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
592 |
} else { |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
593 |
_conc_refine_cards++; |
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3262
diff
changeset
|
594 |
} |
6247 | 595 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
596 |
// This gets set to true if the card being refined has |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
597 |
// references that point into the collection set. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
598 |
bool has_refs_into_cset = trigger_cl.triggered(); |
1374 | 599 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
600 |
// 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
|
601 |
// 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
|
602 |
// a GC worker thread. |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
603 |
assert(!has_refs_into_cset || SafepointSynchronize::is_at_safepoint(), |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
604 |
"invalid result at non safepoint"); |
6247 | 605 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
606 |
return has_refs_into_cset; |
1374 | 607 |
} |
608 |
||
35061 | 609 |
void G1RemSet::print_periodic_summary_info(const char* header, uint period_count) { |
610 |
if ((G1SummarizeRSetStatsPeriod > 0) && log_is_enabled(Trace, gc, remset) && |
|
611 |
(period_count % G1SummarizeRSetStatsPeriod == 0)) { |
|
612 |
||
613 |
if (!_prev_period_summary.initialized()) { |
|
614 |
_prev_period_summary.initialize(this); |
|
615 |
} |
|
1374 | 616 |
|
35061 | 617 |
G1RemSetSummary current; |
618 |
current.initialize(this); |
|
619 |
_prev_period_summary.subtract_from(¤t); |
|
1374 | 620 |
|
37242 | 621 |
Log(gc, remset) log; |
35061 | 622 |
log.trace("%s", header); |
623 |
ResourceMark rm; |
|
624 |
_prev_period_summary.print_on(log.trace_stream()); |
|
625 |
||
626 |
_prev_period_summary.set(¤t); |
|
627 |
} |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
628 |
} |
2881 | 629 |
|
6958 | 630 |
void G1RemSet::print_summary_info() { |
37242 | 631 |
Log(gc, remset, exit) log; |
35061 | 632 |
if (log.is_trace()) { |
633 |
log.trace(" Cumulative RS summary"); |
|
634 |
G1RemSetSummary current; |
|
635 |
current.initialize(this); |
|
636 |
ResourceMark rm; |
|
637 |
current.print_on(log.trace_stream()); |
|
17854
d65bc1546091
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
17327
diff
changeset
|
638 |
} |
1374 | 639 |
} |
6247 | 640 |
|
6958 | 641 |
void G1RemSet::prepare_for_verify() { |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
642 |
if (G1HRRSFlushLogBuffersOnVerify && |
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
643 |
(VerifyBeforeGC || VerifyAfterGC) |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30764
diff
changeset
|
644 |
&& (!_g1->collector_state()->full_collection() || G1VerifyRSetsDuringFullGC)) { |
1374 | 645 |
cleanupHRRS(); |
646 |
_g1->set_refine_cte_cl_concurrency(false); |
|
647 |
if (SafepointSynchronize::is_at_safepoint()) { |
|
648 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
649 |
dcqs.concatenate_logs(); |
|
650 |
} |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
651 |
|
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
652 |
G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
653 |
bool use_hot_card_cache = hot_card_cache->use_cache(); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
654 |
hot_card_cache->set_use_cache(false); |
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
655 |
|
33789
4a76a42bd42e
8141434: G1CollectedHeap::into_cset_dirty_card_queue_set should be moved to G1RemSet
david
parents:
33742
diff
changeset
|
656 |
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
|
657 |
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
|
658 |
_into_cset_dirty_card_queue_set.clear(); |
2249
fb8abed44792
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
2152
diff
changeset
|
659 |
|
17327
4bd0581aa231
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
17108
diff
changeset
|
660 |
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
|
661 |
assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
1374 | 662 |
} |
663 |
} |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
664 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
665 |
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
|
666 |
_card_live_data.create(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
667 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
668 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
669 |
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
|
670 |
_card_live_data.finalize(workers, mark_bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
671 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
672 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
673 |
void G1RemSet::verify_card_live_data(WorkGang* workers, G1CMBitMap* bitmap) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
674 |
_card_live_data.verify(workers, bitmap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
675 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
676 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
677 |
void G1RemSet::clear_card_live_data(WorkGang* workers) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
678 |
_card_live_data.clear(workers); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
679 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
680 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
681 |
#ifdef ASSERT |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
682 |
void G1RemSet::verify_card_live_data_is_clear() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
683 |
_card_live_data.verify_is_clear(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
684 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37248
diff
changeset
|
685 |
#endif |