author | jwilhelm |
Thu, 03 Oct 2013 21:36:29 +0200 | |
changeset 20398 | b206c580c45f |
parent 17108 | cf72dcf9a8f2 |
child 22234 | da823d78ad65 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
13963
e5b53c306fb5
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
13195
diff
changeset
|
2 |
* Copyright (c) 2001, 2012, 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:
4902
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4902
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:
4902
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_SPARSEPRT_HPP |
26 |
#define SHARE_VM_GC_IMPLEMENTATION_G1_SPARSEPRT_HPP |
|
27 |
||
28 |
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
|
29 |
#include "gc_implementation/g1/heapRegion.hpp" |
|
30 |
#include "memory/allocation.hpp" |
|
31 |
#include "memory/cardTableModRefBS.hpp" |
|
32 |
#include "runtime/mutex.hpp" |
|
33 |
#include "utilities/globalDefinitions.hpp" |
|
34 |
||
1374 | 35 |
// Sparse remembered set for a heap region (the "owning" region). Maps |
36 |
// indices of other regions to short sequences of cards in the other region |
|
37 |
// that might contain pointers into the owner region. |
|
38 |
||
39 |
// These tables only expand while they are accessed in parallel -- |
|
40 |
// deletions may be done in single-threaded code. This allows us to allow |
|
41 |
// unsynchronized reads/iterations, as long as expansions caused by |
|
42 |
// insertions only enqueue old versions for deletions, but do not delete |
|
43 |
// old versions synchronously. |
|
44 |
||
13195 | 45 |
class SparsePRTEntry: public CHeapObj<mtGC> { |
1374 | 46 |
public: |
47 |
enum SomePublicConstants { |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
48 |
NullEntry = -1, |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
49 |
UnrollFactor = 4 |
1374 | 50 |
}; |
51 |
private: |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
52 |
RegionIdx_t _region_ind; |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
53 |
int _next_index; |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
54 |
CardIdx_t _cards[1]; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
55 |
// WARNING: Don't put any data members beyond this line. Card array has, in fact, variable length. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
56 |
// It should always be the last data member. |
1374 | 57 |
public: |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
58 |
// Returns the size of the entry, used for entry allocation. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
59 |
static size_t size() { return sizeof(SparsePRTEntry) + sizeof(CardIdx_t) * (cards_num() - 1); } |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
60 |
// Returns the size of the card array. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
61 |
static int cards_num() { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
62 |
// The number of cards should be a multiple of 4, because that's our current |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
63 |
// unrolling factor. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
64 |
static const int s = MAX2<int>(G1RSetSparseRegionEntries & ~(UnrollFactor - 1), UnrollFactor); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
65 |
return s; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
66 |
} |
1374 | 67 |
|
68 |
// Set the region_ind to the given value, and delete all cards. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
69 |
inline void init(RegionIdx_t region_ind); |
1374 | 70 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
71 |
RegionIdx_t r_ind() const { return _region_ind; } |
1374 | 72 |
bool valid_entry() const { return r_ind() >= 0; } |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
73 |
void set_r_ind(RegionIdx_t rind) { _region_ind = rind; } |
1374 | 74 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
75 |
int next_index() const { return _next_index; } |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
76 |
int* next_index_addr() { return &_next_index; } |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
77 |
void set_next_index(int ni) { _next_index = ni; } |
1374 | 78 |
|
79 |
// Returns "true" iff the entry contains the given card index. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
80 |
inline bool contains_card(CardIdx_t card_index) const; |
1374 | 81 |
|
82 |
// Returns the number of non-NULL card entries. |
|
83 |
inline int num_valid_cards() const; |
|
84 |
||
85 |
// Requires that the entry not contain the given card index. If there is |
|
86 |
// space available, add the given card index to the entry and return |
|
87 |
// "true"; otherwise, return "false" to indicate that the entry is full. |
|
88 |
enum AddCardResult { |
|
89 |
overflow, |
|
90 |
found, |
|
91 |
added |
|
92 |
}; |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
93 |
inline AddCardResult add_card(CardIdx_t card_index); |
1374 | 94 |
|
95 |
// Copy the current entry's cards into "cards". |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
96 |
inline void copy_cards(CardIdx_t* cards) const; |
1374 | 97 |
// Copy the current entry's cards into the "_card" array of "e." |
98 |
inline void copy_cards(SparsePRTEntry* e) const; |
|
99 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
100 |
inline CardIdx_t card(int i) const { return _cards[i]; } |
1374 | 101 |
}; |
102 |
||
103 |
||
13195 | 104 |
class RSHashTable : public CHeapObj<mtGC> { |
1374 | 105 |
|
106 |
friend class RSHashTableIter; |
|
107 |
||
108 |
enum SomePrivateConstants { |
|
109 |
NullEntry = -1 |
|
110 |
}; |
|
111 |
||
112 |
size_t _capacity; |
|
113 |
size_t _capacity_mask; |
|
114 |
size_t _occupied_entries; |
|
115 |
size_t _occupied_cards; |
|
116 |
||
117 |
SparsePRTEntry* _entries; |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
118 |
int* _buckets; |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
119 |
int _free_region; |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
120 |
int _free_list; |
1374 | 121 |
|
122 |
// Requires that the caller hold a lock preventing parallel modifying |
|
123 |
// operations, and that the the table be less than completely full. If |
|
124 |
// an entry for "region_ind" is already in the table, finds it and |
|
125 |
// returns its address; otherwise returns "NULL." |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
126 |
SparsePRTEntry* entry_for_region_ind(RegionIdx_t region_ind) const; |
1374 | 127 |
|
128 |
// Requires that the caller hold a lock preventing parallel modifying |
|
129 |
// operations, and that the the table be less than completely full. If |
|
130 |
// an entry for "region_ind" is already in the table, finds it and |
|
131 |
// returns its address; otherwise allocates, initializes, inserts and |
|
132 |
// returns a new entry for "region_ind". |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
133 |
SparsePRTEntry* entry_for_region_ind_create(RegionIdx_t region_ind); |
1374 | 134 |
|
135 |
// Returns the index of the next free entry in "_entries". |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
136 |
int alloc_entry(); |
1374 | 137 |
// Declares the entry "fi" to be free. (It must have already been |
138 |
// deleted from any bucket lists. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
139 |
void free_entry(int fi); |
1374 | 140 |
|
141 |
public: |
|
142 |
RSHashTable(size_t capacity); |
|
143 |
~RSHashTable(); |
|
144 |
||
145 |
// Attempts to ensure that the given card_index in the given region is in |
|
146 |
// the sparse table. If successful (because the card was already |
|
147 |
// present, or because it was successfullly added) returns "true". |
|
148 |
// Otherwise, returns "false" to indicate that the addition would |
|
149 |
// overflow the entry for the region. The caller must transfer these |
|
150 |
// entries to a larger-capacity representation. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
151 |
bool add_card(RegionIdx_t region_id, CardIdx_t card_index); |
1374 | 152 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
153 |
bool get_cards(RegionIdx_t region_id, CardIdx_t* cards); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
154 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
155 |
bool delete_entry(RegionIdx_t region_id); |
1374 | 156 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
157 |
bool contains_card(RegionIdx_t region_id, CardIdx_t card_index) const; |
1374 | 158 |
|
159 |
void add_entry(SparsePRTEntry* e); |
|
160 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
161 |
SparsePRTEntry* get_entry(RegionIdx_t region_id); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
162 |
|
1374 | 163 |
void clear(); |
164 |
||
165 |
size_t capacity() const { return _capacity; } |
|
166 |
size_t capacity_mask() const { return _capacity_mask; } |
|
167 |
size_t occupied_entries() const { return _occupied_entries; } |
|
168 |
size_t occupied_cards() const { return _occupied_cards; } |
|
169 |
size_t mem_size() const; |
|
170 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
171 |
SparsePRTEntry* entry(int i) const { return (SparsePRTEntry*)((char*)_entries + SparsePRTEntry::size() * i); } |
1374 | 172 |
|
173 |
void print(); |
|
174 |
}; |
|
175 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
176 |
// ValueObj because will be embedded in HRRS iterator. |
2013
49e915da0905
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
1374
diff
changeset
|
177 |
class RSHashTableIter VALUE_OBJ_CLASS_SPEC { |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
178 |
int _tbl_ind; // [-1, 0.._rsht->_capacity) |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
179 |
int _bl_ind; // [-1, 0.._rsht->_capacity) |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
180 |
short _card_ind; // [0..SparsePRTEntry::cards_num()) |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
181 |
RSHashTable* _rsht; |
1374 | 182 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
183 |
// If the bucket list pointed to by _bl_ind contains a card, sets |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
184 |
// _bl_ind to the index of that entry, and returns the card. |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
185 |
// Otherwise, returns SparseEntry::NullEntry. |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
186 |
CardIdx_t find_first_card_in_list(); |
1374 | 187 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
188 |
// Computes the proper card index for the card whose offset in the |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
189 |
// current region (as indicated by _bl_ind) is "ci". |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
190 |
// This is subject to errors when there is iteration concurrent with |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
191 |
// modification, but these errors should be benign. |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
192 |
size_t compute_card_ind(CardIdx_t ci); |
1374 | 193 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
194 |
public: |
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
195 |
RSHashTableIter(RSHashTable* rsht) : |
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
196 |
_tbl_ind(RSHashTable::NullEntry), // So that first increment gets to 0. |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
197 |
_bl_ind(RSHashTable::NullEntry), |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
198 |
_card_ind((SparsePRTEntry::cards_num() - 1)), |
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
199 |
_rsht(rsht) {} |
1374 | 200 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
201 |
bool has_next(size_t& card_index); |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
202 |
}; |
1374 | 203 |
|
204 |
// Concurrent accesss to a SparsePRT must be serialized by some external |
|
205 |
// mutex. |
|
206 |
||
207 |
class SparsePRTIter; |
|
8072 | 208 |
class SparsePRTCleanupTask; |
1374 | 209 |
|
2013
49e915da0905
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
1374
diff
changeset
|
210 |
class SparsePRT VALUE_OBJ_CLASS_SPEC { |
8072 | 211 |
friend class SparsePRTCleanupTask; |
212 |
||
1374 | 213 |
// Iterations are done on the _cur hash table, since they only need to |
214 |
// see entries visible at the start of a collection pause. |
|
215 |
// All other operations are done using the _next hash table. |
|
216 |
RSHashTable* _cur; |
|
217 |
RSHashTable* _next; |
|
218 |
||
219 |
HeapRegion* _hr; |
|
220 |
||
221 |
enum SomeAdditionalPrivateConstants { |
|
222 |
InitialCapacity = 16 |
|
223 |
}; |
|
224 |
||
225 |
void expand(); |
|
226 |
||
227 |
bool _expanded; |
|
228 |
||
229 |
bool expanded() { return _expanded; } |
|
230 |
void set_expanded(bool b) { _expanded = b; } |
|
231 |
||
232 |
SparsePRT* _next_expanded; |
|
233 |
||
234 |
SparsePRT* next_expanded() { return _next_expanded; } |
|
235 |
void set_next_expanded(SparsePRT* nxt) { _next_expanded = nxt; } |
|
236 |
||
8072 | 237 |
bool should_be_on_expanded_list(); |
238 |
||
1374 | 239 |
static SparsePRT* _head_expanded_list; |
240 |
||
241 |
public: |
|
242 |
SparsePRT(HeapRegion* hr); |
|
243 |
||
244 |
~SparsePRT(); |
|
245 |
||
246 |
size_t occupied() const { return _next->occupied_cards(); } |
|
247 |
size_t mem_size() const; |
|
248 |
||
249 |
// Attempts to ensure that the given card_index in the given region is in |
|
250 |
// the sparse table. If successful (because the card was already |
|
251 |
// present, or because it was successfullly added) returns "true". |
|
252 |
// Otherwise, returns "false" to indicate that the addition would |
|
253 |
// overflow the entry for the region. The caller must transfer these |
|
254 |
// entries to a larger-capacity representation. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
255 |
bool add_card(RegionIdx_t region_id, CardIdx_t card_index); |
1374 | 256 |
|
257 |
// If the table hold an entry for "region_ind", Copies its |
|
258 |
// cards into "cards", which must be an array of length at least |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
259 |
// "SparePRTEntry::cards_num()", and returns "true"; otherwise, |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
260 |
// returns "false". |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
261 |
bool get_cards(RegionIdx_t region_ind, CardIdx_t* cards); |
1374 | 262 |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
263 |
// Return the pointer to the entry associated with the given region. |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
264 |
SparsePRTEntry* get_entry(RegionIdx_t region_ind); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
265 |
|
1374 | 266 |
// If there is an entry for "region_ind", removes it and return "true"; |
267 |
// otherwise returns "false." |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
268 |
bool delete_entry(RegionIdx_t region_ind); |
1374 | 269 |
|
270 |
// Clear the table, and reinitialize to initial capacity. |
|
271 |
void clear(); |
|
272 |
||
273 |
// Ensure that "_cur" and "_next" point to the same table. |
|
274 |
void cleanup(); |
|
275 |
||
276 |
// Clean up all tables on the expanded list. Called single threaded. |
|
277 |
static void cleanup_all(); |
|
2143
61babb9fbd6f
6810698: G1: two small bugs in the sparse remembered sets
tonyp
parents:
2013
diff
changeset
|
278 |
RSHashTable* cur() const { return _cur; } |
1374 | 279 |
|
280 |
static void add_to_expanded_list(SparsePRT* sprt); |
|
281 |
static SparsePRT* get_from_expanded_list(); |
|
282 |
||
8072 | 283 |
// The purpose of these three methods is to help the GC workers |
284 |
// during the cleanup pause to recreate the expanded list, purging |
|
285 |
// any tables from it that belong to regions that are freed during |
|
286 |
// cleanup (if we don't purge those tables, there is a race that |
|
287 |
// causes various crashes; see CR 7014261). |
|
288 |
// |
|
289 |
// We chose to recreate the expanded list, instead of purging |
|
290 |
// entries from it by iterating over it, to avoid this serial phase |
|
291 |
// at the end of the cleanup pause. |
|
292 |
// |
|
293 |
// The three methods below work as follows: |
|
294 |
// * reset_for_cleanup_tasks() : Nulls the expanded list head at the |
|
295 |
// start of the cleanup pause. |
|
296 |
// * do_cleanup_work() : Called by the cleanup workers for every |
|
297 |
// region that is not free / is being freed by the cleanup |
|
298 |
// pause. It creates a list of expanded tables whose head / tail |
|
299 |
// are on the thread-local SparsePRTCleanupTask object. |
|
300 |
// * finish_cleanup_task() : Called by the cleanup workers after |
|
301 |
// they complete their cleanup task. It adds the local list into |
|
302 |
// the global expanded list. It assumes that the |
|
303 |
// ParGCRareEvent_lock is being held to ensure MT-safety. |
|
304 |
static void reset_for_cleanup_tasks(); |
|
305 |
void do_cleanup_work(SparsePRTCleanupTask* sprt_cleanup_task); |
|
306 |
static void finish_cleanup_task(SparsePRTCleanupTask* sprt_cleanup_task); |
|
307 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2154
diff
changeset
|
308 |
bool contains_card(RegionIdx_t region_id, CardIdx_t card_index) const { |
1374 | 309 |
return _next->contains_card(region_id, card_index); |
310 |
} |
|
311 |
}; |
|
312 |
||
6981
ecfe524b1fa7
6992189: G1: inconsistent base used in sparse rem set iterator
tonyp
parents:
5547
diff
changeset
|
313 |
class SparsePRTIter: public RSHashTableIter { |
1374 | 314 |
public: |
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
315 |
SparsePRTIter(const SparsePRT* sprt) : |
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
316 |
RSHashTableIter(sprt->cur()) {} |
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13963
diff
changeset
|
317 |
|
1374 | 318 |
bool has_next(size_t& card_index) { |
319 |
return RSHashTableIter::has_next(card_index); |
|
320 |
} |
|
321 |
}; |
|
7397 | 322 |
|
8072 | 323 |
// This allows each worker during a cleanup pause to create a |
324 |
// thread-local list of sparse tables that have been expanded and need |
|
325 |
// to be processed at the beginning of the next GC pause. This lists |
|
326 |
// are concatenated into the single expanded list at the end of the |
|
327 |
// cleanup pause. |
|
328 |
class SparsePRTCleanupTask VALUE_OBJ_CLASS_SPEC { |
|
329 |
private: |
|
330 |
SparsePRT* _head; |
|
331 |
SparsePRT* _tail; |
|
332 |
||
333 |
public: |
|
334 |
SparsePRTCleanupTask() : _head(NULL), _tail(NULL) { } |
|
335 |
||
336 |
void add(SparsePRT* sprt); |
|
337 |
SparsePRT* head() { return _head; } |
|
338 |
SparsePRT* tail() { return _tail; } |
|
339 |
}; |
|
340 |
||
7397 | 341 |
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_SPARSEPRT_HPP |