truffle: src/share/vm/classfile/symbolTable.cpp annotate

annotate src/share/vm/classfile/symbolTable.cpp @ 2336:df1347358fe6

7024584: Symbol printouts shouldnt be under PrintGCDetails Summary: Put symbol printing under Verbose and WizardMode so you can get this information if you really want it. Reviewed-by: phh, stefank, never, dholmes, jcoomes

author	coleenp
date	Mon, 07 Mar 2011 16:03:28 -0500
parents	3582bf76420e
children	b099aaf51bf8

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/filemap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "utilities/hashtable.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	38
a61af66fc99e Initial load duke parents: diff changeset	39 SymbolTable* SymbolTable::_the_table = NULL;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	124 // Lookup a symbol in a bucket.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	134 return sym;
a61af66fc99e Initial load duke parents: diff changeset	135 }
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	139 }
a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 // We take care not to be blocking while holding the
a61af66fc99e Initial load duke parents: diff changeset	143 // SymbolTable_lock. Otherwise, the system might deadlock, since the
a61af66fc99e Initial load duke parents: diff changeset	144 // symboltable is used during compilation (VM_thread) The lock free
a61af66fc99e Initial load duke parents: diff changeset	145 // synchronization is simplified by the fact that we do not delete
a61af66fc99e Initial load duke parents: diff changeset	146 // entries in the symbol table during normal execution (only during
a61af66fc99e Initial load duke parents: diff changeset	147 // safepoints).
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	150 unsigned int hashValue = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	151 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 // Found
a61af66fc99e Initial load duke parents: diff changeset	156 if (s != NULL) return s;
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Otherwise, add to symbol to table
a61af66fc99e Initial load duke parents: diff changeset	159 return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	160 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	163 char* buffer;
a61af66fc99e Initial load duke parents: diff changeset	164 int index, len;
a61af66fc99e Initial load duke parents: diff changeset	165 unsigned int hashValue;
a61af66fc99e Initial load duke parents: diff changeset	166 char* name;
a61af66fc99e Initial load duke parents: diff changeset	167 {
a61af66fc99e Initial load duke parents: diff changeset	168 debug_only(No_Safepoint_Verifier nsv;)
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 name = (char*)sym->base() + begin;
a61af66fc99e Initial load duke parents: diff changeset	171 len = end - begin;
a61af66fc99e Initial load duke parents: diff changeset	172 hashValue = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // Found
a61af66fc99e Initial load duke parents: diff changeset	177 if (s != NULL) return s;
a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 // Otherwise, add to symbol to table. Copy to a C string first.
a61af66fc99e Initial load duke parents: diff changeset	181 char stack_buf[128];
a61af66fc99e Initial load duke parents: diff changeset	182 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	183 if (len <= 128) {
a61af66fc99e Initial load duke parents: diff changeset	184 buffer = stack_buf;
a61af66fc99e Initial load duke parents: diff changeset	185 } else {
a61af66fc99e Initial load duke parents: diff changeset	186 buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	189 buffer[i] = name[i];
a61af66fc99e Initial load duke parents: diff changeset	190 }
a61af66fc99e Initial load duke parents: diff changeset	191 // Make sure there is no safepoint in the code above since name can't move.
a61af66fc99e Initial load duke parents: diff changeset	192 // We can't include the code in No_Safepoint_Verifier because of the
a61af66fc99e Initial load duke parents: diff changeset	193 // ResourceMark.
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 return the_table()->basic_add(index, (u1*)buffer, len, hashValue, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	196 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	199 unsigned int& hash) {
a61af66fc99e Initial load duke parents: diff changeset	200 hash = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	201 int index = the_table()->hash_to_index(hash);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	241 void SymbolTable::add(constantPoolHandle cp, int names_count,
a61af66fc99e Initial load duke parents: diff changeset	242 const char** names, int* lengths, int* cp_indices,
a61af66fc99e Initial load duke parents: diff changeset	243 unsigned int* hashValues, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	244 SymbolTable* table = the_table();
a61af66fc99e Initial load duke parents: diff changeset	245 bool added = table->basic_add(cp, names_count, names, lengths,
a61af66fc99e Initial load duke parents: diff changeset	246 cp_indices, hashValues, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	247 if (!added) {
a61af66fc99e Initial load duke parents: diff changeset	248 // do it the hard way
a61af66fc99e Initial load duke parents: diff changeset	249 for (int i=0; i<names_count; i++) {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	252 hashValues[i], CHECK);
a61af66fc99e Initial load duke parents: diff changeset	253 cp->symbol_at_put(cp_indices[i], sym);
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255 }
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	259 unsigned int hashValue, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	260 assert(!Universe::heap()->is_in_reserved(name) \|\| GC_locker::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	261 "proposed name of symbol must be stable");
a61af66fc99e Initial load duke parents: diff changeset	262
a61af66fc99e Initial load duke parents: diff changeset	263 // We assume that lookup() has been called already, that it failed,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	268 MutexLocker ml(SymbolTable_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 assert(sym->equals((char*)name, len), "symbol must be properly initialized");
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	273 // thread beat us in the race to insert the symbol.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	276 if (test != NULL) {
605 98cb887364d3 6810672: Comment typos twisti parents: 0 diff changeset	277 // A race occurred and another thread introduced the symbol, this one
0 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	281 return test;
a61af66fc99e Initial load duke parents: diff changeset	282 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 bool SymbolTable::basic_add(constantPoolHandle cp, int names_count,
a61af66fc99e Initial load duke parents: diff changeset	291 const char** names, int* lengths,
a61af66fc99e Initial load duke parents: diff changeset	292 int* cp_indices, unsigned int* hashValues,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	297 if (!allocated) {
a61af66fc99e Initial load duke parents: diff changeset	298 return false;
a61af66fc99e Initial load duke parents: diff changeset	299 }
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 // Allocation must be done before grabbing the SymbolTable_lock lock
a61af66fc99e Initial load duke parents: diff changeset	302 MutexLocker ml(SymbolTable_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	305 assert(syms[i]->equals(names[i], lengths[i]), "symbol must be properly initialized");
a61af66fc99e Initial load duke parents: diff changeset	306 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	307 // thread beat us in the race to insert the symbol.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	310 if (test != NULL) {
605 98cb887364d3 6810672: Comment typos twisti parents: 0 diff changeset	311 // A race occurred and another thread introduced the symbol, this one
0 a61af66fc99e Initial load duke parents: diff changeset	312 // will be dropped and collected. Use test instead.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	320 add_entry(index, entry);
a61af66fc99e Initial load duke parents: diff changeset	321 cp->symbol_at_put(cp_indices[i], sym);
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 return true;
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328
a61af66fc99e Initial load duke parents: diff changeset	329 void SymbolTable::verify() {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	334 guarantee(s != NULL, "symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	335 unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	336 guarantee(p->hash() == h, "broken hash in symbol table entry");
a61af66fc99e Initial load duke parents: diff changeset	337 guarantee(the_table()->hash_to_index(h) == i,
a61af66fc99e Initial load duke parents: diff changeset	338 "wrong index in symbol table");
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340 }
a61af66fc99e Initial load duke parents: diff changeset	341 }
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343
a61af66fc99e Initial load duke parents: diff changeset	344 //---------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	345 // Non-product code
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 void SymbolTable::print_histogram() {
a61af66fc99e Initial load duke parents: diff changeset	350 MutexLocker ml(SymbolTable_lock);
a61af66fc99e Initial load duke parents: diff changeset	351 const int results_length = 100;
a61af66fc99e Initial load duke parents: diff changeset	352 int results[results_length];
a61af66fc99e Initial load duke parents: diff changeset	353 int i,j;
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 // initialize results to zero
a61af66fc99e Initial load duke parents: diff changeset	356 for (j = 0; j < results_length; j++) {
a61af66fc99e Initial load duke parents: diff changeset	357 results[j] = 0;
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 int total = 0;
a61af66fc99e Initial load duke parents: diff changeset	361 int max_symbols = 0;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	371 total += counter;
a61af66fc99e Initial load duke parents: diff changeset	372 if (counter < results_length) {
a61af66fc99e Initial load duke parents: diff changeset	373 results[counter]++;
a61af66fc99e Initial load duke parents: diff changeset	374 } else {
a61af66fc99e Initial load duke parents: diff changeset	375 out_of_range++;
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377 max_symbols = MAX2(max_symbols, counter);
a61af66fc99e Initial load duke parents: diff changeset	378 }
a61af66fc99e Initial load duke parents: diff changeset	379 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	392 tty->print_cr("%8s %5d", "Total ", total);
a61af66fc99e Initial load duke parents: diff changeset	393 tty->print_cr("%8s %5d", "Maximum", max_symbols);
a61af66fc99e Initial load duke parents: diff changeset	394 tty->print_cr("%8s %3.2f", "Average",
a61af66fc99e Initial load duke parents: diff changeset	395 ((float) total / (float) the_table()->table_size()));
a61af66fc99e Initial load duke parents: diff changeset	396 tty->print_cr("%s", "Histogram:");
a61af66fc99e Initial load duke parents: diff changeset	397 tty->print_cr(" %s %29s", "Length", "Number chains that length");
a61af66fc99e Initial load duke parents: diff changeset	398 for (i = 0; i < results_length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	399 if (results[i] > 0) {
a61af66fc99e Initial load duke parents: diff changeset	400 tty->print_cr("%6d %10d", i, results[i]);
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	434 }
a61af66fc99e Initial load duke parents: diff changeset	435 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	436 }
a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438 }
a61af66fc99e Initial load duke parents: diff changeset	439
a61af66fc99e Initial load duke parents: diff changeset	440 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	441
a61af66fc99e Initial load duke parents: diff changeset	442 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	445 class StableMemoryChecker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	446 enum { _bufsize = wordSize*4 };
a61af66fc99e Initial load duke parents: diff changeset	447
a61af66fc99e Initial load duke parents: diff changeset	448 address _region;
a61af66fc99e Initial load duke parents: diff changeset	449 jint _size;
a61af66fc99e Initial load duke parents: diff changeset	450 u1 _save_buf[_bufsize];
a61af66fc99e Initial load duke parents: diff changeset	451
a61af66fc99e Initial load duke parents: diff changeset	452 int sample(u1* save_buf) {
a61af66fc99e Initial load duke parents: diff changeset	453 if (_size <= _bufsize) {
a61af66fc99e Initial load duke parents: diff changeset	454 memcpy(save_buf, _region, _size);
a61af66fc99e Initial load duke parents: diff changeset	455 return _size;
a61af66fc99e Initial load duke parents: diff changeset	456 } else {
a61af66fc99e Initial load duke parents: diff changeset	457 // copy head and tail
a61af66fc99e Initial load duke parents: diff changeset	458 memcpy(&save_buf[0], _region, _bufsize/2);
a61af66fc99e Initial load duke parents: diff changeset	459 memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2);
a61af66fc99e Initial load duke parents: diff changeset	460 return (_bufsize/2)*2;
a61af66fc99e Initial load duke parents: diff changeset	461 }
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463
a61af66fc99e Initial load duke parents: diff changeset	464 public:
a61af66fc99e Initial load duke parents: diff changeset	465 StableMemoryChecker(const void* region, jint size) {
a61af66fc99e Initial load duke parents: diff changeset	466 _region = (address) region;
a61af66fc99e Initial load duke parents: diff changeset	467 _size = size;
a61af66fc99e Initial load duke parents: diff changeset	468 sample(_save_buf);
a61af66fc99e Initial load duke parents: diff changeset	469 }
a61af66fc99e Initial load duke parents: diff changeset	470
a61af66fc99e Initial load duke parents: diff changeset	471 bool verify() {
a61af66fc99e Initial load duke parents: diff changeset	472 u1 check_buf[sizeof(_save_buf)];
a61af66fc99e Initial load duke parents: diff changeset	473 int check_size = sample(check_buf);
a61af66fc99e Initial load duke parents: diff changeset	474 return (0 == memcmp(_save_buf, check_buf, check_size));
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476
a61af66fc99e Initial load duke parents: diff changeset	477 void set_region(const void* region) { _region = (address) region; }
a61af66fc99e Initial load duke parents: diff changeset	478 };
a61af66fc99e Initial load duke parents: diff changeset	479 #endif
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 // Compute the hash value for a java.lang.String object which would
a61af66fc99e Initial load duke parents: diff changeset	486 // contain the characters passed in. This hash value is used for at
a61af66fc99e Initial load duke parents: diff changeset	487 // least two purposes.
a61af66fc99e Initial load duke parents: diff changeset	488 //
a61af66fc99e Initial load duke parents: diff changeset	489 // (a) As the hash value used by the StringTable for bucket selection
a61af66fc99e Initial load duke parents: diff changeset	490 // and comparison (stored in the HashtableEntry structures). This
a61af66fc99e Initial load duke parents: diff changeset	491 // is used in the String.intern() method.
a61af66fc99e Initial load duke parents: diff changeset	492 //
a61af66fc99e Initial load duke parents: diff changeset	493 // (b) As the hash value used by the String object itself, in
a61af66fc99e Initial load duke parents: diff changeset	494 // String.hashCode(). This value is normally calculate in Java code
a61af66fc99e Initial load duke parents: diff changeset	495 // in the String.hashCode method(), but is precomputed for String
a61af66fc99e Initial load duke parents: diff changeset	496 // objects in the shared archive file.
a61af66fc99e Initial load duke parents: diff changeset	497 //
a61af66fc99e Initial load duke parents: diff changeset	498 // For this reason, THIS ALGORITHM MUST MATCH String.hashCode().
a61af66fc99e Initial load duke parents: diff changeset	499
a61af66fc99e Initial load duke parents: diff changeset	500 int StringTable::hash_string(jchar* s, int len) {
a61af66fc99e Initial load duke parents: diff changeset	501 unsigned h = 0;
a61af66fc99e Initial load duke parents: diff changeset	502 while (len-- > 0) {
a61af66fc99e Initial load duke parents: diff changeset	503 h = 31h + (unsigned) s;
a61af66fc99e Initial load duke parents: diff changeset	504 s++;
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506 return h;
a61af66fc99e Initial load duke parents: diff changeset	507 }
a61af66fc99e Initial load duke parents: diff changeset	508
a61af66fc99e Initial load duke parents: diff changeset	509
a61af66fc99e Initial load duke parents: diff changeset	510 StringTable* StringTable::_the_table = NULL;
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512 oop StringTable::lookup(int index, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	513 int len, unsigned int hash) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	514 for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) {
0 a61af66fc99e Initial load duke parents: diff changeset	515 if (l->hash() == hash) {
a61af66fc99e Initial load duke parents: diff changeset	516 if (java_lang_String::equals(l->literal(), name, len)) {
a61af66fc99e Initial load duke parents: diff changeset	517 return l->literal();
a61af66fc99e Initial load duke parents: diff changeset	518 }
a61af66fc99e Initial load duke parents: diff changeset	519 }
a61af66fc99e Initial load duke parents: diff changeset	520 }
a61af66fc99e Initial load duke parents: diff changeset	521 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	522 }
a61af66fc99e Initial load duke parents: diff changeset	523
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 oop StringTable::basic_add(int index, Handle string_or_null, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	526 int len, unsigned int hashValue, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	527 debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
a61af66fc99e Initial load duke parents: diff changeset	528 assert(!Universe::heap()->is_in_reserved(name) \|\| GC_locker::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	529 "proposed name of symbol must be stable");
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	532 // try to reuse the string if possible
a61af66fc99e Initial load duke parents: diff changeset	533 if (!string_or_null.is_null() && string_or_null()->is_perm()) {
a61af66fc99e Initial load duke parents: diff changeset	534 string = string_or_null;
a61af66fc99e Initial load duke parents: diff changeset	535 } else {
a61af66fc99e Initial load duke parents: diff changeset	536 string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // Allocation must be done before grapping the SymbolTable_lock lock
a61af66fc99e Initial load duke parents: diff changeset	540 MutexLocker ml(StringTable_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	541
a61af66fc99e Initial load duke parents: diff changeset	542 assert(java_lang_String::equals(string(), name, len),
a61af66fc99e Initial load duke parents: diff changeset	543 "string must be properly initialized");
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	546 // thread beat us in the race to insert the symbol.
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int)
a61af66fc99e Initial load duke parents: diff changeset	549 if (test != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	550 // Entry already added
a61af66fc99e Initial load duke parents: diff changeset	551 return test;
a61af66fc99e Initial load duke parents: diff changeset	552 }
a61af66fc99e Initial load duke parents: diff changeset	553
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	554 HashtableEntry<oop>* entry = new_entry(hashValue, string());
0 a61af66fc99e Initial load duke parents: diff changeset	555 add_entry(index, entry);
a61af66fc99e Initial load duke parents: diff changeset	556 return string();
a61af66fc99e Initial load duke parents: diff changeset	557 }
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	560 oop StringTable::lookup(Symbol* symbol) {
0 a61af66fc99e Initial load duke parents: diff changeset	561 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	562 int length;
a61af66fc99e Initial load duke parents: diff changeset	563 jchar* chars = symbol->as_unicode(length);
a61af66fc99e Initial load duke parents: diff changeset	564 unsigned int hashValue = hash_string(chars, length);
a61af66fc99e Initial load duke parents: diff changeset	565 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	566 return the_table()->lookup(index, chars, length, hashValue);
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569
a61af66fc99e Initial load duke parents: diff changeset	570 oop StringTable::intern(Handle string_or_null, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	571 int len, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	572 unsigned int hashValue = hash_string(name, len);
a61af66fc99e Initial load duke parents: diff changeset	573 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	574 oop string = the_table()->lookup(index, name, len, hashValue);
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576 // Found
a61af66fc99e Initial load duke parents: diff changeset	577 if (string != NULL) return string;
a61af66fc99e Initial load duke parents: diff changeset	578
a61af66fc99e Initial load duke parents: diff changeset	579 // Otherwise, add to symbol to table
a61af66fc99e Initial load duke parents: diff changeset	580 return the_table()->basic_add(index, string_or_null, name, len,
a61af66fc99e Initial load duke parents: diff changeset	581 hashValue, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	582 }
a61af66fc99e Initial load duke parents: diff changeset	583
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	584 oop StringTable::intern(Symbol* symbol, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	585 if (symbol == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	586 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	587 int length;
a61af66fc99e Initial load duke parents: diff changeset	588 jchar* chars = symbol->as_unicode(length);
a61af66fc99e Initial load duke parents: diff changeset	589 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	590 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	591 return result;
a61af66fc99e Initial load duke parents: diff changeset	592 }
a61af66fc99e Initial load duke parents: diff changeset	593
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 oop StringTable::intern(oop string, TRAPS)
a61af66fc99e Initial load duke parents: diff changeset	596 {
a61af66fc99e Initial load duke parents: diff changeset	597 if (string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	598 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	599 int length;
a61af66fc99e Initial load duke parents: diff changeset	600 Handle h_string (THREAD, string);
a61af66fc99e Initial load duke parents: diff changeset	601 jchar* chars = java_lang_String::as_unicode_string(string, length);
a61af66fc99e Initial load duke parents: diff changeset	602 oop result = intern(h_string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	603 return result;
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605
a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607 oop StringTable::intern(const char* utf8_string, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	608 if (utf8_string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	609 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	610 int length = UTF8::unicode_length(utf8_string);
a61af66fc99e Initial load duke parents: diff changeset	611 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);
a61af66fc99e Initial load duke parents: diff changeset	612 UTF8::convert_to_unicode(utf8_string, chars, length);
a61af66fc99e Initial load duke parents: diff changeset	613 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	614 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	615 return result;
a61af66fc99e Initial load duke parents: diff changeset	616 }
a61af66fc99e Initial load duke parents: diff changeset	617
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	618 void StringTable::unlink(BoolObjectClosure* is_alive) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	619 // 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	620 // entries at a safepoint.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	621 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	622 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	623 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	624 HashtableEntry<oop>* entry = *p;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	625 if (entry->is_shared()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	626 break;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	627 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	628 assert(entry->literal() != NULL, "just checking");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	629 if (is_alive->do_object_b(entry->literal())) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	630 p = entry->next_addr();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	631 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	632 *p = entry->next();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	633 the_table()->free_entry(entry);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	634 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	635 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	636 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	637 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	638
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	639 void StringTable::oops_do(OopClosure* f) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	640 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	641 HashtableEntry<oop>** p = the_table()->bucket_addr(i);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	642 HashtableEntry<oop>* entry = the_table()->bucket(i);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	643 while (entry != NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	644 f->do_oop((oop*)entry->literal_addr());
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	645
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	646 // 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	647 if (entry->literal() == NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	648 assert(!entry->is_shared(), "immutable hashtable entry?");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	649 *p = entry->next();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	650 the_table()->free_entry(entry);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	651 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	652 p = entry->next_addr();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	653 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	654 entry = (HashtableEntry<oop>)HashtableEntry<oop>::make_ptr(p);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	655 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	656 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	657 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	658
0 a61af66fc99e Initial load duke parents: diff changeset	659 void StringTable::verify() {
a61af66fc99e Initial load duke parents: diff changeset	660 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	661 HashtableEntry<oop>* p = the_table()->bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	662 for ( ; p != NULL; p = p->next()) {
a61af66fc99e Initial load duke parents: diff changeset	663 oop s = p->literal();
a61af66fc99e Initial load duke parents: diff changeset	664 guarantee(s != NULL, "interned string is NULL");
a61af66fc99e Initial load duke parents: diff changeset	665 guarantee(s->is_perm(), "interned string not in permspace");
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667 int length;
a61af66fc99e Initial load duke parents: diff changeset	668 jchar* chars = java_lang_String::as_unicode_string(s, length);
a61af66fc99e Initial load duke parents: diff changeset	669 unsigned int h = hash_string(chars, length);
a61af66fc99e Initial load duke parents: diff changeset	670 guarantee(p->hash() == h, "broken hash in string table entry");
a61af66fc99e Initial load duke parents: diff changeset	671 guarantee(the_table()->hash_to_index(h) == i,
a61af66fc99e Initial load duke parents: diff changeset	672 "wrong index in string table");
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674 }
a61af66fc99e Initial load duke parents: diff changeset	675 }

Mercurial > hg > truffle

annotate src/share/vm/classfile/symbolTable.cpp @ 2336:df1347358fe6