Add TagSet + parallel int[] fixed-map option to UnsynchronizedMapBenchmark

Adds get_tagSetMap / get_tagSetMap_sameKey as a build-once, read-only map
option in the map menu: keys in a TagSet, values in a parallel int[] (no
boxing), get is Support.indexOf plus one array load. Fastest get in the
benchmark and the tightest error bars; results captured in the javadoc.

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

Author: dougqh

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

@@ -24,6 +24,10 @@
  *   <li>TreeMap - better for custom Comparators - case-insensitive Maps (see
  *       CaseInsensitiveMapBenchmark)
  *   <li>LinkedHashMap - only when insertion order is needed
+ *   <li>TagSet + parallel value array - for a FIXED (build-once, read-only) map whose key set is
+ *       known up front: the keys go in a {@link TagSet} and the values in a parallel array indexed
+ *       by the slot {@code indexOf} returns. Fastest get, no per-lookup allocation, no node chasing
+ *       - but it can't change after construction (see get_tagSetMap).
  * </ul>
  *
  * <p>TagMap is the preferred way to store tags.
@@ -91,6 +95,23 @@
  * UnsynchronizedMapBenchmark.iterate_tagMap_forEach    thrpt    6   422407681.630 ±  19493455.109  ops/s
  * UnsynchronizedMapBenchmark.iterate_treeMap           thrpt    6   392884747.896 ±  80190674.417  ops/s
  * </code>
+ *
+ * <p>A TagSet + parallel int[] used as a fixed (build-once) map is the fastest get here -- ahead of
+ * HashMap in both the rotating-key and same-key cases -- and the most predictable (±1-2% vs
+ * HashMap's ~5% and TagMap's ~12%). It pays no boxing (int[] values), chases no node, and allocates
+ * nothing per lookup. It only applies when the key set is fixed at construction. <code>
+ * Fixed-map get comparison incl. TagSet + parallel int[] (Apple M1 Max, 8 threads, Java 8 Zulu 8.0.382)
+ *
+ * Benchmark                                          Mode  Cnt           Score          Error  Units
+ * UnsynchronizedMapBenchmark.get_hashMap            thrpt    6  1086382687.356 ±  52784044.910  ops/s
+ * UnsynchronizedMapBenchmark.get_hashMap_sameKey    thrpt    6  1254600761.612 ±  33664831.344  ops/s
+ * UnsynchronizedMapBenchmark.get_linkedHashMap      thrpt    6  1055047178.664 ±  44355203.950  ops/s
+ * UnsynchronizedMapBenchmark.get_tagMap             thrpt    6   906953688.631 ± 112749682.884  ops/s
+ * UnsynchronizedMapBenchmark.get_tagMap_sameKey     thrpt    6  1055399886.424 ± 162974805.646  ops/s
+ * UnsynchronizedMapBenchmark.get_tagSetMap          thrpt    6  1168134502.026 ±  23922240.061  ops/s
+ * UnsynchronizedMapBenchmark.get_tagSetMap_sameKey  thrpt    6  1379540570.008 ±  15177042.759  ops/s
+ * UnsynchronizedMapBenchmark.get_treeMap            thrpt    6   590656771.941 ±  63177685.351  ops/s
+ * </code>
  */
 @Fork(2)
 @Warmup(iterations = 2)
@@ -305,4 +326,39 @@ public void iterate_tagMap_forEach(Blackhole blackhole) {
   public TagMap clone_tagMap() {
     return TAG_MAP.copy();
   }
+
+  // TagSet + a parallel value array used as a FIXED (build-once, read-only) map. The keys are known
+  // up front, so they go in a TagSet and the values in a plain array indexed by the slot that
+  // Support.indexOf returns. There is no node, no Entry, and no per-lookup allocation -- a get is a
+  // hash probe (with an interned == fast path) plus one array load. Pull the Data into your own
+  // static finals (as below) so the hashes/names refs fold to constants -- same static-vs-instance
+  // win SetBenchmark and KeyOfBenchmark measure. The values live in a parallel int[] -- no boxing,
+  // the same primitive-value advantage TagMap.getInt has over a HashMap<String, Integer>, whose
+  // value type structurally forces the box. The trade-off: it cannot change after construction.
+  static final int[] TAG_SET_HASHES;
+  static final String[] TAG_SET_NAMES;
+  static final int[] TAG_SET_VALUES;
+
+  static {
+    TagSet.Data data = TagSet.Support.create(INSERTION_KEYS);
+    int[] values = new int[data.names.length];
+    for (int i = 0; i < INSERTION_KEYS.length; ++i) {
+      values[TagSet.Support.indexOf(data.hashes, data.names, INSERTION_KEYS[i])] = i;
+    }
+    TAG_SET_HASHES = data.hashes;
+    TAG_SET_NAMES = data.names;
+    TAG_SET_VALUES = values;
+  }
+
+  @Benchmark
+  public int get_tagSetMap() {
+    int slot = TagSet.Support.indexOf(TAG_SET_HASHES, TAG_SET_NAMES, nextLookupKey());
+    return slot < 0 ? -1 : TAG_SET_VALUES[slot];
+  }
+
+  @Benchmark
+  public int get_tagSetMap_sameKey() {
+    int slot = TagSet.Support.indexOf(TAG_SET_HASHES, TAG_SET_NAMES, nextLookupKey(INSERTION_KEYS));
+    return slot < 0 ? -1 : TAG_SET_VALUES[slot];
+  }
 }