author | gziemski |
Fri, 24 Aug 2018 09:12:51 -0500 | |
changeset 51520 | ef7852ece52b |
parent 51435 | 72c82bd05971 |
child 51823 | 2a51125b2794 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
51179
516acf6956a2
8207359: Make SymbolTable increment_refcount disallow zero
coleenp
parents:
49982
diff
changeset
|
2 |
* Copyright (c) 1997, 2018, 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:
2332
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2332
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:
2332
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
13087 | 26 |
#include "classfile/altHashing.hpp" |
34659
3a7071043457
8143615: compactHashtable.hpp includes .inline.hpp file
iklam
parents:
34237
diff
changeset
|
27 |
#include "classfile/compactHashtable.inline.hpp" |
7397 | 28 |
#include "classfile/javaClasses.hpp" |
29 |
#include "classfile/symbolTable.hpp" |
|
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
30 |
#include "memory/allocation.inline.hpp" |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
31 |
#include "memory/metaspaceClosure.hpp" |
37248 | 32 |
#include "memory/resourceArea.hpp" |
7397 | 33 |
#include "oops/oop.inline.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
39713
diff
changeset
|
34 |
#include "runtime/atomic.hpp" |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
35 |
#include "runtime/interfaceSupport.inline.hpp" |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
36 |
#include "runtime/timerTrace.hpp" |
46742 | 37 |
#include "services/diagnosticCommand.hpp" |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
38 |
#include "utilities/concurrentHashTable.inline.hpp" |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
39 |
#include "utilities/concurrentHashTableTasks.inline.hpp" |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
40 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
41 |
// We used to not resize at all, so let's be conservative |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
42 |
// and not set it too short before we decide to resize, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
43 |
// to match previous startup behavior |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
44 |
#define PREF_AVG_LIST_LEN 8 |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
45 |
// 2^17 (131,072) is max size, which is about 6.5 times as large |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
46 |
// as the previous table size (used to be 20,011), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
47 |
// which never resized |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
48 |
#define END_SIZE 17 |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
49 |
// If a chain gets to 100 something might be wrong |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
50 |
#define REHASH_LEN 100 |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
51 |
// We only get a chance to check whether we need |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
52 |
// to clean infrequently (on class unloading), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
53 |
// so if we have even one dead entry then mark table for cleaning |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
54 |
#define CLEAN_DEAD_HIGH_WATER_MARK 0.0 |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
55 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
56 |
#define ON_STACK_BUFFER_LENGTH 128 |
1 | 57 |
|
58 |
// -------------------------------------------------------------------------- |
|
59 |
SymbolTable* SymbolTable::_the_table = NULL; |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
60 |
CompactHashtable<Symbol*, char> SymbolTable::_shared_table; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
61 |
volatile bool SymbolTable::_alt_hash = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
62 |
volatile bool SymbolTable::_lookup_shared_first = false; |
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
63 |
// Static arena for symbols that are not deallocated |
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
64 |
Arena* SymbolTable::_arena = NULL; |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
65 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
66 |
static juint murmur_seed = 0; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
67 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
68 |
static inline void log_trace_symboltable_helper(Symbol* sym, const char* msg) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
69 |
#ifndef PRODUCT |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
70 |
ResourceMark rm; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
71 |
log_trace(symboltable)("%s [%s]", msg, sym->as_quoted_ascii()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
72 |
#endif // PRODUCT |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
73 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
74 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
75 |
// Pick hashing algorithm. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
76 |
static uintx hash_symbol(const char* s, int len, bool useAlt) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
77 |
return useAlt ? |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
78 |
AltHashing::murmur3_32(murmur_seed, (const jbyte*)s, len) : |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
79 |
java_lang_String::hash_code((const jbyte*)s, len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
80 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
81 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
82 |
static uintx hash_shared_symbol(const char* s, int len) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
83 |
return java_lang_String::hash_code((const jbyte*)s, len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
84 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
85 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
86 |
class SymbolTableConfig : public SymbolTableHash::BaseConfig { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
87 |
private: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
88 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
89 |
static uintx get_hash(Symbol* const& value, bool* is_dead) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
90 |
*is_dead = (value->refcount() == 0); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
91 |
if (*is_dead) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
92 |
return 0; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
93 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
94 |
return hash_symbol((const char*)value->bytes(), value->utf8_length(), SymbolTable::_alt_hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
95 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
96 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
97 |
// We use default allocation/deallocation but counted |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
98 |
static void* allocate_node(size_t size, Symbol* const& value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
99 |
SymbolTable::item_added(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
100 |
return SymbolTableHash::BaseConfig::allocate_node(size, value); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
101 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
102 |
static void free_node(void* memory, Symbol* const& value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
103 |
// We get here either because #1 some threads lost a race |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
104 |
// to insert a newly created Symbol, or #2 we are freeing |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
105 |
// a symbol during normal cleanup deletion. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
106 |
// If #1, then the symbol can be a permanent (refcount==PERM_REFCOUNT), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
107 |
// or regular newly created one but with refcount==0 (see SymbolTableCreateEntry) |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
108 |
// If #2, then the symbol must have refcount==0 |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
109 |
assert((value->refcount() == PERM_REFCOUNT) || (value->refcount() == 0), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
110 |
"refcount %d", value->refcount()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
111 |
SymbolTable::delete_symbol(value); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
112 |
SymbolTableHash::BaseConfig::free_node(memory, value); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
113 |
SymbolTable::item_removed(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
114 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
115 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
116 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
117 |
static size_t ceil_log2(size_t value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
118 |
size_t ret; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
119 |
for (ret = 1; ((size_t)1 << ret) < value; ++ret); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
120 |
return ret; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
121 |
} |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
122 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
123 |
SymbolTable::SymbolTable() : |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
124 |
_symbols_removed(0), _symbols_counted(0), _local_table(NULL), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
125 |
_current_size(0), _has_work(0), _needs_rehashing(false), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
126 |
_items_count(0), _uncleaned_items_count(0) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
127 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
128 |
size_t start_size_log_2 = ceil_log2(SymbolTableSize); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
129 |
_current_size = ((size_t)1) << start_size_log_2; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
130 |
log_trace(symboltable)("Start size: " SIZE_FORMAT " (" SIZE_FORMAT ")", |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
131 |
_current_size, start_size_log_2); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
132 |
_local_table = new SymbolTableHash(start_size_log_2, END_SIZE, REHASH_LEN); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
133 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
134 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
135 |
void SymbolTable::delete_symbol(Symbol* sym) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
136 |
if (sym->refcount() == PERM_REFCOUNT) { |
51520
ef7852ece52b
8209622: applications/kitchensink/Kitchensink.java failed with Kitchensink failed with exit code = 138
gziemski
parents:
51435
diff
changeset
|
137 |
MutexLockerEx ml(SymbolArena_lock, Mutex::_no_safepoint_check_flag); // Protect arena |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
138 |
// Deleting permanent symbol should not occur very often (insert race condition), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
139 |
// so log it. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
140 |
log_trace_symboltable_helper(sym, "Freeing permanent symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
141 |
if (!arena()->Afree(sym, sym->size())) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
142 |
log_trace_symboltable_helper(sym, "Leaked permanent symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
143 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
144 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
145 |
delete sym; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
146 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
147 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
148 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
149 |
void SymbolTable::item_added() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
150 |
Atomic::inc(&(SymbolTable::the_table()->_items_count)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
151 |
} |
1 | 152 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
153 |
void SymbolTable::set_item_clean_count(size_t ncl) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
154 |
Atomic::store(ncl, &(SymbolTable::the_table()->_uncleaned_items_count)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
155 |
log_trace(symboltable)("Set uncleaned items:" SIZE_FORMAT, SymbolTable::the_table()->_uncleaned_items_count); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
156 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
157 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
158 |
void SymbolTable::mark_item_clean_count() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
159 |
if (Atomic::cmpxchg((size_t)1, &(SymbolTable::the_table()->_uncleaned_items_count), (size_t)0) == 0) { // only mark if unset |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
160 |
log_trace(symboltable)("Marked uncleaned items:" SIZE_FORMAT, SymbolTable::the_table()->_uncleaned_items_count); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
161 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
162 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
163 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
164 |
void SymbolTable::item_removed() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
165 |
Atomic::inc(&(SymbolTable::the_table()->_symbols_removed)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
166 |
Atomic::dec(&(SymbolTable::the_table()->_items_count)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
167 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
168 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
169 |
double SymbolTable::get_load_factor() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
170 |
return (double)_items_count/_current_size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
171 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
172 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
173 |
double SymbolTable::get_dead_factor() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
174 |
return (double)_uncleaned_items_count/_current_size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
175 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
176 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
177 |
size_t SymbolTable::table_size() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
178 |
return ((size_t)1) << _local_table->get_size_log2(Thread::current()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
179 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
180 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
181 |
void SymbolTable::trigger_concurrent_work() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
182 |
MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
183 |
SymbolTable::the_table()->_has_work = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
184 |
Service_lock->notify_all(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
185 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
186 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
187 |
Symbol* SymbolTable::allocate_symbol(const char* name, int len, bool c_heap, TRAPS) { |
13097
c146b608d91f
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
13087
diff
changeset
|
188 |
assert (len <= Symbol::max_length(), "should be checked by caller"); |
c146b608d91f
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
13087
diff
changeset
|
189 |
|
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
190 |
Symbol* sym; |
15934
104ff83451f1
8009829: CDS: JDK JPRT test fails crash in Symbol::equals()
coleenp
parents:
14742
diff
changeset
|
191 |
if (DumpSharedSpaces) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
192 |
c_heap = false; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
193 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
194 |
if (c_heap) { |
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
195 |
// refcount starts as 1 |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
196 |
sym = new (len, THREAD) Symbol((const u1*)name, len, 1); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13199
diff
changeset
|
197 |
assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13199
diff
changeset
|
198 |
} else { |
15934
104ff83451f1
8009829: CDS: JDK JPRT test fails crash in Symbol::equals()
coleenp
parents:
14742
diff
changeset
|
199 |
// Allocate to global arena |
51520
ef7852ece52b
8209622: applications/kitchensink/Kitchensink.java failed with Kitchensink failed with exit code = 138
gziemski
parents:
51435
diff
changeset
|
200 |
MutexLockerEx ml(SymbolArena_lock, Mutex::_no_safepoint_check_flag); // Protect arena |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
201 |
sym = new (len, arena(), THREAD) Symbol((const u1*)name, len, PERM_REFCOUNT); |
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
202 |
} |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
203 |
return sym; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
204 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
205 |
|
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
206 |
void SymbolTable::initialize_symbols(int arena_alloc_size) { |
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
207 |
// Initialize the arena for global symbols, size passed in depends on CDS. |
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
208 |
if (arena_alloc_size == 0) { |
25946 | 209 |
_arena = new (mtSymbol) Arena(mtSymbol); |
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
210 |
} else { |
25946 | 211 |
_arena = new (mtSymbol) Arena(mtSymbol, arena_alloc_size); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
212 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
213 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
214 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
215 |
class SymbolsDo : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
216 |
SymbolClosure *_cl; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
217 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
218 |
SymbolsDo(SymbolClosure *cl) : _cl(cl) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
219 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
220 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
221 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
222 |
_cl->do_symbol(value); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
223 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
224 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
225 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
226 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
227 |
// Call function for all symbols in the symbol table. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
228 |
void SymbolTable::symbols_do(SymbolClosure *cl) { |
28615
1fb960ea5a7e
8067982: Some jcmd /gc/heap_dump tests failed: hprof output contains warning or error.
jiangli
parents:
28363
diff
changeset
|
229 |
// all symbols from shared table |
1fb960ea5a7e
8067982: Some jcmd /gc/heap_dump tests failed: hprof output contains warning or error.
jiangli
parents:
28363
diff
changeset
|
230 |
_shared_table.symbols_do(cl); |
1fb960ea5a7e
8067982: Some jcmd /gc/heap_dump tests failed: hprof output contains warning or error.
jiangli
parents:
28363
diff
changeset
|
231 |
|
1fb960ea5a7e
8067982: Some jcmd /gc/heap_dump tests failed: hprof output contains warning or error.
jiangli
parents:
28363
diff
changeset
|
232 |
// all symbols from the dynamic table |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
233 |
SymbolsDo sd(cl); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
234 |
if (!SymbolTable::the_table()->_local_table->try_scan(Thread::current(), sd)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
235 |
log_info(stringtable)("symbols_do unavailable at this moment"); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
236 |
} |
22545
b93a7f0e9b9d
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
20283
diff
changeset
|
237 |
} |
b93a7f0e9b9d
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
20283
diff
changeset
|
238 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
239 |
class MetaspacePointersDo : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
240 |
MetaspaceClosure *_it; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
241 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
242 |
MetaspacePointersDo(MetaspaceClosure *it) : _it(it) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
243 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
244 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
245 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
246 |
_it->push(value); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
247 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
248 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
249 |
}; |
22545
b93a7f0e9b9d
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
20283
diff
changeset
|
250 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
251 |
void SymbolTable::metaspace_pointers_do(MetaspaceClosure* it) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
252 |
assert(DumpSharedSpaces, "called only during dump time"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
253 |
MetaspacePointersDo mpd(it); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
254 |
SymbolTable::the_table()->_local_table->do_scan(Thread::current(), mpd); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
255 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
256 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
257 |
Symbol* SymbolTable::lookup_dynamic(const char* name, |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
258 |
int len, unsigned int hash) { |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
259 |
Symbol* sym = SymbolTable::the_table()->do_lookup(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
260 |
assert((sym == NULL) || sym->refcount() != 0, "refcount must not be zero"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
261 |
return sym; |
1 | 262 |
} |
263 |
||
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
264 |
Symbol* SymbolTable::lookup_shared(const char* name, |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
265 |
int len, unsigned int hash) { |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
266 |
if (!_shared_table.empty()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
267 |
if (SymbolTable::_alt_hash) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
268 |
// hash_code parameter may use alternate hashing algorithm but the shared table |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
269 |
// always uses the same original hash code. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
270 |
hash = hash_shared_symbol(name, len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
271 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
272 |
return _shared_table.lookup(name, hash, len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
273 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
274 |
return NULL; |
37198
b96542d1afa1
8152380: Shared symbol table should never use alternate hashcode
iklam
parents:
35898
diff
changeset
|
275 |
} |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
276 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
277 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
278 |
Symbol* SymbolTable::lookup_common(const char* name, |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
279 |
int len, unsigned int hash) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
280 |
Symbol* sym; |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
281 |
if (_lookup_shared_first) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
282 |
sym = lookup_shared(name, len, hash); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
283 |
if (sym == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
284 |
_lookup_shared_first = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
285 |
sym = lookup_dynamic(name, len, hash); |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
286 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
287 |
} else { |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
288 |
sym = lookup_dynamic(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
289 |
if (sym == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
290 |
sym = lookup_shared(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
291 |
if (sym != NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
292 |
_lookup_shared_first = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
293 |
} |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
294 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
295 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
296 |
return sym; |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
297 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
298 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
299 |
Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
300 |
unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
301 |
Symbol* sym = SymbolTable::the_table()->lookup_common(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
302 |
if (sym == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
303 |
sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, true, CHECK_NULL); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
304 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
305 |
assert(sym->refcount() != 0, "lookup should have incremented the count"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
306 |
assert(sym->equals(name, len), "symbol must be properly initialized"); |
39713 | 307 |
return sym; |
308 |
} |
|
309 |
||
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
310 |
Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
311 |
assert(sym->refcount() != 0, "require a valid symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
312 |
const char* name = (const char*)sym->base() + begin; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
313 |
int len = end - begin; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
314 |
unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
315 |
Symbol* found = SymbolTable::the_table()->lookup_common(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
316 |
if (found == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
317 |
found = SymbolTable::the_table()->do_add_if_needed(name, len, hash, true, THREAD); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
318 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
319 |
return found; |
1 | 320 |
} |
321 |
||
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
322 |
class SymbolTableLookup : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
323 |
private: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
324 |
Thread* _thread; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
325 |
uintx _hash; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
326 |
int _len; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
327 |
const char* _str; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
328 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
329 |
SymbolTableLookup(Thread* thread, const char* key, int len, uintx hash) |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
330 |
: _thread(thread), _hash(hash), _len(len), _str(key) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
331 |
uintx get_hash() const { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
332 |
return _hash; |
1 | 333 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
334 |
bool equals(Symbol** value, bool* is_dead) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
335 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
336 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
337 |
Symbol *sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
338 |
if (sym->equals(_str, _len)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
339 |
if (sym->try_increment_refcount()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
340 |
// something is referencing this symbol now. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
341 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
342 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
343 |
assert(sym->refcount() == 0, "expected dead symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
344 |
*is_dead = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
345 |
return false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
346 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
347 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
348 |
*is_dead = (sym->refcount() == 0); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
349 |
return false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
350 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
351 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
352 |
}; |
1 | 353 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
354 |
class SymbolTableGet : public StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
355 |
Symbol* _return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
356 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
357 |
SymbolTableGet() : _return(NULL) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
358 |
void operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
359 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
360 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
361 |
_return = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
362 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
363 |
Symbol* get_res_sym() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
364 |
return _return; |
1 | 365 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
366 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
367 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
368 |
Symbol* SymbolTable::do_lookup(const char* name, int len, uintx hash) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
369 |
Thread* thread = Thread::current(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
370 |
SymbolTableLookup lookup(thread, name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
371 |
SymbolTableGet stg; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
372 |
bool rehash_warning = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
373 |
_local_table->get(thread, lookup, stg, &rehash_warning); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
374 |
if (rehash_warning) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
375 |
_needs_rehashing = true; |
1 | 376 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
377 |
Symbol* sym = stg.get_res_sym(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
378 |
assert((sym == NULL) || sym->refcount() != 0, "found dead symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
379 |
return sym; |
1 | 380 |
} |
381 |
||
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
382 |
Symbol* SymbolTable::lookup_only(const char* name, int len, unsigned int& hash) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
383 |
hash = hash_symbol(name, len, SymbolTable::_alt_hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
384 |
return SymbolTable::the_table()->lookup_common(name, len, hash); |
11480
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
8885
diff
changeset
|
385 |
} |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
8885
diff
changeset
|
386 |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
387 |
// Suggestion: Push unicode-based lookup all the way into the hashing |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
388 |
// and probing logic, so there is no need for convert_to_utf8 until |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
389 |
// an actual new Symbol* is created. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
390 |
Symbol* SymbolTable::lookup_unicode(const jchar* name, int utf16_length, TRAPS) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
391 |
int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
392 |
char stack_buf[ON_STACK_BUFFER_LENGTH]; |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
393 |
if (utf8_length < (int) sizeof(stack_buf)) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
394 |
char* chars = stack_buf; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
395 |
UNICODE::convert_to_utf8(name, utf16_length, chars); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
396 |
return lookup(chars, utf8_length, THREAD); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
397 |
} else { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
398 |
ResourceMark rm(THREAD); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
399 |
char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
400 |
UNICODE::convert_to_utf8(name, utf16_length, chars); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
401 |
return lookup(chars, utf8_length, THREAD); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
402 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
403 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
404 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
405 |
Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length, |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
406 |
unsigned int& hash) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
407 |
int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
408 |
char stack_buf[ON_STACK_BUFFER_LENGTH]; |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
409 |
if (utf8_length < (int) sizeof(stack_buf)) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
410 |
char* chars = stack_buf; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
411 |
UNICODE::convert_to_utf8(name, utf16_length, chars); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
412 |
return lookup_only(chars, utf8_length, hash); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
413 |
} else { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
414 |
ResourceMark rm; |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
415 |
char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
416 |
UNICODE::convert_to_utf8(name, utf16_length, chars); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
417 |
return lookup_only(chars, utf8_length, hash); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
418 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
419 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
420 |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33148
diff
changeset
|
421 |
void SymbolTable::add(ClassLoaderData* loader_data, const constantPoolHandle& cp, |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
422 |
int names_count, const char** names, int* lengths, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
423 |
int* cp_indices, unsigned int* hashValues, TRAPS) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
424 |
bool c_heap = !loader_data->is_the_null_class_loader_data(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
425 |
for (int i = 0; i < names_count; i++) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
426 |
const char *name = names[i]; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
427 |
int len = lengths[i]; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
428 |
unsigned int hash = hashValues[i]; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
429 |
Symbol* sym = SymbolTable::the_table()->lookup_common(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
430 |
if (sym == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
431 |
sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, c_heap, CHECK); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
432 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
433 |
assert(sym->refcount() != 0, "lookup should have incremented the count"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
434 |
cp->symbol_at_put(cp_indices[i], sym); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
435 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
436 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
437 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
438 |
class SymbolTableCreateEntry : public StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
439 |
private: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
440 |
Thread* _thread; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
441 |
const char* _name; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
442 |
int _len; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
443 |
bool _heap; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
444 |
Symbol* _return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
445 |
Symbol* _created; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
446 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
447 |
void assert_for_name(Symbol* sym, const char* where) const { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
448 |
#ifdef ASSERT |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
449 |
assert(sym->utf8_length() == _len, "%s [%d,%d]", where, sym->utf8_length(), _len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
450 |
for (int i = 0; i < _len; i++) { |
51435
72c82bd05971
8209586: AARCH64: SymbolTable changes throw assert on aarch64
gziemski
parents:
51405
diff
changeset
|
451 |
assert(sym->byte_at(i) == (jbyte) _name[i], |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
452 |
"%s [%d,%d,%d]", where, i, sym->byte_at(i), _name[i]); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
453 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
454 |
#endif |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
455 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
456 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
457 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
458 |
SymbolTableCreateEntry(Thread* thread, const char* name, int len, bool heap) |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
459 |
: _thread(thread), _name(name) , _len(len), _heap(heap), _return(NULL) , _created(NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
460 |
assert(_name != NULL, "expected valid name"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
461 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
462 |
Symbol* operator()() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
463 |
_created = SymbolTable::the_table()->allocate_symbol(_name, _len, _heap, _thread); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
464 |
assert(_created != NULL, "expected created symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
465 |
assert_for_name(_created, "operator()()"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
466 |
assert(_created->equals(_name, _len), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
467 |
"symbol must be properly initialized [%p,%d,%d]", _name, _len, (int)_heap); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
468 |
return _created; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
469 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
470 |
void operator()(bool inserted, Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
471 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
472 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
473 |
if (!inserted && (_created != NULL)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
474 |
// We created our symbol, but someone else inserted |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
475 |
// theirs first, so ours will be destroyed. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
476 |
// Since symbols are created with refcount of 1, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
477 |
// we must decrement it here to 0 to delete, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
478 |
// unless it's a permanent one. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
479 |
if (_created->refcount() != PERM_REFCOUNT) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
480 |
assert(_created->refcount() == 1, "expected newly created symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
481 |
_created->decrement_refcount(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
482 |
assert(_created->refcount() == 0, "expected dead symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
483 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
484 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
485 |
_return = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
486 |
assert_for_name(_return, "operator()"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
487 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
488 |
Symbol* get_new_sym() const { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
489 |
assert_for_name(_return, "get_new_sym"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
490 |
return _return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
491 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
492 |
}; |
13097
c146b608d91f
7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
coleenp
parents:
13087
diff
changeset
|
493 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
494 |
Symbol* SymbolTable::do_add_if_needed(const char* name, int len, uintx hash, bool heap, TRAPS) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
495 |
SymbolTableLookup lookup(THREAD, name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
496 |
SymbolTableCreateEntry stce(THREAD, name, len, heap); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
497 |
bool rehash_warning = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
498 |
bool clean_hint = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
499 |
_local_table->get_insert_lazy(THREAD, lookup, stce, stce, &rehash_warning, &clean_hint); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
500 |
if (rehash_warning) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
501 |
_needs_rehashing = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
502 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
503 |
if (clean_hint) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
504 |
// we just found out that there is a dead item, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
505 |
// which we were unable to clean right now, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
506 |
// but we have no way of telling whether it's |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
507 |
// been previously counted or not, so mark |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
508 |
// it only if no other items were found yet |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
509 |
mark_item_clean_count(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
510 |
check_concurrent_work(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
511 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
512 |
Symbol* sym = stce.get_new_sym(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
513 |
assert(sym->refcount() != 0, "zero is invalid"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
514 |
return sym; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
515 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
516 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
517 |
Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
518 |
unsigned int hash = 0; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
519 |
int len = (int)strlen(name); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
520 |
Symbol* sym = SymbolTable::lookup_only(name, len, hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
521 |
if (sym == NULL) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
522 |
sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, false, CHECK_NULL); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
523 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
524 |
if (sym->refcount() != PERM_REFCOUNT) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
525 |
sym->increment_refcount(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
526 |
log_trace_symboltable_helper(sym, "Asked for a permanent symbol, but got a regular one"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
527 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
528 |
return sym; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
529 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
530 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
531 |
struct SizeFunc : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
532 |
size_t operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
533 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
534 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
535 |
return (*value)->size() * HeapWordSize; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
536 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
537 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
538 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
539 |
void SymbolTable::print_table_statistics(outputStream* st, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
540 |
const char* table_name) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
541 |
SizeFunc sz; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
542 |
_local_table->statistics_to(Thread::current(), sz, st, table_name); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
543 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
544 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
545 |
// Verification |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
546 |
class VerifySymbols : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
547 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
548 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
549 |
guarantee(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
550 |
guarantee(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
551 |
Symbol* sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
552 |
guarantee(sym->equals((const char*)sym->bytes(), sym->utf8_length()), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
553 |
"symbol must be internally consistent"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
554 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
555 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
556 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
557 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
558 |
void SymbolTable::verify() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
559 |
Thread* thr = Thread::current(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
560 |
VerifySymbols vs; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
561 |
if (!SymbolTable::the_table()->_local_table->try_scan(thr, vs)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
562 |
log_info(stringtable)("verify unavailable at this moment"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
563 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
564 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
565 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
566 |
// Dumping |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
567 |
class DumpSymbol : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
568 |
Thread* _thr; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
569 |
outputStream* _st; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
570 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
571 |
DumpSymbol(Thread* thr, outputStream* st) : _thr(thr), _st(st) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
572 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
573 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
574 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
575 |
Symbol* sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
576 |
const char* utf8_string = (const char*)sym->bytes(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
577 |
int utf8_length = sym->utf8_length(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
578 |
_st->print("%d %d: ", utf8_length, sym->refcount()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
579 |
HashtableTextDump::put_utf8(_st, utf8_string, utf8_length); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
580 |
_st->cr(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
581 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
582 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
583 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
584 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
585 |
void SymbolTable::dump(outputStream* st, bool verbose) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
586 |
if (!verbose) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
587 |
SymbolTable::the_table()->print_table_statistics(st, "SymbolTable"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
588 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
589 |
Thread* thr = Thread::current(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
590 |
ResourceMark rm(thr); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
591 |
st->print_cr("VERSION: 1.1"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
592 |
DumpSymbol ds(thr, st); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
593 |
if (!SymbolTable::the_table()->_local_table->try_scan(thr, ds)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
594 |
log_info(symboltable)("dump unavailable at this moment"); |
1 | 595 |
} |
596 |
} |
|
597 |
} |
|
598 |
||
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
599 |
#if INCLUDE_CDS |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
600 |
struct CopyToArchive : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
601 |
CompactSymbolTableWriter* _writer; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
602 |
CopyToArchive(CompactSymbolTableWriter* writer) : _writer(writer) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
603 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
604 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
605 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
606 |
Symbol* sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
607 |
unsigned int fixed_hash = hash_shared_symbol((const char*)sym->bytes(), sym->utf8_length()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
608 |
if (fixed_hash == 0) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
609 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
610 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
611 |
assert(fixed_hash == hash_symbol((const char*)sym->bytes(), sym->utf8_length(), false), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
612 |
"must not rehash during dumping"); |
12263
d20640f4f8fe
7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents:
11480
diff
changeset
|
613 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
614 |
// add to the compact table |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
615 |
_writer->add(fixed_hash, sym); |
1 | 616 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
617 |
return true; |
1 | 618 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
619 |
}; |
1 | 620 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
621 |
void SymbolTable::copy_shared_symbol_table(CompactSymbolTableWriter* writer) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
622 |
CopyToArchive copy(writer); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
623 |
SymbolTable::the_table()->_local_table->do_scan(Thread::current(), copy); |
13087 | 624 |
} |
625 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
626 |
void SymbolTable::write_to_archive() { |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
627 |
_shared_table.reset(); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
628 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
629 |
int num_buckets = (int)(SymbolTable::the_table()->_items_count / SharedSymbolTableBucketSize); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
630 |
// calculation of num_buckets can result in zero buckets, we need at least one |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
631 |
CompactSymbolTableWriter writer(num_buckets > 1 ? num_buckets : 1, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
632 |
&MetaspaceShared::stats()->symbol); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
633 |
copy_shared_symbol_table(&writer); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
634 |
writer.dump(&_shared_table); |
37995 | 635 |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
636 |
// Verify table is correct |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
637 |
Symbol* sym = vmSymbols::java_lang_Object(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
638 |
const char* name = (const char*)sym->bytes(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
639 |
int len = sym->utf8_length(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
640 |
unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
641 |
assert(sym == _shared_table.lookup(name, hash, len), "sanity"); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
642 |
} |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
643 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
644 |
void SymbolTable::serialize(SerializeClosure* soc) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
645 |
_shared_table.set_type(CompactHashtable<Symbol*, char>::_symbol_table); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
646 |
_shared_table.serialize(soc); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
647 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
648 |
if (soc->writing()) { |
37995 | 649 |
// Sanity. Make sure we don't use the shared table at dump time |
650 |
_shared_table.reset(); |
|
651 |
} |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
652 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
653 |
#endif //INCLUDE_CDS |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
654 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
655 |
// Concurrent work |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
656 |
void SymbolTable::grow(JavaThread* jt) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
657 |
SymbolTableHash::GrowTask gt(_local_table); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
658 |
if (!gt.prepare(jt)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
659 |
return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
660 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
661 |
log_trace(symboltable)("Started to grow"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
662 |
{ |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
663 |
TraceTime timer("Grow", TRACETIME_LOG(Debug, symboltable, perf)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
664 |
while (gt.do_task(jt)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
665 |
gt.pause(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
666 |
{ |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
667 |
ThreadBlockInVM tbivm(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
668 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
669 |
gt.cont(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
670 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
671 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
672 |
gt.done(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
673 |
_current_size = table_size(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
674 |
log_debug(symboltable)("Grown to size:" SIZE_FORMAT, _current_size); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
675 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
676 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
677 |
struct SymbolTableDoDelete : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
678 |
int _deleted; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
679 |
SymbolTableDoDelete() : _deleted(0) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
680 |
void operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
681 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
682 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
683 |
Symbol *sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
684 |
assert(sym->refcount() == 0, "refcount"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
685 |
_deleted++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
686 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
687 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
688 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
689 |
struct SymbolTableDeleteCheck : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
690 |
int _processed; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
691 |
SymbolTableDeleteCheck() : _processed(0) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
692 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
693 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
694 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
695 |
_processed++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
696 |
Symbol *sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
697 |
return (sym->refcount() == 0); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
698 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
699 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
700 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
701 |
void SymbolTable::clean_dead_entries(JavaThread* jt) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
702 |
SymbolTableHash::BulkDeleteTask bdt(_local_table); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
703 |
if (!bdt.prepare(jt)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
704 |
return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
705 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
706 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
707 |
SymbolTableDeleteCheck stdc; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
708 |
SymbolTableDoDelete stdd; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
709 |
{ |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
710 |
TraceTime timer("Clean", TRACETIME_LOG(Debug, symboltable, perf)); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
711 |
while (bdt.do_task(jt, stdc, stdd)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
712 |
bdt.pause(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
713 |
{ |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
714 |
ThreadBlockInVM tbivm(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
715 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
716 |
bdt.cont(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
717 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
718 |
SymbolTable::the_table()->set_item_clean_count(0); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
719 |
bdt.done(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
720 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
721 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
722 |
Atomic::add((size_t)stdc._processed, &_symbols_counted); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
723 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
724 |
log_debug(symboltable)("Cleaned " INT32_FORMAT " of " INT32_FORMAT, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
725 |
stdd._deleted, stdc._processed); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
726 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
727 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
728 |
void SymbolTable::check_concurrent_work() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
729 |
if (_has_work) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
730 |
return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
731 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
732 |
double load_factor = SymbolTable::get_load_factor(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
733 |
double dead_factor = SymbolTable::get_dead_factor(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
734 |
// We should clean/resize if we have more dead than alive, |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
735 |
// more items than preferred load factor or |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
736 |
// more dead items than water mark. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
737 |
if ((dead_factor > load_factor) || |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
738 |
(load_factor > PREF_AVG_LIST_LEN) || |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
739 |
(dead_factor > CLEAN_DEAD_HIGH_WATER_MARK)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
740 |
log_debug(symboltable)("Concurrent work triggered, live factor:%f dead factor:%f", |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
741 |
load_factor, dead_factor); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
742 |
trigger_concurrent_work(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
743 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
744 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
745 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
746 |
void SymbolTable::concurrent_work(JavaThread* jt) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
747 |
double load_factor = get_load_factor(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
748 |
log_debug(symboltable, perf)("Concurrent work, live factor: %g", load_factor); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
749 |
// We prefer growing, since that also removes dead items |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
750 |
if (load_factor > PREF_AVG_LIST_LEN && !_local_table->is_max_size_reached()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
751 |
grow(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
752 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
753 |
clean_dead_entries(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
754 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
755 |
_has_work = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
756 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
757 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
758 |
class CountDead : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
759 |
int _count; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
760 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
761 |
CountDead() : _count(0) {} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
762 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
763 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
764 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
765 |
Symbol* sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
766 |
if (sym->refcount() == 0) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
767 |
_count++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
768 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
769 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
770 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
771 |
int get_dead_count() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
772 |
return _count; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
773 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
774 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
775 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
776 |
void SymbolTable::do_check_concurrent_work() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
777 |
CountDead counter; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
778 |
if (!SymbolTable::the_table()->_local_table->try_scan(Thread::current(), counter)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
779 |
log_info(symboltable)("count dead unavailable at this moment"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
780 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
781 |
SymbolTable::the_table()->set_item_clean_count(counter.get_dead_count()); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
782 |
SymbolTable::the_table()->check_concurrent_work(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
783 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
784 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
785 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
786 |
void SymbolTable::do_concurrent_work(JavaThread* jt) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
787 |
SymbolTable::the_table()->concurrent_work(jt); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
788 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
789 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
790 |
// Rehash |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
791 |
bool SymbolTable::do_rehash() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
792 |
if (!_local_table->is_safepoint_safe()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
793 |
return false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
794 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
795 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
796 |
// We use max size |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
797 |
SymbolTableHash* new_table = new SymbolTableHash(END_SIZE, END_SIZE, REHASH_LEN); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
798 |
// Use alt hash from now on |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
799 |
_alt_hash = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
800 |
if (!_local_table->try_move_nodes_to(Thread::current(), new_table)) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
801 |
_alt_hash = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
802 |
delete new_table; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
803 |
return false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
804 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
805 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
806 |
// free old table |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
807 |
delete _local_table; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
808 |
_local_table = new_table; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
809 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
810 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
811 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
812 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
813 |
void SymbolTable::try_rehash_table() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
814 |
static bool rehashed = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
815 |
log_debug(symboltable)("Table imbalanced, rehashing called."); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
816 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
817 |
// Grow instead of rehash. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
818 |
if (get_load_factor() > PREF_AVG_LIST_LEN && |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
819 |
!_local_table->is_max_size_reached()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
820 |
log_debug(symboltable)("Choosing growing over rehashing."); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
821 |
trigger_concurrent_work(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
822 |
_needs_rehashing = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
823 |
return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
824 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
825 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
826 |
// Already rehashed. |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
827 |
if (rehashed) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
828 |
log_warning(symboltable)("Rehashing already done, still long lists."); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
829 |
trigger_concurrent_work(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
830 |
_needs_rehashing = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
831 |
return; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
832 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
833 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
834 |
murmur_seed = AltHashing::compute_seed(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
835 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
836 |
if (do_rehash()) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
837 |
rehashed = true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
838 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
839 |
log_info(symboltable)("Resizes in progress rehashing skipped."); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
840 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
841 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
842 |
_needs_rehashing = false; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
843 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
844 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
845 |
void SymbolTable::rehash_table() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
846 |
SymbolTable::the_table()->try_rehash_table(); |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
847 |
} |
1 | 848 |
|
849 |
//--------------------------------------------------------------------------- |
|
850 |
// Non-product code |
|
851 |
||
852 |
#ifndef PRODUCT |
|
853 |
||
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
854 |
class HistogramIterator : StackObj { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
855 |
public: |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
856 |
static const size_t results_length = 100; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
857 |
size_t counts[results_length]; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
858 |
size_t sizes[results_length]; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
859 |
size_t total_size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
860 |
size_t total_count; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
861 |
size_t total_length; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
862 |
size_t max_length; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
863 |
size_t out_of_range_count; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
864 |
size_t out_of_range_size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
865 |
HistogramIterator() : total_size(0), total_count(0), total_length(0), |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
866 |
max_length(0), out_of_range_count(0), out_of_range_size(0) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
867 |
// initialize results to zero |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
868 |
for (size_t i = 0; i < results_length; i++) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
869 |
counts[i] = 0; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
870 |
sizes[i] = 0; |
1 | 871 |
} |
872 |
} |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
873 |
bool operator()(Symbol** value) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
874 |
assert(value != NULL, "expected valid value"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
875 |
assert(*value != NULL, "value should point to a symbol"); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
876 |
Symbol* sym = *value; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
877 |
size_t size = sym->size(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
878 |
size_t len = sym->utf8_length(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
879 |
if (len < results_length) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
880 |
counts[len]++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
881 |
sizes[len] += size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
882 |
} else { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
883 |
out_of_range_count++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
884 |
out_of_range_size += size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
885 |
} |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
886 |
total_count++; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
887 |
total_size += size; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
888 |
total_length += len; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
889 |
max_length = MAX2(max_length, len); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
890 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
891 |
return true; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
892 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
893 |
}; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
894 |
|
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
895 |
void SymbolTable::print_histogram() { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
896 |
SymbolTable* st = SymbolTable::the_table(); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
897 |
HistogramIterator hi; |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
898 |
st->_local_table->do_scan(Thread::current(), hi); |
26923
60c1555c25c5
8057925: PrintSymbolTableSizeHistogram prints misleading output
shade
parents:
26421
diff
changeset
|
899 |
tty->print_cr("Symbol Table Histogram:"); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
900 |
tty->print_cr(" Total number of symbols " SIZE_FORMAT_W(7), hi.total_count); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
901 |
tty->print_cr(" Total size in memory " SIZE_FORMAT_W(7) "K", |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
902 |
(hi.total_size * wordSize) / 1024); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
903 |
tty->print_cr(" Total counted " SIZE_FORMAT_W(7), st->_symbols_counted); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
904 |
tty->print_cr(" Total removed " SIZE_FORMAT_W(7), st->_symbols_removed); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
905 |
if (SymbolTable::the_table()->_symbols_counted > 0) { |
26923
60c1555c25c5
8057925: PrintSymbolTableSizeHistogram prints misleading output
shade
parents:
26421
diff
changeset
|
906 |
tty->print_cr(" Percent removed %3.2f", |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
907 |
((float)st->_symbols_removed / st->_symbols_counted) * 100); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
908 |
} |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
909 |
tty->print_cr(" Reference counts " SIZE_FORMAT_W(7), Symbol::_total_count); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
910 |
tty->print_cr(" Symbol arena used " SIZE_FORMAT_W(7) "K", arena()->used() / 1024); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
911 |
tty->print_cr(" Symbol arena size " SIZE_FORMAT_W(7) "K", arena()->size_in_bytes() / 1024); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
912 |
tty->print_cr(" Total symbol length " SIZE_FORMAT_W(7), hi.total_length); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
913 |
tty->print_cr(" Maximum symbol length " SIZE_FORMAT_W(7), hi.max_length); |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
914 |
tty->print_cr(" Average symbol length %7.2f", ((float)hi.total_length / hi.total_count)); |
26923
60c1555c25c5
8057925: PrintSymbolTableSizeHistogram prints misleading output
shade
parents:
26421
diff
changeset
|
915 |
tty->print_cr(" Symbol length histogram:"); |
60c1555c25c5
8057925: PrintSymbolTableSizeHistogram prints misleading output
shade
parents:
26421
diff
changeset
|
916 |
tty->print_cr(" %6s %10s %10s", "Length", "#Symbols", "Size"); |
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
917 |
for (size_t i = 0; i < hi.results_length; i++) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
918 |
if (hi.counts[i] > 0) { |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
919 |
tty->print_cr(" " SIZE_FORMAT_W(6) " " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) "K", |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
920 |
i, hi.counts[i], (hi.sizes[i] * wordSize) / 1024); |
1 | 921 |
} |
922 |
} |
|
51405
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
923 |
tty->print_cr(" >=" SIZE_FORMAT_W(6) " " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) "K\n", |
8b23aa7cef47
8195100: Use a low latency hashtable for SymbolTable
gziemski
parents:
51179
diff
changeset
|
924 |
hi.results_length, hi.out_of_range_count, (hi.out_of_range_size*wordSize) / 1024); |
1 | 925 |
} |
926 |
#endif // PRODUCT |
|
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
927 |
|
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
928 |
// Utility for dumping symbols |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
929 |
SymboltableDCmd::SymboltableDCmd(outputStream* output, bool heap) : |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
930 |
DCmdWithParser(output, heap), |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
931 |
_verbose("-verbose", "Dump the content of each symbol in the table", |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
932 |
"BOOLEAN", false, "false") { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
933 |
_dcmdparser.add_dcmd_option(&_verbose); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
934 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
935 |
|
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
936 |
void SymboltableDCmd::execute(DCmdSource source, TRAPS) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
937 |
VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpSymbols, |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
938 |
_verbose.value()); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
939 |
VMThread::execute(&dumper); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
940 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
941 |
|
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
942 |
int SymboltableDCmd::num_arguments() { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
943 |
ResourceMark rm; |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
944 |
SymboltableDCmd* dcmd = new SymboltableDCmd(NULL, false); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
945 |
if (dcmd != NULL) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
946 |
DCmdMark mark(dcmd); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
947 |
return dcmd->_dcmdparser.num_arguments(); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
948 |
} else { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
949 |
return 0; |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
950 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
27677
diff
changeset
|
951 |
} |