GH-3499: Cache hashCode() for non-reused Binary instances (up to 73x dictionary-encode speedup)

[iemejia]

Summary

Closes#3499.

Caches Binary.hashCode() per instance for non-reused (immutable-backing) Binary values. Eliminates repeated full-buffer hash recomputation during PLAIN_DICTIONARY encoding, where the same key is hashed many times across a 100k-value page. Reused (mutable-backing) instances skip the cache to preserve their existing semantics.

Uses the java.lang.String.hashCode() idiom — a single int field with sentinel 0 meaning "not yet computed" — so the cache is race-safe without volatile (concurrent first calls compute the same deterministic value; either ordering is correct).

Benchmark

BinaryEncodingBenchmark.encodeDictionary, 100k BINARY values per invocation, JDK 18, JMH -wi 5 -i 10 -f 3 (30 samples per row):

cardinality	stringLength	Before (ops/s)	After (ops/s)	Improvement
LOW	10	13,170,110	20,203,480	+53%
LOW	100	2,955,460	18,048,610	+511%
LOW	1000	300,693	21,933,470	+7193% (72.9x)
HIGH	10	847,657	1,336,238	+58%
HIGH	100	418,327	1,323,284	+216%
HIGH	1000	72,553	1,296,679	+1687% (17.9x)

The relative gain grows with string length (per-call hash work is O(N), cache lookup is O(1)) and with low cardinality (each unique key is hashed many more times).

Negative control: encodePlain (writes Binary without dictionary lookups, so doesn't exercise hashCode) is unchanged within ±2.5% across all parameter combinations. Allocation rate per op (gc.alloc.rate.norm) is identical between baseline and optimized — speedup is pure CPU saved.

Implementation notes

• Single field added: transient int cachedHashCode on Binary (package-private so the three nested subclasses can read it directly on the hot path; inherited private fields are not accessible from nested subclasses without a method-call indirection).
• The cached value is gated on !isBackingBytesReused inside a small package-private cacheHashCode(int) helper that runs only on the cache-miss path.
• 2 new tests in TestBinary:
  • testHashCodeCachedForConstantBinary: constant Binary returns stable hashCode, equal across the three impls (ByteArraySliceBackedBinary, ByteArrayBackedBinary, ByteBufferBackedBinary).
  • testHashCodeNotCachedForReusedBinary: reused Binary returns the new hash after the backing buffer is replaced.

Validation

• parquet-column: 575 tests pass (was 573; +2 new tests for the cache).
• Built with -Dspotless.check.skip=true -Drat.skip=true -Djapicmp.skip=true.

Related

This is the third in a small series of focused performance PRs from work in https://github.com/iemejia/parquet-perf. Previous: #3494 (PlainValuesReader), #3496 (PlainValuesWriter).

How to reproduce the benchmarks

The JMH benchmarks cited above are being added to parquet-benchmarks in #3512. Once that lands, reproduce with:

./mvnw clean package -pl parquet-benchmarks -DskipTests \
-Dspotless.check.skip=true -Drat.skip=true -Djapicmp.skip=true
java -jar parquet-benchmarks/target/parquet-benchmarks.jar 'BinaryEncodingBenchmark.encodeDictionary' \
-wi 5 -i 10 -f 3

Compare runs against master (baseline) and this branch (optimized).

[arouel]

I use a similar optimization already in a patched parquet-column version on my side and verified the improvement.

[iemejia]

Closing in favor of #3566.

I initially submitted a series of small, focused PRs thinking they'd be easier to review. In practice the sheer number (~16 PRs, with more pending) made things harder to follow — even for me. I've regrouped the changes by encoding type / performance area so that each PR is self-contained with its own benchmarks and test coverage, which should make review and performance analysis much more straightforward.

Apologies for the churn. If you've been reviewing this PR, please continue the discussion on #3566 which supersedes it. Thank you.