8328473: StringTable and SymbolTable statistics delay time to safepoint

Reviewed-by: shade, eosterlund

Author: coleenp

src/hotspot/share/classfile/stringTable.cpp

@@ -744,13 +744,29 @@ struct SizeFunc : StackObj {
 TableStatistics StringTable::get_table_statistics() {
   static TableStatistics ts;
   SizeFunc sz;
-  ts = _local_table->statistics_get(Thread::current(), sz, ts);
+
+  Thread* jt = Thread::current();
+  StringTableHash::StatisticsTask sts(_local_table);
+  if (!sts.prepare(jt)) {
+    return ts;  // return old table statistics
+  }
+  {
+    TraceTime timer("GetStatistics", TRACETIME_LOG(Debug, stringtable, perf));
+    while (sts.do_task(jt, sz)) {
+      sts.pause(jt);
+      if (jt->is_Java_thread()) {
+        ThreadBlockInVM tbivm(JavaThread::cast(jt));
+      }
+      sts.cont(jt);
+    }
+  }
+  ts = sts.done(jt);
   return ts;
 }
 
 void StringTable::print_table_statistics(outputStream* st) {
-  SizeFunc sz;
-  _local_table->statistics_to(Thread::current(), sz, st, "StringTable");
+  TableStatistics ts = get_table_statistics();
+  ts.print(st, "StringTable");
 #if INCLUDE_CDS_JAVA_HEAP
   if (!_shared_table.empty()) {
     _shared_table.print_table_statistics(st, "Shared String Table");

src/hotspot/share/classfile/symbolTable.cpp

@@ -572,23 +572,35 @@ Symbol* SymbolTable::new_permanent_symbol(const char* name) {
   return sym;
 }
 
-struct SizeFunc : StackObj {
-  size_t operator()(Symbol* value) {
+TableStatistics SymbolTable::get_table_statistics() {
+  static TableStatistics ts;
+  auto sz = [&](Symbol* value) {
     assert(value != nullptr, "expected valid value");
     return (value)->size() * HeapWordSize;
   };
-};
 
-TableStatistics SymbolTable::get_table_statistics() {
-  static TableStatistics ts;
-  SizeFunc sz;
-  ts = _local_table->statistics_get(Thread::current(), sz, ts);
+  Thread* jt = Thread::current();
+  SymbolTableHash::StatisticsTask sts(_local_table);
+  if (!sts.prepare(jt)) {
+    return ts;  // return old table statistics
+  }
+  {
+    TraceTime timer("GetStatistics", TRACETIME_LOG(Debug, symboltable, perf));
+    while (sts.do_task(jt, sz)) {
+      sts.pause(jt);
+      if (jt->is_Java_thread()) {
+        ThreadBlockInVM tbivm(JavaThread::cast(jt));
+      }
+      sts.cont(jt);
+    }
+  }
+  ts = sts.done(jt);
   return ts;
-}
+};
 
 void SymbolTable::print_table_statistics(outputStream* st) {
-  SizeFunc sz;
-  _local_table->statistics_to(Thread::current(), sz, st, "SymbolTable");
+  TableStatistics ts = get_table_statistics();
+  ts.print(st, "SymbolTable");
 
   if (!_shared_table.empty()) {
     _shared_table.print_table_statistics(st, "Shared Symbol Table");

src/hotspot/share/utilities/concurrentHashTable.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2025, 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
@@ -56,9 +56,12 @@ class ConcurrentHashTable : public CHeapObj<MT> {
       _stats_rate->remove();
     }
   }
-  // Calculate statistics. Item sizes are calculated with VALUE_SIZE_FUNC.
+  // Calculate statistics. Item sizes are calculated with VALUE_SIZE_FUNC, and accumulated in summary and literal_size.
   template <typename VALUE_SIZE_FUNC>
-  TableStatistics statistics_calculate(Thread* thread, VALUE_SIZE_FUNC& vs_f);
+  void internal_statistics_range(Thread* thread, size_t start, size_t stop,
+                                 VALUE_SIZE_FUNC& sts_f, NumberSeq& summary, size_t& literal_size);
+
+  TableStatistics internal_statistics_epilog(Thread* thread, NumberSeq summary, size_t literal_size);
 
   // This is the internal node structure.
   // Only constructed with placement new from memory allocated with MemTag of
@@ -531,12 +534,6 @@ class ConcurrentHashTable : public CHeapObj<MT> {
   template <typename VALUE_SIZE_FUNC>
   TableStatistics statistics_get(Thread* thread, VALUE_SIZE_FUNC& vs_f, TableStatistics old);
 
-  // Writes statistics to the outputStream. Item sizes are calculated with
-  // VALUE_SIZE_FUNC.
-  template <typename VALUE_SIZE_FUNC>
-  void statistics_to(Thread* thread, VALUE_SIZE_FUNC& vs_f, outputStream* st,
-                     const char* table_name);
-
   // Moves all nodes from this table to to_cht with new hash code.
   // Must be done at a safepoint.
   void rehash_nodes_to(Thread* thread, ConcurrentHashTable<CONFIG, MT>* to_cht);
@@ -559,6 +556,7 @@ class ConcurrentHashTable : public CHeapObj<MT> {
  public:
   class BulkDeleteTask;
   class GrowTask;
+  class StatisticsTask;
   class ScanTask;
 };
 

src/hotspot/share/utilities/concurrentHashTable.inline.hpp

@@ -1232,35 +1232,34 @@ inline void ConcurrentHashTable<CONFIG, MT>::
 
 template <typename CONFIG, MemTag MT>
 template <typename VALUE_SIZE_FUNC>
-inline TableStatistics ConcurrentHashTable<CONFIG, MT>::
-  statistics_calculate(Thread* thread, VALUE_SIZE_FUNC& vs_f)
+inline void ConcurrentHashTable<CONFIG, MT>::
+  internal_statistics_range(Thread* thread, size_t start, size_t stop,
+                            VALUE_SIZE_FUNC& vs_f, NumberSeq& summary, size_t& literal_size)
 {
-  constexpr size_t batch_size = 128;
-  NumberSeq summary;
-  size_t literal_bytes = 0;
-  InternalTable* table = get_table();
-  size_t num_batches = table->_size / batch_size;
-  for (size_t batch_start = 0; batch_start < _table->_size; batch_start += batch_size) {
-    // We batch the use of ScopedCS here as it has been found to be quite expensive to
-    // invoke it for every single bucket.
-    size_t batch_end = MIN2(batch_start + batch_size, _table->_size);
-    ScopedCS cs(thread, this);
-    for (size_t bucket_it = batch_start; bucket_it < batch_end; bucket_it++) {
-      size_t count = 0;
-      Bucket* bucket = table->get_bucket(bucket_it);
-      if (bucket->have_redirect() || bucket->is_locked()) {
-        continue;
-      }
-      Node* current_node = bucket->first();
-      while (current_node != nullptr) {
-        ++count;
-        literal_bytes += vs_f(current_node->value());
-        current_node = current_node->next();
-      }
-      summary.add((double)count);
+  // We batch the use of ScopedCS here as it has been found to be quite expensive to
+  // invoke it for every single bucket.
+  ScopedCS cs(thread, this);
+  for (size_t bucket_it = start; bucket_it < stop; bucket_it++) {
+    size_t count = 0;
+    Bucket* bucket = _table->get_bucket(bucket_it);
+    if (bucket->have_redirect() || bucket->is_locked()) {
+      continue;
     }
+    Node* current_node = bucket->first();
+    while (current_node != nullptr) {
+      ++count;
+      literal_size += vs_f(current_node->value());
+      current_node = current_node->next();
+    }
+    summary.add((double)count);
   }
+}
 
+template <typename CONFIG, MemTag MT>
+inline TableStatistics ConcurrentHashTable<CONFIG, MT>::
+  internal_statistics_epilog(Thread* thread, NumberSeq summary, size_t literal_bytes)
+{
+  unlock_resize_lock(thread);
   if (_stats_rate == nullptr) {
     return TableStatistics(summary, literal_bytes, sizeof(Bucket), sizeof(Node));
   } else {
@@ -1276,28 +1275,12 @@ inline TableStatistics ConcurrentHashTable<CONFIG, MT>::
   if (!try_resize_lock(thread)) {
     return old;
   }
+  InternalTable* table = get_table();
+  NumberSeq summary;
+  size_t    literal_bytes = 0;
 
-  TableStatistics ts = statistics_calculate(thread, vs_f);
-  unlock_resize_lock(thread);
-
-  return ts;
-}
-
-template <typename CONFIG, MemTag MT>
-template <typename VALUE_SIZE_FUNC>
-inline void ConcurrentHashTable<CONFIG, MT>::
-  statistics_to(Thread* thread, VALUE_SIZE_FUNC& vs_f,
-                outputStream* st, const char* table_name)
-{
-  if (!try_resize_lock(thread)) {
-    st->print_cr("statistics unavailable at this moment");
-    return;
-  }
-
-  TableStatistics ts = statistics_calculate(thread, vs_f);
-  unlock_resize_lock(thread);
-
-  ts.print(st, table_name);
+  internal_statistics_range(thread, 0, table->_size, vs_f, summary, literal_bytes);
+  return internal_statistics_epilog(thread, summary, literal_bytes);
 }
 
 template <typename CONFIG, MemTag MT>

src/hotspot/share/utilities/concurrentHashTableTasks.inline.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2025, 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
@@ -229,6 +229,50 @@ class ConcurrentHashTable<CONFIG, MT>::GrowTask :
   }
 };
 
+template <typename CONFIG, MemTag MT>
+class ConcurrentHashTable<CONFIG, MT>::StatisticsTask :
+  public BucketsOperation
+{
+  NumberSeq _summary;
+  size_t    _literal_bytes;
+ public:
+  StatisticsTask(ConcurrentHashTable<CONFIG, MT>* cht) : BucketsOperation(cht), _literal_bytes(0) { }
+
+  // Before start prepare must be called.
+  bool prepare(Thread* thread) {
+    bool lock = BucketsOperation::_cht->try_resize_lock(thread);
+    if (!lock) {
+      return false;
+    }
+
+    this->setup(thread);
+    return true;
+  }
+
+  // Scans part of the table adding to statistics.
+  template <typename VALUE_SIZE_FUNC>
+  bool do_task(Thread* thread, VALUE_SIZE_FUNC& sz) {
+    size_t start, stop;
+    assert(BucketsOperation::_cht->_resize_lock_owner != nullptr,
+           "Should be locked");
+    if (!this->claim(&start, &stop)) {
+      return false;
+    }
+    BucketsOperation::_cht->internal_statistics_range(thread, start, stop, sz, _summary, _literal_bytes);
+    assert(BucketsOperation::_cht->_resize_lock_owner != nullptr,
+           "Should be locked");
+    return true;
+  }
+
+  // Must be called after do_task returns false.
+  TableStatistics done(Thread* thread) {
+    this->thread_owns_resize_lock(thread);
+    TableStatistics ts = BucketsOperation::_cht->internal_statistics_epilog(thread, _summary, _literal_bytes);
+    this->thread_do_not_own_resize_lock(thread);
+    return ts;
+  }
+};
+
 template <typename CONFIG, MemTag MT>
 class ConcurrentHashTable<CONFIG, MT>::ScanTask :
   public BucketsOperation