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

equal deleted inserted replaced

-:5bc1634bc0ca
+:739eaf4ac4ad
 /*
-* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // as the previous table size (used to be 20,011),
 // which never resized
 const size_t END_SIZE = 17;
 // If a chain gets to 100 something might be wrong
 const size_t REHASH_LEN = 100;
-// We only get a chance to check whether we need
-// to clean infrequently (on class unloading),
-// so if we have even one dead entry then mark table for cleaning
-const double CLEAN_DEAD_HIGH_WATER_MARK = 0.0;
 const size_t ON_STACK_BUFFER_LENGTH = 128;
 // --------------------------------------------------------------------------
 }
 SymbolTable::SymbolTable() :
 _symbols_removed(0), _symbols_counted(0), _local_table(NULL),
 _current_size(0), _has_work(0), _needs_rehashing(false),
-_items_count(0), _uncleaned_items_count(0) {
+_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);
 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); }
 void SymbolTable::item_added() {
 Atomic::inc(&(SymbolTable::the_table()->_items_count));
-}
-void SymbolTable::set_item_clean_count(size_t ncl) {
-Atomic::store(ncl, &(SymbolTable::the_table()->_uncleaned_items_count));
-log_trace(symboltable)("Set uncleaned items:" SIZE_FORMAT, SymbolTable::the_table()->_uncleaned_items_count);
-}
-// Mark one item as needing to be cleaned, but only if no other items are marked yet
-void SymbolTable::mark_item_clean_count() {
-if (Atomic::cmpxchg((size_t)1, &(SymbolTable::the_table()->_uncleaned_items_count), (size_t)0) == 0) {
-log_trace(symboltable)("Marked uncleaned items:" SIZE_FORMAT, SymbolTable::the_table()->_uncleaned_items_count);
-}
 }
 void SymbolTable::item_removed() {
 Atomic::inc(&(SymbolTable::the_table()->_symbols_removed));
 Atomic::dec(&(SymbolTable::the_table()->_items_count));
 double SymbolTable::get_load_factor() const {
 return (double)_items_count/_current_size;
 }
-double SymbolTable::get_dead_factor() const {
-return (double)_uncleaned_items_count/_current_size;
-}
 size_t SymbolTable::table_size() {
 return ((size_t)1) << _local_table->get_size_log2(Thread::current());
 }
-void SymbolTable::trigger_concurrent_work() {
+void SymbolTable::trigger_cleanup() {
 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 SymbolTable::the_table()->_has_work = true;
 Service_lock->notify_all();
 }
 } while(true);
 update_needs_rehash(rehash_warning);
 if (clean_hint) {
-// we just found out that there is a dead item,
+mark_has_items_to_clean();
-// which we were unable to clean right now,
-// but we have no way of telling whether it's
-// been previously counted or not, so mark
-// it only if no other items were found yet
-mark_item_clean_count();
 check_concurrent_work();
 }
 assert((sym == NULL) || sym->refcount() != 0, "found dead symbol");
 return sym;
 {
 ThreadBlockInVM tbivm(jt);
 }
 bdt.cont(jt);
 }
-SymbolTable::the_table()->set_item_clean_count(0);
+SymbolTable::the_table()->reset_has_items_to_clean();
 bdt.done(jt);
 }
 Atomic::add(stdc._processed, &_symbols_counted);
 void SymbolTable::check_concurrent_work() {
 if (_has_work) {
 return;
 }
-double load_factor = SymbolTable::get_load_factor();
+// We should clean/resize if we have
-double dead_factor = SymbolTable::get_dead_factor();
-// We should clean/resize if we have more dead than alive,
 // more items than preferred load factor or
 // more dead items than water mark.
-if ((dead_factor > load_factor) ||
+if (has_items_to_clean() || (get_load_factor() > PREF_AVG_LIST_LEN)) {
-(load_factor > PREF_AVG_LIST_LEN) ||
+log_debug(symboltable)("Concurrent work triggered, load factor: %f, items to clean: %s",
-(dead_factor > CLEAN_DEAD_HIGH_WATER_MARK)) {
+get_load_factor(), has_items_to_clean() ? "true" : "false");
-log_debug(symboltable)("Concurrent work triggered, live factor:%f dead factor:%f",
+trigger_cleanup();
-load_factor, dead_factor);
-trigger_concurrent_work();
 }
 }
 void SymbolTable::concurrent_work(JavaThread* jt) {
 double load_factor = get_load_factor();
 grow(jt);
 } else {
 clean_dead_entries(jt);
 }
 _has_work = false;
-}
-class CountDead : StackObj {
-size_t _count;
-public:
-CountDead() : _count(0) {}
-bool operator()(Symbol** value) {
-assert(value != NULL, "expected valid value");
-assert(*value != NULL, "value should point to a symbol");
-Symbol* sym = *value;
-if (sym->refcount() == 0) {
-_count++;
-}
-return true;
-};
-size_t get_dead_count() const {
-return _count;
-}
-};
-void SymbolTable::do_check_concurrent_work() {
-CountDead counter;
-if (!SymbolTable::the_table()->_local_table->try_scan(Thread::current(), counter)) {
-log_info(symboltable)("count dead unavailable at this moment");
-} else {
-SymbolTable::the_table()->set_item_clean_count(counter.get_dead_count());
-SymbolTable::the_table()->check_concurrent_work();
-}
 }
 void SymbolTable::do_concurrent_work(JavaThread* jt) {
 SymbolTable::the_table()->concurrent_work(jt);
 }
 // Grow instead of rehash.
 if (get_load_factor() > PREF_AVG_LIST_LEN &&
 !_local_table->is_max_size_reached()) {
 log_debug(symboltable)("Choosing growing over rehashing.");
-trigger_concurrent_work();
+trigger_cleanup();
 _needs_rehashing = false;
 return;
 }
 // Already rehashed.
 if (rehashed) {
 log_warning(symboltable)("Rehashing already done, still long lists.");
-trigger_concurrent_work();
+trigger_cleanup();
 _needs_rehashing = false;
 return;
 }
 murmur_seed = AltHashing::compute_seed();

changeset 53587	739eaf4ac4ad
parent 52951	722eaae2a785
child 53898	853b82a25d53