Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp @ 20494:7baf47cb97cb
8048268: G1 Code Root Migration performs poorly
Summary: Replace G1CodeRootSet with a Hashtable based implementation, merge Code Root Migration phase into Code Root Scanning
Reviewed-by: jmasa, brutisso, tschatzl
| author | mgerdin |
|---|---|
| date | Fri, 29 Aug 2014 13:12:21 +0200 |
| parents | 870c03421152 |
| children | 58925d1f325e |
| rev | line source |
|---|---|
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
1 /* |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
4 * |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
5 * This code is free software; you can redistribute it and/or modify it |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
7 * published by the Free Software Foundation. |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
8 * |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
13 * accompanied this code). |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
14 * |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
15 * You should have received a copy of the GNU General Public License version |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
18 * |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
21 * questions. |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
22 * |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
23 */ |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
24 |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
25 #include "precompiled.hpp" |
| 20494 | 26 #include "code/codeCache.hpp" |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
27 #include "code/nmethod.hpp" |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
28 #include "gc_implementation/g1/g1CodeCacheRemSet.hpp" |
| 20494 | 29 #include "gc_implementation/g1/heapRegion.hpp" |
| 30 #include "memory/heap.hpp" | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
31 #include "memory/iterator.hpp" |
| 20494 | 32 #include "oops/oop.inline.hpp" |
| 33 #include "utilities/hashtable.inline.hpp" | |
| 34 #include "utilities/stack.inline.hpp" | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
35 |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17753
diff
changeset
|
36 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17753
diff
changeset
|
37 |
| 20494 | 38 class CodeRootSetTable : public Hashtable<nmethod*, mtGC> { |
| 39 friend class G1CodeRootSetTest; | |
| 40 typedef HashtableEntry<nmethod*, mtGC> Entry; | |
| 41 | |
| 42 static CodeRootSetTable* volatile _purge_list; | |
| 43 | |
| 44 CodeRootSetTable* _purge_next; | |
| 45 | |
| 46 unsigned int compute_hash(nmethod* nm) { | |
| 47 uintptr_t hash = (uintptr_t)nm; | |
| 48 return hash ^ (hash >> 7); // code heap blocks are 128byte aligned | |
| 49 } | |
| 50 | |
| 51 Entry* new_entry(nmethod* nm); | |
| 52 | |
| 53 public: | |
| 54 CodeRootSetTable(int size) : Hashtable<nmethod*, mtGC>(size, sizeof(Entry)), _purge_next(NULL) {} | |
| 55 ~CodeRootSetTable(); | |
| 56 | |
| 57 // Needs to be protected locks | |
| 58 bool add(nmethod* nm); | |
| 59 bool remove(nmethod* nm); | |
| 60 | |
| 61 // Can be called without locking | |
| 62 bool contains(nmethod* nm); | |
| 63 | |
| 64 int entry_size() const { return BasicHashtable<mtGC>::entry_size(); } | |
| 65 | |
| 66 void copy_to(CodeRootSetTable* new_table); | |
| 67 void nmethods_do(CodeBlobClosure* blk); | |
| 68 | |
| 69 template<typename CB> | |
| 70 void remove_if(CB& should_remove); | |
| 71 | |
| 72 static void purge_list_append(CodeRootSetTable* tbl); | |
| 73 static void purge(); | |
| 74 | |
| 75 static size_t static_mem_size() { | |
| 76 return sizeof(_purge_list); | |
| 77 } | |
| 78 }; | |
| 79 | |
| 80 CodeRootSetTable* volatile CodeRootSetTable::_purge_list = NULL; | |
| 81 | |
| 82 CodeRootSetTable::Entry* CodeRootSetTable::new_entry(nmethod* nm) { | |
| 83 unsigned int hash = compute_hash(nm); | |
| 84 Entry* entry = (Entry*) new_entry_free_list(); | |
| 85 if (entry == NULL) { | |
| 86 entry = (Entry*) NEW_C_HEAP_ARRAY2(char, entry_size(), mtGC, CURRENT_PC); | |
| 87 } | |
| 88 entry->set_next(NULL); | |
| 89 entry->set_hash(hash); | |
| 90 entry->set_literal(nm); | |
| 91 return entry; | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
92 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
93 |
| 20494 | 94 CodeRootSetTable::~CodeRootSetTable() { |
| 95 for (int index = 0; index < table_size(); ++index) { | |
| 96 for (Entry* e = bucket(index); e != NULL; ) { | |
| 97 Entry* to_remove = e; | |
| 98 // read next before freeing. | |
| 99 e = e->next(); | |
| 100 unlink_entry(to_remove); | |
| 101 FREE_C_HEAP_ARRAY(char, to_remove, mtGC); | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
102 } |
| 20494 | 103 } |
| 104 assert(number_of_entries() == 0, "should have removed all entries"); | |
| 105 free_buckets(); | |
| 106 for (BasicHashtableEntry<mtGC>* e = new_entry_free_list(); e != NULL; e = new_entry_free_list()) { | |
| 107 FREE_C_HEAP_ARRAY(char, e, mtGC); | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
108 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
109 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
110 |
| 20494 | 111 bool CodeRootSetTable::add(nmethod* nm) { |
| 112 if (!contains(nm)) { | |
| 113 Entry* e = new_entry(nm); | |
| 114 int index = hash_to_index(e->hash()); | |
| 115 add_entry(index, e); | |
| 116 return true; | |
| 117 } | |
| 118 return false; | |
| 119 } | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
120 |
| 20494 | 121 bool CodeRootSetTable::contains(nmethod* nm) { |
| 122 int index = hash_to_index(compute_hash(nm)); | |
| 123 for (Entry* e = bucket(index); e != NULL; e = e->next()) { | |
| 124 if (e->literal() == nm) { | |
| 125 return true; | |
| 126 } | |
| 127 } | |
| 128 return false; | |
| 129 } | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
130 |
| 20494 | 131 bool CodeRootSetTable::remove(nmethod* nm) { |
| 132 int index = hash_to_index(compute_hash(nm)); | |
| 133 Entry* previous = NULL; | |
| 134 for (Entry* e = bucket(index); e != NULL; previous = e, e = e->next()) { | |
| 135 if (e->literal() == nm) { | |
| 136 if (previous != NULL) { | |
| 137 previous->set_next(e->next()); | |
| 138 } else { | |
| 139 set_entry(index, e->next()); | |
| 140 } | |
| 141 free_entry(e); | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
142 return true; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
143 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
144 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
145 return false; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
146 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20218
diff
changeset
|
147 |
| 20494 | 148 void CodeRootSetTable::copy_to(CodeRootSetTable* new_table) { |
| 149 for (int index = 0; index < table_size(); ++index) { | |
| 150 for (Entry* e = bucket(index); e != NULL; e = e->next()) { | |
| 151 new_table->add(e->literal()); | |
| 152 } | |
| 153 } | |
| 154 new_table->copy_freelist(this); | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
155 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
156 |
| 20494 | 157 void CodeRootSetTable::nmethods_do(CodeBlobClosure* blk) { |
| 158 for (int index = 0; index < table_size(); ++index) { | |
| 159 for (Entry* e = bucket(index); e != NULL; e = e->next()) { | |
| 160 blk->do_code_blob(e->literal()); | |
| 161 } | |
| 162 } | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
163 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
164 |
| 20494 | 165 template<typename CB> |
| 166 void CodeRootSetTable::remove_if(CB& should_remove) { | |
| 167 for (int index = 0; index < table_size(); ++index) { | |
| 168 Entry* previous = NULL; | |
| 169 Entry* e = bucket(index); | |
| 170 while (e != NULL) { | |
| 171 Entry* next = e->next(); | |
| 172 if (should_remove(e->literal())) { | |
| 173 if (previous != NULL) { | |
| 174 previous->set_next(next); | |
| 175 } else { | |
| 176 set_entry(index, next); | |
| 177 } | |
| 178 free_entry(e); | |
| 179 } else { | |
| 180 previous = e; | |
| 181 } | |
| 182 e = next; | |
| 183 } | |
| 184 } | |
| 185 } | |
| 186 | |
| 187 G1CodeRootSet::~G1CodeRootSet() { | |
| 188 delete _table; | |
|
20211
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
189 } |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
190 |
| 20494 | 191 CodeRootSetTable* G1CodeRootSet::load_acquire_table() { |
| 192 return (CodeRootSetTable*) OrderAccess::load_ptr_acquire(&_table); | |
| 193 } | |
| 194 | |
| 195 void G1CodeRootSet::allocate_small_table() { | |
| 196 _table = new CodeRootSetTable(SmallSize); | |
| 197 } | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
198 |
| 20494 | 199 void CodeRootSetTable::purge_list_append(CodeRootSetTable* table) { |
| 200 for (;;) { | |
| 201 table->_purge_next = _purge_list; | |
| 202 CodeRootSetTable* old = (CodeRootSetTable*) Atomic::cmpxchg_ptr(table, &_purge_list, table->_purge_next); | |
| 203 if (old == table->_purge_next) { | |
| 204 break; | |
| 205 } | |
| 206 } | |
| 207 } | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
208 |
| 20494 | 209 void CodeRootSetTable::purge() { |
| 210 CodeRootSetTable* table = _purge_list; | |
| 211 _purge_list = NULL; | |
| 212 while (table != NULL) { | |
| 213 CodeRootSetTable* to_purge = table; | |
| 214 table = table->_purge_next; | |
| 215 delete to_purge; | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
216 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
217 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
218 |
| 20494 | 219 void G1CodeRootSet::move_to_large() { |
| 220 CodeRootSetTable* temp = new CodeRootSetTable(LargeSize); | |
| 221 | |
| 222 _table->copy_to(temp); | |
| 223 | |
| 224 CodeRootSetTable::purge_list_append(_table); | |
| 225 | |
| 226 OrderAccess::release_store_ptr(&_table, temp); | |
|
20211
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
227 } |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
228 |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
229 |
| 20494 | 230 void G1CodeRootSet::purge() { |
| 231 CodeRootSetTable::purge(); | |
| 232 } | |
| 233 | |
| 234 size_t G1CodeRootSet::static_mem_size() { | |
| 235 return CodeRootSetTable::static_mem_size(); | |
| 236 } | |
| 237 | |
| 238 void G1CodeRootSet::add(nmethod* method) { | |
| 239 bool added = false; | |
| 240 if (is_empty()) { | |
| 241 allocate_small_table(); | |
| 242 } | |
| 243 added = _table->add(method); | |
| 244 if (_length == Threshold) { | |
| 245 move_to_large(); | |
| 246 } | |
| 247 if (added) { | |
| 248 ++_length; | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 bool G1CodeRootSet::remove(nmethod* method) { | |
| 253 bool removed = false; | |
| 254 if (_table != NULL) { | |
| 255 removed = _table->remove(method); | |
| 256 } | |
| 257 if (removed) { | |
| 258 _length--; | |
| 259 if (_length == 0) { | |
| 260 clear(); | |
| 261 } | |
| 262 } | |
| 263 return removed; | |
| 264 } | |
| 265 | |
| 266 bool G1CodeRootSet::contains(nmethod* method) { | |
| 267 CodeRootSetTable* table = load_acquire_table(); | |
| 268 if (table != NULL) { | |
| 269 return table->contains(method); | |
|
20211
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
270 } |
| 20494 | 271 return false; |
| 272 } | |
| 273 | |
| 274 void G1CodeRootSet::clear() { | |
| 275 delete _table; | |
| 276 _table = NULL; | |
| 277 _length = 0; | |
| 278 } | |
| 279 | |
| 280 size_t G1CodeRootSet::mem_size() { | |
| 281 return sizeof(*this) + | |
| 282 (_table != NULL ? sizeof(CodeRootSetTable) + _table->entry_size() * _length : 0); | |
| 283 } | |
| 284 | |
| 285 void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const { | |
| 286 if (_table != NULL) { | |
| 287 _table->nmethods_do(blk); | |
| 288 } | |
| 289 } | |
| 290 | |
| 291 class CleanCallback : public StackObj { | |
| 292 class PointsIntoHRDetectionClosure : public OopClosure { | |
| 293 HeapRegion* _hr; | |
| 294 public: | |
| 295 bool _points_into; | |
| 296 PointsIntoHRDetectionClosure(HeapRegion* hr) : _hr(hr), _points_into(false) {} | |
| 297 | |
| 298 void do_oop(narrowOop* o) { | |
| 299 do_oop_work(o); | |
| 300 } | |
| 301 | |
| 302 void do_oop(oop* o) { | |
| 303 do_oop_work(o); | |
| 304 } | |
| 305 | |
| 306 template <typename T> | |
| 307 void do_oop_work(T* p) { | |
| 308 if (_hr->is_in(oopDesc::load_decode_heap_oop(p))) { | |
| 309 _points_into = true; | |
| 310 } | |
| 311 } | |
| 312 }; | |
| 313 | |
| 314 PointsIntoHRDetectionClosure _detector; | |
| 315 CodeBlobToOopClosure _blobs; | |
| 316 | |
| 317 public: | |
| 318 CleanCallback(HeapRegion* hr) : _detector(hr), _blobs(&_detector, !CodeBlobToOopClosure::FixRelocations) {} | |
| 319 | |
| 320 bool operator() (nmethod* nm) { | |
| 321 _detector._points_into = false; | |
| 322 _blobs.do_code_blob(nm); | |
| 323 return _detector._points_into; | |
| 324 } | |
| 325 }; | |
| 326 | |
| 327 void G1CodeRootSet::clean(HeapRegion* owner) { | |
| 328 CleanCallback should_clean(owner); | |
| 329 if (_table != NULL) { | |
| 330 _table->remove_if(should_clean); | |
| 331 } | |
|
20211
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
332 } |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
333 |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
334 #ifndef PRODUCT |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
335 |
| 20494 | 336 class G1CodeRootSetTest { |
| 337 public: | |
| 338 static void test() { | |
| 339 { | |
| 340 G1CodeRootSet set1; | |
| 341 assert(set1.is_empty(), "Code root set must be initially empty but is not."); | |
| 342 | |
| 343 assert(G1CodeRootSet::static_mem_size() == sizeof(void*), | |
| 344 err_msg("The code root set's static memory usage is incorrect, "SIZE_FORMAT" bytes", G1CodeRootSet::static_mem_size())); | |
| 345 | |
| 346 set1.add((nmethod*)1); | |
| 347 assert(set1.length() == 1, err_msg("Added exactly one element, but set contains " | |
| 348 SIZE_FORMAT" elements", set1.length())); | |
| 349 | |
| 350 const size_t num_to_add = (size_t)G1CodeRootSet::Threshold + 1; | |
| 351 | |
| 352 for (size_t i = 1; i <= num_to_add; i++) { | |
| 353 set1.add((nmethod*)1); | |
| 354 } | |
| 355 assert(set1.length() == 1, | |
| 356 err_msg("Duplicate detection should not have increased the set size but " | |
| 357 "is "SIZE_FORMAT, set1.length())); | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
diff
changeset
|
358 |
| 20494 | 359 for (size_t i = 2; i <= num_to_add; i++) { |
| 360 set1.add((nmethod*)(uintptr_t)(i)); | |
| 361 } | |
| 362 assert(set1.length() == num_to_add, | |
| 363 err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they " | |
| 364 "need to be in the set, but there are only "SIZE_FORMAT, | |
| 365 num_to_add, set1.length())); | |
| 366 | |
| 367 assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable"); | |
| 368 | |
| 369 size_t num_popped = 0; | |
| 370 for (size_t i = 1; i <= num_to_add; i++) { | |
| 371 bool removed = set1.remove((nmethod*)i); | |
| 372 if (removed) { | |
| 373 num_popped += 1; | |
| 374 } else { | |
| 375 break; | |
| 376 } | |
| 377 } | |
| 378 assert(num_popped == num_to_add, | |
| 379 err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" " | |
| 380 "were added", num_popped, num_to_add)); | |
| 381 assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable"); | |
| 382 | |
| 383 G1CodeRootSet::purge(); | |
| 384 | |
| 385 assert(CodeRootSetTable::_purge_list == NULL, "should have purged old small tables"); | |
| 386 | |
| 387 } | |
| 388 | |
| 389 } | |
| 390 }; | |
| 391 | |
| 392 void TestCodeCacheRemSet_test() { | |
| 393 G1CodeRootSetTest::test(); | |
|
20211
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
394 } |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
395 |
|
82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
tschatzl
parents:
17937
diff
changeset
|
396 #endif |