Add FlatHashtable open-addressed find-or-create collection

[dougqh]

From Claude:

A reusable open-addressed, single-array find-or-create table over self-contained entries — one reference per slot, so entry publication is a single reference store and readers see null-or-complete (no torn reads, no volatile/atomics when the payload makes a stale/lost read benign). Pure mechanism; cardinality cap / overflow / live-size counting are caller policy.

Static-polymorphism strategies

The per-use policy is split by concern so each operation asks only for what it needs, and each is held as a concrete-typed static final singleton the JIT devirtualizes and inlines (C++-template-style static polymorphism — one algorithm, one monomorphic instantiation per call site):

• MatchingStrategy<E,K> — key side (get/getOrCreate): matches(entry, key) plus hashKey(key) defaulting to key.hashCode() (override only for custom hashing, e.g. case-insensitive). A @FunctionalInterface.
• HashStrategy<E> — entry side (insert/iterator/resize): hashOf(entry). For Entry-based tables this is the cached Entry.hash, so those get strategy-free overloads.
• EntryStrategy<E,K> — both, the abstract base a do-everything user extends (invokevirtual fallback if inlining ever misses).
• CaseInsensitiveStringStrategy<E> — seals hashKey to Strings.caseInsensitiveHashCode (a new, allocation-free primitive consistent with String.equalsIgnoreCase).
• CreateStrategy<E,K> — cold entry minting (non-capturing lambda / ctor-ref).

The table owns the spread (home — a golden-ratio/Fibonacci mix), so a strategy returns a plain hashCode without pre-mixing; hashKey(key) must stay consistent with hashOf(entry) (trivial when both default to hashCode).

Operations

capacityFor / create (typed backing array via Array.newInstance) with load-factor control — DEFAULT_LOAD_FACTOR (0.5) / LOW_LOAD_FACTOR (0.25) constants + (…, float) overloads; get / getOrCreate; insert (Entry and strategy flavors); resize / resizingInsert (explicit, caller-invoked growth — keeps get/insert resize-free on the hot path); forEach; iterator (hash-filtered).

The iterator is specialized via the same static-polymorphism move (abstract base + final template methods; the Entry overload feeds a constant Entry::hash so hashOf inlines structurally) while keeping the plain Iterator<E> API.

Benchmarks (JMH, Zulu 21)

• Map comparisons (SingleThreadedMapBenchmark / ThreadSafeMapBenchmark): FlatHashtable create/get/iterate vs HashMap/TreeMap/ConcurrentHashMap. A CHA-defeat rig (multiple strategy implementors loaded) confirms the strategy calls devirtualize structurally (from the constant INSTANCE), not via a CHA/type-profile bet — verified with -XX:+PrintInlining. Plain get runs in the billions of ops/s (cached String.hashCode, single probe).
• CaseInsensitiveMapBenchmark: the CI FlatHashtable is ~2× TreeMap at the same zero allocation and matches HashMap's throughput without HashMap's per-lookup toLowerCase garbage (which drives its multi-threaded GC pressure). LOW_LOAD_FACTOR is a wash here (the char-fold dominates, not probe count).
• FlatHashtableIteratorBenchmark: demonstrates why the iterator specialization is robust. @Setup poisons the shared hashOf type profile with several strategy types; the single-strategy general iterator then pays 2.1× (18.1M vs 37.9M ops/s, F5, tight CIs) — HotSpot keeps one per-bci profile shared across all inlining contexts, so unrelated callers pollute it, while the specialized iterator's constant type-flow is immune. Unpoisoned the two tie.

Stacked on #11984 (the @Strategy / @StrategyConsumer markers). Real callers land separately (tick-tock).

🤖 Generated with Claude Code

[dd-octo-sts]

🟢 Java Benchmark SLOs — All performance SLOs passed

Suite	Status
Startup	🟢 pass

SLO thresholds are defined here based on automatically generated metrics. A warning is raised when results are within 5% of the threshold.

PR vs. master results

Scenario	Candidate	master	Δ (95% CI of mean)
startup:insecure-bank:iast:Agent	13.99 s	13.89 s	[+0.0%; +1.3%] (maybe worse)
startup:insecure-bank:tracing:Agent	12.99 s	12.99 s	[-0.7%; +0.7%] (no difference)
startup:petclinic:appsec:Agent	16.84 s	16.54 s	[+0.8%; +2.8%] (maybe worse)
startup:petclinic:iast:Agent	16.84 s	16.90 s	[-1.2%; +0.6%] (no difference)
startup:petclinic:profiling:Agent	16.75 s	16.75 s	[-1.4%; +1.4%] (no difference)
startup:petclinic:sca:Agent	16.90 s	16.68 s	[+0.2%; +2.4%] (maybe worse)
startup:petclinic:tracing:Agent	16.09 s	15.71 s	[-2.0%; +6.8%] (no difference)

Commit: ba5e1c6b · CI Pipeline · Benchmarking Platform UI

---

Load and DaCapo benchmarks can be triggered manually in the GitLab pipeline. Results will appear in the Benchmarking Platform UI after completion.