Mercurial > hg > truffle
annotate src/share/vm/utilities/hashtable.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 7baf47cb97cb |
| children | 7848fc12602b |
| 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 |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
39 // This hashtable is implemented as an open hash table with a fixed number of buckets. |
| 0 | 40 |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
41 template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry_free_list() { |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
42 BasicHashtableEntry<F>* entry = NULL; |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
43 if (_free_list != NULL) { |
| 0 | 44 entry = _free_list; |
| 45 _free_list = _free_list->next(); | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
46 } |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
47 return entry; |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
48 } |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
49 |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
50 // HashtableEntrys are allocated in blocks to reduce the space overhead. |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
51 template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) { |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
52 BasicHashtableEntry<F>* entry = new_entry_free_list(); |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
53 |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
54 if (entry == NULL) { |
| 432 | 55 if (_first_free_entry + _entry_size >= _end_block) { |
| 56 int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries)); | |
| 0 | 57 int len = _entry_size * block_size; |
| 432 | 58 len = 1 << log2_intptr(len); // round down to power of 2 |
| 59 assert(len >= _entry_size, ""); | |
| 6197 | 60 _first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC); |
| 0 | 61 _end_block = _first_free_entry + len; |
| 62 } | |
| 6197 | 63 entry = (BasicHashtableEntry<F>*)_first_free_entry; |
| 0 | 64 _first_free_entry += _entry_size; |
| 65 } | |
| 66 | |
| 432 | 67 assert(_entry_size % HeapWordSize == 0, ""); |
| 0 | 68 entry->set_hash(hashValue); |
| 69 return entry; | |
| 70 } | |
| 71 | |
| 72 | |
| 6197 | 73 template <class T, MEMFLAGS F> HashtableEntry<T, F>* Hashtable<T, F>::new_entry(unsigned int hashValue, T obj) { |
| 74 HashtableEntry<T, F>* entry; | |
| 0 | 75 |
| 6197 | 76 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
|
77 entry->set_literal(obj); |
| 0 | 78 return entry; |
| 79 } | |
| 80 | |
| 6162 | 81 // Check to see if the hashtable is unbalanced. The caller set a flag to |
| 82 // rehash at the next safepoint. If this bucket is 60 times greater than the | |
| 83 // expected average bucket length, it's an unbalanced hashtable. | |
| 84 // This is somewhat an arbitrary heuristic but if one bucket gets to | |
| 85 // rehash_count which is currently 100, there's probably something wrong. | |
| 86 | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
87 template <class T, MEMFLAGS F> bool RehashableHashtable<T, F>::check_rehash_table(int count) { |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
88 assert(this->table_size() != 0, "underflow"); |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
89 if (count > (((double)this->number_of_entries()/(double)this->table_size())*rehash_multiple)) { |
| 6162 | 90 // Set a flag for the next safepoint, which should be at some guaranteed |
| 91 // safepoint interval. | |
| 92 return true; | |
| 93 } | |
| 94 return false; | |
| 95 } | |
| 96 | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
97 template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::_seed = 0; |
|
6201
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
98 |
| 6162 | 99 // Create a new table and using alternate hash code, populate the new table |
| 100 // with the existing elements. This can be used to change the hash code | |
| 101 // and could in the future change the size of the table. | |
| 102 | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
103 template <class T, MEMFLAGS F> void RehashableHashtable<T, F>::move_to(RehashableHashtable<T, F>* new_table) { |
|
6201
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
104 |
|
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
105 // Initialize the global seed for hashing. |
|
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
106 _seed = AltHashing::compute_seed(); |
|
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
107 assert(seed() != 0, "shouldn't be zero"); |
|
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
108 |
|
ace99a6ffc83
7181200: JVM new hashing code breaks SA in product mode
coleenp
parents:
6197
diff
changeset
|
109 int saved_entry_count = this->number_of_entries(); |
| 6162 | 110 |
| 111 // Iterate through the table and create a new entry for the new table | |
| 112 for (int i = 0; i < new_table->table_size(); ++i) { | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
113 for (HashtableEntry<T, F>* p = this->bucket(i); p != NULL; ) { |
| 6197 | 114 HashtableEntry<T, F>* next = p->next(); |
| 6162 | 115 T string = p->literal(); |
| 116 // 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
|
117 unsigned int hashValue = string->new_hash(seed()); |
| 6162 | 118 // Get a new index relative to the new table (can also change size) |
| 119 int index = new_table->hash_to_index(hashValue); | |
| 120 p->set_hash(hashValue); | |
|
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
121 // 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
|
122 // 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
|
123 // walking the hashtable past these entries requires |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
124 // BasicHashtableEntry::make_ptr() call. |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
125 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
|
126 this->unlink_entry(p); |
| 6162 | 127 new_table->add_entry(index, p); |
|
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
128 if (keep_shared) { |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
129 p->set_shared(); |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
130 } |
| 6162 | 131 p = next; |
| 132 } | |
| 133 } | |
| 134 // give the new table the free list as well | |
| 135 new_table->copy_freelist(this); | |
| 136 assert(new_table->number_of_entries() == saved_entry_count, "lost entry on dictionary copy?"); | |
| 137 | |
| 138 // Destroy memory used by the buckets in the hashtable. The memory | |
| 139 // for the elements has been used in a new table and is not | |
| 140 // destroyed. The memory reuse will benefit resizing the SystemDictionary | |
| 141 // to avoid a memory allocation spike at safepoint. | |
| 6197 | 142 BasicHashtable<F>::free_buckets(); |
| 6162 | 143 } |
| 144 | |
| 6197 | 145 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
|
146 if (NULL != _buckets) { |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
147 // 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
|
148 // allocated by os::malloc |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
149 if (!UseSharedSpaces || |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
150 !FileMapInfo::current_info()->is_in_shared_space(_buckets)) { |
| 6197 | 151 FREE_C_HEAP_ARRAY(HashtableBucket, _buckets, F); |
|
6172
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
152 } |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
153 _buckets = NULL; |
|
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 |
|
246d977b51f2
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
6162
diff
changeset
|
157 |
| 0 | 158 // Reverse the order of elements in the hash buckets. |
| 159 | |
| 6197 | 160 template <MEMFLAGS F> void BasicHashtable<F>::reverse() { |
| 0 | 161 |
| 162 for (int i = 0; i < _table_size; ++i) { | |
| 6197 | 163 BasicHashtableEntry<F>* new_list = NULL; |
| 164 BasicHashtableEntry<F>* p = bucket(i); | |
| 0 | 165 while (p != NULL) { |
| 6197 | 166 BasicHashtableEntry<F>* next = p->next(); |
| 0 | 167 p->set_next(new_list); |
| 168 new_list = p; | |
| 169 p = next; | |
| 170 } | |
| 171 *bucket_addr(i) = new_list; | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 | |
| 176 // Copy the table to the shared space. | |
| 177 | |
| 6197 | 178 template <MEMFLAGS F> void BasicHashtable<F>::copy_table(char** top, char* end) { |
| 0 | 179 |
| 180 // Dump the hash table entries. | |
| 181 | |
| 182 intptr_t *plen = (intptr_t*)(*top); | |
| 183 *top += sizeof(*plen); | |
| 184 | |
| 185 int i; | |
| 186 for (i = 0; i < _table_size; ++i) { | |
| 6197 | 187 for (BasicHashtableEntry<F>** p = _buckets[i].entry_addr(); |
| 0 | 188 *p != NULL; |
| 189 p = (*p)->next_addr()) { | |
| 190 if (*top + entry_size() > end) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
191 report_out_of_shared_space(SharedMiscData); |
| 0 | 192 } |
| 6197 | 193 *p = (BasicHashtableEntry<F>*)memcpy(*top, *p, entry_size()); |
| 0 | 194 *top += entry_size(); |
| 195 } | |
| 196 } | |
| 197 *plen = (char*)(*top) - (char*)plen - sizeof(*plen); | |
| 198 | |
| 199 // Set the shared bit. | |
| 200 | |
| 201 for (i = 0; i < _table_size; ++i) { | |
| 6197 | 202 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) { |
| 0 | 203 p->set_shared(); |
| 204 } | |
| 205 } | |
| 206 } | |
| 207 | |
| 208 | |
| 209 | |
| 210 // Reverse the order of elements in the hash buckets. | |
| 211 | |
| 6197 | 212 template <class T, MEMFLAGS F> void Hashtable<T, F>::reverse(void* boundary) { |
| 0 | 213 |
| 6197 | 214 for (int i = 0; i < this->table_size(); ++i) { |
| 215 HashtableEntry<T, F>* high_list = NULL; | |
| 216 HashtableEntry<T, F>* low_list = NULL; | |
| 217 HashtableEntry<T, F>* last_low_entry = NULL; | |
| 218 HashtableEntry<T, F>* p = bucket(i); | |
| 0 | 219 while (p != NULL) { |
| 6197 | 220 HashtableEntry<T, F>* next = p->next(); |
| 0 | 221 if ((void*)p->literal() >= boundary) { |
| 222 p->set_next(high_list); | |
| 223 high_list = p; | |
| 224 } else { | |
| 225 p->set_next(low_list); | |
| 226 low_list = p; | |
| 227 if (last_low_entry == NULL) { | |
| 228 last_low_entry = p; | |
| 229 } | |
| 230 } | |
| 231 p = next; | |
| 232 } | |
| 233 if (low_list != NULL) { | |
| 234 *bucket_addr(i) = low_list; | |
| 235 last_low_entry->set_next(high_list); | |
| 236 } else { | |
| 237 *bucket_addr(i) = high_list; | |
| 238 } | |
| 239 } | |
| 240 } | |
| 241 | |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
242 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(Symbol *symbol) { |
|
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
243 return symbol->size() * HeapWordSize; |
|
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 |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
246 template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(oop oop) { |
|
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
247 // 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
|
248 // 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
|
249 // the String.value array is not shared anymore. |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
250 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
|
251 return (oop->size() + java_lang_String::value(oop)->size()) * HeapWordSize; |
|
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 |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
254 // Dump footprint and bucket length statistics |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
255 // |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
256 // 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
|
257 // add a new function Hashtable<T, F>::literal_size(MyNewType lit) |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
258 |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
259 template <class T, MEMFLAGS F> void RehashableHashtable<T, F>::dump_table(outputStream* st, const char *table_name) { |
|
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
260 NumberSeq summary; |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
261 int literal_bytes = 0; |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
262 for (int i = 0; i < this->table_size(); ++i) { |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
263 int count = 0; |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
264 for (HashtableEntry<T, F>* e = this->bucket(i); |
|
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
265 e != NULL; e = e->next()) { |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
266 count++; |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
267 literal_bytes += literal_size(e->literal()); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
268 } |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
269 summary.add((double)count); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
270 } |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
271 double num_buckets = summary.num(); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
272 double num_entries = summary.sum(); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
273 |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
274 int bucket_bytes = (int)num_buckets * sizeof(HashtableBucket<F>); |
|
10312
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
275 int entry_bytes = (int)num_entries * sizeof(HashtableEntry<T, F>); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
276 int total_bytes = literal_bytes + bucket_bytes + entry_bytes; |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
277 |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
278 double bucket_avg = (num_buckets <= 0) ? 0 : (bucket_bytes / num_buckets); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
279 double entry_avg = (num_entries <= 0) ? 0 : (entry_bytes / num_entries); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
280 double literal_avg = (num_entries <= 0) ? 0 : (literal_bytes / num_entries); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
281 |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
282 st->print_cr("%s statistics:", table_name); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
283 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
|
284 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
|
285 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
|
286 st->print_cr("Total footprint : %9s = %9d bytes", "", total_bytes); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
287 st->print_cr("Average bucket size : %9.3f", summary.avg()); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
288 st->print_cr("Variance of bucket size : %9.3f", summary.variance()); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
289 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
|
290 st->print_cr("Maximum bucket size : %9d", (int)summary.maximum()); |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
291 } |
|
a5d6f0c3585f
8014262: PrintStringTableStatistics should include more footprint info
iklam
parents:
6725
diff
changeset
|
292 |
| 0 | 293 |
| 294 // Dump the hash table buckets. | |
| 295 | |
| 6197 | 296 template <MEMFLAGS F> void BasicHashtable<F>::copy_buckets(char** top, char* end) { |
| 297 intptr_t len = _table_size * sizeof(HashtableBucket<F>); | |
| 0 | 298 *(intptr_t*)(*top) = len; |
| 299 *top += sizeof(intptr_t); | |
| 300 | |
| 301 *(intptr_t*)(*top) = _number_of_entries; | |
| 302 *top += sizeof(intptr_t); | |
| 303 | |
| 304 if (*top + len > end) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
305 report_out_of_shared_space(SharedMiscData); |
| 0 | 306 } |
| 6197 | 307 _buckets = (HashtableBucket<F>*)memcpy(*top, _buckets, len); |
| 0 | 308 *top += len; |
| 309 } | |
| 310 | |
| 311 | |
| 312 #ifndef PRODUCT | |
| 313 | |
| 6197 | 314 template <class T, MEMFLAGS F> void Hashtable<T, F>::print() { |
| 0 | 315 ResourceMark rm; |
| 316 | |
| 6197 | 317 for (int i = 0; i < BasicHashtable<F>::table_size(); i++) { |
| 318 HashtableEntry<T, F>* entry = bucket(i); | |
| 0 | 319 while(entry != NULL) { |
| 320 tty->print("%d : ", i); | |
| 321 entry->literal()->print(); | |
| 322 tty->cr(); | |
| 323 entry = entry->next(); | |
| 324 } | |
| 325 } | |
| 326 } | |
| 327 | |
| 328 | |
| 6197 | 329 template <MEMFLAGS F> void BasicHashtable<F>::verify() { |
| 0 | 330 int count = 0; |
| 331 for (int i = 0; i < table_size(); i++) { | |
| 6197 | 332 for (BasicHashtableEntry<F>* p = bucket(i); p != NULL; p = p->next()) { |
| 0 | 333 ++count; |
| 334 } | |
| 335 } | |
| 336 assert(count == number_of_entries(), "number of hashtable entries incorrect"); | |
| 337 } | |
| 338 | |
| 339 | |
| 340 #endif // PRODUCT | |
| 341 | |
| 342 | |
| 343 #ifdef ASSERT | |
| 344 | |
| 6197 | 345 template <MEMFLAGS F> void BasicHashtable<F>::verify_lookup_length(double load) { |
| 0 | 346 if ((double)_lookup_length / (double)_lookup_count > load * 2.0) { |
| 347 warning("Performance bug: SystemDictionary lookup_count=%d " | |
| 348 "lookup_length=%d average=%lf load=%f", | |
| 349 _lookup_count, _lookup_length, | |
| 350 (double) _lookup_length / _lookup_count, load); | |
| 351 } | |
| 352 } | |
| 353 | |
| 354 #endif | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
355 // Explicitly instantiate these types |
| 20494 | 356 #if INCLUDE_ALL_GCS |
| 357 template class Hashtable<nmethod*, mtGC>; | |
| 358 template class HashtableEntry<nmethod*, mtGC>; | |
| 359 template class BasicHashtable<mtGC>; | |
| 360 #endif | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6260
diff
changeset
|
361 template class Hashtable<ConstantPool*, mtClass>; |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
362 template class RehashableHashtable<Symbol*, mtSymbol>; |
|
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
363 template class RehashableHashtable<oopDesc*, mtSymbol>; |
| 6197 | 364 template class Hashtable<Symbol*, mtSymbol>; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6260
diff
changeset
|
365 template class Hashtable<Klass*, mtClass>; |
| 6197 | 366 template class Hashtable<oop, mtClass>; |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10312
diff
changeset
|
367 #if defined(SOLARIS) || defined(CHECK_UNHANDLED_OOPS) |
| 6197 | 368 template class Hashtable<oop, mtSymbol>; |
|
20493
152cf4afc11f
8056084: Refactor Hashtable to allow implementations without rehashing support
mgerdin
parents:
17709
diff
changeset
|
369 template class RehashableHashtable<oop, mtSymbol>; |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10312
diff
changeset
|
370 #endif // SOLARIS || CHECK_UNHANDLED_OOPS |
| 6197 | 371 template class Hashtable<oopDesc*, mtSymbol>; |
| 372 template class Hashtable<Symbol*, mtClass>; | |
| 373 template class HashtableEntry<Symbol*, mtSymbol>; | |
| 374 template class HashtableEntry<Symbol*, mtClass>; | |
| 375 template class HashtableEntry<oop, mtSymbol>; | |
| 376 template class BasicHashtableEntry<mtSymbol>; | |
| 377 template class BasicHashtableEntry<mtCode>; | |
| 378 template class BasicHashtable<mtClass>; | |
| 379 template class BasicHashtable<mtSymbol>; | |
| 380 template class BasicHashtable<mtCode>; | |
| 381 template class BasicHashtable<mtInternal>; |