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

annotate src/share/vm/classfile/symbolTable.cpp @ 8850:ede380e13960

8009763: Add WB test for String.intern() Summary: Add convenience method in StringTable, add WhiteBox method and simple sanity test Reviewed-by: mgerdin, zgu Contributed-by: leonid.mesnik@oracle.com

author	mgerdin
date	Tue, 02 Apr 2013 11:28:33 +0200
parents	0ede345ec7c9
children	f258c5828eb8

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8718 0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	2 * Copyright (c) 1997, 2013, 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"
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	26 #include "classfile/altHashing.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "gc_interface/collectedHeap.inline.hpp"
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	31 #include "memory/allocation.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "memory/filemap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #include "utilities/hashtable.inline.hpp"
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	38 #include "utilities/numberSeq.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 SymbolTable* SymbolTable::_the_table = NULL;
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	43 // Static arena for symbols that are not deallocated
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	44 Arena* SymbolTable::_arena = NULL;
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	45 bool SymbolTable::_needs_rehashing = false;
0 a61af66fc99e Initial load duke parents: diff changeset	46
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	47 Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) {
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	48 assert (len <= Symbol::max_length(), "should be checked by caller");
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	49
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	50 Symbol* sym;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	51
8718 0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	52 if (DumpSharedSpaces) {
0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	53 // Allocate all symbols to CLD shared metaspace
0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	54 sym = new (len, ClassLoaderData::the_null_class_loader_data(), THREAD) Symbol(name, len, -1);
0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	55 } else if (c_heap) {
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	56 // refcount starts as 1
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	57 sym = new (len, THREAD) Symbol(name, len, 1);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	58 assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	59 } else {
8718 0ede345ec7c9 8009829: CDS: JDK JPRT test fails crash in Symbol::equals() coleenp parents: 7399 diff changeset	60 // Allocate to global arena
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	61 sym = new (len, arena(), THREAD) Symbol(name, len, -1);
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	62 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	63 return sym;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	64 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	65
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	66 void SymbolTable::initialize_symbols(int arena_alloc_size) {
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	67 // Initialize the arena for global symbols, size passed in depends on CDS.
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	68 if (arena_alloc_size == 0) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	69 _arena = new (mtSymbol) Arena();
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	70 } else {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	71 _arena = new (mtSymbol) Arena(arena_alloc_size);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	72 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	73 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	74
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	75 // 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	76 void SymbolTable::symbols_do(SymbolClosure *cl) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	77 const int n = the_table()->table_size();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	78 for (int i = 0; i < n; i++) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	79 for (HashtableEntry<Symbol, mtSymbol> p = the_table()->bucket(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	80 p != NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	81 p = p->next()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	82 cl->do_symbol(p->literal_addr());
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	83 }
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 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	86
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	87 int SymbolTable::symbols_removed = 0;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	88 int SymbolTable::symbols_counted = 0;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	89
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	90 // Remove unreferenced symbols from the symbol table
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	91 // This is done late during GC.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	92 void SymbolTable::unlink() {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	93 int removed = 0;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	94 int total = 0;
2336 df1347358fe6 7024584: Symbol printouts shouldnt be under PrintGCDetails coleenp parents: 2177 diff changeset	95 size_t memory_total = 0;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	96 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	97 HashtableEntry<Symbol, mtSymbol>* p = the_table()->bucket_addr(i);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	98 HashtableEntry<Symbol, mtSymbol> entry = the_table()->bucket(i);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	99 while (entry != NULL) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	100 // Shared entries are normally at the end of the bucket and if we run into
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	101 // a shared entry, then there is nothing more to remove. However, if we
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	102 // have rehashed the table, then the shared entries are no longer at the
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	103 // end of the bucket.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	104 if (entry->is_shared() && !use_alternate_hashcode()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	105 break;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	106 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	107 Symbol* s = entry->literal();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	108 memory_total += s->size();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	109 total++;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	110 assert(s != NULL, "just checking");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	111 // If reference count is zero, remove.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	112 if (s->refcount() == 0) {
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	113 assert(!entry->is_shared(), "shared entries should be kept live");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	114 delete s;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	115 removed++;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	116 *p = entry->next();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	117 the_table()->free_entry(entry);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	118 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	119 p = entry->next_addr();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	120 }
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	121 // get next entry
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	122 entry = (HashtableEntry<Symbol, mtSymbol>)HashtableEntry<Symbol, mtSymbol>::make_ptr(p);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	123 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	124 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	125 symbols_removed += removed;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	126 symbols_counted += total;
2336 df1347358fe6 7024584: Symbol printouts shouldnt be under PrintGCDetails coleenp parents: 2177 diff changeset	127 // Exclude printing for normal PrintGCDetails because people parse
df1347358fe6 7024584: Symbol printouts shouldnt be under PrintGCDetails coleenp parents: 2177 diff changeset	128 // this output.
df1347358fe6 7024584: Symbol printouts shouldnt be under PrintGCDetails coleenp parents: 2177 diff changeset	129 if (PrintGCDetails && Verbose && WizardMode) {
df1347358fe6 7024584: Symbol printouts shouldnt be under PrintGCDetails coleenp parents: 2177 diff changeset	130 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	131 (memory_total*HeapWordSize)/1024);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	132 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	133 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	134
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	135 // Create a new table and using alternate hash code, populate the new table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	136 // with the existing strings. Set flag to use the alternate hash code afterwards.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	137 void SymbolTable::rehash_table() {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	138 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	139 // This should never happen with -Xshare:dump but it might in testing mode.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	140 if (DumpSharedSpaces) return;
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	141 // Create a new symbol table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	142 SymbolTable* new_table = new SymbolTable();
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	143
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	144 the_table()->move_to(new_table);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	145
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	146 // Delete the table and buckets (entries are reused in new table).
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	147 delete _the_table;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	148 // Don't check if we need rehashing until the table gets unbalanced again.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	149 // Then rehash with a new global seed.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	150 _needs_rehashing = false;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	151 _the_table = new_table;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	152 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	153
0 a61af66fc99e Initial load duke parents: diff changeset	154 // Lookup a symbol in a bucket.
a61af66fc99e Initial load duke parents: diff changeset	155
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	156 Symbol* SymbolTable::lookup(int index, const char* name,
0 a61af66fc99e Initial load duke parents: diff changeset	157 int len, unsigned int hash) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	158 int count = 0;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	159 for (HashtableEntry<Symbol, mtSymbol> e = bucket(index); e != NULL; e = e->next()) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	160 count++; // count all entries in this bucket, not just ones with same hash
0 a61af66fc99e Initial load duke parents: diff changeset	161 if (e->hash() == hash) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	162 Symbol* sym = e->literal();
0 a61af66fc99e Initial load duke parents: diff changeset	163 if (sym->equals(name, len)) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	164 // something is referencing this symbol now.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	165 sym->increment_refcount();
0 a61af66fc99e Initial load duke parents: diff changeset	166 return sym;
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	170 // If the bucket size is too deep check if this hash code is insufficient.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	171 if (count >= BasicHashtable<mtSymbol>::rehash_count && !needs_rehashing()) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	172 _needs_rehashing = check_rehash_table(count);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	173 }
0 a61af66fc99e Initial load duke parents: diff changeset	174 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	177 // Pick hashing algorithm.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	178 unsigned int SymbolTable::hash_symbol(const char* s, int len) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	179 return use_alternate_hashcode() ?
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	180 AltHashing::murmur3_32(seed(), (const jbyte*)s, len) :
7399 2aa953165ade 8004661: Comment and function name java_lang_String::toHash is wrong brutisso parents: 6725 diff changeset	181 java_lang_String::hash_code(s, len);
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	182 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	183
0 a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 // We take care not to be blocking while holding the
a61af66fc99e Initial load duke parents: diff changeset	186 // SymbolTable_lock. Otherwise, the system might deadlock, since the
a61af66fc99e Initial load duke parents: diff changeset	187 // symboltable is used during compilation (VM_thread) The lock free
a61af66fc99e Initial load duke parents: diff changeset	188 // synchronization is simplified by the fact that we do not delete
a61af66fc99e Initial load duke parents: diff changeset	189 // entries in the symbol table during normal execution (only during
a61af66fc99e Initial load duke parents: diff changeset	190 // safepoints).
a61af66fc99e Initial load duke parents: diff changeset	191
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	192 Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	193 unsigned int hashValue = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	194 int index = the_table()->hash_to_index(hashValue);
a61af66fc99e Initial load duke parents: diff changeset	195
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	196 Symbol* s = the_table()->lookup(index, name, len, hashValue);
0 a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 // Found
a61af66fc99e Initial load duke parents: diff changeset	199 if (s != NULL) return s;
a61af66fc99e Initial load duke parents: diff changeset	200
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	201 // Grab SymbolTable_lock first.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	202 MutexLocker ml(SymbolTable_lock, THREAD);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	203
0 a61af66fc99e Initial load duke parents: diff changeset	204 // Otherwise, add to symbol to table
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	205 return the_table()->basic_add(index, (u1*)name, len, hashValue, true, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	206 }
a61af66fc99e Initial load duke parents: diff changeset	207
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	208 Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	209 char* buffer;
a61af66fc99e Initial load duke parents: diff changeset	210 int index, len;
a61af66fc99e Initial load duke parents: diff changeset	211 unsigned int hashValue;
a61af66fc99e Initial load duke parents: diff changeset	212 char* name;
a61af66fc99e Initial load duke parents: diff changeset	213 {
a61af66fc99e Initial load duke parents: diff changeset	214 debug_only(No_Safepoint_Verifier nsv;)
a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216 name = (char*)sym->base() + begin;
a61af66fc99e Initial load duke parents: diff changeset	217 len = end - begin;
a61af66fc99e Initial load duke parents: diff changeset	218 hashValue = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	219 index = the_table()->hash_to_index(hashValue);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	220 Symbol* s = the_table()->lookup(index, name, len, hashValue);
0 a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 // Found
a61af66fc99e Initial load duke parents: diff changeset	223 if (s != NULL) return s;
a61af66fc99e Initial load duke parents: diff changeset	224 }
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 // Otherwise, add to symbol to table. Copy to a C string first.
a61af66fc99e Initial load duke parents: diff changeset	227 char stack_buf[128];
a61af66fc99e Initial load duke parents: diff changeset	228 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	229 if (len <= 128) {
a61af66fc99e Initial load duke parents: diff changeset	230 buffer = stack_buf;
a61af66fc99e Initial load duke parents: diff changeset	231 } else {
a61af66fc99e Initial load duke parents: diff changeset	232 buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	235 buffer[i] = name[i];
a61af66fc99e Initial load duke parents: diff changeset	236 }
a61af66fc99e Initial load duke parents: diff changeset	237 // Make sure there is no safepoint in the code above since name can't move.
a61af66fc99e Initial load duke parents: diff changeset	238 // We can't include the code in No_Safepoint_Verifier because of the
a61af66fc99e Initial load duke parents: diff changeset	239 // ResourceMark.
a61af66fc99e Initial load duke parents: diff changeset	240
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	241 // Grab SymbolTable_lock first.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	242 MutexLocker ml(SymbolTable_lock, THREAD);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	243
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	244 return the_table()->basic_add(index, (u1*)buffer, len, hashValue, true, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	245 }
a61af66fc99e Initial load duke parents: diff changeset	246
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	247 Symbol* SymbolTable::lookup_only(const char* name, int len,
0 a61af66fc99e Initial load duke parents: diff changeset	248 unsigned int& hash) {
a61af66fc99e Initial load duke parents: diff changeset	249 hash = hash_symbol(name, len);
a61af66fc99e Initial load duke parents: diff changeset	250 int index = the_table()->hash_to_index(hash);
a61af66fc99e Initial load duke parents: diff changeset	251
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	252 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	253 return s;
0 a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	256 // Look up the address of the literal in the SymbolTable for this Symbol*
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	257 // Do not create any new symbols
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	258 // Do not increment the reference count to keep this alive
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	259 Symbol** SymbolTable::lookup_symbol_addr(Symbol* sym){
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	260 unsigned int hash = hash_symbol((char*)sym->bytes(), sym->utf8_length());
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	261 int index = the_table()->hash_to_index(hash);
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	262
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	263 for (HashtableEntry<Symbol, mtSymbol> e = the_table()->bucket(index); e != NULL; e = e->next()) {
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	264 if (e->hash() == hash) {
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	265 Symbol* literal_sym = e->literal();
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	266 if (sym == literal_sym) {
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	267 return e->literal_addr();
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	268 }
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	269 }
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	270 }
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	271 return NULL;
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	272 }
94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2418 diff changeset	273
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	274 // Suggestion: Push unicode-based lookup all the way into the hashing
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	275 // 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	276 // an actual new Symbol* is created.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	277 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	278 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	279 char stack_buf[128];
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	280 if (utf8_length < (int) sizeof(stack_buf)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	281 char* chars = stack_buf;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	282 UNICODE::convert_to_utf8(name, utf16_length, chars);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	283 return lookup(chars, utf8_length, THREAD);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	284 } else {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	285 ResourceMark rm(THREAD);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	286 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	287 UNICODE::convert_to_utf8(name, utf16_length, chars);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	288 return lookup(chars, utf8_length, THREAD);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	289 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	290 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	291
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	292 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	293 unsigned int& hash) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	294 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	295 char stack_buf[128];
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	296 if (utf8_length < (int) sizeof(stack_buf)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	297 char* chars = stack_buf;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	298 UNICODE::convert_to_utf8(name, utf16_length, chars);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	299 return lookup_only(chars, utf8_length, hash);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	300 } else {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	301 ResourceMark rm;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	302 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	303 UNICODE::convert_to_utf8(name, utf16_length, chars);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	304 return lookup_only(chars, utf8_length, hash);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	305 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	306 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	307
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	308 void SymbolTable::add(ClassLoaderData* loader_data, constantPoolHandle cp,
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	309 int names_count,
0 a61af66fc99e Initial load duke parents: diff changeset	310 const char** names, int* lengths, int* cp_indices,
a61af66fc99e Initial load duke parents: diff changeset	311 unsigned int* hashValues, TRAPS) {
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	312 // Grab SymbolTable_lock first.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	313 MutexLocker ml(SymbolTable_lock, THREAD);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	314
0 a61af66fc99e Initial load duke parents: diff changeset	315 SymbolTable* table = the_table();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	316 bool added = table->basic_add(loader_data, cp, names_count, names, lengths,
0 a61af66fc99e Initial load duke parents: diff changeset	317 cp_indices, hashValues, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	318 if (!added) {
a61af66fc99e Initial load duke parents: diff changeset	319 // do it the hard way
a61af66fc99e Initial load duke parents: diff changeset	320 for (int i=0; i<names_count; i++) {
a61af66fc99e Initial load duke parents: diff changeset	321 int index = table->hash_to_index(hashValues[i]);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	322 bool c_heap = !loader_data->is_the_null_class_loader_data();
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	323 Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], hashValues[i], c_heap, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	324 cp->symbol_at_put(cp_indices[i], sym);
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327 }
a61af66fc99e Initial load duke parents: diff changeset	328
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	329 Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) {
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	330 unsigned int hash;
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	331 Symbol* result = SymbolTable::lookup_only((char*)name, (int)strlen(name), hash);
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	332 if (result != NULL) {
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	333 return result;
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	334 }
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	335 // Grab SymbolTable_lock first.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	336 MutexLocker ml(SymbolTable_lock, THREAD);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	337
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	338 SymbolTable* table = the_table();
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	339 int index = table->hash_to_index(hash);
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	340 return table->basic_add(index, (u1*)name, (int)strlen(name), hash, false, THREAD);
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	341 }
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	342
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	343 Symbol* SymbolTable::basic_add(int index_arg, u1 *name, int len,
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	344 unsigned int hashValue_arg, bool c_heap, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	345 assert(!Universe::heap()->is_in_reserved(name) \|\| GC_locker::is_active(),
a61af66fc99e Initial load duke parents: diff changeset	346 "proposed name of symbol must be stable");
a61af66fc99e Initial load duke parents: diff changeset	347
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	348 // Don't allow symbols to be created which cannot fit in a Symbol*.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	349 if (len > Symbol::max_length()) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	350 THROW_MSG_0(vmSymbols::java_lang_InternalError(),
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	351 "name is too long to represent");
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	352 }
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	353
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	354 // Cannot hit a safepoint in this function because the "this" pointer can move.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	355 No_Safepoint_Verifier nsv;
0 a61af66fc99e Initial load duke parents: diff changeset	356
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	357 // Check if the symbol table has been rehashed, if so, need to recalculate
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	358 // the hash value and index.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	359 unsigned int hashValue;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	360 int index;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	361 if (use_alternate_hashcode()) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	362 hashValue = hash_symbol((const char*)name, len);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	363 index = hash_to_index(hashValue);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	364 } else {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	365 hashValue = hashValue_arg;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	366 index = index_arg;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	367 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	368
0 a61af66fc99e Initial load duke parents: diff changeset	369 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	370 // thread beat us in the race to insert the symbol.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	371 Symbol* test = lookup(index, (char*)name, len, hashValue);
0 a61af66fc99e Initial load duke parents: diff changeset	372 if (test != NULL) {
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	373 // A race occurred and another thread introduced the symbol.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	374 assert(test->refcount() != 0, "lookup should have incremented the count");
0 a61af66fc99e Initial load duke parents: diff changeset	375 return test;
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	378 // Create a new symbol.
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	379 Symbol* sym = allocate_symbol(name, len, c_heap, CHECK_NULL);
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	380 assert(sym->equals((char*)name, len), "symbol must be properly initialized");
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	381
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	382 HashtableEntry<Symbol, mtSymbol> entry = new_entry(hashValue, sym);
0 a61af66fc99e Initial load duke parents: diff changeset	383 add_entry(index, entry);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	384 return sym;
0 a61af66fc99e Initial load duke parents: diff changeset	385 }
a61af66fc99e Initial load duke parents: diff changeset	386
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	387 // This version of basic_add adds symbols in batch from the constant pool
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	388 // parsing.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	389 bool SymbolTable::basic_add(ClassLoaderData* loader_data, constantPoolHandle cp,
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	390 int names_count,
0 a61af66fc99e Initial load duke parents: diff changeset	391 const char** names, int* lengths,
a61af66fc99e Initial load duke parents: diff changeset	392 int* cp_indices, unsigned int* hashValues,
a61af66fc99e Initial load duke parents: diff changeset	393 TRAPS) {
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	394
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	395 // Check symbol names are not too long. If any are too long, don't add any.
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	396 for (int i = 0; i< names_count; i++) {
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	397 if (lengths[i] > Symbol::max_length()) {
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	398 THROW_MSG_0(vmSymbols::java_lang_InternalError(),
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	399 "name is too long to represent");
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	400 }
0 a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	403 // Cannot hit a safepoint in this function because the "this" pointer can move.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	404 No_Safepoint_Verifier nsv;
0 a61af66fc99e Initial load duke parents: diff changeset	405
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	406 for (int i=0; i<names_count; i++) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	407 // Check if the symbol table has been rehashed, if so, need to recalculate
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	408 // the hash value.
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	409 unsigned int hashValue;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	410 if (use_alternate_hashcode()) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	411 hashValue = hash_symbol(names[i], lengths[i]);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	412 } else {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	413 hashValue = hashValues[i];
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	414 }
0 a61af66fc99e Initial load duke parents: diff changeset	415 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	416 // thread beat us in the race to insert the symbol.
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	417 int index = hash_to_index(hashValue);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	418 Symbol* test = lookup(index, names[i], lengths[i], hashValue);
0 a61af66fc99e Initial load duke parents: diff changeset	419 if (test != NULL) {
605 98cb887364d3 6810672: Comment typos twisti parents: 0 diff changeset	420 // A race occurred and another thread introduced the symbol, this one
0 a61af66fc99e Initial load duke parents: diff changeset	421 // will be dropped and collected. Use test instead.
a61af66fc99e Initial load duke parents: diff changeset	422 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	423 assert(test->refcount() != 0, "lookup should have incremented the count");
0 a61af66fc99e Initial load duke parents: diff changeset	424 } else {
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	425 // Create a new symbol. The null class loader is never unloaded so these
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	426 // are allocated specially in a permanent arena.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	427 bool c_heap = !loader_data->is_the_null_class_loader_data();
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	428 Symbol* sym = allocate_symbol((const u1*)names[i], lengths[i], c_heap, CHECK_(false));
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	429 assert(sym->equals(names[i], lengths[i]), "symbol must be properly initialized"); // why wouldn't it be???
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	430 HashtableEntry<Symbol, mtSymbol> entry = new_entry(hashValue, sym);
0 a61af66fc99e Initial load duke parents: diff changeset	431 add_entry(index, entry);
a61af66fc99e Initial load duke parents: diff changeset	432 cp->symbol_at_put(cp_indices[i], sym);
a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434 }
a61af66fc99e Initial load duke parents: diff changeset	435 return true;
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 void SymbolTable::verify() {
a61af66fc99e Initial load duke parents: diff changeset	440 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	441 HashtableEntry<Symbol, mtSymbol> p = the_table()->bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	442 for ( ; p != NULL; p = p->next()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	443 Symbol* s = (Symbol*)(p->literal());
0 a61af66fc99e Initial load duke parents: diff changeset	444 guarantee(s != NULL, "symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	445 unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	446 guarantee(p->hash() == h, "broken hash in symbol table entry");
a61af66fc99e Initial load duke parents: diff changeset	447 guarantee(the_table()->hash_to_index(h) == i,
a61af66fc99e Initial load duke parents: diff changeset	448 "wrong index in symbol table");
a61af66fc99e Initial load duke parents: diff changeset	449 }
a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	453 void SymbolTable::dump(outputStream* st) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	454 NumberSeq summary;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	455 for (int i = 0; i < the_table()->table_size(); ++i) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	456 int count = 0;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	457 for (HashtableEntry<Symbol, mtSymbol> e = the_table()->bucket(i);
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	458 e != NULL; e = e->next()) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	459 count++;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	460 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	461 summary.add((double)count);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	462 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	463 st->print_cr("SymbolTable statistics:");
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	464 st->print_cr("Number of buckets : %7d", summary.num());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	465 st->print_cr("Average bucket size : %7.0f", summary.avg());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	466 st->print_cr("Variance of bucket size : %7.0f", summary.variance());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	467 st->print_cr("Std. dev. of bucket size: %7.0f", summary.sd());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	468 st->print_cr("Maximum bucket size : %7.0f", summary.maximum());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	469 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	470
0 a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472 //---------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	473 // Non-product code
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	476
a61af66fc99e Initial load duke parents: diff changeset	477 void SymbolTable::print_histogram() {
a61af66fc99e Initial load duke parents: diff changeset	478 MutexLocker ml(SymbolTable_lock);
a61af66fc99e Initial load duke parents: diff changeset	479 const int results_length = 100;
a61af66fc99e Initial load duke parents: diff changeset	480 int results[results_length];
a61af66fc99e Initial load duke parents: diff changeset	481 int i,j;
a61af66fc99e Initial load duke parents: diff changeset	482
a61af66fc99e Initial load duke parents: diff changeset	483 // initialize results to zero
a61af66fc99e Initial load duke parents: diff changeset	484 for (j = 0; j < results_length; j++) {
a61af66fc99e Initial load duke parents: diff changeset	485 results[j] = 0;
a61af66fc99e Initial load duke parents: diff changeset	486 }
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 int total = 0;
a61af66fc99e Initial load duke parents: diff changeset	489 int max_symbols = 0;
a61af66fc99e Initial load duke parents: diff changeset	490 int out_of_range = 0;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	491 int memory_total = 0;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	492 int count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	493 for (i = 0; i < the_table()->table_size(); i++) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	494 HashtableEntry<Symbol, mtSymbol> p = the_table()->bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	495 for ( ; p != NULL; p = p->next()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	496 memory_total += p->literal()->size();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	497 count++;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	498 int counter = p->literal()->utf8_length();
0 a61af66fc99e Initial load duke parents: diff changeset	499 total += counter;
a61af66fc99e Initial load duke parents: diff changeset	500 if (counter < results_length) {
a61af66fc99e Initial load duke parents: diff changeset	501 results[counter]++;
a61af66fc99e Initial load duke parents: diff changeset	502 } else {
a61af66fc99e Initial load duke parents: diff changeset	503 out_of_range++;
a61af66fc99e Initial load duke parents: diff changeset	504 }
a61af66fc99e Initial load duke parents: diff changeset	505 max_symbols = MAX2(max_symbols, counter);
a61af66fc99e Initial load duke parents: diff changeset	506 }
a61af66fc99e Initial load duke parents: diff changeset	507 }
a61af66fc99e Initial load duke parents: diff changeset	508 tty->print_cr("Symbol Table:");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	509 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	510 tty->print_cr("Total size in memory %5dK",
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	511 (memory_total*HeapWordSize)/1024);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	512 tty->print_cr("Total counted %5d", symbols_counted);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	513 tty->print_cr("Total removed %5d", symbols_removed);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	514 if (symbols_counted > 0) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	515 tty->print_cr("Percent removed %3.2f",
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	516 ((float)symbols_removed/(float)symbols_counted)* 100);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	517 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	518 tty->print_cr("Reference counts %5d", Symbol::_total_count);
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	519 tty->print_cr("Symbol arena size %5d used %5d",
fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 4800 diff changeset	520 arena()->size_in_bytes(), arena()->used());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	521 tty->print_cr("Histogram of symbol length:");
0 a61af66fc99e Initial load duke parents: diff changeset	522 tty->print_cr("%8s %5d", "Total ", total);
a61af66fc99e Initial load duke parents: diff changeset	523 tty->print_cr("%8s %5d", "Maximum", max_symbols);
a61af66fc99e Initial load duke parents: diff changeset	524 tty->print_cr("%8s %3.2f", "Average",
a61af66fc99e Initial load duke parents: diff changeset	525 ((float) total / (float) the_table()->table_size()));
a61af66fc99e Initial load duke parents: diff changeset	526 tty->print_cr("%s", "Histogram:");
a61af66fc99e Initial load duke parents: diff changeset	527 tty->print_cr(" %s %29s", "Length", "Number chains that length");
a61af66fc99e Initial load duke parents: diff changeset	528 for (i = 0; i < results_length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	529 if (results[i] > 0) {
a61af66fc99e Initial load duke parents: diff changeset	530 tty->print_cr("%6d %10d", i, results[i]);
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 if (Verbose) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	534 int line_length = 70;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	535 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	536 for (i = 0; i < results_length; i++) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	537 if (results[i] > 0) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	538 tty->print("%4d", i);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	539 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	540 tty->print("%1s", "*");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	541 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	542 if (j == line_length) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	543 tty->print("%1s", "+");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	544 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	545 tty->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	546 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	547 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	548 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	549 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	550 results_length, out_of_range);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	551 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	552
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	553 void SymbolTable::print() {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	554 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	555 HashtableEntry<Symbol, mtSymbol>* p = the_table()->bucket_addr(i);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	556 HashtableEntry<Symbol, mtSymbol> entry = the_table()->bucket(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	557 if (entry != NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	558 while (entry != NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	559 tty->print(PTR_FORMAT " ", entry->literal());
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	560 entry->literal()->print();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	561 tty->print(" %d", entry->literal()->refcount());
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	562 p = entry->next_addr();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	563 entry = (HashtableEntry<Symbol, mtSymbol>)HashtableEntry<Symbol, mtSymbol>::make_ptr(p);
0 a61af66fc99e Initial load duke parents: diff changeset	564 }
a61af66fc99e Initial load duke parents: diff changeset	565 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	566 }
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568 }
a61af66fc99e Initial load duke parents: diff changeset	569 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	570
a61af66fc99e Initial load duke parents: diff changeset	571 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	574 class StableMemoryChecker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	575 enum { _bufsize = wordSize*4 };
a61af66fc99e Initial load duke parents: diff changeset	576
a61af66fc99e Initial load duke parents: diff changeset	577 address _region;
a61af66fc99e Initial load duke parents: diff changeset	578 jint _size;
a61af66fc99e Initial load duke parents: diff changeset	579 u1 _save_buf[_bufsize];
a61af66fc99e Initial load duke parents: diff changeset	580
a61af66fc99e Initial load duke parents: diff changeset	581 int sample(u1* save_buf) {
a61af66fc99e Initial load duke parents: diff changeset	582 if (_size <= _bufsize) {
a61af66fc99e Initial load duke parents: diff changeset	583 memcpy(save_buf, _region, _size);
a61af66fc99e Initial load duke parents: diff changeset	584 return _size;
a61af66fc99e Initial load duke parents: diff changeset	585 } else {
a61af66fc99e Initial load duke parents: diff changeset	586 // copy head and tail
a61af66fc99e Initial load duke parents: diff changeset	587 memcpy(&save_buf[0], _region, _bufsize/2);
a61af66fc99e Initial load duke parents: diff changeset	588 memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2);
a61af66fc99e Initial load duke parents: diff changeset	589 return (_bufsize/2)*2;
a61af66fc99e Initial load duke parents: diff changeset	590 }
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592
a61af66fc99e Initial load duke parents: diff changeset	593 public:
a61af66fc99e Initial load duke parents: diff changeset	594 StableMemoryChecker(const void* region, jint size) {
a61af66fc99e Initial load duke parents: diff changeset	595 _region = (address) region;
a61af66fc99e Initial load duke parents: diff changeset	596 _size = size;
a61af66fc99e Initial load duke parents: diff changeset	597 sample(_save_buf);
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599
a61af66fc99e Initial load duke parents: diff changeset	600 bool verify() {
a61af66fc99e Initial load duke parents: diff changeset	601 u1 check_buf[sizeof(_save_buf)];
a61af66fc99e Initial load duke parents: diff changeset	602 int check_size = sample(check_buf);
a61af66fc99e Initial load duke parents: diff changeset	603 return (0 == memcmp(_save_buf, check_buf, check_size));
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605
a61af66fc99e Initial load duke parents: diff changeset	606 void set_region(const void* region) { _region = (address) region; }
a61af66fc99e Initial load duke parents: diff changeset	607 };
a61af66fc99e Initial load duke parents: diff changeset	608 #endif
a61af66fc99e Initial load duke parents: diff changeset	609
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611 // --------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	612 StringTable* StringTable::_the_table = NULL;
a61af66fc99e Initial load duke parents: diff changeset	613
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	614 bool StringTable::_needs_rehashing = false;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	615
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	616 // Pick hashing algorithm
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	617 unsigned int StringTable::hash_string(const jchar* s, int len) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	618 return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) :
7399 2aa953165ade 8004661: Comment and function name java_lang_String::toHash is wrong brutisso parents: 6725 diff changeset	619 java_lang_String::hash_code(s, len);
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	620 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	621
0 a61af66fc99e Initial load duke parents: diff changeset	622 oop StringTable::lookup(int index, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	623 int len, unsigned int hash) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	624 int count = 0;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	625 for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	626 count++;
0 a61af66fc99e Initial load duke parents: diff changeset	627 if (l->hash() == hash) {
a61af66fc99e Initial load duke parents: diff changeset	628 if (java_lang_String::equals(l->literal(), name, len)) {
a61af66fc99e Initial load duke parents: diff changeset	629 return l->literal();
a61af66fc99e Initial load duke parents: diff changeset	630 }
a61af66fc99e Initial load duke parents: diff changeset	631 }
a61af66fc99e Initial load duke parents: diff changeset	632 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	633 // If the bucket size is too deep check if this hash code is insufficient.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	634 if (count >= BasicHashtable<mtSymbol>::rehash_count && !needs_rehashing()) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	635 _needs_rehashing = check_rehash_table(count);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	636 }
0 a61af66fc99e Initial load duke parents: diff changeset	637 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	638 }
a61af66fc99e Initial load duke parents: diff changeset	639
a61af66fc99e Initial load duke parents: diff changeset	640
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	641 oop StringTable::basic_add(int index_arg, Handle string, jchar* name,
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	642 int len, unsigned int hashValue_arg, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	643
a61af66fc99e Initial load duke parents: diff changeset	644 assert(java_lang_String::equals(string(), name, len),
a61af66fc99e Initial load duke parents: diff changeset	645 "string must be properly initialized");
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	646 // Cannot hit a safepoint in this function because the "this" pointer can move.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	647 No_Safepoint_Verifier nsv;
0 a61af66fc99e Initial load duke parents: diff changeset	648
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	649 // Check if the symbol table has been rehashed, if so, need to recalculate
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	650 // the hash value and index before second lookup.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	651 unsigned int hashValue;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	652 int index;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	653 if (use_alternate_hashcode()) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	654 hashValue = hash_string(name, len);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	655 index = hash_to_index(hashValue);
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	656 } else {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	657 hashValue = hashValue_arg;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	658 index = index_arg;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	659 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	660
0 a61af66fc99e Initial load duke parents: diff changeset	661 // Since look-up was done lock-free, we need to check if another
a61af66fc99e Initial load duke parents: diff changeset	662 // thread beat us in the race to insert the symbol.
a61af66fc99e Initial load duke parents: diff changeset	663
a61af66fc99e Initial load duke parents: diff changeset	664 oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int)
a61af66fc99e Initial load duke parents: diff changeset	665 if (test != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	666 // Entry already added
a61af66fc99e Initial load duke parents: diff changeset	667 return test;
a61af66fc99e Initial load duke parents: diff changeset	668 }
a61af66fc99e Initial load duke parents: diff changeset	669
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	670 HashtableEntry<oop, mtSymbol>* entry = new_entry(hashValue, string());
0 a61af66fc99e Initial load duke parents: diff changeset	671 add_entry(index, entry);
a61af66fc99e Initial load duke parents: diff changeset	672 return string();
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674
a61af66fc99e Initial load duke parents: diff changeset	675
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	676 oop StringTable::lookup(Symbol* symbol) {
0 a61af66fc99e Initial load duke parents: diff changeset	677 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	678 int length;
a61af66fc99e Initial load duke parents: diff changeset	679 jchar* chars = symbol->as_unicode(length);
8850 ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	680 return lookup(chars, length);
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	681 }
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	682
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	683
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	684 oop StringTable::lookup(jchar* name, int len) {
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	685 unsigned int hash = hash_string(name, len);
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	686 int index = the_table()->hash_to_index(hash);
ede380e13960 8009763: Add WB test for String.intern() mgerdin parents: 8718 diff changeset	687 return the_table()->lookup(index, name, len, hash);
0 a61af66fc99e Initial load duke parents: diff changeset	688 }
a61af66fc99e Initial load duke parents: diff changeset	689
a61af66fc99e Initial load duke parents: diff changeset	690
a61af66fc99e Initial load duke parents: diff changeset	691 oop StringTable::intern(Handle string_or_null, jchar* name,
a61af66fc99e Initial load duke parents: diff changeset	692 int len, TRAPS) {
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	693 unsigned int hashValue = hash_string(name, len);
0 a61af66fc99e Initial load duke parents: diff changeset	694 int index = the_table()->hash_to_index(hashValue);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	695 oop found_string = the_table()->lookup(index, name, len, hashValue);
0 a61af66fc99e Initial load duke parents: diff changeset	696
a61af66fc99e Initial load duke parents: diff changeset	697 // Found
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	698 if (found_string != NULL) return found_string;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	699
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	700 debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	701 assert(!Universe::heap()->is_in_reserved(name) \|\| GC_locker::is_active(),
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	702 "proposed name of symbol must be stable");
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	703
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	704 Handle string;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	705 // try to reuse the string if possible
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	706 if (!string_or_null.is_null()) {
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	707 string = string_or_null;
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	708 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6201 diff changeset	709 string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	710 }
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	711
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	712 // Grab the StringTable_lock before getting the_table() because it could
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	713 // change at safepoint.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	714 MutexLocker ml(StringTable_lock, THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	715
a61af66fc99e Initial load duke parents: diff changeset	716 // Otherwise, add to symbol to table
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	717 return the_table()->basic_add(index, string, name, len,
0 a61af66fc99e Initial load duke parents: diff changeset	718 hashValue, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	719 }
a61af66fc99e Initial load duke parents: diff changeset	720
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	721 oop StringTable::intern(Symbol* symbol, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	722 if (symbol == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	723 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	724 int length;
a61af66fc99e Initial load duke parents: diff changeset	725 jchar* chars = symbol->as_unicode(length);
a61af66fc99e Initial load duke parents: diff changeset	726 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	727 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	728 return result;
a61af66fc99e Initial load duke parents: diff changeset	729 }
a61af66fc99e Initial load duke parents: diff changeset	730
a61af66fc99e Initial load duke parents: diff changeset	731
a61af66fc99e Initial load duke parents: diff changeset	732 oop StringTable::intern(oop string, TRAPS)
a61af66fc99e Initial load duke parents: diff changeset	733 {
a61af66fc99e Initial load duke parents: diff changeset	734 if (string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	735 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	736 int length;
a61af66fc99e Initial load duke parents: diff changeset	737 Handle h_string (THREAD, string);
a61af66fc99e Initial load duke parents: diff changeset	738 jchar* chars = java_lang_String::as_unicode_string(string, length);
a61af66fc99e Initial load duke parents: diff changeset	739 oop result = intern(h_string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	740 return result;
a61af66fc99e Initial load duke parents: diff changeset	741 }
a61af66fc99e Initial load duke parents: diff changeset	742
a61af66fc99e Initial load duke parents: diff changeset	743
a61af66fc99e Initial load duke parents: diff changeset	744 oop StringTable::intern(const char* utf8_string, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	745 if (utf8_string == NULL) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	746 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	747 int length = UTF8::unicode_length(utf8_string);
a61af66fc99e Initial load duke parents: diff changeset	748 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);
a61af66fc99e Initial load duke parents: diff changeset	749 UTF8::convert_to_unicode(utf8_string, chars, length);
a61af66fc99e Initial load duke parents: diff changeset	750 Handle string;
a61af66fc99e Initial load duke parents: diff changeset	751 oop result = intern(string, chars, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	752 return result;
a61af66fc99e Initial load duke parents: diff changeset	753 }
a61af66fc99e Initial load duke parents: diff changeset	754
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	755 void StringTable::unlink(BoolObjectClosure* is_alive) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	756 // 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	757 // entries at a safepoint.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	758 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	759 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	760 HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	761 HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	762 while (entry != NULL) {
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	763 // Shared entries are normally at the end of the bucket and if we run into
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	764 // a shared entry, then there is nothing more to remove. However, if we
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	765 // have rehashed the table, then the shared entries are no longer at the
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	766 // end of the bucket.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	767 if (entry->is_shared() && !use_alternate_hashcode()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	768 break;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	769 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	770 assert(entry->literal() != NULL, "just checking");
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	771 if (entry->is_shared() \|\| is_alive->do_object_b(entry->literal())) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	772 p = entry->next_addr();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	773 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	774 *p = entry->next();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	775 the_table()->free_entry(entry);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	776 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	777 entry = (HashtableEntry<oop, mtSymbol>)HashtableEntry<oop, mtSymbol>::make_ptr(p);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	778 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	779 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	780 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	781
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	782 void StringTable::oops_do(OopClosure* f) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	783 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	784 HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	785 HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	786 while (entry != NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	787 f->do_oop((oop*)entry->literal_addr());
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	788
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	789 // 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	790 if (entry->literal() == NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	791 assert(!entry->is_shared(), "immutable hashtable entry?");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	792 *p = entry->next();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	793 the_table()->free_entry(entry);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	794 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	795 p = entry->next_addr();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	796 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	797 entry = (HashtableEntry<oop, mtSymbol>)HashtableEntry<oop, mtSymbol>::make_ptr(p);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	798 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	799 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	800 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	801
0 a61af66fc99e Initial load duke parents: diff changeset	802 void StringTable::verify() {
a61af66fc99e Initial load duke parents: diff changeset	803 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	804 HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
0 a61af66fc99e Initial load duke parents: diff changeset	805 for ( ; p != NULL; p = p->next()) {
a61af66fc99e Initial load duke parents: diff changeset	806 oop s = p->literal();
a61af66fc99e Initial load duke parents: diff changeset	807 guarantee(s != NULL, "interned string is NULL");
2418 352622fd140a 7032129: Native memory usage grow unexpectedly for vm/oom/InternedString tests never* parents: 2379 diff changeset	808 unsigned int h = java_lang_String::hash_string(s);
0 a61af66fc99e Initial load duke parents: diff changeset	809 guarantee(p->hash() == h, "broken hash in string table entry");
a61af66fc99e Initial load duke parents: diff changeset	810 guarantee(the_table()->hash_to_index(h) == i,
a61af66fc99e Initial load duke parents: diff changeset	811 "wrong index in string table");
a61af66fc99e Initial load duke parents: diff changeset	812 }
a61af66fc99e Initial load duke parents: diff changeset	813 }
a61af66fc99e Initial load duke parents: diff changeset	814 }
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	815
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	816 void StringTable::dump(outputStream* st) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	817 NumberSeq summary;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	818 for (int i = 0; i < the_table()->table_size(); ++i) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6172 diff changeset	819 HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	820 int count = 0;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	821 for ( ; p != NULL; p = p->next()) {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	822 count++;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	823 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	824 summary.add((double)count);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	825 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	826 st->print_cr("StringTable statistics:");
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	827 st->print_cr("Number of buckets : %7d", summary.num());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	828 st->print_cr("Average bucket size : %7.0f", summary.avg());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	829 st->print_cr("Variance of bucket size : %7.0f", summary.variance());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	830 st->print_cr("Std. dev. of bucket size: %7.0f", summary.sd());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	831 st->print_cr("Maximum bucket size : %7.0f", summary.maximum());
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	832 }
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	833
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	834
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	835 // Create a new table and using alternate hash code, populate the new table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	836 // with the existing strings. Set flag to use the alternate hash code afterwards.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	837 void StringTable::rehash_table() {
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	838 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
6172 246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	839 // This should never happen with -Xshare:dump but it might in testing mode.
246d977b51f2 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table coleenp parents: 6162 diff changeset	840 if (DumpSharedSpaces) return;
6162 e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	841 StringTable* new_table = new StringTable();
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	842
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	843 // Rehash the table
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	844 the_table()->move_to(new_table);
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	845
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	846 // Delete the table and buckets (entries are reused in new table).
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	847 delete _the_table;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	848 // Don't check if we need rehashing until the table gets unbalanced again.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	849 // Then rehash with a new global seed.
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	850 _needs_rehashing = false;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	851 _the_table = new_table;
e9140bf80b4a 7158800: Improve storage of symbol tables coleenp parents: 5979 diff changeset	852 }

Mercurial > hg > truffle

annotate src/share/vm/classfile/symbolTable.cpp @ 8850:ede380e13960