Address review: numSlots() accessor + comment cleanup

- StringIndex: replace the public `slots` field with a `numSlots()` method on
  both the instance and Support (don't expose it as a field); update the two
  StringIndexTest call sites.
- StringIndex Javadoc: drop Data from the "ways to use it" list — it's just
  create's multi-value return, not a usage mode.
- ImmutableSetBenchmark: trim the "Key findings" prose to conclusions (the
  results table carries the numbers; relative comparisons kept).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dougqh

internal-api/src/jmh/java/datadog/trace/util/ImmutableSetBenchmark.java

@@ -63,19 +63,17 @@
  * <p>Key findings:
  *
  * <ul>
- *   <li>The static {@code Support} path is the fastest membership structure — it beats {@code
- *       HashSet} on both hit and miss, and crushes the scan/search/tree forms.
+ *   <li>The static {@code Support} path is the fastest — it beats {@code HashSet} on hit and miss
+ *       and crushes the scan/search/tree forms.
  *   <li>{@code stringIndex} (the instance wrapper) trails {@code Support} by the field-load
- *       indirection (~10% on hit), landing near {@code HashSet}. Off the hot path that cost is
- *       fine; on it, prefer {@code Support}.
- *   <li>{@link java.util.Set#copyOf} ({@code SetN}, the compact array-backed form the agent uses
- *       for fixed config sets) is ~1.2x behind {@code Support} on hit — but it is the most
- *       <i>compact</i> (~27% smaller than StringIndex per the JOL test): StringIndex pays for its
- *       cached {@code int[]} hashes + the 2x-oversized table. So StringIndex's edge over {@code
- *       SetN} is speed + the {@code indexOf}-&gt;parallel-array capability, NOT footprint; vs
- *       {@code HashSet} it wins on both.
- *   <li>{@code array} / {@code sortedArray} / {@code treeSet} scan, binary-search, or tree-walk per
- *       lookup, so they trail the hashed structures, most visibly on miss.
+ *       indirection (~10% on hit), landing near {@code HashSet} — fine off the hot path, prefer
+ *       {@code Support} on it.
+ *   <li>{@link java.util.Set#copyOf} ({@code SetN}, the agent's compact fixed-set form) is ~1.2x
+ *       behind {@code Support} on hit but the most <i>compact</i> (~27% smaller — no cached hashes,
+ *       no 2x table). So StringIndex's edge over {@code SetN} is speed + the {@code
+ *       indexOf}-&gt;parallel-array capability, not footprint; over {@code HashSet} it wins both.
+ *   <li>{@code array} / {@code sortedArray} / {@code treeSet} trail the hashed structures, most on
+ *       miss.
  * </ul>
  *
  * <p><b>Caveat — the instance {@code stringIndex} miss is bimodal across forks</b> (confirmed at

internal-api/src/main/java/datadog/trace/util/StringIndex.java

@@ -8,21 +8,19 @@
 /**
  * Flat open-addressed name set. Generic — it knows only names.
  *
- * <p>Three ways to use it, trading convenience for indirection:
+ * <p>Two ways to use it, trading convenience for indirection:
  *
  * <ul>
  *   <li>{@link Support} — static algorithm over <b>raw arrays</b>. Keep the arrays in your own
  *       (ideally {@code static final}) fields and the JIT folds the refs to constants. The fastest
  *       path; nothing to dereference.
- *   <li>{@link Data} — a <b>build-time carrier</b> for the placed {@code {hashes, names}} returned
- *       by {@link Support#create}. Pull its fields into your own and discard it.
  *   <li>The {@code StringIndex} <b>instance</b> ({@link #of}) — a convenience wrapper holding the
  *       arrays; {@link #indexOf}/{@link #contains} delegate to {@link Support}. Costs an
  *       instance-field load per call (the indirection the static path removes) — fine off the hot
  *       path.
  * </ul>
  *
- * <p>Consumers attach their own parallel payload arrays (ids, values, ...) sized to {@link #slots}
+ * <p>Consumers attach their own parallel payload arrays (ids, values, ...) sized to {@link #numSlots()}
  * and indexed by the slot {@code indexOf} returns. {@code mapValues}/{@code mapIntValues}/{@code
  * mapLongValues} build such an array at construction; {@code lookup}/{@code lookupOrDefault} read
  * one back in a single call (slot resolve + array read).
@@ -43,12 +41,10 @@
 public final class StringIndex {
   private final int[] hashes;
   private final String[] names;
-  public final int slots; // == hashes.length
 
   private StringIndex(int[] hashes, String[] names) {
     this.hashes = hashes;
     this.names = names;
-    this.slots = hashes.length;
   }
 
   /**
@@ -69,8 +65,8 @@ public boolean contains(String name) {
   }
 
   /** Table size — allocate parallel payload arrays of this length. */
-  public int slots() {
-    return this.slots;
+  public int numSlots() {
+    return hashes.length;
   }
 
   // --- value mapping: build a slot-aligned parallel array (off the hot path) ---
@@ -250,6 +246,11 @@ public static int indexOf(int[] hashes, String[] names, String name) {
       return indexOf(hashes, names, name, hash(name));
     }
 
+    /** Number of slots — the length to size parallel payload arrays to. */
+    public static int numSlots(int[] hashes) {
+      return hashes.length;
+    }
+
     /** {@code data[indexOf(...)]}, or {@code null} when {@code key} is absent. */
     public static <T> T lookup(int[] hashes, String[] names, T[] data, String key) {
       int slot = indexOf(hashes, names, key);

internal-api/src/test/java/datadog/trace/util/StringIndexTest.java

@@ -35,7 +35,7 @@ void tableSizeFor_isPow2_andOversized() {
   void instance_contains_internedAndCopy_andMiss() {
     StringIndex set = StringIndex.of("foo", "bar", "baz");
 
-    assertEquals(8, set.slots()); // 3 names -> tableSizeFor(3) == 8
+    assertEquals(8, set.numSlots()); // 3 names -> tableSizeFor(3) == 8
 
     assertTrue(set.contains("foo")); // interned literal -> == fast path in eq
     assertTrue(set.contains(new String("bar"))); // non-interned -> .equals path
@@ -106,7 +106,7 @@ void mapIntValues_slotAligned_andLookup() {
     StringIndex idx = StringIndex.of("a", "b", "c");
     // 1-based ids; 0 stays the empty-slot / not-found sentinel.
     int[] ids = idx.mapIntValues(s -> s.charAt(0) - 'a' + 1);
-    assertEquals(idx.slots(), ids.length); // sized to the table, not the name count
+    assertEquals(idx.numSlots(), ids.length); // sized to the table, not the name count
 
     assertEquals(1, idx.lookup(ids, "a"));
     assertEquals(2, idx.lookup(ids, "b"));