author | stefank |
Tue, 26 Nov 2019 10:47:46 +0100 | |
changeset 59290 | 97d13893ec3c |
parent 58447 | 319173c62caa |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53601
112ad164d26c
8215505: Cleanup jvm.cpp obsolete code after JDK-8210094: Better loading of classloader classes
coleenp
parents:
53322
diff
changeset
|
2 |
* Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 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:
5426
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5426
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:
5426
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
34257
diff
changeset
|
26 |
#include "classfile/classLoaderData.inline.hpp" |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
27 |
#include "classfile/dictionary.hpp" |
46382
5520c435279b
8178336: Unnecessary SystemDictionary walk for Protection domain liveness
coleenp
parents:
46380
diff
changeset
|
28 |
#include "classfile/protectionDomainCache.hpp" |
7397 | 29 |
#include "classfile/systemDictionary.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
30 |
#include "logging/log.hpp" |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
31 |
#include "logging/logStream.hpp" |
20405 | 32 |
#include "memory/iterator.hpp" |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
33 |
#include "memory/metaspaceClosure.hpp" |
37248 | 34 |
#include "memory/resourceArea.hpp" |
7397 | 35 |
#include "oops/oop.inline.hpp" |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
36 |
#include "runtime/mutexLocker.hpp" |
49594
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49348
diff
changeset
|
37 |
#include "runtime/safepointVerifiers.hpp" |
7397 | 38 |
#include "utilities/hashtable.inline.hpp" |
1 | 39 |
|
47774 | 40 |
// Optimization: if any dictionary needs resizing, we set this flag, |
41 |
// so that we dont't have to walk all dictionaries to check if any actually |
|
42 |
// needs resizing, which is costly to do at Safepoint. |
|
43 |
bool Dictionary::_some_dictionary_needs_resizing = false; |
|
44 |
||
45 |
Dictionary::Dictionary(ClassLoaderData* loader_data, int table_size, bool resizable) |
|
52514
f4e3900c8d08
8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents:
52340
diff
changeset
|
46 |
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)sizeof(DictionaryEntry)), |
51334
cc2c79d22508
8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents:
50634
diff
changeset
|
47 |
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) { |
1 | 48 |
}; |
49 |
||
50 |
||
46729 | 51 |
Dictionary::Dictionary(ClassLoaderData* loader_data, |
52 |
int table_size, HashtableBucket<mtClass>* t, |
|
47774 | 53 |
int number_of_entries, bool resizable) |
52514
f4e3900c8d08
8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents:
52340
diff
changeset
|
54 |
: Hashtable<InstanceKlass*, mtClass>(table_size, (int)sizeof(DictionaryEntry), t, number_of_entries), |
51334
cc2c79d22508
8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents:
50634
diff
changeset
|
55 |
_resizable(resizable), _needs_resizing(false), _loader_data(loader_data) { |
1 | 56 |
}; |
57 |
||
46729 | 58 |
Dictionary::~Dictionary() { |
59 |
DictionaryEntry* probe = NULL; |
|
60 |
for (int index = 0; index < table_size(); index++) { |
|
61 |
for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { |
|
62 |
probe = *p; |
|
63 |
*p = probe->next(); |
|
64 |
free_entry(probe); |
|
65 |
} |
|
66 |
} |
|
67 |
assert(number_of_entries() == 0, "should have removed all entries"); |
|
68 |
assert(new_entry_free_list() == NULL, "entry present on Dictionary's free list"); |
|
20405 | 69 |
} |
1 | 70 |
|
46729 | 71 |
DictionaryEntry* Dictionary::new_entry(unsigned int hash, InstanceKlass* klass) { |
72 |
DictionaryEntry* entry = (DictionaryEntry*)Hashtable<InstanceKlass*, mtClass>::allocate_new_entry(hash, klass); |
|
1 | 73 |
entry->set_pd_set(NULL); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
74 |
assert(klass->is_instance_klass(), "Must be"); |
1 | 75 |
return entry; |
76 |
} |
|
77 |
||
78 |
||
79 |
void Dictionary::free_entry(DictionaryEntry* entry) { |
|
80 |
// avoid recursion when deleting linked list |
|
47098
e704f55561c3
8164207: Checking missing load-acquire in relation to _pd_set in dictionary.cpp
coleenp
parents:
46746
diff
changeset
|
81 |
// pd_set is accessed during a safepoint. |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
82 |
// This doesn't require a lock because nothing is reading this |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
83 |
// entry anymore. The ClassLoader is dead. |
1 | 84 |
while (entry->pd_set() != NULL) { |
85 |
ProtectionDomainEntry* to_delete = entry->pd_set(); |
|
86 |
entry->set_pd_set(to_delete->next()); |
|
87 |
delete to_delete; |
|
88 |
} |
|
46729 | 89 |
// Unlink from the Hashtable prior to freeing |
90 |
unlink_entry(entry); |
|
91 |
FREE_C_HEAP_ARRAY(char, entry); |
|
1 | 92 |
} |
93 |
||
47774 | 94 |
const int _resize_load_trigger = 5; // load factor that will trigger the resize |
95 |
const double _resize_factor = 2.0; // by how much we will resize using current number of entries |
|
96 |
const int _resize_max_size = 40423; // the max dictionary size allowed |
|
97 |
const int _primelist[] = {107, 1009, 2017, 4049, 5051, 10103, 20201, _resize_max_size}; |
|
98 |
const int _prime_array_size = sizeof(_primelist)/sizeof(int); |
|
99 |
||
100 |
// Calculate next "good" dictionary size based on requested count |
|
101 |
static int calculate_dictionary_size(int requested) { |
|
102 |
int newsize = _primelist[0]; |
|
103 |
int index = 0; |
|
104 |
for (newsize = _primelist[index]; index < (_prime_array_size - 1); |
|
105 |
newsize = _primelist[++index]) { |
|
106 |
if (requested <= newsize) { |
|
107 |
break; |
|
108 |
} |
|
109 |
} |
|
110 |
return newsize; |
|
111 |
} |
|
112 |
||
113 |
bool Dictionary::does_any_dictionary_needs_resizing() { |
|
114 |
return Dictionary::_some_dictionary_needs_resizing; |
|
115 |
} |
|
116 |
||
117 |
void Dictionary::check_if_needs_resize() { |
|
118 |
if (_resizable == true) { |
|
119 |
if (number_of_entries() > (_resize_load_trigger*table_size())) { |
|
120 |
_needs_resizing = true; |
|
121 |
Dictionary::_some_dictionary_needs_resizing = true; |
|
122 |
} |
|
123 |
} |
|
124 |
} |
|
125 |
||
126 |
bool Dictionary::resize_if_needed() { |
|
127 |
int desired_size = 0; |
|
128 |
if (_needs_resizing == true) { |
|
129 |
desired_size = calculate_dictionary_size((int)(_resize_factor*number_of_entries())); |
|
130 |
if (desired_size >= _resize_max_size) { |
|
131 |
desired_size = _resize_max_size; |
|
132 |
// We have reached the limit, turn resizing off |
|
133 |
_resizable = false; |
|
134 |
} |
|
135 |
if ((desired_size != 0) && (desired_size != table_size())) { |
|
136 |
if (!resize(desired_size)) { |
|
137 |
// Something went wrong, turn resizing off |
|
138 |
_resizable = false; |
|
139 |
} |
|
140 |
} |
|
141 |
} |
|
142 |
||
143 |
_needs_resizing = false; |
|
144 |
Dictionary::_some_dictionary_needs_resizing = false; |
|
145 |
||
146 |
return (desired_size != 0); |
|
147 |
} |
|
1 | 148 |
|
149 |
bool DictionaryEntry::contains_protection_domain(oop protection_domain) const { |
|
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
150 |
// Lock the pd_set list. This lock cannot safepoint since the caller holds |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
151 |
// a Dictionary entry, which can be moved if the Dictionary is resized. |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53962
diff
changeset
|
152 |
MutexLocker ml(ProtectionDomainSet_lock, Mutex::_no_safepoint_check_flag); |
1 | 153 |
#ifdef ASSERT |
58177 | 154 |
if (protection_domain == instance_klass()->protection_domain()) { |
1 | 155 |
// Ensure this doesn't show up in the pd_set (invariant) |
156 |
bool in_pd_set = false; |
|
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
157 |
for (ProtectionDomainEntry* current = pd_set(); |
1 | 158 |
current != NULL; |
159 |
current = current->next()) { |
|
58177 | 160 |
if (current->object_no_keepalive() == protection_domain) { |
1 | 161 |
in_pd_set = true; |
162 |
break; |
|
163 |
} |
|
164 |
} |
|
165 |
if (in_pd_set) { |
|
166 |
assert(false, "A klass's protection domain should not show up " |
|
167 |
"in its sys. dict. PD set"); |
|
168 |
} |
|
169 |
} |
|
170 |
#endif /* ASSERT */ |
|
171 |
||
58177 | 172 |
if (protection_domain == instance_klass()->protection_domain()) { |
1 | 173 |
// Succeeds trivially |
174 |
return true; |
|
175 |
} |
|
176 |
||
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
177 |
for (ProtectionDomainEntry* current = pd_set(); |
1 | 178 |
current != NULL; |
179 |
current = current->next()) { |
|
58177 | 180 |
if (current->object_no_keepalive() == protection_domain) return true; |
1 | 181 |
} |
182 |
return false; |
|
183 |
} |
|
184 |
||
185 |
||
46274
534d019edb92
8175104: Unhandled oop in ProtectionDomainCacheTable::compute_hash
coleenp
parents:
46271
diff
changeset
|
186 |
void DictionaryEntry::add_protection_domain(Dictionary* dict, Handle protection_domain) { |
1 | 187 |
assert_locked_or_safepoint(SystemDictionary_lock); |
46274
534d019edb92
8175104: Unhandled oop in ProtectionDomainCacheTable::compute_hash
coleenp
parents:
46271
diff
changeset
|
188 |
if (!contains_protection_domain(protection_domain())) { |
46729 | 189 |
ProtectionDomainCacheEntry* entry = SystemDictionary::cache_get(protection_domain); |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
190 |
// The pd_set in the dictionary entry is protected by a low level lock. |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
191 |
// With concurrent PD table cleanup, these links could be broken. |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53962
diff
changeset
|
192 |
MutexLocker ml(ProtectionDomainSet_lock, Mutex::_no_safepoint_check_flag); |
1 | 193 |
ProtectionDomainEntry* new_head = |
47098
e704f55561c3
8164207: Checking missing load-acquire in relation to _pd_set in dictionary.cpp
coleenp
parents:
46746
diff
changeset
|
194 |
new ProtectionDomainEntry(entry, pd_set()); |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
195 |
set_pd_set(new_head); |
1 | 196 |
} |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
197 |
LogTarget(Trace, protectiondomain) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
198 |
if (lt.is_enabled()) { |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
199 |
LogStream ls(lt); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46475
diff
changeset
|
200 |
print_count(&ls); |
1 | 201 |
} |
202 |
} |
|
203 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
204 |
// Just the classes from defining class loaders |
46729 | 205 |
void Dictionary::classes_do(void f(InstanceKlass*)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
206 |
for (int index = 0; index < table_size(); index++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
207 |
for (DictionaryEntry* probe = bucket(index); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
208 |
probe != NULL; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
209 |
probe = probe->next()) { |
46729 | 210 |
InstanceKlass* k = probe->instance_klass(); |
211 |
if (loader_data() == k->class_loader_data()) { |
|
1 | 212 |
f(k); |
213 |
} |
|
214 |
} |
|
215 |
} |
|
216 |
} |
|
217 |
||
218 |
// Added for initialize_itable_for_klass to handle exceptions |
|
219 |
// Just the classes from defining class loaders |
|
46729 | 220 |
void Dictionary::classes_do(void f(InstanceKlass*, TRAPS), TRAPS) { |
1 | 221 |
for (int index = 0; index < table_size(); index++) { |
222 |
for (DictionaryEntry* probe = bucket(index); |
|
223 |
probe != NULL; |
|
224 |
probe = probe->next()) { |
|
46729 | 225 |
InstanceKlass* k = probe->instance_klass(); |
226 |
if (loader_data() == k->class_loader_data()) { |
|
1 | 227 |
f(k, CHECK); |
228 |
} |
|
229 |
} |
|
230 |
} |
|
231 |
} |
|
232 |
||
46729 | 233 |
// All classes, and their class loaders, including initiating class loaders |
51530
1f0b605bdc28
8209821: Make JVMTI GetClassLoaderClasses not walk CLDG
coleenp
parents:
51523
diff
changeset
|
234 |
void Dictionary::all_entries_do(KlassClosure* closure) { |
1 | 235 |
for (int index = 0; index < table_size(); index++) { |
236 |
for (DictionaryEntry* probe = bucket(index); |
|
237 |
probe != NULL; |
|
238 |
probe = probe->next()) { |
|
46729 | 239 |
InstanceKlass* k = probe->instance_klass(); |
51530
1f0b605bdc28
8209821: Make JVMTI GetClassLoaderClasses not walk CLDG
coleenp
parents:
51523
diff
changeset
|
240 |
closure->do_klass(k); |
1 | 241 |
} |
242 |
} |
|
243 |
} |
|
244 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
245 |
// Used to scan and relocate the classes during CDS archive dump. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
246 |
void Dictionary::classes_do(MetaspaceClosure* it) { |
58447
319173c62caa
8231606: _method_ordering is not set during CDS dynamic dump time
ccheung
parents:
58177
diff
changeset
|
247 |
Arguments::assert_is_dumping_archive(); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
248 |
for (int index = 0; index < table_size(); index++) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
249 |
for (DictionaryEntry* probe = bucket(index); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
250 |
probe != NULL; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
251 |
probe = probe->next()) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
252 |
it->push(probe->klass_addr()); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
253 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
254 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
255 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
256 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
257 |
|
1 | 258 |
|
46729 | 259 |
// Add a loaded class to the dictionary. |
1 | 260 |
// Readers of the SystemDictionary aren't always locked, so _buckets |
261 |
// is volatile. The store of the next field in the constructor is |
|
262 |
// also cast to volatile; we do this to ensure store order is maintained |
|
263 |
// by the compilers. |
|
264 |
||
47774 | 265 |
void Dictionary::add_klass(unsigned int hash, Symbol* class_name, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46274
diff
changeset
|
266 |
InstanceKlass* obj) { |
1 | 267 |
assert_locked_or_safepoint(SystemDictionary_lock); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46274
diff
changeset
|
268 |
assert(obj != NULL, "adding NULL obj"); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46274
diff
changeset
|
269 |
assert(obj->name() == class_name, "sanity check on name"); |
1 | 270 |
|
46729 | 271 |
DictionaryEntry* entry = new_entry(hash, obj); |
47774 | 272 |
int index = hash_to_index(hash); |
1 | 273 |
add_entry(index, entry); |
47774 | 274 |
check_if_needs_resize(); |
1 | 275 |
} |
276 |
||
277 |
||
46729 | 278 |
// This routine does not lock the dictionary. |
1 | 279 |
// |
280 |
// Since readers don't hold a lock, we must make sure that system |
|
281 |
// dictionary entries are only removed at a safepoint (when only one |
|
282 |
// thread is running), and are added to in a safe way (all links must |
|
283 |
// be updated in an MT-safe manner). |
|
284 |
// |
|
285 |
// Callers should be aware that an entry could be added just after |
|
286 |
// _buckets[index] is read here, so the caller will not see the new entry. |
|
287 |
DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash, |
|
46729 | 288 |
Symbol* class_name) { |
1 | 289 |
for (DictionaryEntry* entry = bucket(index); |
290 |
entry != NULL; |
|
291 |
entry = entry->next()) { |
|
46729 | 292 |
if (entry->hash() == hash && entry->equals(class_name)) { |
52514
f4e3900c8d08
8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents:
52340
diff
changeset
|
293 |
return entry; |
1 | 294 |
} |
295 |
} |
|
296 |
return NULL; |
|
297 |
} |
|
298 |
||
299 |
||
47774 | 300 |
InstanceKlass* Dictionary::find(unsigned int hash, Symbol* name, |
46729 | 301 |
Handle protection_domain) { |
47774 | 302 |
NoSafepointVerifier nsv; |
303 |
||
304 |
int index = hash_to_index(hash); |
|
46729 | 305 |
DictionaryEntry* entry = get_entry(index, hash, name); |
1 | 306 |
if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) { |
46729 | 307 |
return entry->instance_klass(); |
1 | 308 |
} else { |
309 |
return NULL; |
|
310 |
} |
|
311 |
} |
|
312 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46274
diff
changeset
|
313 |
InstanceKlass* Dictionary::find_class(int index, unsigned int hash, |
46729 | 314 |
Symbol* name) { |
1 | 315 |
assert_locked_or_safepoint(SystemDictionary_lock); |
46729 | 316 |
assert (index == index_for(name), "incorrect index?"); |
1 | 317 |
|
46729 | 318 |
DictionaryEntry* entry = get_entry(index, hash, name); |
319 |
return (entry != NULL) ? entry->instance_klass() : NULL; |
|
1 | 320 |
} |
321 |
||
322 |
||
323 |
void Dictionary::add_protection_domain(int index, unsigned int hash, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46274
diff
changeset
|
324 |
InstanceKlass* klass, |
46729 | 325 |
Handle protection_domain, |
1 | 326 |
TRAPS) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
327 |
Symbol* klass_name = klass->name(); |
46729 | 328 |
DictionaryEntry* entry = get_entry(index, hash, klass_name); |
1 | 329 |
|
330 |
assert(entry != NULL,"entry must be present, we just created it"); |
|
331 |
assert(protection_domain() != NULL, |
|
332 |
"real protection domain should be present"); |
|
333 |
||
46274
534d019edb92
8175104: Unhandled oop in ProtectionDomainCacheTable::compute_hash
coleenp
parents:
46271
diff
changeset
|
334 |
entry->add_protection_domain(this, protection_domain); |
1 | 335 |
|
48811
58787a1708d2
8175249: VMThread::run fails in VerifyBeforeExit : Universe::verify
coleenp
parents:
48781
diff
changeset
|
336 |
#ifdef ASSERT |
58787a1708d2
8175249: VMThread::run fails in VerifyBeforeExit : Universe::verify
coleenp
parents:
48781
diff
changeset
|
337 |
assert(loader_data() != ClassLoaderData::the_null_class_loader_data(), "doesn't make sense"); |
58787a1708d2
8175249: VMThread::run fails in VerifyBeforeExit : Universe::verify
coleenp
parents:
48781
diff
changeset
|
338 |
#endif |
58787a1708d2
8175249: VMThread::run fails in VerifyBeforeExit : Universe::verify
coleenp
parents:
48781
diff
changeset
|
339 |
|
1 | 340 |
assert(entry->contains_protection_domain(protection_domain()), |
341 |
"now protection domain should be present"); |
|
342 |
} |
|
343 |
||
344 |
||
47774 | 345 |
bool Dictionary::is_valid_protection_domain(unsigned int hash, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
346 |
Symbol* name, |
1 | 347 |
Handle protection_domain) { |
47774 | 348 |
int index = hash_to_index(hash); |
46729 | 349 |
DictionaryEntry* entry = get_entry(index, hash, name); |
1 | 350 |
return entry->is_valid_protection_domain(protection_domain); |
351 |
} |
|
352 |
||
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
353 |
// During class loading we may have cached a protection domain that has |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
354 |
// since been unreferenced, so this entry should be cleared. |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
355 |
void Dictionary::clean_cached_protection_domains() { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
356 |
assert_locked_or_safepoint(SystemDictionary_lock); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
357 |
|
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
358 |
if (loader_data()->is_the_null_class_loader_data()) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
359 |
// Classes in the boot loader are not loaded with protection domains |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
360 |
return; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
361 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
362 |
|
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
363 |
for (int index = 0; index < table_size(); index++) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
364 |
for (DictionaryEntry* probe = bucket(index); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
365 |
probe != NULL; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
366 |
probe = probe->next()) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
367 |
Klass* e = probe->instance_klass(); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
368 |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53962
diff
changeset
|
369 |
MutexLocker ml(ProtectionDomainSet_lock, Mutex::_no_safepoint_check_flag); |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
370 |
ProtectionDomainEntry* current = probe->pd_set(); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
371 |
ProtectionDomainEntry* prev = NULL; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
372 |
while (current != NULL) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
373 |
if (current->object_no_keepalive() == NULL) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
374 |
LogTarget(Debug, protectiondomain) lt; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
375 |
if (lt.is_enabled()) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
376 |
ResourceMark rm; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
377 |
// Print out trace information |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
378 |
LogStream ls(lt); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
379 |
ls.print_cr("PD in set is not alive:"); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
380 |
ls.print("class loader: "); loader_data()->class_loader()->print_value_on(&ls); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
381 |
ls.print(" loading: "); probe->instance_klass()->print_value_on(&ls); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
382 |
ls.cr(); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
383 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
384 |
if (probe->pd_set() == current) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
385 |
probe->set_pd_set(current->next()); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
386 |
} else { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
387 |
assert(prev != NULL, "should be set by alive entry"); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
388 |
prev->set_next(current->next()); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
389 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
390 |
ProtectionDomainEntry* to_delete = current; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
391 |
current = current->next(); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
392 |
delete to_delete; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
393 |
} else { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
394 |
prev = current; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
395 |
current = current->next(); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
396 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
397 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
398 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
399 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
400 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
401 |
|
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
402 |
|
2534 | 403 |
SymbolPropertyTable::SymbolPropertyTable(int table_size) |
13195 | 404 |
: Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry)) |
2534 | 405 |
{ |
406 |
} |
|
13195 | 407 |
SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t, |
2534 | 408 |
int number_of_entries) |
13195 | 409 |
: Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries) |
2534 | 410 |
{ |
411 |
} |
|
412 |
||
413 |
||
414 |
SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
415 |
Symbol* sym, |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
2534
diff
changeset
|
416 |
intptr_t sym_mode) { |
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
2534
diff
changeset
|
417 |
assert(index == index_for(sym, sym_mode), "incorrect index?"); |
2534 | 418 |
for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
419 |
if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) { |
2534 | 420 |
return p; |
421 |
} |
|
422 |
} |
|
423 |
return NULL; |
|
424 |
} |
|
425 |
||
426 |
||
427 |
SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
428 |
Symbol* sym, intptr_t sym_mode) { |
2534 | 429 |
assert_locked_or_safepoint(SystemDictionary_lock); |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
2534
diff
changeset
|
430 |
assert(index == index_for(sym, sym_mode), "incorrect index?"); |
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
2534
diff
changeset
|
431 |
assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry"); |
2534 | 432 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
433 |
SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode); |
13195 | 434 |
Hashtable<Symbol*, mtSymbol>::add_entry(index, p); |
2534 | 435 |
return p; |
436 |
} |
|
437 |
||
438 |
void SymbolPropertyTable::oops_do(OopClosure* f) { |
|
439 |
for (int index = 0; index < table_size(); index++) { |
|
440 |
for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
441 |
if (p->method_type() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
442 |
f->do_oop(p->method_type_addr()); |
2534 | 443 |
} |
444 |
} |
|
445 |
} |
|
446 |
} |
|
447 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
448 |
void SymbolPropertyTable::methods_do(void f(Method*)) { |
2534 | 449 |
for (int index = 0; index < table_size(); index++) { |
450 |
for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
451 |
Method* prop = p->method(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
452 |
if (prop != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
453 |
f((Method*)prop); |
2534 | 454 |
} |
455 |
} |
|
456 |
} |
|
457 |
} |
|
458 |
||
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
459 |
void DictionaryEntry::verify_protection_domain_set() { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53962
diff
changeset
|
460 |
MutexLocker ml(ProtectionDomainSet_lock, Mutex::_no_safepoint_check_flag); |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
461 |
for (ProtectionDomainEntry* current = pd_set(); // accessed at a safepoint |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
462 |
current != NULL; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
463 |
current = current->_next) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
464 |
guarantee(oopDesc::is_oop_or_null(current->_pd_cache->object_no_keepalive()), "Invalid oop"); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
465 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
466 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
467 |
|
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
468 |
void DictionaryEntry::print_count(outputStream *st) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53962
diff
changeset
|
469 |
MutexLocker ml(ProtectionDomainSet_lock, Mutex::_no_safepoint_check_flag); |
53962
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
470 |
int count = 0; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
471 |
for (ProtectionDomainEntry* current = pd_set(); // accessed inside SD lock |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
472 |
current != NULL; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
473 |
current = current->_next) { |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
474 |
count++; |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
475 |
} |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
476 |
st->print_cr("pd set count = #%d", count); |
2653e078b057
8218266: G1 crash in AccessInternal::PostRuntimeDispatch
coleenp
parents:
53601
diff
changeset
|
477 |
} |
1 | 478 |
|
479 |
// ---------------------------------------------------------------------------- |
|
480 |
||
46742 | 481 |
void Dictionary::print_on(outputStream* st) const { |
1 | 482 |
ResourceMark rm; |
483 |
||
46729 | 484 |
assert(loader_data() != NULL, "loader data should not be null"); |
51523
73523d329966
8208061: runtime/LoadClass/TestResize.java fails with "Load factor too high" when running in CDS mode.
jiangli
parents:
51334
diff
changeset
|
485 |
st->print_cr("Java dictionary (table_size=%d, classes=%d, resizable=%s)", |
73523d329966
8208061: runtime/LoadClass/TestResize.java fails with "Load factor too high" when running in CDS mode.
jiangli
parents:
51334
diff
changeset
|
486 |
table_size(), number_of_entries(), BOOL_TO_STR(_resizable)); |
46742 | 487 |
st->print_cr("^ indicates that initiating loader is different from defining loader"); |
1 | 488 |
|
489 |
for (int index = 0; index < table_size(); index++) { |
|
490 |
for (DictionaryEntry* probe = bucket(index); |
|
491 |
probe != NULL; |
|
492 |
probe = probe->next()) { |
|
46729 | 493 |
Klass* e = probe->instance_klass(); |
1 | 494 |
bool is_defining_class = |
46729 | 495 |
(loader_data() == e->class_loader_data()); |
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
496 |
st->print("%4d: %s%s", index, is_defining_class ? " " : "^", e->external_name()); |
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
497 |
ClassLoaderData* cld = e->class_loader_data(); |
52514
f4e3900c8d08
8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents:
52340
diff
changeset
|
498 |
if (!loader_data()->is_the_null_class_loader_data()) { |
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
499 |
// Class loader output for the dictionary for the null class loader data is |
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
500 |
// redundant and obvious. |
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
501 |
st->print(", "); |
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49340
diff
changeset
|
502 |
cld->print_value_on(st); |
39982
1a3808e3f4d9
8138760: [JVMCI] VM warning: Performance bug: SystemDictionary lookup_count=21831450 lookup_length=1275207287 average=58.411479 load=5.572844
gziemski
parents:
38259
diff
changeset
|
503 |
} |
46742 | 504 |
st->cr(); |
1 | 505 |
} |
506 |
} |
|
20405 | 507 |
tty->cr(); |
1 | 508 |
} |
509 |
||
46475
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
510 |
void DictionaryEntry::verify() { |
46729 | 511 |
Klass* e = instance_klass(); |
512 |
guarantee(e->is_instance_klass(), |
|
513 |
"Verify of dictionary failed"); |
|
514 |
e->verify(); |
|
515 |
verify_protection_domain_set(); |
|
516 |
} |
|
517 |
||
518 |
void Dictionary::verify() { |
|
519 |
guarantee(number_of_entries() >= 0, "Verify of dictionary failed"); |
|
520 |
||
46475
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
521 |
ClassLoaderData* cld = loader_data(); |
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
522 |
// class loader must be present; a null class loader is the |
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
523 |
// boostrap loader |
52514
f4e3900c8d08
8213346: Re-implement shared dictionary using CompactHashtable
iklam
parents:
52340
diff
changeset
|
524 |
guarantee(cld != NULL || |
46475
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
525 |
cld->class_loader() == NULL || |
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
526 |
cld->class_loader()->is_instance(), |
75902cea18af
8166848: Performance bug: SystemDictionary - optimization
coleenp
parents:
46382
diff
changeset
|
527 |
"checking type of class_loader"); |
46729 | 528 |
|
529 |
ResourceMark rm; |
|
530 |
stringStream tempst; |
|
50634
c349d409262a
8202605: Standardize on ClassLoaderData::loader_name() throughout the VM to obtain a class loader's name
lfoltan
parents:
50429
diff
changeset
|
531 |
tempst.print("System Dictionary for %s class loader", cld->loader_name_and_id()); |
46729 | 532 |
verify_table<DictionaryEntry>(tempst.as_string()); |
42073
89e056fd82cc
8166145: runtime/threads/ThreadInterruptTest3 fails with ExitCode 0
gziemski
parents:
39982
diff
changeset
|
533 |
} |