diff -r 4f1f939d8f5d -r ea619918de95 src/hotspot/share/classfile/stringTable.cpp --- a/src/hotspot/share/classfile/stringTable.cpp Thu May 16 16:40:48 2019 +0530 +++ b/src/hotspot/share/classfile/stringTable.cpp Thu May 16 07:09:17 2019 -0400 @@ -30,7 +30,6 @@ #include "classfile/systemDictionary.hpp" #include "gc/shared/collectedHeap.hpp" #include "gc/shared/oopStorage.inline.hpp" -#include "gc/shared/oopStorageParState.inline.hpp" #include "logging/log.hpp" #include "logging/logStream.hpp" #include "memory/allocation.inline.hpp" @@ -79,9 +78,21 @@ #endif // -------------------------------------------------------------------------- -StringTable* StringTable::_the_table = NULL; -volatile bool StringTable::_alt_hash = false; + +typedef ConcurrentHashTable, + StringTableConfig, mtSymbol> StringTableHash; +static StringTableHash* _local_table = NULL; + +volatile bool StringTable::_has_work = false; +volatile bool StringTable::_needs_rehashing = false; +volatile size_t StringTable::_uncleaned_items_count = 0; +OopStorage* StringTable::_weak_handles = NULL; + +static size_t _current_size = 0; +static volatile size_t _items_count = 0; + +volatile bool _alt_hash = false; static juint murmur_seed = 0; uintx hash_string(const jchar* s, int len, bool useAlt) { @@ -107,7 +118,7 @@ int length; jchar* chars = java_lang_String::as_unicode_string(val_oop, length, THREAD); if (chars != NULL) { - return hash_string(chars, length, StringTable::_alt_hash); + return hash_string(chars, length, _alt_hash); } vm_exit_out_of_memory(length, OOM_MALLOC_ERROR, "get hash from oop"); return 0; @@ -196,8 +207,7 @@ return ret; } -StringTable::StringTable() : _local_table(NULL), _current_size(0), _has_work(0), - _needs_rehashing(false), _weak_handles(NULL), _items_count(0), _uncleaned_items_count(0) { +void StringTable::create_table() { _weak_handles = new OopStorage("StringTable weak", StringTableWeakAlloc_lock, StringTableWeakActive_lock); @@ -208,33 +218,27 @@ _local_table = new StringTableHash(start_size_log_2, END_SIZE, REHASH_LEN); } -void StringTable::update_needs_rehash(bool rehash) { - if (rehash) { - _needs_rehashing = true; - } -} - size_t StringTable::item_added() { - return Atomic::add((size_t)1, &(the_table()->_items_count)); + return Atomic::add((size_t)1, &_items_count); } size_t StringTable::add_items_to_clean(size_t ndead) { - size_t total = Atomic::add((size_t)ndead, &(the_table()->_uncleaned_items_count)); + size_t total = Atomic::add((size_t)ndead, &_uncleaned_items_count); log_trace(stringtable)( "Uncleaned items:" SIZE_FORMAT " added: " SIZE_FORMAT " total:" SIZE_FORMAT, - the_table()->_uncleaned_items_count, ndead, total); + _uncleaned_items_count, ndead, total); return total; } void StringTable::item_removed() { - Atomic::add((size_t)-1, &(the_table()->_items_count)); + Atomic::add((size_t)-1, &_items_count); } -double StringTable::get_load_factor() const { +double StringTable::get_load_factor() { return (double)_items_count/_current_size; } -double StringTable::get_dead_factor() const { +double StringTable::get_dead_factor() { return (double)_uncleaned_items_count/_current_size; } @@ -244,7 +248,7 @@ void StringTable::trigger_concurrent_work() { MutexLocker ml(Service_lock, Mutex::_no_safepoint_check_flag); - the_table()->_has_work = true; + _has_work = true; Service_lock->notify_all(); } @@ -258,14 +262,14 @@ oop StringTable::lookup(const jchar* name, int len) { unsigned int hash = java_lang_String::hash_code(name, len); - oop string = StringTable::the_table()->lookup_shared(name, len, hash); + oop string = lookup_shared(name, len, hash); if (string != NULL) { return string; } - if (StringTable::_alt_hash) { + if (_alt_hash) { hash = hash_string(name, len, true); } - return StringTable::the_table()->do_lookup(name, len, hash); + return do_lookup(name, len, hash); } class StringTableGet : public StackObj { @@ -329,19 +333,18 @@ oop StringTable::intern(Handle string_or_null_h, const jchar* name, int len, TRAPS) { // shared table always uses java_lang_String::hash_code unsigned int hash = java_lang_String::hash_code(name, len); - oop found_string = StringTable::the_table()->lookup_shared(name, len, hash); + oop found_string = lookup_shared(name, len, hash); if (found_string != NULL) { return found_string; } - if (StringTable::_alt_hash) { + if (_alt_hash) { hash = hash_string(name, len, true); } - found_string = StringTable::the_table()->do_lookup(name, len, hash); + found_string = do_lookup(name, len, hash); if (found_string != NULL) { return found_string; } - return StringTable::the_table()->do_intern(string_or_null_h, name, len, - hash, CHECK_NULL); + return do_intern(string_or_null_h, name, len, hash, CHECK_NULL); } oop StringTable::do_intern(Handle string_or_null_h, const jchar* name, @@ -384,15 +387,7 @@ void StringTable::oops_do(OopClosure* f) { assert(f != NULL, "No closure"); - StringTable::the_table()->_weak_handles->oops_do(f); -} - -void StringTable::possibly_parallel_oops_do( - OopStorage::ParState* - _par_state_string, OopClosure* f) -{ - assert(f != NULL, "No closure"); - _par_state_string->oops_do(f); + _weak_handles->oops_do(f); } // Concurrent work @@ -480,7 +475,7 @@ } } -void StringTable::concurrent_work(JavaThread* jt) { +void StringTable::do_concurrent_work(JavaThread* jt) { _has_work = false; double load_factor = get_load_factor(); log_debug(stringtable, perf)("Concurrent work, live factor: %g", load_factor); @@ -492,10 +487,6 @@ } } -void StringTable::do_concurrent_work(JavaThread* jt) { - StringTable::the_table()->concurrent_work(jt); -} - // Rehash bool StringTable::do_rehash() { if (!_local_table->is_safepoint_safe()) { @@ -519,7 +510,7 @@ return true; } -void StringTable::try_rehash_table() { +void StringTable::rehash_table() { static bool rehashed = false; log_debug(stringtable)("Table imbalanced, rehashing called."); @@ -550,10 +541,6 @@ _needs_rehashing = false; } -void StringTable::rehash_table() { - StringTable::the_table()->try_rehash_table(); -} - // Statistics static int literal_size(oop obj) { // NOTE: this would over-count if (pre-JDK8) @@ -609,7 +596,7 @@ void StringTable::verify() { Thread* thr = Thread::current(); VerifyStrings vs; - if (!the_table()->_local_table->try_scan(thr, vs)) { + if (!_local_table->try_scan(thr, vs)) { log_info(stringtable)("verify unavailable at this moment"); } } @@ -642,10 +629,10 @@ Thread* thr = Thread::current(); GrowableArray* oops = new (ResourceObj::C_HEAP, mtInternal) - GrowableArray((int)the_table()->_current_size, true); + GrowableArray((int)_current_size, true); VerifyCompStrings vcs(oops); - if (!the_table()->_local_table->try_scan(thr, vcs)) { + if (!_local_table->try_scan(thr, vcs)) { log_info(stringtable)("verify unavailable at this moment"); } delete oops; @@ -692,13 +679,13 @@ void StringTable::dump(outputStream* st, bool verbose) { if (!verbose) { - the_table()->print_table_statistics(st, "StringTable"); + print_table_statistics(st, "StringTable"); } else { Thread* thr = Thread::current(); ResourceMark rm(thr); st->print_cr("VERSION: 1.1"); PrintString ps(thr, st); - if (!the_table()->_local_table->try_scan(thr, ps)) { + if (!_local_table->try_scan(thr, ps)) { st->print_cr("dump unavailable at this moment"); } } @@ -785,15 +772,14 @@ assert(HeapShared::is_heap_object_archiving_allowed(), "must be"); CopyToArchive copy(writer); - StringTable::the_table()->_local_table->do_safepoint_scan(copy); + _local_table->do_safepoint_scan(copy); } void StringTable::write_to_archive() { assert(HeapShared::is_heap_object_archiving_allowed(), "must be"); _shared_table.reset(); - int num_buckets = CompactHashtableWriter::default_num_buckets( - StringTable::the_table()->_items_count); + int num_buckets = CompactHashtableWriter::default_num_buckets(_items_count); CompactHashtableWriter writer(num_buckets, &MetaspaceShared::stats()->string);