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

annotate src/share/vm/classfile/symbolTable.cpp @ 4181:319860ae697a

Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.

author	Christian Wimmer <Christian.Wimmer@Oracle.com>
date	Mon, 02 Jan 2012 14:16:08 -0800
parents	352622fd140a
children	94ec88ca68e2

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	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 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 StringTable* StringTable::_the_table = NULL;
a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 oop StringTable::lookup(int index, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	488 if (l->hash() == hash) {
a61af66fc99e Initial load duke parents: diff changeset	489 if (java_lang_String::equals(l->literal(), name, len)) {
a61af66fc99e Initial load duke parents: diff changeset	490 return l->literal();
a61af66fc99e Initial load duke parents: diff changeset	491 }
a61af66fc99e Initial load duke parents: diff changeset	492 }
a61af66fc99e Initial load duke parents: diff changeset	493 }
a61af66fc99e Initial load duke parents: diff changeset	494 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	495 }
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497
a61af66fc99e Initial load duke parents: diff changeset	498 oop StringTable::basic_add(int index, Handle string_or_null, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	499 int len, unsigned int hashValue, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	500 debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
a61af66fc99e Initial load duke parents: diff changeset	501 assert(!Universe::heap()->is_in_reserved(name) \|\| GC_locker::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	502 "proposed name of symbol must be stable");
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	507 string = string_or_null;
a61af66fc99e Initial load duke parents: diff changeset	508 } else {
a61af66fc99e Initial load duke parents: diff changeset	509 string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512 // Allocation must be done before grapping the SymbolTable_lock lock
a61af66fc99e Initial load duke parents: diff changeset	513 MutexLocker ml(StringTable_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 assert(java_lang_String::equals(string(), name, len),
a61af66fc99e Initial load duke parents: diff changeset	516 "string must be properly initialized");
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	519 // thread beat us in the race to insert the symbol.
a61af66fc99e Initial load duke parents: diff changeset	520
a61af66fc99e Initial load duke parents: diff changeset	521 oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int)
a61af66fc99e Initial load duke parents: diff changeset	522 if (test != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	523 // Entry already added
a61af66fc99e Initial load duke parents: diff changeset	524 return test;
a61af66fc99e Initial load duke parents: diff changeset	525 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	528 add_entry(index, entry);
a61af66fc99e Initial load duke parents: diff changeset	529 return string();
a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	534 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	535 int length;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	538 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	539 return the_table()->lookup(index, chars, length, hashValue);
a61af66fc99e Initial load duke parents: diff changeset	540 }
a61af66fc99e Initial load duke parents: diff changeset	541
a61af66fc99e Initial load duke parents: diff changeset	542
a61af66fc99e Initial load duke parents: diff changeset	543 oop StringTable::intern(Handle string_or_null, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	546 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	547 oop string = the_table()->lookup(index, name, len, hashValue);
a61af66fc99e Initial load duke parents: diff changeset	548
a61af66fc99e Initial load duke parents: diff changeset	549 // Found
a61af66fc99e Initial load duke parents: diff changeset	550 if (string != NULL) return string;
a61af66fc99e Initial load duke parents: diff changeset	551
a61af66fc99e Initial load duke parents: diff changeset	552 // Otherwise, add to symbol to table
a61af66fc99e Initial load duke parents: diff changeset	553 return the_table()->basic_add(index, string_or_null, name, len,
a61af66fc99e Initial load duke parents: diff changeset	554 hashValue, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	555 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	558 if (symbol == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	559 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	560 int length;
a61af66fc99e Initial load duke parents: diff changeset	561 jchar* chars = symbol->as_unicode(length);
a61af66fc99e Initial load duke parents: diff changeset	562 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	563 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	564 return result;
a61af66fc99e Initial load duke parents: diff changeset	565 }
a61af66fc99e Initial load duke parents: diff changeset	566
a61af66fc99e Initial load duke parents: diff changeset	567
a61af66fc99e Initial load duke parents: diff changeset	568 oop StringTable::intern(oop string, TRAPS)
a61af66fc99e Initial load duke parents: diff changeset	569 {
a61af66fc99e Initial load duke parents: diff changeset	570 if (string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	571 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	572 int length;
a61af66fc99e Initial load duke parents: diff changeset	573 Handle h_string (THREAD, string);
a61af66fc99e Initial load duke parents: diff changeset	574 jchar* chars = java_lang_String::as_unicode_string(string, length);
a61af66fc99e Initial load duke parents: diff changeset	575 oop result = intern(h_string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	576 return result;
a61af66fc99e Initial load duke parents: diff changeset	577 }
a61af66fc99e Initial load duke parents: diff changeset	578
a61af66fc99e Initial load duke parents: diff changeset	579
a61af66fc99e Initial load duke parents: diff changeset	580 oop StringTable::intern(const char* utf8_string, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	581 if (utf8_string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	582 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	583 int length = UTF8::unicode_length(utf8_string);
a61af66fc99e Initial load duke parents: diff changeset	584 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);
a61af66fc99e Initial load duke parents: diff changeset	585 UTF8::convert_to_unicode(utf8_string, chars, length);
a61af66fc99e Initial load duke parents: diff changeset	586 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	587 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	588 return result;
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	632 void StringTable::verify() {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	635 for ( ; p != NULL; p = p->next()) {
a61af66fc99e Initial load duke parents: diff changeset	636 oop s = p->literal();
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	640 guarantee(p->hash() == h, "broken hash in string table entry");
a61af66fc99e Initial load duke parents: diff changeset	641 guarantee(the_table()->hash_to_index(h) == i,
a61af66fc99e Initial load duke parents: diff changeset	642 "wrong index in string table");
a61af66fc99e Initial load duke parents: diff changeset	643 }
a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645 }

Mercurial > hg > truffle

annotate src/share/vm/classfile/symbolTable.cpp @ 4181:319860ae697a