author | tschatzl |
Mon, 21 Dec 2015 12:02:08 +0100 | |
changeset 35199 | a12e8d5aa2f7 |
parent 35061 | be6025ebffea |
child 35200 | 7802299b31e7 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
30764 | 2 |
* Copyright (c) 2001, 2015, 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:
5346
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5346
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:
5346
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
30764 | 25 |
#ifndef SHARE_VM_GC_G1_HEAPREGIONREMSET_HPP |
26 |
#define SHARE_VM_GC_G1_HEAPREGIONREMSET_HPP |
|
7397 | 27 |
|
30764 | 28 |
#include "gc/g1/g1CodeCacheRemSet.hpp" |
35199 | 29 |
#include "gc/g1/g1FromCardCache.hpp" |
30764 | 30 |
#include "gc/g1/sparsePRT.hpp" |
7397 | 31 |
|
1374 | 32 |
// Remembered set for a heap region. Represent a set of "cards" that |
33 |
// contain pointers into the owner heap region. Cards are defined somewhat |
|
34 |
// abstractly, in terms of what the "BlockOffsetTable" in use can parse. |
|
35 |
||
36 |
class G1CollectedHeap; |
|
37 |
class G1BlockOffsetSharedArray; |
|
38 |
class HeapRegion; |
|
39 |
class HeapRegionRemSetIterator; |
|
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
40 |
class PerRegionTable; |
1374 | 41 |
class SparsePRT; |
19339 | 42 |
class nmethod; |
1374 | 43 |
|
8072 | 44 |
// Essentially a wrapper around SparsePRTCleanupTask. See |
45 |
// sparsePRT.hpp for more details. |
|
46 |
class HRRSCleanupTask : public SparsePRTCleanupTask { |
|
47 |
}; |
|
1374 | 48 |
|
49 |
// The "_coarse_map" is a bitmap with one bit for each region, where set |
|
50 |
// bits indicate that the corresponding region may contain some pointer |
|
51 |
// into the owning region. |
|
52 |
||
53 |
// The "_fine_grain_entries" array is an open hash table of PerRegionTables |
|
54 |
// (PRTs), indicating regions for which we're keeping the RS as a set of |
|
55 |
// cards. The strategy is to cap the size of the fine-grain table, |
|
56 |
// deleting an entry and setting the corresponding coarse-grained bit when |
|
57 |
// we would overflow this cap. |
|
58 |
||
59 |
// We use a mixture of locking and lock-free techniques here. We allow |
|
60 |
// threads to locate PRTs without locking, but threads attempting to alter |
|
61 |
// a bucket list obtain a lock. This means that any failing attempt to |
|
62 |
// find a PRT must be retried with the lock. It might seem dangerous that |
|
63 |
// a read can find a PRT that is concurrently deleted. This is all right, |
|
64 |
// because: |
|
65 |
// |
|
66 |
// 1) We only actually free PRT's at safe points (though we reuse them at |
|
67 |
// other times). |
|
68 |
// 2) We find PRT's in an attempt to add entries. If a PRT is deleted, |
|
69 |
// it's _coarse_map bit is set, so the that we were attempting to add |
|
70 |
// is represented. If a deleted PRT is re-used, a thread adding a bit, |
|
71 |
// thinking the PRT is for a different region, does no harm. |
|
72 |
||
2013
49e915da0905
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
1374
diff
changeset
|
73 |
class OtherRegionsTable VALUE_OBJ_CLASS_SPEC { |
1374 | 74 |
friend class HeapRegionRemSetIterator; |
75 |
||
76 |
G1CollectedHeap* _g1h; |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
77 |
Mutex* _m; |
1374 | 78 |
HeapRegion* _hr; |
79 |
||
80 |
// These are protected by "_m". |
|
81 |
BitMap _coarse_map; |
|
82 |
size_t _n_coarse_entries; |
|
83 |
static jint _n_coarsenings; |
|
84 |
||
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
85 |
PerRegionTable** _fine_grain_regions; |
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
86 |
size_t _n_fine_entries; |
1374 | 87 |
|
13335 | 88 |
// The fine grain remembered sets are doubly linked together using |
89 |
// their 'next' and 'prev' fields. |
|
90 |
// This allows fast bulk freeing of all the fine grain remembered |
|
91 |
// set entries, and fast finding of all of them without iterating |
|
92 |
// over the _fine_grain_regions table. |
|
93 |
PerRegionTable * _first_all_fine_prts; |
|
94 |
PerRegionTable * _last_all_fine_prts; |
|
95 |
||
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
96 |
// Used to sample a subset of the fine grain PRTs to determine which |
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
97 |
// PRT to evict and coarsen. |
1374 | 98 |
size_t _fine_eviction_start; |
99 |
static size_t _fine_eviction_stride; |
|
100 |
static size_t _fine_eviction_sample_size; |
|
101 |
||
102 |
SparsePRT _sparse_table; |
|
103 |
||
104 |
// These are static after init. |
|
105 |
static size_t _max_fine_entries; |
|
106 |
static size_t _mod_max_fine_entries_mask; |
|
107 |
||
108 |
// Requires "prt" to be the first element of the bucket list appropriate |
|
109 |
// for "hr". If this list contains an entry for "hr", return it, |
|
110 |
// otherwise return "NULL". |
|
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
111 |
PerRegionTable* find_region_table(size_t ind, HeapRegion* hr) const; |
1374 | 112 |
|
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
113 |
// Find, delete, and return a candidate PerRegionTable, if any exists, |
1374 | 114 |
// adding the deleted region to the coarse bitmap. Requires the caller |
115 |
// to hold _m, and the fine-grain table to be full. |
|
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
116 |
PerRegionTable* delete_region_table(); |
1374 | 117 |
|
13335 | 118 |
// link/add the given fine grain remembered set into the "all" list |
119 |
void link_to_all(PerRegionTable * prt); |
|
120 |
// unlink/remove the given fine grain remembered set into the "all" list |
|
121 |
void unlink_from_all(PerRegionTable * prt); |
|
122 |
||
28030 | 123 |
bool contains_reference_locked(OopOrNarrowOopStar from) const; |
124 |
||
125 |
// Clear the from_card_cache entries for this region. |
|
126 |
void clear_fcc(); |
|
1374 | 127 |
public: |
28030 | 128 |
// Create a new remembered set for the given heap region. The given mutex should |
129 |
// be used to ensure consistency. |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
130 |
OtherRegionsTable(HeapRegion* hr, Mutex* m); |
1374 | 131 |
|
132 |
// For now. Could "expand" some tables in the future, so that this made |
|
133 |
// sense. |
|
26850
515ff48cf5f0
8036116: Fix thread-id types in G1 remembered set implementations
brutisso
parents:
26422
diff
changeset
|
134 |
void add_reference(OopOrNarrowOopStar from, uint tid); |
1374 | 135 |
|
28030 | 136 |
// Returns whether the remembered set contains the given reference. |
137 |
bool contains_reference(OopOrNarrowOopStar from) const; |
|
138 |
||
28379
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
139 |
// Returns whether this remembered set (and all sub-sets) have an occupancy |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
140 |
// that is less or equal than the given occupancy. |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
141 |
bool occupancy_less_or_equal_than(size_t limit) const; |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
142 |
|
1374 | 143 |
// Removes any entries shown by the given bitmaps to contain only dead |
28030 | 144 |
// objects. Not thread safe. |
145 |
// Set bits in the bitmaps indicate that the given region or card is live. |
|
1374 | 146 |
void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm); |
147 |
||
28030 | 148 |
// Returns whether this remembered set (and all sub-sets) does not contain any entry. |
25889
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
149 |
bool is_empty() const; |
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
150 |
|
28030 | 151 |
// Returns the number of cards contained in this remembered set. |
1374 | 152 |
size_t occupied() const; |
153 |
size_t occ_fine() const; |
|
154 |
size_t occ_coarse() const; |
|
155 |
size_t occ_sparse() const; |
|
156 |
||
157 |
static jint n_coarsenings() { return _n_coarsenings; } |
|
158 |
||
28030 | 159 |
// Returns size of the actual remembered set containers in bytes. |
1374 | 160 |
size_t mem_size() const; |
28030 | 161 |
// Returns the size of static data in bytes. |
1374 | 162 |
static size_t static_mem_size(); |
28030 | 163 |
// Returns the size of the free list content in bytes. |
1374 | 164 |
static size_t fl_mem_size(); |
165 |
||
28030 | 166 |
// Clear the entire contents of this remembered set. |
1374 | 167 |
void clear(); |
168 |
||
8072 | 169 |
void do_cleanup_work(HRRSCleanupTask* hrrs_cleanup_task); |
1374 | 170 |
}; |
171 |
||
13195 | 172 |
class HeapRegionRemSet : public CHeapObj<mtGC> { |
1374 | 173 |
friend class VMStructs; |
174 |
friend class HeapRegionRemSetIterator; |
|
175 |
||
176 |
private: |
|
177 |
G1BlockOffsetSharedArray* _bosa; |
|
178 |
||
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
179 |
// A set of code blobs (nmethods) whose code contains pointers into |
19339 | 180 |
// the region that owns this RSet. |
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
181 |
G1CodeRootSet _code_roots; |
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
182 |
|
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
183 |
Mutex _m; |
19339 | 184 |
|
1374 | 185 |
OtherRegionsTable _other_regions; |
186 |
||
187 |
enum ParIterState { Unclaimed, Claimed, Complete }; |
|
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
188 |
volatile ParIterState _iter_state; |
23523
75f522e33395
8037295: Add size_t versions of Atomic::add, dec, and inc
mgronlun
parents:
23456
diff
changeset
|
189 |
volatile size_t _iter_claimed; |
1374 | 190 |
|
191 |
public: |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
192 |
HeapRegionRemSet(G1BlockOffsetSharedArray* bosa, HeapRegion* hr); |
1374 | 193 |
|
23452
d7dca4e6b95d
8035815: Cache-align and pad the from card cache
tschatzl
parents:
23451
diff
changeset
|
194 |
static uint num_par_rem_sets(); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
195 |
static void setup_remset_size(); |
1374 | 196 |
|
25889
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
197 |
bool is_empty() const { |
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
198 |
return (strong_code_roots_list_length() == 0) && _other_regions.is_empty(); |
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
199 |
} |
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
200 |
|
28379
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
201 |
bool occupancy_less_or_equal_than(size_t occ) const { |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
202 |
return (strong_code_roots_list_length() == 0) && _other_regions.occupancy_less_or_equal_than(occ); |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
203 |
} |
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
28030
diff
changeset
|
204 |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
205 |
size_t occupied() { |
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
206 |
MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); |
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
207 |
return occupied_locked(); |
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
208 |
} |
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
209 |
size_t occupied_locked() { |
1374 | 210 |
return _other_regions.occupied(); |
211 |
} |
|
212 |
size_t occ_fine() const { |
|
213 |
return _other_regions.occ_fine(); |
|
214 |
} |
|
215 |
size_t occ_coarse() const { |
|
216 |
return _other_regions.occ_coarse(); |
|
217 |
} |
|
218 |
size_t occ_sparse() const { |
|
219 |
return _other_regions.occ_sparse(); |
|
220 |
} |
|
221 |
||
222 |
static jint n_coarsenings() { return OtherRegionsTable::n_coarsenings(); } |
|
223 |
||
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
224 |
// Used in the sequential case. |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2881
diff
changeset
|
225 |
void add_reference(OopOrNarrowOopStar from) { |
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
226 |
_other_regions.add_reference(from, 0); |
1374 | 227 |
} |
228 |
||
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
229 |
// Used in the parallel case. |
26850
515ff48cf5f0
8036116: Fix thread-id types in G1 remembered set implementations
brutisso
parents:
26422
diff
changeset
|
230 |
void add_reference(OopOrNarrowOopStar from, uint tid) { |
1374 | 231 |
_other_regions.add_reference(from, tid); |
232 |
} |
|
233 |
||
28030 | 234 |
// Removes any entries in the remembered set shown by the given bitmaps to |
235 |
// contain only dead objects. Not thread safe. |
|
236 |
// One bits in the bitmaps indicate that the given region or card is live. |
|
1374 | 237 |
void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm); |
238 |
||
239 |
// The region is being reclaimed; clear its remset, and any mention of |
|
240 |
// entries for this region in other remsets. |
|
241 |
void clear(); |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
242 |
void clear_locked(); |
1374 | 243 |
|
244 |
// Attempt to claim the region. Returns true iff this call caused an |
|
245 |
// atomic transition from Unclaimed to Claimed. |
|
246 |
bool claim_iter(); |
|
247 |
// Sets the iteration state to "complete". |
|
248 |
void set_iter_complete(); |
|
249 |
// Returns "true" iff the region's iteration is complete. |
|
250 |
bool iter_is_complete(); |
|
251 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
252 |
// Support for claiming blocks of cards during iteration |
23523
75f522e33395
8037295: Add size_t versions of Atomic::add, dec, and inc
mgronlun
parents:
23456
diff
changeset
|
253 |
size_t iter_claimed() const { return _iter_claimed; } |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
254 |
// Claim the next block of cards |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
255 |
size_t iter_claimed_next(size_t step) { |
23523
75f522e33395
8037295: Add size_t versions of Atomic::add, dec, and inc
mgronlun
parents:
23456
diff
changeset
|
256 |
return Atomic::add(step, &_iter_claimed) - step; |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
257 |
} |
23523
75f522e33395
8037295: Add size_t versions of Atomic::add, dec, and inc
mgronlun
parents:
23456
diff
changeset
|
258 |
|
10000
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
8072
diff
changeset
|
259 |
void reset_for_par_iteration(); |
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
8072
diff
changeset
|
260 |
|
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
8072
diff
changeset
|
261 |
bool verify_ready_for_par_iteration() { |
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
8072
diff
changeset
|
262 |
return (_iter_state == Unclaimed) && (_iter_claimed == 0); |
5bbb58b0dbb9
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
8072
diff
changeset
|
263 |
} |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
3262
diff
changeset
|
264 |
|
1374 | 265 |
// The actual # of bytes this hr_remset takes up. |
19339 | 266 |
// Note also includes the strong code root set. |
1374 | 267 |
size_t mem_size() { |
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
268 |
MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); |
1374 | 269 |
return _other_regions.mem_size() |
270 |
// This correction is necessary because the above includes the second |
|
271 |
// part. |
|
24108
dfc2242fc6b0
8040792: G1: Memory usage calculation uses sizeof(this) instead of sizeof(classname)
tschatzl
parents:
24102
diff
changeset
|
272 |
+ (sizeof(HeapRegionRemSet) - sizeof(OtherRegionsTable)) |
19339 | 273 |
+ strong_code_roots_mem_size(); |
1374 | 274 |
} |
275 |
||
276 |
// Returns the memory occupancy of all static data structures associated |
|
277 |
// with remembered sets. |
|
278 |
static size_t static_mem_size() { |
|
26422 | 279 |
return OtherRegionsTable::static_mem_size() + G1CodeRootSet::static_mem_size(); |
1374 | 280 |
} |
281 |
||
282 |
// Returns the memory occupancy of all free_list data structures associated |
|
283 |
// with remembered sets. |
|
284 |
static size_t fl_mem_size() { |
|
26422 | 285 |
return OtherRegionsTable::fl_mem_size(); |
1374 | 286 |
} |
287 |
||
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
2881
diff
changeset
|
288 |
bool contains_reference(OopOrNarrowOopStar from) const { |
1374 | 289 |
return _other_regions.contains_reference(from); |
290 |
} |
|
19339 | 291 |
|
292 |
// Routines for managing the list of code roots that point into |
|
293 |
// the heap region that owns this RSet. |
|
294 |
void add_strong_code_root(nmethod* nm); |
|
26422 | 295 |
void add_strong_code_root_locked(nmethod* nm); |
19339 | 296 |
void remove_strong_code_root(nmethod* nm); |
297 |
||
298 |
// Applies blk->do_code_blob() to each of the entries in |
|
299 |
// the strong code roots list |
|
300 |
void strong_code_roots_do(CodeBlobClosure* blk) const; |
|
301 |
||
26422 | 302 |
void clean_strong_code_roots(HeapRegion* hr); |
303 |
||
19339 | 304 |
// Returns the number of elements in the strong code roots list |
25889
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
24108
diff
changeset
|
305 |
size_t strong_code_roots_list_length() const { |
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
306 |
return _code_roots.length(); |
19339 | 307 |
} |
308 |
||
309 |
// Returns true if the strong code roots contains the given |
|
310 |
// nmethod. |
|
311 |
bool strong_code_roots_list_contains(nmethod* nm) { |
|
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
312 |
return _code_roots.contains(nm); |
19339 | 313 |
} |
314 |
||
315 |
// Returns the amount of memory, in bytes, currently |
|
316 |
// consumed by the strong code roots. |
|
317 |
size_t strong_code_roots_mem_size(); |
|
318 |
||
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
319 |
void print() PRODUCT_RETURN; |
1374 | 320 |
|
321 |
// Called during a stop-world phase to perform any deferred cleanups. |
|
322 |
static void cleanup(); |
|
323 |
||
324 |
// Declare the heap size (in # of regions) to the HeapRegionRemSet(s). |
|
325 |
// (Uses it to initialize from_card_cache). |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
10677
diff
changeset
|
326 |
static void init_heap(uint max_regions) { |
28030 | 327 |
FromCardCache::initialize(num_par_rem_sets(), max_regions); |
1374 | 328 |
} |
329 |
||
28030 | 330 |
static void invalidate_from_card_cache(uint start_idx, size_t num_regions) { |
331 |
FromCardCache::invalidate(start_idx, num_regions); |
|
1374 | 332 |
} |
333 |
||
334 |
#ifndef PRODUCT |
|
335 |
static void print_from_card_cache() { |
|
28030 | 336 |
FromCardCache::print(); |
1374 | 337 |
} |
338 |
#endif |
|
339 |
||
8072 | 340 |
// These are wrappers for the similarly-named methods on |
341 |
// SparsePRT. Look at sparsePRT.hpp for more details. |
|
342 |
static void reset_for_cleanup_tasks(); |
|
343 |
void do_cleanup_work(HRRSCleanupTask* hrrs_cleanup_task); |
|
344 |
static void finish_cleanup_task(HRRSCleanupTask* hrrs_cleanup_task); |
|
345 |
||
1374 | 346 |
// Run unit tests. |
347 |
#ifndef PRODUCT |
|
348 |
static void test(); |
|
349 |
#endif |
|
350 |
}; |
|
351 |
||
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13335
diff
changeset
|
352 |
class HeapRegionRemSetIterator : public StackObj { |
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
353 |
private: |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
354 |
// The region RSet over which we are iterating. |
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
355 |
HeapRegionRemSet* _hrrs; |
1374 | 356 |
|
357 |
// Local caching of HRRS fields. |
|
358 |
const BitMap* _coarse_map; |
|
359 |
||
360 |
G1BlockOffsetSharedArray* _bosa; |
|
361 |
G1CollectedHeap* _g1h; |
|
362 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
363 |
// The number of cards yielded since initialization. |
1374 | 364 |
size_t _n_yielded_fine; |
365 |
size_t _n_yielded_coarse; |
|
366 |
size_t _n_yielded_sparse; |
|
367 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
368 |
// Indicates what granularity of table that we are currently iterating over. |
17108
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13335
diff
changeset
|
369 |
// We start iterating over the sparse table, progress to the fine grain |
cf72dcf9a8f2
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
13335
diff
changeset
|
370 |
// table, and then finish with the coarse table. |
1374 | 371 |
enum IterState { |
372 |
Sparse, |
|
373 |
Fine, |
|
374 |
Coarse |
|
375 |
}; |
|
376 |
IterState _is; |
|
377 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
378 |
// For both Coarse and Fine remembered set iteration this contains the |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
379 |
// first card number of the heap region we currently iterate over. |
1374 | 380 |
size_t _cur_region_card_offset; |
381 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
382 |
// Current region index for the Coarse remembered set iteration. |
10677
370a8da2d63f
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
10000
diff
changeset
|
383 |
int _coarse_cur_region_index; |
370a8da2d63f
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
10000
diff
changeset
|
384 |
size_t _coarse_cur_region_cur_card; |
1374 | 385 |
|
386 |
bool coarse_has_next(size_t& card_index); |
|
387 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
388 |
// The PRT we are currently iterating over. |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
389 |
PerRegionTable* _fine_cur_prt; |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
390 |
// Card offset within the current PRT. |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
391 |
size_t _cur_card_in_prt; |
13113
ab3870a79b18
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
12381
diff
changeset
|
392 |
|
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
393 |
// Update internal variables when switching to the given PRT. |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
394 |
void switch_to_prt(PerRegionTable* prt); |
1374 | 395 |
bool fine_has_next(); |
396 |
bool fine_has_next(size_t& card_index); |
|
397 |
||
24101
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
398 |
// The Sparse remembered set iterator. |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
399 |
SparsePRTIter _sparse_iter; |
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
400 |
|
bd1a2ee20760
8037344: Use the "next" field to iterate over fine remembered instead of using the hash table
tschatzl
parents:
24099
diff
changeset
|
401 |
public: |
23451
ed2b8bb28fed
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
22234
diff
changeset
|
402 |
HeapRegionRemSetIterator(HeapRegionRemSet* hrrs); |
1374 | 403 |
|
404 |
// If there remains one or more cards to be yielded, returns true and |
|
405 |
// sets "card_index" to one of those cards (which is then considered |
|
406 |
// yielded.) Otherwise, returns false (and leaves "card_index" |
|
407 |
// undefined.) |
|
408 |
bool has_next(size_t& card_index); |
|
409 |
||
410 |
size_t n_yielded_fine() { return _n_yielded_fine; } |
|
411 |
size_t n_yielded_coarse() { return _n_yielded_coarse; } |
|
412 |
size_t n_yielded_sparse() { return _n_yielded_sparse; } |
|
413 |
size_t n_yielded() { |
|
414 |
return n_yielded_fine() + n_yielded_coarse() + n_yielded_sparse(); |
|
415 |
} |
|
416 |
}; |
|
417 |
||
30764 | 418 |
#endif // SHARE_VM_GC_G1_HEAPREGIONREMSET_HPP |