Fix FrontierTable capacity poisoning across shared-JVM tests

resetSearchStateForTest() only reset the frontier table's occupancy,
not its capacity, so an earlier test's smaller framecap= permanently
capped the singleton for every later test in the same JVM.

Author: jbachorik

ddprof-lib/src/main/cpp/referenceChains.cpp

@@ -38,6 +38,22 @@ FrontierTable::FrontierTable(int max_cap)
 
 FrontierTable::~FrontierTable() { free(_table); }
 
+void FrontierTable::resetCapacityForTest(int max_cap) {
+  _table_lock.lock();
+  free(_table);
+  _table = nullptr;
+  _table_max_cap = std::max(max_cap, 0);
+  _table_cap = std::min(INITIAL_TABLE_CAPACITY, _table_max_cap);
+  if (_table_cap > 0) {
+    _table = (FrontierEntry *)calloc(_table_cap, sizeof(FrontierEntry));
+    if (_table == nullptr) {
+      _table_cap = 0;
+    }
+  }
+  _table_size.store(0, std::memory_order_relaxed);
+  _table_lock.unlock();
+}
+
 bool FrontierTable::growLocked(int required_cap) {
   if (required_cap <= _table_cap) {
     return true;
@@ -237,8 +253,14 @@ Error ReferenceChainTracker::start(Arguments &args) {
   // frontier table once and keep it across repeated start()/stop() cycles -
   // do not reallocate on a second start() with a possibly different cap, for
   // the same reason LivenessTracker keeps its first-initialize() result.
+  // Recorded unconditionally, even on a start() call that finds _frontier
+  // already constructed (see _configured_frontier_cap's own comment) - this
+  // is what resetSearchStateForTest() rebuilds the table at, undoing
+  // whatever cap an earlier test in this same JVM happened to construct it
+  // with.
+  _configured_frontier_cap = args._reference_chains_frontier_cap;
   if (_frontier == nullptr) {
-    _frontier = new FrontierTable(args._reference_chains_frontier_cap);
+    _frontier = new FrontierTable(_configured_frontier_cap);
   }
 
   _hop_cap = args._reference_chains_hop_cap;
@@ -647,7 +669,12 @@ void ReferenceChainTracker::resetSearchStateForTest(jvmtiEnv *jvmti,
   _search_pain_ms = 0;
 
   if (_frontier != nullptr) {
-    _frontier->resetForRestart();
+    // Rebuilds the table at this test's own _configured_frontier_cap,
+    // undoing any smaller framecap= an earlier test left it permanently
+    // sized at (this class's own header comment on @TestMethodOrder) -
+    // restartSearch()'s production path only calls the cheaper
+    // resetForRestart() since it never needs to change the cap mid-JVM.
+    _frontier->resetCapacityForTest(_configured_frontier_cap);
   }
   _next_tag = 1;
 

ddprof-lib/src/main/cpp/referenceChains.h

@@ -335,6 +335,17 @@ class alignas(alignof(SpinLock)) FrontierTable {
     _table_lock.unlock();
   }
 
+  // Debug-only test seam (ReferenceChainTracker::resetSearchStateForTest()).
+  // Unlike resetForRestart(), which only forgets this table's occupancy,
+  // this discards the table's whole allocation and rebuilds it at
+  // `max_cap` - the only way to undo the "sized once, on the first start()
+  // in this JVM" capacity choice (this class's own constructor comment)
+  // that a differently-configured test running earlier in the same,
+  // no-forkEvery JVM (ProfilerTestPlugin.kt) would otherwise leave every
+  // later test permanently stuck with. Defined in referenceChains.cpp
+  // alongside the constructor it mirrors.
+  void resetCapacityForTest(int max_cap);
+
   int capacity() const { return _table_cap; }
   int maxCapacity() const { return _table_max_cap; }
 
@@ -415,6 +426,13 @@ class ReferenceChainTracker {
   // multiple start/stop recording cycles.
   FrontierTable *_frontier;
 
+  // args._reference_chains_frontier_cap as of the most recent start() call -
+  // recorded unconditionally (even once _frontier already exists and start()
+  // itself skips reconstructing it), so resetSearchStateForTest() has
+  // something to rebuild the table at other than whatever cap the first
+  // start() in this JVM happened to use (see _frontier's own comment).
+  int _configured_frontier_cap;
+
   // Class-tag -> StringDictionary id table. Populated by
   // resolveLoadedClasses(), read by heapReferenceCallback(). Survives
   // stop()/start() cycles for the same reason _frontier does - a class,
@@ -765,7 +783,8 @@ class ReferenceChainTracker {
   std::atomic<bool> _abort_pass_requested;
 
   ReferenceChainTracker()
-      : _enabled(false), _frontier(nullptr), _last_class_map_generation(0),
+      : _enabled(false), _frontier(nullptr), _configured_frontier_cap(0),
+        _last_class_map_generation(0),
         _last_resolved_class_count(0),
         _gc_start_epoch(0),
         _gc_finish_epoch(0), _next_tag(1), _next_class_tag_magnitude(1),