jdk-sandbox: comparison src/hotspot/share/classfile/symbolTable.cpp

equal deleted inserted replaced

-:4f1f939d8f5d
+:ea619918de95
 const char*, Symbol*,
 symbol_equals_compact_hashtable_entry
 > _shared_table;
 // --------------------------------------------------------------------------
-SymbolTable* SymbolTable::_the_table = NULL;
-volatile bool SymbolTable::_alt_hash = false;
+typedef ConcurrentHashTable<Symbol*,
-volatile bool SymbolTable::_lookup_shared_first = false;
+SymbolTableConfig, mtSymbol> SymbolTableHash;
+static SymbolTableHash* _local_table = NULL;
+volatile bool SymbolTable::_has_work = 0;
+volatile bool SymbolTable::_needs_rehashing = false;
+// For statistics
+static size_t _symbols_removed = 0;
+static size_t _symbols_counted = 0;
+static size_t _current_size = 0;
+static volatile size_t _items_count = 0;
+static volatile bool   _has_items_to_clean = false;
+static volatile bool _alt_hash = false;
+static volatile bool _lookup_shared_first = false;
 // Static arena for symbols that are not deallocated
 Arena* SymbolTable::_arena = NULL;
 static juint murmur_seed = 0;
 static uintx get_hash(Symbol* const& value, bool* is_dead) {
 *is_dead = (value->refcount() == 0);
 if (*is_dead) {
 return 0;
 } else {
-return hash_symbol((const char*)value->bytes(), value->utf8_length(), SymbolTable::_alt_hash);
+return hash_symbol((const char*)value->bytes(), value->utf8_length(), _alt_hash);
 }
 }
 // We use default allocation/deallocation but counted
 static void* allocate_node(size_t size, Symbol* const& value) {
 SymbolTable::item_added();
 size_t ret;
 for (ret = 1; ((size_t)1 << ret) < value; ++ret);
 return ret;
 }
-SymbolTable::SymbolTable() :
+void SymbolTable::create_table ()  {
-_symbols_removed(0), _symbols_counted(0), _local_table(NULL),
-_current_size(0), _has_work(0), _needs_rehashing(false),
-_items_count(0), _has_items_to_clean(false) {
 size_t start_size_log_2 = ceil_log2(SymbolTableSize);
 _current_size = ((size_t)1) << start_size_log_2;
 log_trace(symboltable)("Start size: " SIZE_FORMAT " (" SIZE_FORMAT ")",
 _current_size, start_size_log_2);
 _local_table = new SymbolTableHash(start_size_log_2, END_SIZE, REHASH_LEN);
+// Initialize the arena for global symbols, size passed in depends on CDS.
+if (symbol_alloc_arena_size == 0) {
+_arena = new (mtSymbol) Arena(mtSymbol);
+} else {
+_arena = new (mtSymbol) Arena(mtSymbol, symbol_alloc_arena_size);
+}
 }
 void SymbolTable::delete_symbol(Symbol* sym) {
 if (sym->refcount() == PERM_REFCOUNT) {
 MutexLocker ml(SymbolArena_lock, Mutex::_no_safepoint_check_flag); // Protect arena
 } else {
 delete sym;
 }
 }
-void SymbolTable::update_needs_rehash(bool rehash) {
-if (rehash) {
-_needs_rehashing = true;
-}
-}
 void SymbolTable::reset_has_items_to_clean() { Atomic::store(false, &_has_items_to_clean); }
 void SymbolTable::mark_has_items_to_clean()  { Atomic::store(true, &_has_items_to_clean); }
-bool SymbolTable::has_items_to_clean() const { return Atomic::load(&_has_items_to_clean); }
+bool SymbolTable::has_items_to_clean()       { return Atomic::load(&_has_items_to_clean); }
 void SymbolTable::item_added() {
-Atomic::inc(&(SymbolTable::the_table()->_items_count));
+Atomic::inc(&_items_count);
 }
 void SymbolTable::item_removed() {
-Atomic::inc(&(SymbolTable::the_table()->_symbols_removed));
+Atomic::inc(&(_symbols_removed));
-Atomic::dec(&(SymbolTable::the_table()->_items_count));
+Atomic::dec(&_items_count);
 }
-double SymbolTable::get_load_factor() const {
+double SymbolTable::get_load_factor() {
 return (double)_items_count/_current_size;
 }
 size_t SymbolTable::table_size() {
 return ((size_t)1) << _local_table->get_size_log2(Thread::current());
 }
 void SymbolTable::trigger_cleanup() {
 MutexLocker ml(Service_lock, Mutex::_no_safepoint_check_flag);
-SymbolTable::the_table()->_has_work = true;
+_has_work = true;
 Service_lock->notify_all();
 }
 Symbol* SymbolTable::allocate_symbol(const char* name, int len, bool c_heap) {
 assert (len <= Symbol::max_length(), "should be checked by caller");
 // Allocate to global arena
 MutexLocker ml(SymbolArena_lock, Mutex::_no_safepoint_check_flag); // Protect arena
 sym = new (len, arena()) Symbol((const u1*)name, len, PERM_REFCOUNT);
 }
 return sym;
-}
-void SymbolTable::initialize_symbols(int arena_alloc_size) {
-// Initialize the arena for global symbols, size passed in depends on CDS.
-if (arena_alloc_size == 0) {
-_arena = new (mtSymbol) Arena(mtSymbol);
-} else {
-_arena = new (mtSymbol) Arena(mtSymbol, arena_alloc_size);
-}
 }
 class SymbolsDo : StackObj {
 SymbolClosure *_cl;
 public:
 SharedSymbolIterator iter(cl);
 _shared_table.iterate(&iter);
 // all symbols from the dynamic table
 SymbolsDo sd(cl);
-if (!SymbolTable::the_table()->_local_table->try_scan(Thread::current(), sd)) {
+if (!_local_table->try_scan(Thread::current(), sd)) {
 log_info(stringtable)("symbols_do unavailable at this moment");
 }
 }
 class MetaspacePointersDo : StackObj {
 };
 void SymbolTable::metaspace_pointers_do(MetaspaceClosure* it) {
 assert(DumpSharedSpaces, "called only during dump time");
 MetaspacePointersDo mpd(it);
-SymbolTable::the_table()->_local_table->do_safepoint_scan(mpd);
+_local_table->do_safepoint_scan(mpd);
 }
 Symbol* SymbolTable::lookup_dynamic(const char* name,
 int len, unsigned int hash) {
-Symbol* sym = SymbolTable::the_table()->do_lookup(name, len, hash);
+Symbol* sym = do_lookup(name, len, hash);
 assert((sym == NULL) || sym->refcount() != 0, "refcount must not be zero");
 return sym;
 }
 Symbol* SymbolTable::lookup_shared(const char* name,
 int len, unsigned int hash) {
 if (!_shared_table.empty()) {
-if (SymbolTable::_alt_hash) {
+if (_alt_hash) {
 // hash_code parameter may use alternate hashing algorithm but the shared table
 // always uses the same original hash code.
 hash = hash_shared_symbol(name, len);
 }
 return _shared_table.lookup(name, hash, len);
 }
 return sym;
 }
 Symbol* SymbolTable::new_symbol(const char* name, int len) {
-unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash);
+unsigned int hash = hash_symbol(name, len, _alt_hash);
-Symbol* sym = SymbolTable::the_table()->lookup_common(name, len, hash);
+Symbol* sym = lookup_common(name, len, hash);
 if (sym == NULL) {
-sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, true);
+sym = do_add_if_needed(name, len, hash, true);
 }
 assert(sym->refcount() != 0, "lookup should have incremented the count");
 assert(sym->equals(name, len), "symbol must be properly initialized");
 return sym;
 }
 Symbol* SymbolTable::new_symbol(const Symbol* sym, int begin, int end) {
 assert(begin <= end && end <= sym->utf8_length(), "just checking");
 assert(sym->refcount() != 0, "require a valid symbol");
 const char* name = (const char*)sym->base() + begin;
 int len = end - begin;
-unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash);
+unsigned int hash = hash_symbol(name, len, _alt_hash);
-Symbol* found = SymbolTable::the_table()->lookup_common(name, len, hash);
+Symbol* found = lookup_common(name, len, hash);
 if (found == NULL) {
-found = SymbolTable::the_table()->do_add_if_needed(name, len, hash, true);
+found = do_add_if_needed(name, len, hash, true);
 }
 return found;
 }
 class SymbolTableLookup : StackObj {
 assert((sym == NULL) || sym->refcount() != 0, "found dead symbol");
 return sym;
 }
 Symbol* SymbolTable::lookup_only(const char* name, int len, unsigned int& hash) {
-hash = hash_symbol(name, len, SymbolTable::_alt_hash);
+hash = hash_symbol(name, len, _alt_hash);
-return SymbolTable::the_table()->lookup_common(name, len, hash);
+return lookup_common(name, len, hash);
 }
 // Suggestion: Push unicode-based lookup all the way into the hashing
 // and probing logic, so there is no need for convert_to_utf8 until
 // an actual new Symbol* is created.
 bool c_heap = !loader_data->is_the_null_class_loader_data();
 for (int i = 0; i < names_count; i++) {
 const char *name = names[i];
 int len = lengths[i];
 unsigned int hash = hashValues[i];
-assert(SymbolTable::the_table()->lookup_shared(name, len, hash) == NULL, "must have checked already");
+assert(lookup_shared(name, len, hash) == NULL, "must have checked already");
-Symbol* sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, c_heap);
+Symbol* sym = do_add_if_needed(name, len, hash, c_heap);
 assert(sym->refcount() != 0, "lookup should have incremented the count");
 cp->symbol_at_put(cp_indices[i], sym);
 }
 }
 do {
 if (_local_table->get(THREAD, lookup, stg, &rehash_warning)) {
 sym = stg.get_res_sym();
 break;
 }
-sym = SymbolTable::the_table()->allocate_symbol(name, len, heap);
+sym = allocate_symbol(name, len, heap);
 if (_local_table->insert(THREAD, lookup, sym, &rehash_warning, &clean_hint)) {
 break;
 }
 } while(true);
 Symbol* SymbolTable::new_permanent_symbol(const char* name) {
 unsigned int hash = 0;
 int len = (int)strlen(name);
 Symbol* sym = SymbolTable::lookup_only(name, len, hash);
 if (sym == NULL) {
-sym = SymbolTable::the_table()->do_add_if_needed(name, len, hash, false);
+sym = do_add_if_needed(name, len, hash, false);
 }
 if (!sym->is_permanent()) {
 sym->make_permanent();
 log_trace_symboltable_helper(sym, "Asked for a permanent symbol, but got a regular one");
 }
 };
 void SymbolTable::verify() {
 Thread* thr = Thread::current();
 VerifySymbols vs;
-if (!SymbolTable::the_table()->_local_table->try_scan(thr, vs)) {
+if (!_local_table->try_scan(thr, vs)) {
 log_info(stringtable)("verify unavailable at this moment");
 }
 }
 // Dumping
 };
 };
 void SymbolTable::dump(outputStream* st, bool verbose) {
 if (!verbose) {
-SymbolTable::the_table()->print_table_statistics(st, "SymbolTable");
+print_table_statistics(st, "SymbolTable");
 } else {
 Thread* thr = Thread::current();
 ResourceMark rm(thr);
 st->print_cr("VERSION: 1.1");
 DumpSymbol ds(thr, st);
-if (!SymbolTable::the_table()->_local_table->try_scan(thr, ds)) {
+if (!_local_table->try_scan(thr, ds)) {
 log_info(symboltable)("dump unavailable at this moment");
 }
 }
 }
 }
 };
 void SymbolTable::copy_shared_symbol_table(CompactHashtableWriter* writer) {
 CopyToArchive copy(writer);
-SymbolTable::the_table()->_local_table->do_safepoint_scan(copy);
+_local_table->do_safepoint_scan(copy);
 }
 void SymbolTable::write_to_archive() {
 _shared_table.reset();
 int num_buckets = CompactHashtableWriter::default_num_buckets(
-SymbolTable::the_table()->_items_count);
+_items_count);
 CompactHashtableWriter writer(num_buckets,
 &MetaspaceShared::stats()->symbol);
 copy_shared_symbol_table(&writer);
 writer.dump(&_shared_table, "symbol");
 // Verify table is correct
 Symbol* sym = vmSymbols::java_lang_Object();
 const char* name = (const char*)sym->bytes();
 int len = sym->utf8_length();
-unsigned int hash = hash_symbol(name, len, SymbolTable::_alt_hash);
+unsigned int hash = hash_symbol(name, len, _alt_hash);
 assert(sym == _shared_table.lookup(name, hash, len), "sanity");
 }
 void SymbolTable::serialize_shared_table_header(SerializeClosure* soc) {
 _shared_table.serialize_header(soc);
 {
 ThreadBlockInVM tbivm(jt);
 }
 bdt.cont(jt);
 }
-SymbolTable::the_table()->reset_has_items_to_clean();
+reset_has_items_to_clean();
 bdt.done(jt);
 }
 Atomic::add(stdc._processed, &_symbols_counted);
 get_load_factor(), has_items_to_clean() ? "true" : "false");
 trigger_cleanup();
 }
 }
-void SymbolTable::concurrent_work(JavaThread* jt) {
+void SymbolTable::do_concurrent_work(JavaThread* jt) {
 double load_factor = get_load_factor();
 log_debug(symboltable, perf)("Concurrent work, live factor: %g", load_factor);
 // We prefer growing, since that also removes dead items
 if (load_factor > PREF_AVG_LIST_LEN && !_local_table->is_max_size_reached()) {
 grow(jt);
 } else {
 clean_dead_entries(jt);
 }
 _has_work = false;
-}
-void SymbolTable::do_concurrent_work(JavaThread* jt) {
-SymbolTable::the_table()->concurrent_work(jt);
 }
 // Rehash
 bool SymbolTable::do_rehash() {
 if (!_local_table->is_safepoint_safe()) {
 _local_table = new_table;
 return true;
 }
-void SymbolTable::try_rehash_table() {
+void SymbolTable::rehash_table() {
 static bool rehashed = false;
 log_debug(symboltable)("Table imbalanced, rehashing called.");
 // Grow instead of rehash.
 if (get_load_factor() > PREF_AVG_LIST_LEN &&
 } else {
 log_info(symboltable)("Resizes in progress rehashing skipped.");
 }
 _needs_rehashing = false;
-}
-void SymbolTable::rehash_table() {
-SymbolTable::the_table()->try_rehash_table();
 }
 //---------------------------------------------------------------------------
 // Non-product code
 return true;
 };
 };
 void SymbolTable::print_histogram() {
-SymbolTable* st = SymbolTable::the_table();
 HistogramIterator hi;
-st->_local_table->do_scan(Thread::current(), hi);
+_local_table->do_scan(Thread::current(), hi);
 tty->print_cr("Symbol Table Histogram:");
 tty->print_cr("  Total number of symbols  " SIZE_FORMAT_W(7), hi.total_count);
 tty->print_cr("  Total size in memory     " SIZE_FORMAT_W(7) "K",
 (hi.total_size * wordSize) / 1024);
-tty->print_cr("  Total counted            " SIZE_FORMAT_W(7), st->_symbols_counted);
+tty->print_cr("  Total counted            " SIZE_FORMAT_W(7), _symbols_counted);
-tty->print_cr("  Total removed            " SIZE_FORMAT_W(7), st->_symbols_removed);
+tty->print_cr("  Total removed            " SIZE_FORMAT_W(7), _symbols_removed);
-if (SymbolTable::the_table()->_symbols_counted > 0) {
+if (_symbols_counted > 0) {
 tty->print_cr("  Percent removed          %3.2f",
-((float)st->_symbols_removed / st->_symbols_counted) * 100);
+((float)_symbols_removed / _symbols_counted) * 100);
 }
 tty->print_cr("  Reference counts         " SIZE_FORMAT_W(7), Symbol::_total_count);
 tty->print_cr("  Symbol arena used        " SIZE_FORMAT_W(7) "K", arena()->used() / 1024);
 tty->print_cr("  Symbol arena size        " SIZE_FORMAT_W(7) "K", arena()->size_in_bytes() / 1024);
 tty->print_cr("  Total symbol length      " SIZE_FORMAT_W(7), hi.total_length);

changeset 54896	ea619918de95
parent 54847	59ea39bb2809
child 54927	1512d88b24c6