Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/sparsePRT.hpp @ 807:d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
Summary: For heaps larger than 32Gb, the number of heap regions overflows the data type used to hold the region index in the SparsePRT structure. Changed the region indexes, card indexes, and RSet hash table buckets to ints and added some size overflow guarantees.
Reviewed-by: ysr, tonyp
| author | johnc |
|---|---|
| date | Thu, 11 Jun 2009 17:19:33 -0700 |
| parents | 7bb995fbd3c0 |
| children | 2c79770d1f6e |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 579 | 2 * Copyright 2001-2009 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // Sparse remembered set for a heap region (the "owning" region). Maps | |
| 26 // indices of other regions to short sequences of cards in the other region | |
| 27 // that might contain pointers into the owner region. | |
| 28 | |
| 29 // These tables only expand while they are accessed in parallel -- | |
| 30 // deletions may be done in single-threaded code. This allows us to allow | |
| 31 // unsynchronized reads/iterations, as long as expansions caused by | |
| 32 // insertions only enqueue old versions for deletions, but do not delete | |
| 33 // old versions synchronously. | |
| 34 | |
| 35 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
36 class SparsePRTEntry: public CHeapObj { |
| 342 | 37 public: |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
38 |
| 342 | 39 enum SomePublicConstants { |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
40 CardsPerEntry = 4, |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
41 NullEntry = -1 |
| 342 | 42 }; |
| 43 | |
| 44 private: | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
45 RegionIdx_t _region_ind; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
46 int _next_index; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
47 CardIdx_t _cards[CardsPerEntry]; |
| 342 | 48 |
| 49 public: | |
| 50 | |
| 51 // Set the region_ind to the given value, and delete all cards. | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
52 inline void init(RegionIdx_t region_ind); |
| 342 | 53 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
54 RegionIdx_t r_ind() const { return _region_ind; } |
| 342 | 55 bool valid_entry() const { return r_ind() >= 0; } |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
56 void set_r_ind(RegionIdx_t rind) { _region_ind = rind; } |
| 342 | 57 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
58 int next_index() const { return _next_index; } |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
59 int* next_index_addr() { return &_next_index; } |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
60 void set_next_index(int ni) { _next_index = ni; } |
| 342 | 61 |
| 62 // Returns "true" iff the entry contains the given card index. | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
63 inline bool contains_card(CardIdx_t card_index) const; |
| 342 | 64 |
| 65 // Returns the number of non-NULL card entries. | |
| 66 inline int num_valid_cards() const; | |
| 67 | |
| 68 // Requires that the entry not contain the given card index. If there is | |
| 69 // space available, add the given card index to the entry and return | |
| 70 // "true"; otherwise, return "false" to indicate that the entry is full. | |
| 71 enum AddCardResult { | |
| 72 overflow, | |
| 73 found, | |
| 74 added | |
| 75 }; | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
76 inline AddCardResult add_card(CardIdx_t card_index); |
| 342 | 77 |
| 78 // Copy the current entry's cards into "cards". | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
79 inline void copy_cards(CardIdx_t* cards) const; |
| 342 | 80 // Copy the current entry's cards into the "_card" array of "e." |
| 81 inline void copy_cards(SparsePRTEntry* e) const; | |
| 82 | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
83 inline CardIdx_t card(int i) const { return _cards[i]; } |
| 342 | 84 }; |
| 85 | |
| 86 | |
| 87 class RSHashTable : public CHeapObj { | |
| 88 | |
| 89 friend class RSHashTableIter; | |
| 90 | |
| 91 enum SomePrivateConstants { | |
| 92 NullEntry = -1 | |
| 93 }; | |
| 94 | |
| 95 size_t _capacity; | |
| 96 size_t _capacity_mask; | |
| 97 size_t _occupied_entries; | |
| 98 size_t _occupied_cards; | |
| 99 | |
| 100 SparsePRTEntry* _entries; | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
101 int* _buckets; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
102 int _free_region; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
103 int _free_list; |
| 342 | 104 |
| 105 static RSHashTable* _head_deleted_list; | |
| 106 RSHashTable* _next_deleted; | |
| 107 RSHashTable* next_deleted() { return _next_deleted; } | |
| 108 void set_next_deleted(RSHashTable* rsht) { _next_deleted = rsht; } | |
| 109 bool _deleted; | |
| 110 void set_deleted(bool b) { _deleted = b; } | |
| 111 | |
| 112 // Requires that the caller hold a lock preventing parallel modifying | |
| 113 // operations, and that the the table be less than completely full. If | |
| 114 // an entry for "region_ind" is already in the table, finds it and | |
| 115 // returns its address; otherwise returns "NULL." | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
116 SparsePRTEntry* entry_for_region_ind(RegionIdx_t region_ind) const; |
| 342 | 117 |
| 118 // Requires that the caller hold a lock preventing parallel modifying | |
| 119 // operations, and that the the table be less than completely full. If | |
| 120 // an entry for "region_ind" is already in the table, finds it and | |
| 121 // returns its address; otherwise allocates, initializes, inserts and | |
| 122 // returns a new entry for "region_ind". | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
123 SparsePRTEntry* entry_for_region_ind_create(RegionIdx_t region_ind); |
| 342 | 124 |
| 125 // Returns the index of the next free entry in "_entries". | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
126 int alloc_entry(); |
| 342 | 127 // Declares the entry "fi" to be free. (It must have already been |
| 128 // deleted from any bucket lists. | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
129 void free_entry(int fi); |
| 342 | 130 |
| 131 public: | |
| 132 RSHashTable(size_t capacity); | |
| 133 ~RSHashTable(); | |
| 134 | |
| 135 // Attempts to ensure that the given card_index in the given region is in | |
| 136 // the sparse table. If successful (because the card was already | |
| 137 // present, or because it was successfullly added) returns "true". | |
| 138 // Otherwise, returns "false" to indicate that the addition would | |
| 139 // overflow the entry for the region. The caller must transfer these | |
| 140 // entries to a larger-capacity representation. | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
141 bool add_card(RegionIdx_t region_id, CardIdx_t card_index); |
| 342 | 142 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
143 bool get_cards(RegionIdx_t region_id, CardIdx_t* cards); |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
144 bool delete_entry(RegionIdx_t region_id); |
| 342 | 145 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
146 bool contains_card(RegionIdx_t region_id, CardIdx_t card_index) const; |
| 342 | 147 |
| 148 void add_entry(SparsePRTEntry* e); | |
| 149 | |
| 150 void clear(); | |
| 151 | |
| 152 size_t capacity() const { return _capacity; } | |
| 153 size_t capacity_mask() const { return _capacity_mask; } | |
| 154 size_t occupied_entries() const { return _occupied_entries; } | |
| 155 size_t occupied_cards() const { return _occupied_cards; } | |
| 156 size_t mem_size() const; | |
| 157 bool deleted() { return _deleted; } | |
| 158 | |
| 159 SparsePRTEntry* entry(int i) const { return &_entries[i]; } | |
| 160 | |
| 161 void print(); | |
| 162 | |
| 163 static void add_to_deleted_list(RSHashTable* rsht); | |
| 164 static RSHashTable* get_from_deleted_list(); | |
| 165 }; | |
| 166 | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
167 // ValueObj because will be embedded in HRRS iterator. |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
168 class RSHashTableIter VALUE_OBJ_CLASS_SPEC { |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
169 int _tbl_ind; // [-1, 0.._rsht->_capacity) |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
170 int _bl_ind; // [-1, 0.._rsht->_capacity) |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
171 short _card_ind; // [0..CardsPerEntry) |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
172 RSHashTable* _rsht; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
173 size_t _heap_bot_card_ind; |
| 342 | 174 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
175 enum SomePrivateConstants { |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
176 CardsPerRegion = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
177 }; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
178 |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
179 // If the bucket list pointed to by _bl_ind contains a card, sets |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
180 // _bl_ind to the index of that entry, and returns the card. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
181 // Otherwise, returns SparseEntry::NullEntry. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
182 CardIdx_t find_first_card_in_list(); |
| 342 | 183 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
184 // Computes the proper card index for the card whose offset in the |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
185 // current region (as indicated by _bl_ind) is "ci". |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
186 // This is subject to errors when there is iteration concurrent with |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
187 // modification, but these errors should be benign. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
188 size_t compute_card_ind(CardIdx_t ci); |
| 342 | 189 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
190 public: |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
191 RSHashTableIter(size_t heap_bot_card_ind) : |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
192 _tbl_ind(RSHashTable::NullEntry), |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
193 _bl_ind(RSHashTable::NullEntry), |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
194 _card_ind((SparsePRTEntry::CardsPerEntry-1)), |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
195 _rsht(NULL), |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
196 _heap_bot_card_ind(heap_bot_card_ind) |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
197 {} |
| 342 | 198 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
199 void init(RSHashTable* rsht) { |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
200 _rsht = rsht; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
201 _tbl_ind = -1; // So that first increment gets to 0. |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
202 _bl_ind = RSHashTable::NullEntry; |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
203 _card_ind = (SparsePRTEntry::CardsPerEntry-1); |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
204 } |
| 342 | 205 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
206 bool has_next(size_t& card_index); |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
207 }; |
| 342 | 208 |
| 209 // Concurrent accesss to a SparsePRT must be serialized by some external | |
| 210 // mutex. | |
| 211 | |
| 212 class SparsePRTIter; | |
| 213 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
214 class SparsePRT VALUE_OBJ_CLASS_SPEC { |
| 342 | 215 // Iterations are done on the _cur hash table, since they only need to |
| 216 // see entries visible at the start of a collection pause. | |
| 217 // All other operations are done using the _next hash table. | |
| 218 RSHashTable* _cur; | |
| 219 RSHashTable* _next; | |
| 220 | |
| 221 HeapRegion* _hr; | |
| 222 | |
| 223 enum SomeAdditionalPrivateConstants { | |
| 224 InitialCapacity = 16 | |
| 225 }; | |
| 226 | |
| 227 void expand(); | |
| 228 | |
| 229 bool _expanded; | |
| 230 | |
| 231 bool expanded() { return _expanded; } | |
| 232 void set_expanded(bool b) { _expanded = b; } | |
| 233 | |
| 234 SparsePRT* _next_expanded; | |
| 235 | |
| 236 SparsePRT* next_expanded() { return _next_expanded; } | |
| 237 void set_next_expanded(SparsePRT* nxt) { _next_expanded = nxt; } | |
| 238 | |
| 239 static SparsePRT* _head_expanded_list; | |
| 240 | |
| 241 public: | |
| 242 SparsePRT(HeapRegion* hr); | |
| 243 | |
| 244 ~SparsePRT(); | |
| 245 | |
| 246 size_t occupied() const { return _next->occupied_cards(); } | |
| 247 size_t mem_size() const; | |
| 248 | |
| 249 // Attempts to ensure that the given card_index in the given region is in | |
| 250 // the sparse table. If successful (because the card was already | |
| 251 // present, or because it was successfullly added) returns "true". | |
| 252 // Otherwise, returns "false" to indicate that the addition would | |
| 253 // overflow the entry for the region. The caller must transfer these | |
| 254 // entries to a larger-capacity representation. | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
255 bool add_card(RegionIdx_t region_id, CardIdx_t card_index); |
| 342 | 256 |
| 257 // If the table hold an entry for "region_ind", Copies its | |
| 258 // cards into "cards", which must be an array of length at least | |
| 259 // "CardsPerEntry", and returns "true"; otherwise, returns "false". | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
260 bool get_cards(RegionIdx_t region_ind, CardIdx_t* cards); |
| 342 | 261 |
| 262 // If there is an entry for "region_ind", removes it and return "true"; | |
| 263 // otherwise returns "false." | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
264 bool delete_entry(RegionIdx_t region_ind); |
| 342 | 265 |
| 266 // Clear the table, and reinitialize to initial capacity. | |
| 267 void clear(); | |
| 268 | |
| 269 // Ensure that "_cur" and "_next" point to the same table. | |
| 270 void cleanup(); | |
| 271 | |
| 272 // Clean up all tables on the expanded list. Called single threaded. | |
| 273 static void cleanup_all(); | |
|
617
0db4adb6e914
6810698: G1: two small bugs in the sparse remembered sets
tonyp
parents:
549
diff
changeset
|
274 RSHashTable* cur() const { return _cur; } |
| 342 | 275 |
| 276 void init_iterator(SparsePRTIter* sprt_iter); | |
| 277 | |
| 278 static void add_to_expanded_list(SparsePRT* sprt); | |
| 279 static SparsePRT* get_from_expanded_list(); | |
| 280 | |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
628
diff
changeset
|
281 bool contains_card(RegionIdx_t region_id, CardIdx_t card_index) const { |
| 342 | 282 return _next->contains_card(region_id, card_index); |
| 283 } | |
| 284 | |
| 285 #if 0 | |
| 286 void verify_is_cleared(); | |
| 287 void print(); | |
| 288 #endif | |
| 289 }; | |
| 290 | |
| 291 | |
| 292 class SparsePRTIter: public /* RSHashTable:: */RSHashTableIter { | |
| 293 public: | |
| 294 SparsePRTIter(size_t heap_bot_card_ind) : | |
| 295 /* RSHashTable:: */RSHashTableIter(heap_bot_card_ind) | |
| 296 {} | |
| 297 | |
| 298 void init(const SparsePRT* sprt) { | |
|
617
0db4adb6e914
6810698: G1: two small bugs in the sparse remembered sets
tonyp
parents:
549
diff
changeset
|
299 RSHashTableIter::init(sprt->cur()); |
| 342 | 300 } |
| 301 bool has_next(size_t& card_index) { | |
| 302 return RSHashTableIter::has_next(card_index); | |
| 303 } | |
| 304 }; |