src/hotspot/share/classfile/stringTable.cpp

*** 62,74 ****
  // If we have as many dead items as 50% of the number of bucket
  #define CLEAN_DEAD_HIGH_WATER_MARK 0.5
  
  // --------------------------------------------------------------------------
  StringTable* StringTable::_the_table = NULL;
- bool StringTable::_shared_string_mapped = false;
  CompactHashtable<oop, char> StringTable::_shared_table;
! bool StringTable::_alt_hash = false;
  
  static juint murmur_seed = 0;
  
  uintx hash_string(const jchar* s, int len, bool useAlt) {
    return  useAlt ?
--- 62,74 ----
  // If we have as many dead items as 50% of the number of bucket
  #define CLEAN_DEAD_HIGH_WATER_MARK 0.5
  
  // --------------------------------------------------------------------------
  StringTable* StringTable::_the_table = NULL;
  CompactHashtable<oop, char> StringTable::_shared_table;
! volatile bool StringTable::_shared_string_mapped = false;
! volatile bool StringTable::_alt_hash = false;
  
  static juint murmur_seed = 0;
  
  uintx hash_string(const jchar* s, int len, bool useAlt) {
    return  useAlt ?
*** 174,223 ****
      _found = Handle(_thread, value->resolve());
      return true;
    }
  };
  
! static size_t ceil_pow_2(uintx val) {
    size_t ret;
    for (ret = 1; ((size_t)1 << ret) < val; ++ret);
    return ret;
  }
  
  StringTable::StringTable() : _local_table(NULL), _current_size(0), _has_work(0),
!   _needs_rehashing(false), _weak_handles(NULL), _items(0), _uncleaned_items(0) {
    _weak_handles = new OopStorage("StringTable weak",
                                   StringTableWeakAlloc_lock,
                                   StringTableWeakActive_lock);
!   size_t start_size_log_2 = ceil_pow_2(StringTableSize);
    _current_size = ((size_t)1) << start_size_log_2;
    log_trace(stringtable)("Start size: " SIZE_FORMAT " (" SIZE_FORMAT ")",
                           _current_size, start_size_log_2);
    _local_table = new StringTableHash(start_size_log_2, END_SIZE, REHASH_LEN);
  }
  
  size_t StringTable::item_added() {
!   return Atomic::add((size_t)1, &(the_table()->_items));
  }
  
! size_t StringTable::add_items_to_clean(size_t ndead) {
!   size_t total = Atomic::add((size_t)ndead, &(the_table()->_uncleaned_items));
    log_trace(stringtable)(
       "Uncleaned items:" SIZE_FORMAT " added: " SIZE_FORMAT " total:" SIZE_FORMAT,
!      the_table()->_uncleaned_items, ndead, total);
    return total;
  }
  
  void StringTable::item_removed() {
!   Atomic::add((size_t)-1, &(the_table()->_items));
  }
  
  double StringTable::get_load_factor() {
!   return (_items*1.0)/_current_size;
  }
  
  double StringTable::get_dead_factor() {
!   return (_uncleaned_items*1.0)/_current_size;
  }
  
  size_t StringTable::table_size(Thread* thread) {
    return ((size_t)(1)) << _local_table->get_size_log2(thread != NULL ? thread
                                                        : Thread::current());
--- 174,223 ----
      _found = Handle(_thread, value->resolve());
      return true;
    }
  };
  
! static size_t log2_ceil(uintx val) {
    size_t ret;
    for (ret = 1; ((size_t)1 << ret) < val; ++ret);
    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) {
    _weak_handles = new OopStorage("StringTable weak",
                                   StringTableWeakAlloc_lock,
                                   StringTableWeakActive_lock);
!   size_t start_size_log_2 = log2_ceil(StringTableSize);
    _current_size = ((size_t)1) << start_size_log_2;
    log_trace(stringtable)("Start size: " SIZE_FORMAT " (" SIZE_FORMAT ")",
                           _current_size, start_size_log_2);
    _local_table = new StringTableHash(start_size_log_2, END_SIZE, REHASH_LEN);
  }
  
  size_t StringTable::item_added() {
!   return Atomic::add((size_t)1, &(the_table()->_items_count));
  }
  
! size_t StringTable::add_items_count_to_clean(size_t ndead) {
!   size_t total = Atomic::add((size_t)ndead, &(the_table()->_uncleaned_items_count));
    log_trace(stringtable)(
       "Uncleaned items:" SIZE_FORMAT " added: " SIZE_FORMAT " total:" SIZE_FORMAT,
!      the_table()->_uncleaned_items_count, ndead, total);
    return total;
  }
  
  void StringTable::item_removed() {
!   Atomic::add((size_t)-1, &(the_table()->_items_count));
  }
  
  double StringTable::get_load_factor() {
!   return (double)_items_count/_current_size;
  }
  
  double StringTable::get_dead_factor() {
!   return (double)_uncleaned_items_count/_current_size;
  }
  
  size_t StringTable::table_size(Thread* thread) {
    return ((size_t)(1)) << _local_table->get_size_log2(thread != NULL ? thread
                                                        : Thread::current());
*** 404,414 ****
  
    StringTable::the_table()->_weak_handles->weak_oops_do(&stiac, tmp);
  
    // This is the serial case without ParState.
    // Just set the correct number and check for a cleaning phase.
!   the_table()->_uncleaned_items = stiac._count;
    StringTable::the_table()->check_concurrent_work();
  
    if (processed != NULL) {
      *processed = (int) stiac._count_total;
    }
--- 404,414 ----
  
    StringTable::the_table()->_weak_handles->weak_oops_do(&stiac, tmp);
  
    // This is the serial case without ParState.
    // Just set the correct number and check for a cleaning phase.
!   the_table()->_uncleaned_items_count = stiac._count;
    StringTable::the_table()->check_concurrent_work();
  
    if (processed != NULL) {
      *processed = (int) stiac._count_total;
    }
*** 431,441 ****
    StringTableIsAliveCounter stiac(cl);
  
    _par_state_string->weak_oops_do(&stiac, &dnc);
  
    // Accumulate the dead strings.
!   the_table()->add_items_to_clean(stiac._count);
  
    *processed = (int) stiac._count_total;
    *removed = (int) stiac._count;
  }
  
--- 431,441 ----
    StringTableIsAliveCounter stiac(cl);
  
    _par_state_string->weak_oops_do(&stiac, &dnc);
  
    // Accumulate the dead strings.
!   the_table()->add_items_count_to_clean(stiac._count);
  
    *processed = (int) stiac._count_total;
    *removed = (int) stiac._count;
  }
  
*** 841,851 ****
  
  void StringTable::write_to_archive() {
    assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be");
  
    _shared_table.reset();
!   int num_buckets = the_table()->_items / SharedSymbolTableBucketSize;
    // calculation of num_buckets can result in zero buckets, we need at least one
    CompactStringTableWriter writer(num_buckets > 1 ? num_buckets : 1,
                                    &MetaspaceShared::stats()->string);
  
    // Copy the interned strings into the "string space" within the java heap
--- 841,851 ----
  
  void StringTable::write_to_archive() {
    assert(MetaspaceShared::is_heap_object_archiving_allowed(), "must be");
  
    _shared_table.reset();
!   int num_buckets = the_table()->_items_count / SharedSymbolTableBucketSize;
    // calculation of num_buckets can result in zero buckets, we need at least one
    CompactStringTableWriter writer(num_buckets > 1 ? num_buckets : 1,
                                    &MetaspaceShared::stats()->string);
  
    // Copy the interned strings into the "string space" within the java heap