Mercurial > hg > truffle
annotate src/share/vm/classfile/symbolTable.cpp @ 3762:5c0a3c1858b1
7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359
Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675.
Reviewed-by: brutisso
author | ysr |
---|---|
date | Thu, 02 Jun 2011 10:23:36 -0700 |
parents | 352622fd140a |
children | 94ec88ca68e2 |
rev | line source |
---|---|
0 | 1 /* |
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2379
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
665
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/javaClasses.hpp" | |
27 #include "classfile/symbolTable.hpp" | |
28 #include "classfile/systemDictionary.hpp" | |
29 #include "gc_interface/collectedHeap.inline.hpp" | |
30 #include "memory/filemap.hpp" | |
31 #include "memory/gcLocker.inline.hpp" | |
32 #include "oops/oop.inline.hpp" | |
33 #include "oops/oop.inline2.hpp" | |
34 #include "runtime/mutexLocker.hpp" | |
35 #include "utilities/hashtable.inline.hpp" | |
0 | 36 |
37 // -------------------------------------------------------------------------- | |
38 | |
39 SymbolTable* SymbolTable::_the_table = NULL; | |
40 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
41 Symbol* SymbolTable::allocate_symbol(const u1* name, int len, TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
42 // Don't allow symbols to be created which cannot fit in a Symbol*. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
43 if (len > Symbol::max_length()) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
44 THROW_MSG_0(vmSymbols::java_lang_InternalError(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
45 "name is too long to represent"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
46 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
47 Symbol* sym = new (len) Symbol(name, len); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
48 assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
49 return sym; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
50 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
51 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
52 bool SymbolTable::allocate_symbols(int names_count, const u1** names, |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
53 int* lengths, Symbol** syms, TRAPS) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
54 for (int i = 0; i< names_count; i++) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
55 if (lengths[i] > Symbol::max_length()) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
56 THROW_MSG_0(vmSymbols::java_lang_InternalError(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
57 "name is too long to represent"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
58 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
59 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
60 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
61 for (int i = 0; i< names_count; i++) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
62 int len = lengths[i]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
63 syms[i] = new (len) Symbol(names[i], len); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
64 assert(syms[i] != NULL, "new should call vm_exit_out_of_memory if " |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
65 "C_HEAP is exhausted"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
66 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
67 return true; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
68 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
69 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
70 // Call function for all symbols in the symbol table. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
71 void SymbolTable::symbols_do(SymbolClosure *cl) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
72 const int n = the_table()->table_size(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
73 for (int i = 0; i < n; i++) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
74 for (HashtableEntry<Symbol*>* p = the_table()->bucket(i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
75 p != NULL; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
76 p = p->next()) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
77 cl->do_symbol(p->literal_addr()); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
78 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
79 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
80 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
81 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
82 int SymbolTable::symbols_removed = 0; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
83 int SymbolTable::symbols_counted = 0; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
84 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
85 // Remove unreferenced symbols from the symbol table |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
86 // This is done late during GC. This doesn't use the hash table unlink because |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
87 // it assumes that the literals are oops. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
88 void SymbolTable::unlink() { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
89 int removed = 0; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
90 int total = 0; |
2336
df1347358fe6
7024584: Symbol printouts shouldnt be under PrintGCDetails
coleenp
parents:
2177
diff
changeset
|
91 size_t memory_total = 0; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
92 for (int i = 0; i < the_table()->table_size(); ++i) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
93 for (HashtableEntry<Symbol*>** p = the_table()->bucket_addr(i); *p != NULL; ) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
94 HashtableEntry<Symbol*>* entry = *p; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
95 if (entry->is_shared()) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
96 break; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
97 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
98 Symbol* s = entry->literal(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
99 memory_total += s->object_size(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
100 total++; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
101 assert(s != NULL, "just checking"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
102 // If reference count is zero, remove. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
103 if (s->refcount() == 0) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
104 delete s; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
105 removed++; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
106 *p = entry->next(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
107 the_table()->free_entry(entry); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
108 } else { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
109 p = entry->next_addr(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
110 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
111 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
112 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
113 symbols_removed += removed; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
114 symbols_counted += total; |
2336
df1347358fe6
7024584: Symbol printouts shouldnt be under PrintGCDetails
coleenp
parents:
2177
diff
changeset
|
115 // Exclude printing for normal PrintGCDetails because people parse |
df1347358fe6
7024584: Symbol printouts shouldnt be under PrintGCDetails
coleenp
parents:
2177
diff
changeset
|
116 // this output. |
df1347358fe6
7024584: Symbol printouts shouldnt be under PrintGCDetails
coleenp
parents:
2177
diff
changeset
|
117 if (PrintGCDetails && Verbose && WizardMode) { |
df1347358fe6
7024584: Symbol printouts shouldnt be under PrintGCDetails
coleenp
parents:
2177
diff
changeset
|
118 gclog_or_tty->print(" [Symbols=%d size=" SIZE_FORMAT "K] ", total, |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
119 (memory_total*HeapWordSize)/1024); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
120 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
121 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
122 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
123 |
0 | 124 // Lookup a symbol in a bucket. |
125 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
126 Symbol* SymbolTable::lookup(int index, const char* name, |
0 | 127 int len, unsigned int hash) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
128 for (HashtableEntry<Symbol*>* e = bucket(index); e != NULL; e = e->next()) { |
0 | 129 if (e->hash() == hash) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
130 Symbol* sym = e->literal(); |
0 | 131 if (sym->equals(name, len)) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
132 // something is referencing this symbol now. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
133 sym->increment_refcount(); |
0 | 134 return sym; |
135 } | |
136 } | |
137 } | |
138 return NULL; | |
139 } | |
140 | |
141 | |
142 // We take care not to be blocking while holding the | |
143 // SymbolTable_lock. Otherwise, the system might deadlock, since the | |
144 // symboltable is used during compilation (VM_thread) The lock free | |
145 // synchronization is simplified by the fact that we do not delete | |
146 // entries in the symbol table during normal execution (only during | |
147 // safepoints). | |
148 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
149 Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) { |
0 | 150 unsigned int hashValue = hash_symbol(name, len); |
151 int index = the_table()->hash_to_index(hashValue); | |
152 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
153 Symbol* s = the_table()->lookup(index, name, len, hashValue); |
0 | 154 |
155 // Found | |
156 if (s != NULL) return s; | |
157 | |
158 // Otherwise, add to symbol to table | |
159 return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL); | |
160 } | |
161 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
162 Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) { |
0 | 163 char* buffer; |
164 int index, len; | |
165 unsigned int hashValue; | |
166 char* name; | |
167 { | |
168 debug_only(No_Safepoint_Verifier nsv;) | |
169 | |
170 name = (char*)sym->base() + begin; | |
171 len = end - begin; | |
172 hashValue = hash_symbol(name, len); | |
173 index = the_table()->hash_to_index(hashValue); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
174 Symbol* s = the_table()->lookup(index, name, len, hashValue); |
0 | 175 |
176 // Found | |
177 if (s != NULL) return s; | |
178 } | |
179 | |
180 // Otherwise, add to symbol to table. Copy to a C string first. | |
181 char stack_buf[128]; | |
182 ResourceMark rm(THREAD); | |
183 if (len <= 128) { | |
184 buffer = stack_buf; | |
185 } else { | |
186 buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len); | |
187 } | |
188 for (int i=0; i<len; i++) { | |
189 buffer[i] = name[i]; | |
190 } | |
191 // Make sure there is no safepoint in the code above since name can't move. | |
192 // We can't include the code in No_Safepoint_Verifier because of the | |
193 // ResourceMark. | |
194 | |
195 return the_table()->basic_add(index, (u1*)buffer, len, hashValue, CHECK_NULL); | |
196 } | |
197 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
198 Symbol* SymbolTable::lookup_only(const char* name, int len, |
0 | 199 unsigned int& hash) { |
200 hash = hash_symbol(name, len); | |
201 int index = the_table()->hash_to_index(hash); | |
202 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
203 Symbol* s = the_table()->lookup(index, name, len, hash); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
204 return s; |
0 | 205 } |
206 | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
207 // Suggestion: Push unicode-based lookup all the way into the hashing |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
208 // and probing logic, so there is no need for convert_to_utf8 until |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
209 // an actual new Symbol* is created. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
210 Symbol* SymbolTable::lookup_unicode(const jchar* name, int utf16_length, TRAPS) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
211 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
212 char stack_buf[128]; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
213 if (utf8_length < (int) sizeof(stack_buf)) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
214 char* chars = stack_buf; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
215 UNICODE::convert_to_utf8(name, utf16_length, chars); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
216 return lookup(chars, utf8_length, THREAD); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
217 } else { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
218 ResourceMark rm(THREAD); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
219 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
220 UNICODE::convert_to_utf8(name, utf16_length, chars); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
221 return lookup(chars, utf8_length, THREAD); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
222 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
223 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
224 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length, |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
226 unsigned int& hash) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
227 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
228 char stack_buf[128]; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
229 if (utf8_length < (int) sizeof(stack_buf)) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
230 char* chars = stack_buf; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
231 UNICODE::convert_to_utf8(name, utf16_length, chars); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
232 return lookup_only(chars, utf8_length, hash); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
233 } else { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
234 ResourceMark rm; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
235 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
236 UNICODE::convert_to_utf8(name, utf16_length, chars); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
237 return lookup_only(chars, utf8_length, hash); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
238 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
239 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
240 |
0 | 241 void SymbolTable::add(constantPoolHandle cp, int names_count, |
242 const char** names, int* lengths, int* cp_indices, | |
243 unsigned int* hashValues, TRAPS) { | |
244 SymbolTable* table = the_table(); | |
245 bool added = table->basic_add(cp, names_count, names, lengths, | |
246 cp_indices, hashValues, CHECK); | |
247 if (!added) { | |
248 // do it the hard way | |
249 for (int i=0; i<names_count; i++) { | |
250 int index = table->hash_to_index(hashValues[i]); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
251 Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], |
0 | 252 hashValues[i], CHECK); |
253 cp->symbol_at_put(cp_indices[i], sym); | |
254 } | |
255 } | |
256 } | |
257 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
258 Symbol* SymbolTable::basic_add(int index, u1 *name, int len, |
0 | 259 unsigned int hashValue, TRAPS) { |
260 assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), | |
261 "proposed name of symbol must be stable"); | |
262 | |
263 // We assume that lookup() has been called already, that it failed, | |
264 // and symbol was not found. We create the symbol here. | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
265 Symbol* sym = allocate_symbol(name, len, CHECK_NULL); |
0 | 266 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
267 // Allocation must be done before grabbing the SymbolTable_lock lock |
0 | 268 MutexLocker ml(SymbolTable_lock, THREAD); |
269 | |
270 assert(sym->equals((char*)name, len), "symbol must be properly initialized"); | |
271 | |
272 // Since look-up was done lock-free, we need to check if another | |
273 // thread beat us in the race to insert the symbol. | |
274 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
275 Symbol* test = lookup(index, (char*)name, len, hashValue); |
0 | 276 if (test != NULL) { |
605 | 277 // A race occurred and another thread introduced the symbol, this one |
0 | 278 // will be dropped and collected. |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
279 delete sym; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
280 assert(test->refcount() != 0, "lookup should have incremented the count"); |
0 | 281 return test; |
282 } | |
283 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
284 HashtableEntry<Symbol*>* entry = new_entry(hashValue, sym); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
285 sym->increment_refcount(); |
0 | 286 add_entry(index, entry); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
287 return sym; |
0 | 288 } |
289 | |
290 bool SymbolTable::basic_add(constantPoolHandle cp, int names_count, | |
291 const char** names, int* lengths, | |
292 int* cp_indices, unsigned int* hashValues, | |
293 TRAPS) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
294 Symbol* syms[symbol_alloc_batch_size]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
295 bool allocated = allocate_symbols(names_count, (const u1**)names, lengths, |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
296 syms, CHECK_false); |
0 | 297 if (!allocated) { |
298 return false; | |
299 } | |
300 | |
301 // Allocation must be done before grabbing the SymbolTable_lock lock | |
302 MutexLocker ml(SymbolTable_lock, THREAD); | |
303 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
304 for (int i=0; i<names_count; i++) { |
0 | 305 assert(syms[i]->equals(names[i], lengths[i]), "symbol must be properly initialized"); |
306 // Since look-up was done lock-free, we need to check if another | |
307 // thread beat us in the race to insert the symbol. | |
308 int index = hash_to_index(hashValues[i]); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
309 Symbol* test = lookup(index, names[i], lengths[i], hashValues[i]); |
0 | 310 if (test != NULL) { |
605 | 311 // A race occurred and another thread introduced the symbol, this one |
0 | 312 // will be dropped and collected. Use test instead. |
313 cp->symbol_at_put(cp_indices[i], test); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
314 assert(test->refcount() != 0, "lookup should have incremented the count"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
315 delete syms[i]; |
0 | 316 } else { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
317 Symbol* sym = syms[i]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
318 HashtableEntry<Symbol*>* entry = new_entry(hashValues[i], sym); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
319 sym->increment_refcount(); // increment refcount in external hashtable |
0 | 320 add_entry(index, entry); |
321 cp->symbol_at_put(cp_indices[i], sym); | |
322 } | |
323 } | |
324 | |
325 return true; | |
326 } | |
327 | |
328 | |
329 void SymbolTable::verify() { | |
330 for (int i = 0; i < the_table()->table_size(); ++i) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
331 HashtableEntry<Symbol*>* p = the_table()->bucket(i); |
0 | 332 for ( ; p != NULL; p = p->next()) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
333 Symbol* s = (Symbol*)(p->literal()); |
0 | 334 guarantee(s != NULL, "symbol is NULL"); |
335 unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length()); | |
336 guarantee(p->hash() == h, "broken hash in symbol table entry"); | |
337 guarantee(the_table()->hash_to_index(h) == i, | |
338 "wrong index in symbol table"); | |
339 } | |
340 } | |
341 } | |
342 | |
343 | |
344 //--------------------------------------------------------------------------- | |
345 // Non-product code | |
346 | |
347 #ifndef PRODUCT | |
348 | |
349 void SymbolTable::print_histogram() { | |
350 MutexLocker ml(SymbolTable_lock); | |
351 const int results_length = 100; | |
352 int results[results_length]; | |
353 int i,j; | |
354 | |
355 // initialize results to zero | |
356 for (j = 0; j < results_length; j++) { | |
357 results[j] = 0; | |
358 } | |
359 | |
360 int total = 0; | |
361 int max_symbols = 0; | |
362 int out_of_range = 0; | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
363 int memory_total = 0; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
364 int count = 0; |
0 | 365 for (i = 0; i < the_table()->table_size(); i++) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
366 HashtableEntry<Symbol*>* p = the_table()->bucket(i); |
0 | 367 for ( ; p != NULL; p = p->next()) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
368 memory_total += p->literal()->object_size(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
369 count++; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
370 int counter = p->literal()->utf8_length(); |
0 | 371 total += counter; |
372 if (counter < results_length) { | |
373 results[counter]++; | |
374 } else { | |
375 out_of_range++; | |
376 } | |
377 max_symbols = MAX2(max_symbols, counter); | |
378 } | |
379 } | |
380 tty->print_cr("Symbol Table:"); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
381 tty->print_cr("Total number of symbols %5d", count); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
382 tty->print_cr("Total size in memory %5dK", |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
383 (memory_total*HeapWordSize)/1024); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
384 tty->print_cr("Total counted %5d", symbols_counted); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
385 tty->print_cr("Total removed %5d", symbols_removed); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
386 if (symbols_counted > 0) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
387 tty->print_cr("Percent removed %3.2f", |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
388 ((float)symbols_removed/(float)symbols_counted)* 100); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
389 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
390 tty->print_cr("Reference counts %5d", Symbol::_total_count); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
391 tty->print_cr("Histogram of symbol length:"); |
0 | 392 tty->print_cr("%8s %5d", "Total ", total); |
393 tty->print_cr("%8s %5d", "Maximum", max_symbols); | |
394 tty->print_cr("%8s %3.2f", "Average", | |
395 ((float) total / (float) the_table()->table_size())); | |
396 tty->print_cr("%s", "Histogram:"); | |
397 tty->print_cr(" %s %29s", "Length", "Number chains that length"); | |
398 for (i = 0; i < results_length; i++) { | |
399 if (results[i] > 0) { | |
400 tty->print_cr("%6d %10d", i, results[i]); | |
401 } | |
402 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
403 if (Verbose) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
404 int line_length = 70; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
405 tty->print_cr("%s %30s", " Length", "Number chains that length"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
406 for (i = 0; i < results_length; i++) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
407 if (results[i] > 0) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
408 tty->print("%4d", i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
409 for (j = 0; (j < results[i]) && (j < line_length); j++) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
410 tty->print("%1s", "*"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
411 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
412 if (j == line_length) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
413 tty->print("%1s", "+"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
414 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
415 tty->cr(); |
0 | 416 } |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
417 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
418 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
419 tty->print_cr(" %s %d: %d\n", "Number chains longer than", |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
420 results_length, out_of_range); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
421 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
422 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
423 void SymbolTable::print() { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
424 for (int i = 0; i < the_table()->table_size(); ++i) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
425 HashtableEntry<Symbol*>** p = the_table()->bucket_addr(i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
426 HashtableEntry<Symbol*>* entry = the_table()->bucket(i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
427 if (entry != NULL) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
428 while (entry != NULL) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
429 tty->print(PTR_FORMAT " ", entry->literal()); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
430 entry->literal()->print(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
431 tty->print(" %d", entry->literal()->refcount()); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
432 p = entry->next_addr(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
433 entry = (HashtableEntry<Symbol*>*)HashtableEntry<Symbol*>::make_ptr(*p); |
0 | 434 } |
435 tty->cr(); | |
436 } | |
437 } | |
438 } | |
439 | |
440 #endif // PRODUCT | |
441 | |
442 // -------------------------------------------------------------------------- | |
443 | |
444 #ifdef ASSERT | |
445 class StableMemoryChecker : public StackObj { | |
446 enum { _bufsize = wordSize*4 }; | |
447 | |
448 address _region; | |
449 jint _size; | |
450 u1 _save_buf[_bufsize]; | |
451 | |
452 int sample(u1* save_buf) { | |
453 if (_size <= _bufsize) { | |
454 memcpy(save_buf, _region, _size); | |
455 return _size; | |
456 } else { | |
457 // copy head and tail | |
458 memcpy(&save_buf[0], _region, _bufsize/2); | |
459 memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2); | |
460 return (_bufsize/2)*2; | |
461 } | |
462 } | |
463 | |
464 public: | |
465 StableMemoryChecker(const void* region, jint size) { | |
466 _region = (address) region; | |
467 _size = size; | |
468 sample(_save_buf); | |
469 } | |
470 | |
471 bool verify() { | |
472 u1 check_buf[sizeof(_save_buf)]; | |
473 int check_size = sample(check_buf); | |
474 return (0 == memcmp(_save_buf, check_buf, check_size)); | |
475 } | |
476 | |
477 void set_region(const void* region) { _region = (address) region; } | |
478 }; | |
479 #endif | |
480 | |
481 | |
482 // -------------------------------------------------------------------------- | |
483 StringTable* StringTable::_the_table = NULL; | |
484 | |
485 oop StringTable::lookup(int index, jchar* name, | |
486 int len, unsigned int hash) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
487 for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) { |
0 | 488 if (l->hash() == hash) { |
489 if (java_lang_String::equals(l->literal(), name, len)) { | |
490 return l->literal(); | |
491 } | |
492 } | |
493 } | |
494 return NULL; | |
495 } | |
496 | |
497 | |
498 oop StringTable::basic_add(int index, Handle string_or_null, jchar* name, | |
499 int len, unsigned int hashValue, TRAPS) { | |
500 debug_only(StableMemoryChecker smc(name, len * sizeof(name[0]))); | |
501 assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), | |
502 "proposed name of symbol must be stable"); | |
503 | |
504 Handle string; | |
505 // try to reuse the string if possible | |
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2336
diff
changeset
|
506 if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) { |
0 | 507 string = string_or_null; |
508 } else { | |
509 string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL); | |
510 } | |
511 | |
512 // Allocation must be done before grapping the SymbolTable_lock lock | |
513 MutexLocker ml(StringTable_lock, THREAD); | |
514 | |
515 assert(java_lang_String::equals(string(), name, len), | |
516 "string must be properly initialized"); | |
517 | |
518 // Since look-up was done lock-free, we need to check if another | |
519 // thread beat us in the race to insert the symbol. | |
520 | |
521 oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int) | |
522 if (test != NULL) { | |
523 // Entry already added | |
524 return test; | |
525 } | |
526 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
527 HashtableEntry<oop>* entry = new_entry(hashValue, string()); |
0 | 528 add_entry(index, entry); |
529 return string(); | |
530 } | |
531 | |
532 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
533 oop StringTable::lookup(Symbol* symbol) { |
0 | 534 ResourceMark rm; |
535 int length; | |
536 jchar* chars = symbol->as_unicode(length); | |
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2379
diff
changeset
|
537 unsigned int hashValue = java_lang_String::hash_string(chars, length); |
0 | 538 int index = the_table()->hash_to_index(hashValue); |
539 return the_table()->lookup(index, chars, length, hashValue); | |
540 } | |
541 | |
542 | |
543 oop StringTable::intern(Handle string_or_null, jchar* name, | |
544 int len, TRAPS) { | |
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2379
diff
changeset
|
545 unsigned int hashValue = java_lang_String::hash_string(name, len); |
0 | 546 int index = the_table()->hash_to_index(hashValue); |
547 oop string = the_table()->lookup(index, name, len, hashValue); | |
548 | |
549 // Found | |
550 if (string != NULL) return string; | |
551 | |
552 // Otherwise, add to symbol to table | |
553 return the_table()->basic_add(index, string_or_null, name, len, | |
554 hashValue, CHECK_NULL); | |
555 } | |
556 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
557 oop StringTable::intern(Symbol* symbol, TRAPS) { |
0 | 558 if (symbol == NULL) return NULL; |
559 ResourceMark rm(THREAD); | |
560 int length; | |
561 jchar* chars = symbol->as_unicode(length); | |
562 Handle string; | |
563 oop result = intern(string, chars, length, CHECK_NULL); | |
564 return result; | |
565 } | |
566 | |
567 | |
568 oop StringTable::intern(oop string, TRAPS) | |
569 { | |
570 if (string == NULL) return NULL; | |
571 ResourceMark rm(THREAD); | |
572 int length; | |
573 Handle h_string (THREAD, string); | |
574 jchar* chars = java_lang_String::as_unicode_string(string, length); | |
575 oop result = intern(h_string, chars, length, CHECK_NULL); | |
576 return result; | |
577 } | |
578 | |
579 | |
580 oop StringTable::intern(const char* utf8_string, TRAPS) { | |
581 if (utf8_string == NULL) return NULL; | |
582 ResourceMark rm(THREAD); | |
583 int length = UTF8::unicode_length(utf8_string); | |
584 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length); | |
585 UTF8::convert_to_unicode(utf8_string, chars, length); | |
586 Handle string; | |
587 oop result = intern(string, chars, length, CHECK_NULL); | |
588 return result; | |
589 } | |
590 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
591 void StringTable::unlink(BoolObjectClosure* is_alive) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
592 // Readers of the table are unlocked, so we should only be removing |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
593 // entries at a safepoint. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
594 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
595 for (int i = 0; i < the_table()->table_size(); ++i) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
596 for (HashtableEntry<oop>** p = the_table()->bucket_addr(i); *p != NULL; ) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
597 HashtableEntry<oop>* entry = *p; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
598 if (entry->is_shared()) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
599 break; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
600 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
601 assert(entry->literal() != NULL, "just checking"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
602 if (is_alive->do_object_b(entry->literal())) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
603 p = entry->next_addr(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
604 } else { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
605 *p = entry->next(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
606 the_table()->free_entry(entry); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
607 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
608 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
609 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
610 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
611 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
612 void StringTable::oops_do(OopClosure* f) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
613 for (int i = 0; i < the_table()->table_size(); ++i) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
614 HashtableEntry<oop>** p = the_table()->bucket_addr(i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
615 HashtableEntry<oop>* entry = the_table()->bucket(i); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
616 while (entry != NULL) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
617 f->do_oop((oop*)entry->literal_addr()); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
618 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
619 // Did the closure remove the literal from the table? |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
620 if (entry->literal() == NULL) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
621 assert(!entry->is_shared(), "immutable hashtable entry?"); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
622 *p = entry->next(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
623 the_table()->free_entry(entry); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
624 } else { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
625 p = entry->next_addr(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
626 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
627 entry = (HashtableEntry<oop>*)HashtableEntry<oop>::make_ptr(*p); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
628 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
629 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
630 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
631 |
0 | 632 void StringTable::verify() { |
633 for (int i = 0; i < the_table()->table_size(); ++i) { | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
634 HashtableEntry<oop>* p = the_table()->bucket(i); |
0 | 635 for ( ; p != NULL; p = p->next()) { |
636 oop s = p->literal(); | |
637 guarantee(s != NULL, "interned string is NULL"); | |
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2336
diff
changeset
|
638 guarantee(s->is_perm() || !JavaObjectsInPerm, "interned string not in permspace"); |
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2379
diff
changeset
|
639 unsigned int h = java_lang_String::hash_string(s); |
0 | 640 guarantee(p->hash() == h, "broken hash in string table entry"); |
641 guarantee(the_table()->hash_to_index(h) == i, | |
642 "wrong index in string table"); | |
643 } | |
644 } | |
645 } |