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