author | stefank |
Tue, 26 Nov 2019 10:47:46 +0100 | |
changeset 59290 | 97d13893ec3c |
parent 58084 | cddef3bde924 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
58084
cddef3bde924
8230398: Remove NULL checks before FREE_C_HEAP_ARRAY
lkorinth
parents:
55510
diff
changeset
|
2 |
* Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved. |
1374 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4902
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4902
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4902
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
30764 | 26 |
#include "gc/g1/heapRegion.hpp" |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
27 |
#include "gc/g1/heapRegionBounds.inline.hpp" |
30764 | 28 |
#include "gc/g1/heapRegionRemSet.hpp" |
29 |
#include "gc/g1/sparsePRT.hpp" |
|
49455
848864ed9b17
8199604: Rename CardTableModRefBS to CardTableBarrierSet
eosterlund
parents:
49164
diff
changeset
|
30 |
#include "gc/shared/cardTableBarrierSet.hpp" |
30764 | 31 |
#include "gc/shared/space.inline.hpp" |
7397 | 32 |
#include "memory/allocation.inline.hpp" |
33 |
#include "runtime/mutexLocker.hpp" |
|
1374 | 34 |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
35 |
// Check that the size of the SparsePRTEntry is evenly divisible by the maximum |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
36 |
// member type to avoid SIGBUS when accessing them. |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
37 |
STATIC_ASSERT(sizeof(SparsePRTEntry) % sizeof(int) == 0); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
38 |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
39 |
void SparsePRTEntry::init(RegionIdx_t region_ind) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
40 |
// Check that the card array element type can represent all cards in the region. |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
41 |
// Choose a large SparsePRTEntry::card_elem_t (e.g. CardIdx_t) if required. |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
42 |
assert(((size_t)1 << (sizeof(SparsePRTEntry::card_elem_t) * BitsPerByte)) * |
49164
7e958a8ebcd3
8195142: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents:
47634
diff
changeset
|
43 |
G1CardTable::card_size >= HeapRegionBounds::max_size(), "precondition"); |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
44 |
assert(G1RSetSparseRegionEntries > 0, "precondition"); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
45 |
_region_ind = region_ind; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
46 |
_next_index = RSHashTable::NullEntry; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
47 |
_next_null = 0; |
1374 | 48 |
} |
49 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
50 |
bool SparsePRTEntry::contains_card(CardIdx_t card_index) const { |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
51 |
for (int i = 0; i < num_valid_cards(); i++) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
52 |
if (card(i) == card_index) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
53 |
return true; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
54 |
} |
1374 | 55 |
} |
56 |
return false; |
|
57 |
} |
|
58 |
||
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
59 |
SparsePRTEntry::AddCardResult SparsePRTEntry::add_card(CardIdx_t card_index) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
60 |
for (int i = 0; i < num_valid_cards(); i++) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
61 |
if (card(i) == card_index) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
62 |
return found; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
63 |
} |
1374 | 64 |
} |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
65 |
if (num_valid_cards() < cards_num() - 1) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
66 |
_cards[_next_null] = (card_elem_t)card_index; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
67 |
_next_null++; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
68 |
return added; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
69 |
} |
1374 | 70 |
// Otherwise, we're full. |
71 |
return overflow; |
|
72 |
} |
|
73 |
||
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
74 |
void SparsePRTEntry::copy_cards(card_elem_t* cards) const { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
75 |
memcpy(cards, _cards, cards_num() * sizeof(card_elem_t)); |
1374 | 76 |
} |
77 |
||
78 |
void SparsePRTEntry::copy_cards(SparsePRTEntry* e) const { |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
79 |
copy_cards(e->_cards); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
80 |
assert(_next_null >= 0, "invariant"); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
81 |
assert(_next_null <= cards_num(), "invariant"); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
82 |
e->_next_null = _next_null; |
1374 | 83 |
} |
84 |
||
85 |
// ---------------------------------------------------------------------- |
|
86 |
||
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
87 |
float RSHashTable::TableOccupancyFactor = 0.5f; |
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
88 |
|
1374 | 89 |
RSHashTable::RSHashTable(size_t capacity) : |
51332 | 90 |
_num_entries(0), |
91 |
_capacity(capacity), |
|
92 |
_capacity_mask(capacity-1), |
|
93 |
_occupied_entries(0), |
|
94 |
_occupied_cards(0), |
|
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
95 |
_entries(NULL), |
13195 | 96 |
_buckets(NEW_C_HEAP_ARRAY(int, capacity, mtGC)), |
51332 | 97 |
_free_region(0), |
98 |
_free_list(NullEntry) |
|
1374 | 99 |
{ |
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
100 |
_num_entries = (capacity * TableOccupancyFactor) + 1; |
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
101 |
_entries = (SparsePRTEntry*)NEW_C_HEAP_ARRAY(char, _num_entries * SparsePRTEntry::size(), mtGC); |
1374 | 102 |
clear(); |
103 |
} |
|
104 |
||
105 |
RSHashTable::~RSHashTable() { |
|
58084
cddef3bde924
8230398: Remove NULL checks before FREE_C_HEAP_ARRAY
lkorinth
parents:
55510
diff
changeset
|
106 |
FREE_C_HEAP_ARRAY(SparsePRTEntry, _entries); |
cddef3bde924
8230398: Remove NULL checks before FREE_C_HEAP_ARRAY
lkorinth
parents:
55510
diff
changeset
|
107 |
FREE_C_HEAP_ARRAY(int, _buckets); |
1374 | 108 |
} |
109 |
||
110 |
void RSHashTable::clear() { |
|
111 |
_occupied_entries = 0; |
|
112 |
_occupied_cards = 0; |
|
113 |
guarantee(_entries != NULL, "INV"); |
|
114 |
guarantee(_buckets != NULL, "INV"); |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
115 |
|
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
116 |
guarantee(_capacity <= ((size_t)1 << (sizeof(int)*BitsPerByte-1)) - 1, |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
117 |
"_capacity too large"); |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
118 |
|
1374 | 119 |
// This will put -1 == NullEntry in the key field of all entries. |
46630
75aa3e39d02c
8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents:
41283
diff
changeset
|
120 |
memset((void*)_entries, NullEntry, _num_entries * SparsePRTEntry::size()); |
75aa3e39d02c
8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents:
41283
diff
changeset
|
121 |
memset((void*)_buckets, NullEntry, _capacity * sizeof(int)); |
1374 | 122 |
_free_list = NullEntry; |
123 |
_free_region = 0; |
|
124 |
} |
|
125 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
126 |
bool RSHashTable::add_card(RegionIdx_t region_ind, CardIdx_t card_index) { |
1374 | 127 |
SparsePRTEntry* e = entry_for_region_ind_create(region_ind); |
128 |
assert(e != NULL && e->r_ind() == region_ind, |
|
129 |
"Postcondition of call above."); |
|
130 |
SparsePRTEntry::AddCardResult res = e->add_card(card_index); |
|
131 |
if (res == SparsePRTEntry::added) _occupied_cards++; |
|
132 |
assert(e->num_valid_cards() > 0, "Postcondition"); |
|
133 |
return res != SparsePRTEntry::overflow; |
|
134 |
} |
|
135 |
||
24464
901aa0dcba08
8042474: Clean up duplicated code in RSHashTable
brutisso
parents:
24108
diff
changeset
|
136 |
SparsePRTEntry* RSHashTable::get_entry(RegionIdx_t region_ind) const { |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
137 |
int ind = (int) (region_ind & capacity_mask()); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
138 |
int cur_ind = _buckets[ind]; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
139 |
SparsePRTEntry* cur; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
140 |
while (cur_ind != NullEntry && |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
141 |
(cur = entry(cur_ind))->r_ind() != region_ind) { |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
142 |
cur_ind = cur->next_index(); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
143 |
} |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
144 |
|
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
145 |
if (cur_ind == NullEntry) return NULL; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
146 |
// Otherwise... |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
147 |
assert(cur->r_ind() == region_ind, "Postcondition of loop + test above."); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
148 |
assert(cur->num_valid_cards() > 0, "Inv"); |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
149 |
return cur; |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
150 |
} |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
151 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
152 |
bool RSHashTable::delete_entry(RegionIdx_t region_ind) { |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
153 |
int ind = (int) (region_ind & capacity_mask()); |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
154 |
int* prev_loc = &_buckets[ind]; |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
155 |
int cur_ind = *prev_loc; |
1374 | 156 |
SparsePRTEntry* cur; |
157 |
while (cur_ind != NullEntry && |
|
158 |
(cur = entry(cur_ind))->r_ind() != region_ind) { |
|
159 |
prev_loc = cur->next_index_addr(); |
|
160 |
cur_ind = *prev_loc; |
|
161 |
} |
|
162 |
||
163 |
if (cur_ind == NullEntry) return false; |
|
164 |
// Otherwise, splice out "cur". |
|
165 |
*prev_loc = cur->next_index(); |
|
166 |
_occupied_cards -= cur->num_valid_cards(); |
|
167 |
free_entry(cur_ind); |
|
168 |
_occupied_entries--; |
|
169 |
return true; |
|
170 |
} |
|
171 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
172 |
SparsePRTEntry* |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
173 |
RSHashTable::entry_for_region_ind_create(RegionIdx_t region_ind) { |
24464
901aa0dcba08
8042474: Clean up duplicated code in RSHashTable
brutisso
parents:
24108
diff
changeset
|
174 |
SparsePRTEntry* res = get_entry(region_ind); |
1374 | 175 |
if (res == NULL) { |
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
176 |
int new_ind = alloc_entry(); |
1374 | 177 |
res = entry(new_ind); |
178 |
res->init(region_ind); |
|
179 |
// Insert at front. |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
180 |
int ind = (int) (region_ind & capacity_mask()); |
1374 | 181 |
res->set_next_index(_buckets[ind]); |
182 |
_buckets[ind] = new_ind; |
|
183 |
_occupied_entries++; |
|
184 |
} |
|
185 |
return res; |
|
186 |
} |
|
187 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
188 |
int RSHashTable::alloc_entry() { |
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
189 |
int res; |
1374 | 190 |
if (_free_list != NullEntry) { |
191 |
res = _free_list; |
|
192 |
_free_list = entry(res)->next_index(); |
|
193 |
return res; |
|
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
194 |
} else if ((size_t)_free_region < _num_entries) { |
1374 | 195 |
res = _free_region; |
196 |
_free_region++; |
|
197 |
return res; |
|
198 |
} else { |
|
199 |
return NullEntry; |
|
200 |
} |
|
201 |
} |
|
202 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
203 |
void RSHashTable::free_entry(int fi) { |
1374 | 204 |
entry(fi)->set_next_index(_free_list); |
205 |
_free_list = fi; |
|
206 |
} |
|
207 |
||
208 |
void RSHashTable::add_entry(SparsePRTEntry* e) { |
|
209 |
assert(e->num_valid_cards() > 0, "Precondition."); |
|
210 |
SparsePRTEntry* e2 = entry_for_region_ind_create(e->r_ind()); |
|
211 |
e->copy_cards(e2); |
|
212 |
_occupied_cards += e2->num_valid_cards(); |
|
213 |
assert(e2->num_valid_cards() > 0, "Postcondition."); |
|
214 |
} |
|
215 |
||
6983
a8c50cedbce9
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
6981
diff
changeset
|
216 |
CardIdx_t RSHashTableIter::find_first_card_in_list() { |
1374 | 217 |
while (_bl_ind != RSHashTable::NullEntry) { |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
218 |
SparsePRTEntry* sparse_entry = _rsht->entry(_bl_ind); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
219 |
if (sparse_entry->num_valid_cards() > 0) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
220 |
return sparse_entry->card(0); |
1374 | 221 |
} else { |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
222 |
_bl_ind = sparse_entry->next_index(); |
1374 | 223 |
} |
224 |
} |
|
225 |
// Otherwise, none found: |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
226 |
return NoCardFound; |
1374 | 227 |
} |
228 |
||
6983
a8c50cedbce9
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
6981
diff
changeset
|
229 |
size_t RSHashTableIter::compute_card_ind(CardIdx_t ci) { |
6981
ecfe524b1fa7
6992189: G1: inconsistent base used in sparse rem set iterator
tonyp
parents:
6250
diff
changeset
|
230 |
return (_rsht->entry(_bl_ind)->r_ind() * HeapRegion::CardsPerRegion) + ci; |
1374 | 231 |
} |
232 |
||
6983
a8c50cedbce9
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
6981
diff
changeset
|
233 |
bool RSHashTableIter::has_next(size_t& card_index) { |
1374 | 234 |
_card_ind++; |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
235 |
if (_bl_ind >= 0) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
236 |
SparsePRTEntry* e = _rsht->entry(_bl_ind); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
237 |
if (_card_ind < e->num_valid_cards()) { |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
238 |
CardIdx_t ci = e->card(_card_ind); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
239 |
card_index = compute_card_ind(ci); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
240 |
return true; |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
241 |
} |
1374 | 242 |
} |
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
243 |
|
1374 | 244 |
// Otherwise, must find the next valid entry. |
245 |
_card_ind = 0; |
|
246 |
||
247 |
if (_bl_ind != RSHashTable::NullEntry) { |
|
248 |
_bl_ind = _rsht->entry(_bl_ind)->next_index(); |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
249 |
CardIdx_t ci = find_first_card_in_list(); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
250 |
if (ci != NoCardFound) { |
1374 | 251 |
card_index = compute_card_ind(ci); |
252 |
return true; |
|
253 |
} |
|
254 |
} |
|
255 |
// If we didn't return above, must go to the next non-null table index. |
|
256 |
_tbl_ind++; |
|
257 |
while ((size_t)_tbl_ind < _rsht->capacity()) { |
|
258 |
_bl_ind = _rsht->_buckets[_tbl_ind]; |
|
38271
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
259 |
CardIdx_t ci = find_first_card_in_list(); |
4425ba8ed50f
8047328: Improve memory usage for cards in SparsePRTEntry
tschatzl
parents:
38269
diff
changeset
|
260 |
if (ci != NoCardFound) { |
1374 | 261 |
card_index = compute_card_ind(ci); |
262 |
return true; |
|
263 |
} |
|
264 |
// Otherwise, try next entry. |
|
265 |
_tbl_ind++; |
|
266 |
} |
|
267 |
// Otherwise, there were no entry. |
|
268 |
return false; |
|
269 |
} |
|
270 |
||
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
271 |
bool RSHashTableBucketIter::has_next(SparsePRTEntry*& entry) { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
272 |
while (_bl_ind == RSHashTable::NullEntry) { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
273 |
if (_tbl_ind == (int)_rsht->capacity() - 1) { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
274 |
return false; |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
275 |
} |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
276 |
_tbl_ind++; |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
277 |
_bl_ind = _rsht->_buckets[_tbl_ind]; |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
278 |
} |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
279 |
entry = _rsht->entry(_bl_ind); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
280 |
_bl_ind = entry->next_index(); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
281 |
return true; |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
282 |
} |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
52716
diff
changeset
|
283 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
284 |
bool RSHashTable::contains_card(RegionIdx_t region_index, CardIdx_t card_index) const { |
24464
901aa0dcba08
8042474: Clean up duplicated code in RSHashTable
brutisso
parents:
24108
diff
changeset
|
285 |
SparsePRTEntry* e = get_entry(region_index); |
1374 | 286 |
return (e != NULL && e->contains_card(card_index)); |
287 |
} |
|
288 |
||
289 |
size_t RSHashTable::mem_size() const { |
|
24108
dfc2242fc6b0
8040792: G1: Memory usage calculation uses sizeof(this) instead of sizeof(classname)
tschatzl
parents:
22234
diff
changeset
|
290 |
return sizeof(RSHashTable) + |
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
291 |
_num_entries * (SparsePRTEntry::size() + sizeof(int)); |
1374 | 292 |
} |
293 |
||
294 |
// ---------------------------------------------------------------------- |
|
295 |
||
52347
14ef0f74667b
8211388: Make OtherRegionsTable independent of the region it is for
tschatzl
parents:
51332
diff
changeset
|
296 |
SparsePRT::SparsePRT() : |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
297 |
_table(new RSHashTable(InitialCapacity)) { |
1374 | 298 |
} |
299 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
300 |
|
1374 | 301 |
SparsePRT::~SparsePRT() { |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
302 |
delete _table; |
1374 | 303 |
} |
304 |
||
305 |
||
306 |
size_t SparsePRT::mem_size() const { |
|
307 |
// We ignore "_cur" here, because it either = _next, or else it is |
|
308 |
// on the deleted list. |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
309 |
return sizeof(SparsePRT) + _table->mem_size(); |
1374 | 310 |
} |
311 |
||
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
312 |
bool SparsePRT::add_card(RegionIdx_t region_id, CardIdx_t card_index) { |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
313 |
if (_table->should_expand()) { |
1374 | 314 |
expand(); |
315 |
} |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
316 |
return _table->add_card(region_id, card_index); |
1374 | 317 |
} |
318 |
||
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
319 |
SparsePRTEntry* SparsePRT::get_entry(RegionIdx_t region_id) { |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
320 |
return _table->get_entry(region_id); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
321 |
} |
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4100
diff
changeset
|
322 |
|
2996
1097030e5ec3
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
2143
diff
changeset
|
323 |
bool SparsePRT::delete_entry(RegionIdx_t region_id) { |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
324 |
return _table->delete_entry(region_id); |
1374 | 325 |
} |
326 |
||
327 |
void SparsePRT::clear() { |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
328 |
// If the entry table is not at initial capacity, just create a new one. |
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
329 |
if (_table->capacity() != InitialCapacity) { |
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
330 |
delete _table; |
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
331 |
_table = new RSHashTable(InitialCapacity); |
1374 | 332 |
} else { |
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
333 |
_table->clear(); |
1374 | 334 |
} |
335 |
} |
|
336 |
||
337 |
void SparsePRT::expand() { |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
338 |
RSHashTable* last = _table; |
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
339 |
_table = new RSHashTable(last->capacity() * 2); |
38269
d18cab031e64
8155721: Sparse remset wastes half of entry memory
tschatzl
parents:
33741
diff
changeset
|
340 |
for (size_t i = 0; i < last->num_entries(); i++) { |
1374 | 341 |
SparsePRTEntry* e = last->entry((int)i); |
342 |
if (e->valid_entry()) { |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
343 |
_table->add_entry(e); |
1374 | 344 |
} |
345 |
} |
|
52716
877dd2b0f36c
8213996: Remove one of the SparsePRT entry tables
tschatzl
parents:
52347
diff
changeset
|
346 |
delete last; |
1374 | 347 |
} |