Mercurial > hg > truffle
annotate src/share/vm/utilities/hashtable.cpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
author | minqi |
---|---|
date | Wed, 26 Feb 2014 15:20:41 -0800 |
parents | f9e35a9dc8c7 |
children | 524b54a7f1b5 152cf4afc11f |
rev | line source |
---|---|
0 | 1 /* |
17709
f9e35a9dc8c7
8033792: AltHashing used jint for imprecise bit shifting
minqi
parents:
12316
diff
changeset
|
2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
470
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
470
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
470
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
6201
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
26 #include "classfile/altHashing.hpp" |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
27 #include "classfile/javaClasses.hpp" |
1972 | 28 #include "memory/allocation.inline.hpp" |
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
29 #include "memory/filemap.hpp" |
1972 | 30 #include "memory/resourceArea.hpp" |
31 #include "oops/oop.inline.hpp" | |
32 #include "runtime/safepoint.hpp" | |
33 #include "utilities/dtrace.hpp" | |
34 #include "utilities/hashtable.hpp" | |
35 #include "utilities/hashtable.inline.hpp" | |
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
36 #include "utilities/numberSeq.hpp" |
0 | 37 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
38 |
0 | 39 // This is a generic hashtable, designed to be used for the symbol |
40 // and string tables. | |
41 // | |
42 // It is implemented as an open hash table with a fixed number of buckets. | |
43 // | |
44 // %note: | |
45 // - HashtableEntrys are allocated in blocks to reduce the space overhead. | |
46 | |
6197 | 47 template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) { |
48 BasicHashtableEntry<F>* entry; | |
0 | 49 |
50 if (_free_list) { | |
51 entry = _free_list; | |
52 _free_list = _free_list->next(); | |
53 } else { | |
432 | 54 if (_first_free_entry + _entry_size >= _end_block) { |
55 int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries)); | |
0 | 56 int len = _entry_size * block_size; |
432 | 57 len = 1 << log2_intptr(len); // round down to power of 2 |
58 assert(len >= _entry_size, ""); | |
6197 | 59 _first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC); |
0 | 60 _end_block = _first_free_entry + len; |
61 } | |
6197 | 62 entry = (BasicHashtableEntry<F>*)_first_free_entry; |
0 | 63 _first_free_entry += _entry_size; |
64 } | |
65 | |
432 | 66 assert(_entry_size % HeapWordSize == 0, ""); |
0 | 67 entry->set_hash(hashValue); |
68 return entry; | |
69 } | |
70 | |
71 | |
6197 | 72 template <class T, MEMFLAGS F> HashtableEntry<T, F>* Hashtable<T, F>::new_entry(unsigned int hashValue, T obj) { |
73 HashtableEntry<T, F>* entry; | |
0 | 74 |
6197 | 75 entry = (HashtableEntry<T, F>*)BasicHashtable<F>::new_entry(hashValue); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
76 entry->set_literal(obj); |
0 | 77 return entry; |
78 } | |
79 | |
6162 | 80 // Check to see if the hashtable is unbalanced. The caller set a flag to |
81 // rehash at the next safepoint. If this bucket is 60 times greater than the | |
82 // expected average bucket length, it's an unbalanced hashtable. | |
83 // This is somewhat an arbitrary heuristic but if one bucket gets to | |
84 // rehash_count which is currently 100, there's probably something wrong. | |
85 | |
6197 | 86 template <MEMFLAGS F> bool BasicHashtable<F>::check_rehash_table(int count) { |
6162 | 87 assert(table_size() != 0, "underflow"); |
88 if (count > (((double)number_of_entries()/(double)table_size())*rehash_multiple)) { | |
89 // Set a flag for the next safepoint, which should be at some guaranteed | |
90 // safepoint interval. | |
91 return true; | |
92 } | |
93 return false; | |
94 } | |
95 | |
17709
f9e35a9dc8c7
8033792: AltHashing used jint for imprecise bit shifting
minqi
parents:
12316
diff
changeset
|
96 template <class T, MEMFLAGS F> juint Hashtable<T, F>::_seed = 0; |
6201
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
97 |
6162 | 98 // Create a new table and using alternate hash code, populate the new table |
99 // with the existing elements. This can be used to change the hash code | |
100 // and could in the future change the size of the table. | |
101 | |
6197 | 102 template <class T, MEMFLAGS F> void Hashtable<T, F>::move_to(Hashtable<T, F>* new_table) { |
6201
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
103 |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
104 // Initialize the global seed for hashing. |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
105 _seed = AltHashing::compute_seed(); |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
106 assert(seed() != 0, "shouldn't be zero"); |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
107 |
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
108 int saved_entry_count = this->number_of_entries(); |
6162 | 109 |
110 // Iterate through the table and create a new entry for the new table | |
111 for (int i = 0; i < new_table->table_size(); ++i) { | |
6197 | 112 for (HashtableEntry<T, F>* p = bucket(i); p != NULL; ) { |
113 HashtableEntry<T, F>* next = p->next(); | |
6162 | 114 T string = p->literal(); |
115 // Use alternate hashing algorithm on the symbol in the first table | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6260
diff
changeset
|
116 unsigned int hashValue = string->new_hash(seed()); |
6162 | 117 // Get a new index relative to the new table (can also change size) |
118 int index = new_table->hash_to_index(hashValue); | |
119 p->set_hash(hashValue); | |
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
120 // Keep the shared bit in the Hashtable entry to indicate that this entry |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
121 // can't be deleted. The shared bit is the LSB in the _next field so |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
122 // walking the hashtable past these entries requires |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
123 // BasicHashtableEntry::make_ptr() call. |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
124 bool keep_shared = p->is_shared(); |
6260
5e2dc722e70d
7186278: Build error after CR#6995781 / 7151532 with GCC 4.7.0
andrew
parents:
6201
diff
changeset
|
125 this->unlink_entry(p); |
6162 | 126 new_table->add_entry(index, p); |
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
127 if (keep_shared) { |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
128 p->set_shared(); |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
129 } |
6162 | 130 p = next; |
131 } | |
132 } | |
133 // give the new table the free list as well | |
134 new_table->copy_freelist(this); | |
135 assert(new_table->number_of_entries() == saved_entry_count, "lost entry on dictionary copy?"); | |
136 | |
137 // Destroy memory used by the buckets in the hashtable. The memory | |
138 // for the elements has been used in a new table and is not | |
139 // destroyed. The memory reuse will benefit resizing the SystemDictionary | |
140 // to avoid a memory allocation spike at safepoint. | |
6197 | 141 BasicHashtable<F>::free_buckets(); |
6162 | 142 } |
143 | |
6197 | 144 template <MEMFLAGS F> void BasicHashtable<F>::free_buckets() { |
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
145 if (NULL != _buckets) { |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
146 // Don't delete the buckets in the shared space. They aren't |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
147 // allocated by os::malloc |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
148 if (!UseSharedSpaces || |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
149 !FileMapInfo::current_info()->is_in_shared_space(_buckets)) { |
6197 | 150 FREE_C_HEAP_ARRAY(HashtableBucket, _buckets, F); |
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
151 } |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
152 _buckets = NULL; |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
153 } |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
154 } |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
155 |
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
156 |
0 | 157 // Reverse the order of elements in the hash buckets. |
158 | |
6197 | 159 template <MEMFLAGS F> void BasicHashtable<F>::reverse() { |
0 | 160 |
161 for (int i = 0; i < _table_size; ++i) { | |
6197 | 162 BasicHashtableEntry<F>* new_list = NULL; |
163 BasicHashtableEntry<F>* p = bucket(i); | |
0 | 164 while (p != NULL) { |
6197 | 165 BasicHashtableEntry<F>* next = p->next(); |
0 | 166 p->set_next(new_list); |
167 new_list = p; | |
168 p = next; | |
169 } | |
170 *bucket_addr(i) = new_list; | |
171 } | |
172 } | |
173 | |
174 | |
175 // Copy the table to the shared space. | |
176 | |
6197 | 177 template <MEMFLAGS F> void BasicHashtable<F>::copy_table(char** top, char* end) { |
0 | 178 |
179 // Dump the hash table entries. | |
180 | |
181 intptr_t *plen = (intptr_t*)(*top); | |
182 *top += sizeof(*plen); | |
183 | |
184 int i; | |
185 for (i = 0; i < _table_size; ++i) { | |
6197 | 186 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr(); |
0 | 187 *p != NULL; |
188 p = (*p)->next_addr()) { | |
189 if (*top + entry_size() > end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
190 report_out_of_shared_space(SharedMiscData); |
0 | 191 } |
6197 | 192 *p = (BasicHashtableEntry<F>*)memcpy(*top, *p, entry_size()); |
0 | 193 *top += entry_size(); |
194 } | |
195 } | |
196 *plen = (char*)(*top) - (char*)plen - sizeof(*plen); | |
197 | |
198 // Set the shared bit. | |
199 | |
200 for (i = 0; i < _table_size; ++i) { | |
6197 | 201 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) { |
0 | 202 p->set_shared(); |
203 } | |
204 } | |
205 } | |
206 | |
207 | |
208 | |
209 // Reverse the order of elements in the hash buckets. | |
210 | |
6197 | 211 template <class T, MEMFLAGS F> void Hashtable<T, F>::reverse(void* boundary) { |
0 | 212 |
6197 | 213 for (int i = 0; i < this->table_size(); ++i) { |
214 HashtableEntry<T, F>* high_list = NULL; | |
215 HashtableEntry<T, F>* low_list = NULL; | |
216 HashtableEntry<T, F>* last_low_entry = NULL; | |
217 HashtableEntry<T, F>* p = bucket(i); | |
0 | 218 while (p != NULL) { |
6197 | 219 HashtableEntry<T, F>* next = p->next(); |
0 | 220 if ((void*)p->literal() >= boundary) { |
221 p->set_next(high_list); | |
222 high_list = p; | |
223 } else { | |
224 p->set_next(low_list); | |
225 low_list = p; | |
226 if (last_low_entry == NULL) { | |
227 last_low_entry = p; | |
228 } | |
229 } | |
230 p = next; | |
231 } | |
232 if (low_list != NULL) { | |
233 *bucket_addr(i) = low_list; | |
234 last_low_entry->set_next(high_list); | |
235 } else { | |
236 *bucket_addr(i) = high_list; | |
237 } | |
238 } | |
239 } | |
240 | |
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
241 template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(Symbol *symbol) { |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
242 return symbol->size() * HeapWordSize; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
243 } |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
244 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
245 template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(oop oop) { |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
246 // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true, |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
247 // and the String.value array is shared by several Strings. However, starting from JDK8, |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
248 // the String.value array is not shared anymore. |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
249 assert(oop != NULL && oop->klass() == SystemDictionary::String_klass(), "only strings are supported"); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
250 return (oop->size() + java_lang_String::value(oop)->size()) * HeapWordSize; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
251 } |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
252 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
253 // Dump footprint and bucket length statistics |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
254 // |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
255 // Note: if you create a new subclass of Hashtable<MyNewType, F>, you will need to |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
256 // add a new function Hashtable<T, F>::literal_size(MyNewType lit) |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
257 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
258 template <class T, MEMFLAGS F> void Hashtable<T, F>::dump_table(outputStream* st, const char *table_name) { |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
259 NumberSeq summary; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
260 int literal_bytes = 0; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
261 for (int i = 0; i < this->table_size(); ++i) { |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
262 int count = 0; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
263 for (HashtableEntry<T, F>* e = bucket(i); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
264 e != NULL; e = e->next()) { |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
265 count++; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
266 literal_bytes += literal_size(e->literal()); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
267 } |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
268 summary.add((double)count); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
269 } |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
270 double num_buckets = summary.num(); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
271 double num_entries = summary.sum(); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
272 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
273 int bucket_bytes = (int)num_buckets * sizeof(bucket(0)); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
274 int entry_bytes = (int)num_entries * sizeof(HashtableEntry<T, F>); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
275 int total_bytes = literal_bytes + bucket_bytes + entry_bytes; |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
276 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
277 double bucket_avg = (num_buckets <= 0) ? 0 : (bucket_bytes / num_buckets); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
278 double entry_avg = (num_entries <= 0) ? 0 : (entry_bytes / num_entries); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
279 double literal_avg = (num_entries <= 0) ? 0 : (literal_bytes / num_entries); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
280 |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
281 st->print_cr("%s statistics:", table_name); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
282 st->print_cr("Number of buckets : %9d = %9d bytes, avg %7.3f", (int)num_buckets, bucket_bytes, bucket_avg); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
283 st->print_cr("Number of entries : %9d = %9d bytes, avg %7.3f", (int)num_entries, entry_bytes, entry_avg); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
284 st->print_cr("Number of literals : %9d = %9d bytes, avg %7.3f", (int)num_entries, literal_bytes, literal_avg); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
285 st->print_cr("Total footprint : %9s = %9d bytes", "", total_bytes); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
286 st->print_cr("Average bucket size : %9.3f", summary.avg()); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
287 st->print_cr("Variance of bucket size : %9.3f", summary.variance()); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
288 st->print_cr("Std. dev. of bucket size: %9.3f", summary.sd()); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
289 st->print_cr("Maximum bucket size : %9d", (int)summary.maximum()); |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
290 } |
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
291 |
0 | 292 |
293 // Dump the hash table buckets. | |
294 | |
6197 | 295 template <MEMFLAGS F> void BasicHashtable<F>::copy_buckets(char** top, char* end) { |
296 intptr_t len = _table_size * sizeof(HashtableBucket<F>); | |
0 | 297 *(intptr_t*)(*top) = len; |
298 *top += sizeof(intptr_t); | |
299 | |
300 *(intptr_t*)(*top) = _number_of_entries; | |
301 *top += sizeof(intptr_t); | |
302 | |
303 if (*top + len > end) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
304 report_out_of_shared_space(SharedMiscData); |
0 | 305 } |
6197 | 306 _buckets = (HashtableBucket<F>*)memcpy(*top, _buckets, len); |
0 | 307 *top += len; |
308 } | |
309 | |
310 | |
311 #ifndef PRODUCT | |
312 | |
6197 | 313 template <class T, MEMFLAGS F> void Hashtable<T, F>::print() { |
0 | 314 ResourceMark rm; |
315 | |
6197 | 316 for (int i = 0; i < BasicHashtable<F>::table_size(); i++) { |
317 HashtableEntry<T, F>* entry = bucket(i); | |
0 | 318 while(entry != NULL) { |
319 tty->print("%d : ", i); | |
320 entry->literal()->print(); | |
321 tty->cr(); | |
322 entry = entry->next(); | |
323 } | |
324 } | |
325 } | |
326 | |
327 | |
6197 | 328 template <MEMFLAGS F> void BasicHashtable<F>::verify() { |
0 | 329 int count = 0; |
330 for (int i = 0; i < table_size(); i++) { | |
6197 | 331 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) { |
0 | 332 ++count; |
333 } | |
334 } | |
335 assert(count == number_of_entries(), "number of hashtable entries incorrect"); | |
336 } | |
337 | |
338 | |
339 #endif // PRODUCT | |
340 | |
341 | |
342 #ifdef ASSERT | |
343 | |
6197 | 344 template <MEMFLAGS F> void BasicHashtable<F>::verify_lookup_length(double load) { |
0 | 345 if ((double)_lookup_length / (double)_lookup_count > load * 2.0) { |
346 warning("Performance bug: SystemDictionary lookup_count=%d " | |
347 "lookup_length=%d average=%lf load=%f", | |
348 _lookup_count, _lookup_length, | |
349 (double) _lookup_length / _lookup_count, load); | |
350 } | |
351 } | |
352 | |
353 #endif | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
354 // Explicitly instantiate these types |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6260
diff
changeset
|
355 template class Hashtable<ConstantPool*, mtClass>; |
6197 | 356 template class Hashtable<Symbol*, mtSymbol>; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6260
diff
changeset
|
357 template class Hashtable<Klass*, mtClass>; |
6197 | 358 template class Hashtable<oop, mtClass>; |
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10312
diff
changeset
|
359 #if defined(SOLARIS) || defined(CHECK_UNHANDLED_OOPS) |
6197 | 360 template class Hashtable<oop, mtSymbol>; |
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10312
diff
changeset
|
361 #endif // SOLARIS || CHECK_UNHANDLED_OOPS |
6197 | 362 template class Hashtable<oopDesc*, mtSymbol>; |
363 template class Hashtable<Symbol*, mtClass>; | |
364 template class HashtableEntry<Symbol*, mtSymbol>; | |
365 template class HashtableEntry<Symbol*, mtClass>; | |
366 template class HashtableEntry<oop, mtSymbol>; | |
367 template class BasicHashtableEntry<mtSymbol>; | |
368 template class BasicHashtableEntry<mtCode>; | |
369 template class BasicHashtable<mtClass>; | |
370 template class BasicHashtable<mtSymbol>; | |
371 template class BasicHashtable<mtCode>; | |
372 template class BasicHashtable<mtInternal>; |