Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | 5888334c9c24 |
| children | de6a9e811145 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1390
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1390
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1390
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONREMSET_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONREMSET_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/sparsePRT.hpp" | |
| 29 | |
| 342 | 30 // Remembered set for a heap region. Represent a set of "cards" that |
| 31 // contain pointers into the owner heap region. Cards are defined somewhat | |
| 32 // abstractly, in terms of what the "BlockOffsetTable" in use can parse. | |
| 33 | |
| 34 class G1CollectedHeap; | |
| 35 class G1BlockOffsetSharedArray; | |
| 36 class HeapRegion; | |
| 37 class HeapRegionRemSetIterator; | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
38 class PerRegionTable; |
| 342 | 39 class SparsePRT; |
| 12080 | 40 class nmethod; |
| 342 | 41 |
| 2173 | 42 // Essentially a wrapper around SparsePRTCleanupTask. See |
| 43 // sparsePRT.hpp for more details. | |
| 44 class HRRSCleanupTask : public SparsePRTCleanupTask { | |
| 45 }; | |
| 342 | 46 |
| 47 // The "_coarse_map" is a bitmap with one bit for each region, where set | |
| 48 // bits indicate that the corresponding region may contain some pointer | |
| 49 // into the owning region. | |
| 50 | |
| 51 // The "_fine_grain_entries" array is an open hash table of PerRegionTables | |
| 52 // (PRTs), indicating regions for which we're keeping the RS as a set of | |
| 53 // cards. The strategy is to cap the size of the fine-grain table, | |
| 54 // deleting an entry and setting the corresponding coarse-grained bit when | |
| 55 // we would overflow this cap. | |
| 56 | |
| 57 // We use a mixture of locking and lock-free techniques here. We allow | |
| 58 // threads to locate PRTs without locking, but threads attempting to alter | |
| 59 // a bucket list obtain a lock. This means that any failing attempt to | |
| 60 // find a PRT must be retried with the lock. It might seem dangerous that | |
| 61 // a read can find a PRT that is concurrently deleted. This is all right, | |
| 62 // because: | |
| 63 // | |
| 64 // 1) We only actually free PRT's at safe points (though we reuse them at | |
| 65 // other times). | |
| 66 // 2) We find PRT's in an attempt to add entries. If a PRT is deleted, | |
| 67 // it's _coarse_map bit is set, so the that we were attempting to add | |
| 68 // is represented. If a deleted PRT is re-used, a thread adding a bit, | |
| 69 // thinking the PRT is for a different region, does no harm. | |
| 70 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
71 class OtherRegionsTable VALUE_OBJ_CLASS_SPEC { |
| 342 | 72 friend class HeapRegionRemSetIterator; |
| 73 | |
| 74 G1CollectedHeap* _g1h; | |
| 75 Mutex _m; | |
| 76 HeapRegion* _hr; | |
| 77 | |
| 78 // These are protected by "_m". | |
| 79 BitMap _coarse_map; | |
| 80 size_t _n_coarse_entries; | |
| 81 static jint _n_coarsenings; | |
| 82 | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
83 PerRegionTable** _fine_grain_regions; |
|
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
84 size_t _n_fine_entries; |
| 342 | 85 |
| 6253 | 86 // The fine grain remembered sets are doubly linked together using |
| 87 // their 'next' and 'prev' fields. | |
| 88 // This allows fast bulk freeing of all the fine grain remembered | |
| 89 // set entries, and fast finding of all of them without iterating | |
| 90 // over the _fine_grain_regions table. | |
| 91 PerRegionTable * _first_all_fine_prts; | |
| 92 PerRegionTable * _last_all_fine_prts; | |
| 93 | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
94 // Used to sample a subset of the fine grain PRTs to determine which |
|
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
95 // PRT to evict and coarsen. |
| 342 | 96 size_t _fine_eviction_start; |
| 97 static size_t _fine_eviction_stride; | |
| 98 static size_t _fine_eviction_sample_size; | |
| 99 | |
| 100 SparsePRT _sparse_table; | |
| 101 | |
| 102 // These are static after init. | |
| 103 static size_t _max_fine_entries; | |
| 104 static size_t _mod_max_fine_entries_mask; | |
| 105 | |
| 106 // Requires "prt" to be the first element of the bucket list appropriate | |
| 107 // for "hr". If this list contains an entry for "hr", return it, | |
| 108 // otherwise return "NULL". | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
109 PerRegionTable* find_region_table(size_t ind, HeapRegion* hr) const; |
| 342 | 110 |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
111 // Find, delete, and return a candidate PerRegionTable, if any exists, |
| 342 | 112 // adding the deleted region to the coarse bitmap. Requires the caller |
| 113 // to hold _m, and the fine-grain table to be full. | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
114 PerRegionTable* delete_region_table(); |
| 342 | 115 |
| 116 // If a PRT for "hr" is in the bucket list indicated by "ind" (which must | |
| 117 // be the correct index for "hr"), delete it and return true; else return | |
| 118 // false. | |
| 119 bool del_single_region_table(size_t ind, HeapRegion* hr); | |
| 120 | |
| 121 // Indexed by thread X heap region, to minimize thread contention. | |
| 122 static int** _from_card_cache; | |
| 123 static size_t _from_card_cache_max_regions; | |
| 124 static size_t _from_card_cache_mem_size; | |
| 125 | |
| 6253 | 126 // link/add the given fine grain remembered set into the "all" list |
| 127 void link_to_all(PerRegionTable * prt); | |
| 128 // unlink/remove the given fine grain remembered set into the "all" list | |
| 129 void unlink_from_all(PerRegionTable * prt); | |
| 130 | |
| 342 | 131 public: |
| 132 OtherRegionsTable(HeapRegion* hr); | |
| 133 | |
| 134 HeapRegion* hr() const { return _hr; } | |
| 135 | |
| 136 // For now. Could "expand" some tables in the future, so that this made | |
| 137 // sense. | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
138 void add_reference(OopOrNarrowOopStar from, int tid); |
| 342 | 139 |
| 140 // Removes any entries shown by the given bitmaps to contain only dead | |
| 141 // objects. | |
| 142 void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm); | |
| 143 | |
| 144 // Not const because it takes a lock. | |
| 145 size_t occupied() const; | |
| 146 size_t occ_fine() const; | |
| 147 size_t occ_coarse() const; | |
| 148 size_t occ_sparse() const; | |
| 149 | |
| 150 static jint n_coarsenings() { return _n_coarsenings; } | |
| 151 | |
| 152 // Returns size in bytes. | |
| 153 // Not const because it takes a lock. | |
| 154 size_t mem_size() const; | |
| 155 static size_t static_mem_size(); | |
| 156 static size_t fl_mem_size(); | |
| 157 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
158 bool contains_reference(OopOrNarrowOopStar from) const; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
159 bool contains_reference_locked(OopOrNarrowOopStar from) const; |
| 342 | 160 |
| 161 void clear(); | |
| 162 | |
| 163 // Specifically clear the from_card_cache. | |
| 164 void clear_fcc(); | |
| 165 | |
| 166 // "from_hr" is being cleared; remove any entries from it. | |
| 167 void clear_incoming_entry(HeapRegion* from_hr); | |
| 168 | |
| 2173 | 169 void do_cleanup_work(HRRSCleanupTask* hrrs_cleanup_task); |
| 170 | |
| 342 | 171 // Declare the heap size (in # of regions) to the OtherRegionsTable. |
| 172 // (Uses it to initialize from_card_cache). | |
| 173 static void init_from_card_cache(size_t max_regions); | |
| 174 | |
| 175 // Declares that only regions i s.t. 0 <= i < new_n_regs are in use. | |
| 176 // Make sure any entries for higher regions are invalid. | |
| 177 static void shrink_from_card_cache(size_t new_n_regs); | |
| 178 | |
| 179 static void print_from_card_cache(); | |
| 180 }; | |
| 181 | |
| 6197 | 182 class HeapRegionRemSet : public CHeapObj<mtGC> { |
| 342 | 183 friend class VMStructs; |
| 184 friend class HeapRegionRemSetIterator; | |
| 185 | |
| 186 public: | |
| 187 enum Event { | |
| 188 Event_EvacStart, Event_EvacEnd, Event_RSUpdateEnd | |
| 189 }; | |
| 190 | |
| 191 private: | |
| 192 G1BlockOffsetSharedArray* _bosa; | |
| 193 G1BlockOffsetSharedArray* bosa() const { return _bosa; } | |
| 194 | |
| 12080 | 195 // A list of code blobs (nmethods) whose code contains pointers into |
| 196 // the region that owns this RSet. | |
| 197 GrowableArray<nmethod*>* _strong_code_roots_list; | |
| 198 | |
| 342 | 199 OtherRegionsTable _other_regions; |
| 200 | |
| 201 enum ParIterState { Unclaimed, Claimed, Complete }; | |
| 1261 | 202 volatile ParIterState _iter_state; |
| 203 volatile jlong _iter_claimed; | |
| 342 | 204 |
| 205 // Unused unless G1RecordHRRSOops is true. | |
| 206 | |
| 207 static const int MaxRecorded = 1000000; | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
208 static OopOrNarrowOopStar* _recorded_oops; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
209 static HeapWord** _recorded_cards; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
210 static HeapRegion** _recorded_regions; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
211 static int _n_recorded; |
| 342 | 212 |
| 213 static const int MaxRecordedEvents = 1000; | |
| 214 static Event* _recorded_events; | |
| 215 static int* _recorded_event_index; | |
| 216 static int _n_recorded_events; | |
| 217 | |
| 218 static void print_event(outputStream* str, Event evnt); | |
| 219 | |
| 220 public: | |
| 221 HeapRegionRemSet(G1BlockOffsetSharedArray* bosa, | |
| 222 HeapRegion* hr); | |
| 223 | |
| 224 static int num_par_rem_sets(); | |
| 1261 | 225 static void setup_remset_size(); |
| 342 | 226 |
| 227 HeapRegion* hr() const { | |
| 228 return _other_regions.hr(); | |
| 229 } | |
| 230 | |
| 231 size_t occupied() const { | |
| 232 return _other_regions.occupied(); | |
| 233 } | |
| 234 size_t occ_fine() const { | |
| 235 return _other_regions.occ_fine(); | |
| 236 } | |
| 237 size_t occ_coarse() const { | |
| 238 return _other_regions.occ_coarse(); | |
| 239 } | |
| 240 size_t occ_sparse() const { | |
| 241 return _other_regions.occ_sparse(); | |
| 242 } | |
| 243 | |
| 244 static jint n_coarsenings() { return OtherRegionsTable::n_coarsenings(); } | |
| 245 | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
246 // Used in the sequential case. |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
247 void add_reference(OopOrNarrowOopStar from) { |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
248 _other_regions.add_reference(from, 0); |
| 342 | 249 } |
| 250 | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
251 // Used in the parallel case. |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
252 void add_reference(OopOrNarrowOopStar from, int tid) { |
| 342 | 253 _other_regions.add_reference(from, tid); |
| 254 } | |
| 255 | |
| 256 // Removes any entries shown by the given bitmaps to contain only dead | |
| 257 // objects. | |
| 258 void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm); | |
| 259 | |
| 260 // The region is being reclaimed; clear its remset, and any mention of | |
| 261 // entries for this region in other remsets. | |
| 262 void clear(); | |
| 263 | |
| 264 // Attempt to claim the region. Returns true iff this call caused an | |
| 265 // atomic transition from Unclaimed to Claimed. | |
| 266 bool claim_iter(); | |
| 267 // Sets the iteration state to "complete". | |
| 268 void set_iter_complete(); | |
| 269 // Returns "true" iff the region's iteration is complete. | |
| 270 bool iter_is_complete(); | |
| 271 | |
| 1261 | 272 // Support for claiming blocks of cards during iteration |
| 273 size_t iter_claimed() const { return (size_t)_iter_claimed; } | |
| 274 // Claim the next block of cards | |
| 275 size_t iter_claimed_next(size_t step) { | |
| 276 size_t current, next; | |
| 277 do { | |
| 278 current = iter_claimed(); | |
| 279 next = current + step; | |
| 280 } while (Atomic::cmpxchg((jlong)next, &_iter_claimed, (jlong)current) != (jlong)current); | |
| 281 return current; | |
| 282 } | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
2173
diff
changeset
|
283 void reset_for_par_iteration(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
2173
diff
changeset
|
284 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
2173
diff
changeset
|
285 bool verify_ready_for_par_iteration() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
2173
diff
changeset
|
286 return (_iter_state == Unclaimed) && (_iter_claimed == 0); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
2173
diff
changeset
|
287 } |
| 1261 | 288 |
| 342 | 289 // The actual # of bytes this hr_remset takes up. |
| 12080 | 290 // Note also includes the strong code root set. |
| 342 | 291 size_t mem_size() { |
| 292 return _other_regions.mem_size() | |
| 293 // This correction is necessary because the above includes the second | |
| 294 // part. | |
| 12080 | 295 + (sizeof(this) - sizeof(OtherRegionsTable)) |
| 296 + strong_code_roots_mem_size(); | |
| 342 | 297 } |
| 298 | |
| 299 // Returns the memory occupancy of all static data structures associated | |
| 300 // with remembered sets. | |
| 301 static size_t static_mem_size() { | |
| 302 return OtherRegionsTable::static_mem_size(); | |
| 303 } | |
| 304 | |
| 305 // Returns the memory occupancy of all free_list data structures associated | |
| 306 // with remembered sets. | |
| 307 static size_t fl_mem_size() { | |
| 308 return OtherRegionsTable::fl_mem_size(); | |
| 309 } | |
| 310 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
311 bool contains_reference(OopOrNarrowOopStar from) const { |
| 342 | 312 return _other_regions.contains_reference(from); |
| 313 } | |
| 12080 | 314 |
| 315 // Routines for managing the list of code roots that point into | |
| 316 // the heap region that owns this RSet. | |
| 317 void add_strong_code_root(nmethod* nm); | |
| 318 void remove_strong_code_root(nmethod* nm); | |
| 319 | |
| 320 // During a collection, migrate the successfully evacuated strong | |
| 321 // code roots that referenced into the region that owns this RSet | |
| 322 // to the RSets of the new regions that they now point into. | |
| 323 // Unsuccessfully evacuated code roots are not migrated. | |
| 324 void migrate_strong_code_roots(); | |
| 325 | |
| 326 // Applies blk->do_code_blob() to each of the entries in | |
| 327 // the strong code roots list | |
| 328 void strong_code_roots_do(CodeBlobClosure* blk) const; | |
| 329 | |
| 330 // Returns the number of elements in the strong code roots list | |
| 331 int strong_code_roots_list_length() { | |
| 332 return _strong_code_roots_list->length(); | |
| 333 } | |
| 334 | |
| 335 // Returns true if the strong code roots contains the given | |
| 336 // nmethod. | |
| 337 bool strong_code_roots_list_contains(nmethod* nm) { | |
| 338 return _strong_code_roots_list->contains(nm); | |
| 339 } | |
| 340 | |
| 341 // Returns the amount of memory, in bytes, currently | |
| 342 // consumed by the strong code roots. | |
| 343 size_t strong_code_roots_mem_size(); | |
| 344 | |
| 342 | 345 void print() const; |
| 346 | |
| 347 // Called during a stop-world phase to perform any deferred cleanups. | |
| 348 static void cleanup(); | |
| 349 | |
| 350 // Declare the heap size (in # of regions) to the HeapRegionRemSet(s). | |
| 351 // (Uses it to initialize from_card_cache). | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
3986
diff
changeset
|
352 static void init_heap(uint max_regions) { |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
3986
diff
changeset
|
353 OtherRegionsTable::init_from_card_cache((size_t) max_regions); |
| 342 | 354 } |
| 355 | |
| 356 // Declares that only regions i s.t. 0 <= i < new_n_regs are in use. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
3986
diff
changeset
|
357 static void shrink_heap(uint new_n_regs) { |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
3986
diff
changeset
|
358 OtherRegionsTable::shrink_from_card_cache((size_t) new_n_regs); |
| 342 | 359 } |
| 360 | |
| 361 #ifndef PRODUCT | |
| 362 static void print_from_card_cache() { | |
| 363 OtherRegionsTable::print_from_card_cache(); | |
| 364 } | |
| 365 #endif | |
| 366 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
794
diff
changeset
|
367 static void record(HeapRegion* hr, OopOrNarrowOopStar f); |
| 342 | 368 static void print_recorded(); |
| 369 static void record_event(Event evnt); | |
| 370 | |
| 2173 | 371 // These are wrappers for the similarly-named methods on |
| 372 // SparsePRT. Look at sparsePRT.hpp for more details. | |
| 373 static void reset_for_cleanup_tasks(); | |
| 374 void do_cleanup_work(HRRSCleanupTask* hrrs_cleanup_task); | |
| 375 static void finish_cleanup_task(HRRSCleanupTask* hrrs_cleanup_task); | |
| 376 | |
| 342 | 377 // Run unit tests. |
| 378 #ifndef PRODUCT | |
|
10333
6702da6b6082
8014405: G1: PerRegionTable::fl_mem_size() calculates size of the free list using wrong element sizes
tschatzl
parents:
10182
diff
changeset
|
379 static void test_prt(); |
| 342 | 380 static void test(); |
| 381 #endif | |
| 382 }; | |
| 383 | |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
384 class HeapRegionRemSetIterator : public StackObj { |
| 342 | 385 |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
386 // The region RSet over which we're iterating. |
| 342 | 387 const HeapRegionRemSet* _hrrs; |
| 388 | |
| 389 // Local caching of HRRS fields. | |
| 390 const BitMap* _coarse_map; | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
391 PerRegionTable** _fine_grain_regions; |
| 342 | 392 |
| 393 G1BlockOffsetSharedArray* _bosa; | |
| 394 G1CollectedHeap* _g1h; | |
| 395 | |
| 396 // The number yielded since initialization. | |
| 397 size_t _n_yielded_fine; | |
| 398 size_t _n_yielded_coarse; | |
| 399 size_t _n_yielded_sparse; | |
| 400 | |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
401 // Indicates what granularity of table that we're currently iterating over. |
|
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
402 // We start iterating over the sparse table, progress to the fine grain |
|
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
403 // table, and then finish with the coarse table. |
|
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
404 // See HeapRegionRemSetIterator::has_next(). |
| 342 | 405 enum IterState { |
| 406 Sparse, | |
| 407 Fine, | |
| 408 Coarse | |
| 409 }; | |
| 410 IterState _is; | |
| 411 | |
| 412 // In both kinds of iteration, heap offset of first card of current | |
| 413 // region. | |
| 414 size_t _cur_region_card_offset; | |
| 415 // Card offset within cur region. | |
| 416 size_t _cur_region_cur_card; | |
| 417 | |
| 418 // Coarse table iteration fields: | |
| 419 | |
| 420 // Current region index; | |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3777
diff
changeset
|
421 int _coarse_cur_region_index; |
|
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3777
diff
changeset
|
422 size_t _coarse_cur_region_cur_card; |
| 342 | 423 |
| 424 bool coarse_has_next(size_t& card_index); | |
| 425 | |
| 426 // Fine table iteration fields: | |
| 427 | |
| 428 // Index of bucket-list we're working on. | |
| 429 int _fine_array_index; | |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
430 |
| 342 | 431 // Per Region Table we're doing within current bucket list. |
|
6188
7994a5a35fcf
6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets
johnc
parents:
6010
diff
changeset
|
432 PerRegionTable* _fine_cur_prt; |
| 342 | 433 |
| 434 /* SparsePRT::*/ SparsePRTIter _sparse_iter; | |
| 435 | |
| 436 void fine_find_next_non_null_prt(); | |
| 437 | |
| 438 bool fine_has_next(); | |
| 439 bool fine_has_next(size_t& card_index); | |
| 440 | |
| 441 public: | |
| 442 // We require an iterator to be initialized before use, so the | |
| 443 // constructor does little. | |
|
10182
5c93c1f61226
8011724: G1: Stack allocate instances of HeapRegionRemSetIterator
johnc
parents:
6253
diff
changeset
|
444 HeapRegionRemSetIterator(const HeapRegionRemSet* hrrs); |
| 342 | 445 |
| 446 // If there remains one or more cards to be yielded, returns true and | |
| 447 // sets "card_index" to one of those cards (which is then considered | |
| 448 // yielded.) Otherwise, returns false (and leaves "card_index" | |
| 449 // undefined.) | |
| 450 bool has_next(size_t& card_index); | |
| 451 | |
| 452 size_t n_yielded_fine() { return _n_yielded_fine; } | |
| 453 size_t n_yielded_coarse() { return _n_yielded_coarse; } | |
| 454 size_t n_yielded_sparse() { return _n_yielded_sparse; } | |
| 455 size_t n_yielded() { | |
| 456 return n_yielded_fine() + n_yielded_coarse() + n_yielded_sparse(); | |
| 457 } | |
| 458 }; | |
| 459 | |
| 1972 | 460 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONREMSET_HPP |