perf(avro): one cached name index per schema, not a scan per case field (#103)

[kryptt]

PR #98's nominal rung is correct and stays correct. This PR changes only what it costs.

Closes #103. #105 has landed on main (squash 75c7eaa); this branch is rebased onto main and its diff is its own work only.

The mechanism

AvroWalk.totalNominalIndex calls nominalIndex once per case field. nominalIndex tries Avro's
exact-name hash and, on a miss, linear-scans every schema field calling sameFieldName — with
no early exit, deliberately, because it has to see a second match before it can call a name
ambiguous.

So a drilled hop costs arity x fields.size x nameLength. And the bill lands on exactly the
population the rung exists for: a name transform (withSnakeCaseFieldNames, a custom
transformFieldNames, a vulcan.Codec rename map) guarantees the exact-name miss, while an
identity-named codec answers from the hash and never scans at all — and was already resolving
correctly by position before #98 existed.

Two multipliers on top: the work is redone per drilled hop (a k-hop chain into one record pays
k times) and a def-shaped or parameterised-given optic re-resolves per operation.

The fix. One O(n) pass over the record's fields builds a normalisedName -> position index;
each case field is then one lookup. The index is cached per record schema, so the k-hop chain and
the per-operation re-resolution both pay once.

Two details worth naming:

• The exact-name hash stays the first rung, untouched and allocation-free. An identity-named
  codec never builds or consults an index, so the control path is bit-for-bit what it was — and its
  allocation count is measured byte-identical. The transformed path pays for the time it saves:
  see It trades bytes for time.
• Normalisation is per-CHARACTER (Character.toLowerCase), not String.toLowerCase. The latter
  is locale-sensitive and can change a string's length (U+0130 lower-cases to two chars), so it
  would not agree with the pairwise cursor walk it replaces. Per-char keeps the key exactly as
  discriminating as sameFieldName was.
• Ambiguity detection is preserved and merely moved. A normalised key already present while
  building the index is the same signal the scan produced on its second hit — detected once per
  schema instead of once per query.

Before / after

Correction to an earlier revision of this section. It claimed the cold column improved at
n=2 (3,230 -> 2,690 ns). It does not, and the change's own cost spec says so: building the index
costs more than the scan it replaces when there is almost nothing to scan, so the first
resolution against a one- or two-field record is slower. Everything below is re-measured —
min of 25 trials, both implementations timed in the same JVM (the frozen pre-index rung is kept in
the test tree as NominalResolutionOracle), schema construction outside the clock — and the
regression is stated rather than averaged away.

ns per resolution:

codec shape	fields	warm before	warm after	cold before	cold after
identity-named	2	34	36	108	107
identity-named	12	194	196	289	256
identity-named	66	2,128	2,122	5,902	4,067
snake_cased	2	490	224	605	757
snake_cased	12	17,271	1,361	18,367	3,963
snake_cased	66	496,939	8,745	500,700	20,466

warm = repeated resolution against one schema (what a def-shaped or parameterised-given optic
pays per operation); cold = first resolution against each of 200 never-before-seen schemas,
index build included.

The cold path regresses on small records

Median of 25 trials, snake_cased, two independent runs of the same harness:

fields	cold before	cold after	delta
1	147 / 148	434 / 395	+287 / +247 ns	2.7-3.0x slower
2	719 / 723	831 / 765	+113 / +41 ns	1.1-1.2x slower
3	1,339 / 1,320	1,126 / 1,169	-213 / -151 ns	crossover
4	2,296 / 2,294	1,538 / 1,518	-758 / -776 ns	1.5x faster
6	4,944 / 5,976	2,142 / 2,364	-2.8 / -3.6 us	2.3-2.5x faster

Crossover at n=3. The penalty is bounded and one-time: a few hundred nanoseconds per schema,
paid on the first hop and amortised over every hop after it, against a 24x cold and 57x warm win at
n=66. The trade is obviously right — it is here because the section previously asserted the
opposite.

It trades bytes for time, and only on the transformed path

The sameFieldName cursor walk it replaces was allocation-free by design; normalisedName
materialises a String per case field per resolution. Deterministic counts, via
com.sun.management.ThreadMXBean.getThreadAllocatedBytes, identical across repeat runs:

codec shape	fields	B/resolution before	B/resolution after
identity-named	2 / 12 / 33 / 66	24 / 64 / 152 / 280	24 / 64 / 152 / 280	unchanged, as claimed
snake_cased	2	24	256	+104 B per case field
snake_cased	12	64	1,336	+104 B per case field
snake_cased	33	152	3,608	+104 B per case field
snake_cased	66	280	7,168	+104 B per case field

The identity-named row is the whole of what that path allocates: the out array, 16 B of header
plus 4 B per case field, and nothing else. It is the control, and it did not move.

This is per operation for a def-shaped or parameterised-given optic, not construction-time
only, so it is nursery traffic on the hot path — and "B/op gates, ns/op advises" is this repo's own
benchmark doctrine, so a future gate will see it. ~490 us of CPU for ~8 KB of nursery at n=66 is
the right way round, but it belongs on the record, not in a test comment.

Correction. An earlier revision of this section said the index lookup had been hoisted out of
the per-case-field loop and measured byte-for-byte unchanged. Half of that was wrong, and the
numbers above are the post-hoist ones. The hoist is now in (perf(avro): resolve the name index once per resolution): the index is threaded through the @tailrec loop as a recursion parameter
rather than re-fetched per case field, which removes one ConcurrentHashMap probe and one
throwaway SchemaQuery key per case field beyond the first. Measured saving: exactly
(arity - 1) x 24 B at every size — 24 B at n=2, 1,560 B at n=66 — so the key was not being
scalar-replaced by escape analysis, contrary to what "byte-for-byte unchanged" implied. Net
-17.9% on the transformed path at n=66.

Threaded, not hoisted above the loop: hoisting would make the identity-named codec fetch an index
it never reads, and that path has to stay exactly as it is.

What the hoist does not do is close the regression, and that half was right: the normalised
String is the remaining ~104 B per case field. Closing it properly means probing the index by a
cursor-computed hash of the normalised name and confirming the candidate with the old
allocation-free pairwise comparison — a larger change than #103 asked for, and deliberately not
taken here.

Both costs are now stated in the CHANGELOG and in the scaladoc beside the code that pays them.

The shape changed, which is the actual claim:

ratio	before	after	linear	quadratic
t(2n) / t(n), snake_cased	3.97	2.2	~2	~4
t(4n) / t(n), snake_cased	15.44	5.1	~4	~16
snake_cased / identity-named at n=66	242x	4.0x

Identity-named fast path: unchanged. Warm is flat to within a few nanoseconds at every size and
the allocation count is byte-identical; the code path is provably untouched, since the index is
reached only from the exact-miss branch.

Cache effectiveness. First hop into a schema (cold, n=66 snake) 20,466 ns; second and every hop
after (warm) 8,745 ns, with the index instance identical across hops —
NominalNameIndexCacheSpec pins that by reference (beTheSameAs), so "a k-hop chain rebuilds k
times" is refuted deterministically rather than by timing.

The verdict diff — empty

This is the load-bearing correctness step: a cost rewrite of a resolution rule is only safe if it
is verdict-identical, and "the suite is still green" cannot show that — an example pins one cell,
while the rung's semantics are a function over (schema, case-field list, declaration index).

NominalResolutionOracle is a verbatim copy of #98's implementation, frozen in the test tree.
NominalResolutionParitySpec diffs the live rung against it over two corpora:

=== nominal verdict diff, real fixtures (case field -> schema field, or ABSTAIN) ===
  Three                schema{a,computed,b,c}
    a                was a                now a               same
    b                was b                now b               same
    c                was c                now c               same
  Pair                 schema{beta,alpha}
    alpha            was alpha            now alpha           same
    beta             was beta             now beta            same
  SnakeComputed        schema{click_id,computed,landing_page_id}
    clickId          was click_id         now click_id        same
    landingPageId    was landing_page_id  now landing_page_id same
  ...
  Tw                   schema{userId_,user_id}
    userId           was ABSTAIN          now ABSTAIN         same
    tag              was ABSTAIN          now ABSTAIN         same
  mismatches: 0
=== nominal verdict diff, synthetic: 259 schemas x 585 case-name lists (151515 pairs, every declIdx in [-1..arity]) ===
  mismatches: 0

• Exhaustive synthetic: every ordered schema-field list of length 1-3 over a pool of
  deliberately confusable names (a, A, _a, a_b, ab, aB, b — exact, case and separator
  collisions), crossed with every case-name list of length 0-3 over that pool plus one unmatched
  name, crossed with every declIdx in [-1..arity]. Duplicated case names included, because a
  duplicate is the sharpest injectivity probe.
• Real fixtures: every codec behind DivergentCodecs, ResolutionFalsePositiveSpec,
  AvroNominalResolutionSpec and ResolutionResidualSpec — 27 codecs, printed field by field.

Each semantic that was easy to lose is also pinned as its own named example, so a failure says
which rule broke rather than printing a synthetic triple:

semantic	existing coverage	added
exact name beats a normalised match elsewhere	implied by Doc / Acct	explicit example
more than one normalised match => ambiguous, never first-wins	ResolutionResidualSpec at3 (Tw)	explicit example on a 3-field record
arity > record.getFields.size short-circuits	FpRow, FpClick	explicit example
injectivity across the WHOLE case-field list	FpVisit (partial: not-total, not not-injective)	added — two case fields normalising onto one schema field, both abstain
empty caseNames (NamedTuple parent)	ThreeNt indirectly	explicit example
declIdx < 0 or >= arity	none	added

Two were genuinely uncovered before: whole-list injectivity (the suite had "not total" fixtures
but no "not injective" one) and the out-of-range declIdx guard.

Cache design, and the leak story

A ConcurrentHashMap side table keyed on the schema's reference identity behind weak keys.

• Identity, not Schema as the key. Schema.equals is deep-structural — a record compares
  every field, recursively — and Schema is mutable: addProp resets its cached hash. A
  structural key would pay a deep compare per lookup and could lose an entry when a schema is
  annotated after insertion. (Verified against the Avro 1.11/1.12 sources: hashCode() memoises
  into a field that addProp invalidates; RecordSchema.equals walks the field list.)
• Not Avro's own per-schema property storage, which was the obvious slot to check first, as the
  issue asked. Refuted: a prop is part of Schema.equals, of toString, and of the JSON and
  canonical forms — parking a cache there would change what the schema serialises as, and
  therefore its fingerprint. Hence a side table.
• Weak, not bounded. Schemas are usually module-level and immortal, where the two are
  equivalent; but a registry client resolving writer schemas per message would leak them forever
  under a strong map, or thrash under a bound. Weak keys make the entry's lifetime the schema's own.
  The cached value holds no reference back to the schema — only Strings copied out of the field
  names — so the entry is genuinely collectable, and cleared keys are drained from a
  ReferenceQueue on the next cache miss (never on the hot path). NominalNameIndexCacheSpec
  proves the no-retention claim by resolving through a schema, dropping every strong reference, and
  watching it be collected.
• Lookups use a plain throwaway query key (not a WeakReference), so a cache hit costs no GC
  registration; the stored key is the weak one, and equals checks reference identity first so a
  cleared key can still be removed by the purge.

Scaladoc

Three additions.

One sentence on the nominal rung's known-residual note, per the investigation that settled it:
neither the record's schema name nor its parsing fingerprint can detect the residual — the
residual pair is two renamed, swapped columns of the same physical type inside one record, so both
candidate readings carry the same fullname and the same fingerprint by construction, and a
schema-derived value only ever sees one of the two operands a comparison would need. The only
mechanism that reaches the class is the differential codec probe, #100. This is there to stop the
idea being re-proposed.

And the pre-index's two costs, stated beside the code that pays them: the ~104 B per case field the
normalised key materialises on a miss, and the small-n cold regression with its crossover at
n=3.

Review pass: three fixes on top of the green PR

Three independent audit lenses read the pre-index. All three findings were real; two were code, one
was a policy call.

1. The cache probe was still per case field

The multiplier #103 exists to remove had survived one level down. totalNominalIndex asked a
per-case-field helper for each name, and every helper call that missed the exact-name hash called
normalisedNameIndex, which probes the cache with a freshly allocated SchemaQuery. On the
transformed path every exact lookup misses by construction, so at arity 66 that is 66 CHM probes
and 66 throwaway keys per resolution, all answering with the same map.

Fixed by threading the resolved index through the @tailrec loop. The exact-name rung is untouched
and still first. Numbers in the allocation section above; the identity path is byte-identical.

2. normalisedNameIndex handed out the live mutable map

private[avro] is a Scala-only fence — the method is public in bytecode — and what it returned was
the live java.util.HashMap sitting in a process-wide, per-schema cache. One put on that
reference silently and permanently corrupts field resolution for that schema for the life of the
JVM: wrong slot, valid wire bytes, no error.

Now wrapped in Collections.unmodifiableMap, with the wrapper stored in the cache so the wrap
is one allocation per schema rather than one per lookup. NominalNameIndexCacheSpec pins instance
identity with beTheSameAs and still passes unchanged against the stored wrapper — no test needed
weakening.

3. Wall-clock assertions gated the whole CI matrix

NominalResolutionCostSpec put three timing-ratio assertions into the always-run root sbt test,
so they gated the temurin@17 / @21 / @25 matrix on shared GitHub runners. That contradicts this
repo's own standing rule — a nanosecond on a shared box is +/-15-50%, only B/op and within-run
ratios are load-bearing, which is why timing claims live in the JMH pipeline. The margins are
healthy, but 2n/n's bound of 3.0 against a measured 2.18 is a 38% excursion from turning the whole
matrix red for a reason unrelated to the diff under test. (Worth noting: the tightest bound is
2n/n, not the snake/identity one with the noisy denominator.)

Chosen: run them under the quality workflow. The three assertions are armed by
-Deo.costGate=true and skip — visibly, with the reason printed — without it. quality.yml arms
them in a job of its own, not a step in the coverage+mutation job: a timing flake must not abort
that sweep and cost the tag its QA artifacts, a runner doing nothing else is the only place a
wall-clock ratio means anything, and a separate job never sees scoverage-instrumented bytecode,
which would make any timing meaningless. It is the one gate in a workflow that is otherwise all
reports, and it is isolated accordingly. Nothing is weakened: same sizes, same bounds, same
interleaving. The table above them still prints on every lane, gates nothing, and costs ~4 s. An
explicit discarded warm-up over all three sizes was added too, since the gate no longer runs right
after the table that used to warm it.

Rejected — widen and keep in the default lane. The widening would have to survive an arbitrarily
contended runner, at which point the assertion stops separating linear from quadratic, and it
leaves a clock on the critical path of every diff in the repo.

Rejected — replace with a non-timing assertion. Preferred, and searched for first; it does not
exist. The deterministic halves of the claim are already pinned (NominalNameIndexCacheSpec pins
one index instance per schema and no rebuild across resolutions; NominalResolutionParitySpec pins
every verdict). What is left is "how much work per case field", which is not observable from
outside the method: Schema's constructors are package-private so it cannot be subclassed to count
field accesses, and an internal probe counter would put mutable state on the hot path this issue
exists to make cheap. Allocated bytes — deterministic here, and this repo's other load-bearing
metric — cannot see the regression that matters either: the quadratic scan allocated less than
the index does (280 B vs 7,168 B at n=66), so a return to it would read as an improvement. The
reasoning is recorded in the spec's scaladoc so it is not re-searched.

Also

One stale comment: the parity spec's injectivity example described a, _a and A, none of which
appear in it. Rewritten to describe the actual fixture — two case fields normalising onto one schema
field, so the map is non-injective and the rung abstains entirely rather than letting the first one
win. The example was and is correct.

Gates

JDK 25 (Gentoo Temurin 25.0.4.1), so the kyo module was in the root aggregate
(KyoOpticsSpec ran).

gate	result
sbt compile	pass
sbt test (root aggregate, incl. kyo)	pass — 878 examples, 0 failures, 2 skipped
sbt avroIntegration/test	pass — 228 examples, 226 passed, 2 skipped
sbt benchmarks/compile	pass
sbt mimaReportBinaryIssues	pass (vacuous: mimaPreviousArtifacts is empty on every module in this branch state)
sbt docs/mdoc; docs/laikaSite	pass
sbt scalafmtCheckAll; scalafixAll --check; scalafmtSbtCheck; benchmarks/scalafmtCheck	pass, run last

The 2 skipped are the cost spec's ratio examples, disarmed as described above. The example count is
unchanged at 878 — nothing was deleted, the two assertions moved lanes.

The verdict diff was re-run after the resolution-path change and is still empty: 151,515
synthetic cells plus every real fixture, zero mismatches.

Every gate above was re-run after the correction pass (which touched the CHANGELOG, two scaladoc
blocks and two commit messages) and the format gate ran last, clean, with no files rewritten.

One thing worth knowing: scalafmtCheckAll reported success once from a stale cache while three
test files were in fact unformatted. It reproduced on the review pass — a check run straight after a
format run reads the cache that run just wrote and examines almost nothing. The final gate here was
therefore run with every target/streams/*/scalafmt* and */scalafix* cache deleted first, so all
22 source groups (Compile + Test for every module, avro included) were genuinely re-read: clean.
Also worth knowing: scalafixAll and scalafmtAll disagree about a trailing comma in a multi-line
import — scalafix removes what scalafmt accepts — so the two must be run in that order, not one or
the other.

Commits

1. test(avro) — the RED harness. Fails on the current implementation with 2n/n = 3.97, 4n/n =
   15.44 and 472,474 ns per resolution at 66 snake_cased fields.
2. perf(avro) — the pre-index and its cache.
3. docs(avro) — the residual sentence, the cost disclosures (allocation and the small-n cold
   regression), and the CHANGELOG entry.

Review pass, one commit per finding:

4. perf(avro) — resolve the name index once per resolution, not per case field.
5. fix(avro) — hand out an unmodifiable view of the cached name index.
6. docs(avro) — the injectivity comment describes the example below it.
7. test(avro) — arm the wall-clock cost ratios only where a clock means something.
8. docs(changelog) — the measured per-field cost, and the unmodifiable index view.

Out of scope on purpose: no alias rung (#104), no new resolution rungs, no refactors the pre-index
did not need.

🤖 Generated with Claude Code

https://claude.ai/code/session_0194EHFR4NamCpTHiqy7B74V

[github-actions]

🚀 Cloudflare Pages preview for perf/nominal-preindex-103 is live:

https://573af685.cats-eo-docs.pages.dev

Branch alias: https://perf-nominal-preindex-103.cats-eo-docs.pages.dev

_{Built from commit d9e4ddaebc15dca435c5f63840bbdcf03f3ce4d2 · updated on every push.}

[github-actions]

Benchmark A/B

Allocation (B/op) — authoritative

Benchmark	params	base	head	Δ
OrderAvroBench.eoModifyNames	size=8	2,160.0	1,992.0	-7.8%
AvroJsonBridgeBench.eoWideToJson	-	1,472.0	1,408.0	-4.3%
AvroVulcanBench.encode_bridged	-	1,224.0	1,240.0	+1.3%
OrderAvroBench.monocleModifyNames	size=8	5,448.0	5,400.0	-0.9%
AvroBytesBench.eoModifyPartner	-	3,272.0	3,256.0	-0.5%
AvroJsonBridgeBench.eoClickToAvro	-	9,400.0	9,368.0	-0.3%
OrderAvroBench.naiveModifyStreet	size=64	20,856.2	20,880.2	+0.1%
OrderAvroBench.naiveModifyNames	size=64	27,912.2	27,936.3	+0.1%
OrderAvroBench.monocleReadStreet	size=512	69,797.9	69,765.6	-0.0%
OrderAvroBench.monocleModifyStreet	size=512	169,072.9	169,084.6	+0.0%
OrderAvroBench.eoModifyNames	size=512	97,408.0	97,405.4	-0.0%
OrderAvroBench.naiveModifyNames	size=512	226,288.4	226,287.3	-0.0%
OrderAvroBench.naiveReadStreet	size=512	69,797.8	69,797.5	-0.0%
OrderAvroBench.monocleModifyNames	size=64	39,866.8	39,866.7	-0.0%
OrderAvroBench.naiveModifyStreet	size=512	169,060.9	169,061.0	+0.0%
OrderAvroBench.monocleModifyNames	size=512	382,757.3	382,757.5	+0.0%
OrderAvroBench.eoModifyStreet	size=512	328.0	328.0	-0.0%
OrderAvroBench.monocleReadStreet	size=64	8,848.1	8,848.1	-0.0%
OrderAvroBench.eoReadStreet	size=512	88.0	88.0	+0.0%
AvroJsonBridgeBench.naiveWideToJson	-	4,376.0	4,376.0	-0.0%

38 more benchmarks

Benchmark	params	base	head	Δ
AvroBytesBench.prunedReadCountry	-	1,976.0	1,976.0	-0.0%
AvroBytesBench.naivePassthroughPayload	-	10,600.1	10,600.1	+0.0%
AvroVulcanBench.fieldGet_bridged	-	432.0	432.0	+0.0%
OrderAvroBench.eoModifyStreet	size=64	328.0	328.0	-0.0%
AvroBytesBench.naiveReadCountry	-	4,256.0	4,256.0	-0.0%
AvroBytesBench.prunedReadPartner	-	1,592.0	1,592.0	+0.0%
OrderAvroBench.monocleModifyStreet	size=64	20,904.2	20,904.2	+0.0%
OrderAvroBench.eoModifyNames	size=64	12,560.1	12,560.1	-0.0%
AvroVulcanBench.fieldGet_native	-	432.0	432.0	-0.0%
OrderAvroBench.monocleReadStreet	size=8	1,208.0	1,208.0	-0.0%
OrderAvroBench.eoReadStreet	size=8	88.0	88.0	-0.0%
AvroJsonBridgeBench.eoClickToJson	-	4,000.0	4,000.0	-0.0%
AvroJsonBridgeBench.naiveClickToJson	-	4,696.0	4,696.0	-0.0%
OrderAvroBench.naiveModifyNames	size=8	3,752.0	3,752.0	-0.0%
AvroBytesBench.naiveModifyCountry	-	7,616.0	7,616.0	+0.0%
AvroBytesBench.naiveReadPartner	-	4,264.0	4,264.0	-0.0%
OrderAvroBench.naiveReadStreet	size=8	1,208.0	1,208.0	-0.0%
OrderAvroBench.eoModifyStreet	size=8	328.0	328.0	-0.0%
AvroBytesBench.eoReadPartner	-	480.0	480.0	-0.0%
OrderAvroBench.naiveReadStreet	size=64	8,848.1	8,848.1	-0.0%
AvroJsonBridgeBench.naiveWideToAvro	-	3,504.0	3,504.0	-0.0%
AvroVulcanBench.rootGet_bridged	-	1,472.0	1,472.0	-0.0%
AvroJsonBridgeBench.naiveClickToAvro	-	3,928.0	3,928.0	+0.0%
OrderAvroBench.monocleModifyStreet	size=8	2,992.0	2,992.0	-0.0%
OrderAvroBench.eoReadStreet	size=64	88.0	88.0	-0.0%
AvroBytesBench.naiveModifyPartner	-	7,536.0	7,536.0	+0.0%
AvroVulcanBench.decode_bridged	-	880.0	880.0	-0.0%
AvroVulcanBench.decode_native	-	48.0	48.0	+0.0%
AvroVulcanBench.decode_vulcanRaw	-	880.0	880.0	-0.0%
AvroBytesBench.eoReadCountry	-	520.0	520.0	+0.0%
AvroVulcanBench.encode_native	-	56.0	56.0	+0.0%
AvroBytesBench.eoGraftPayload	-	720.0	720.0	+0.0%
AvroJsonBridgeBench.eoWideToAvro	-	6,584.0	6,584.0	+0.0%
AvroBytesBench.eoModifyCountry	-	3,200.0	3,200.0	-0.0%
OrderAvroBench.naiveModifyStreet	size=8	2,968.0	2,968.0	+0.0%
AvroVulcanBench.encode_vulcanRaw	-	1,224.0	1,224.0	-0.0%
AvroVulcanBench.rootGet_native	-	600.0	600.0	-0.0%
AvroBytesBench.eoSliceGraftPayload	-	1,192.0	1,192.0	+0.0%

Timing (ns/op) — directional only, same-VM but shared runner

Benchmark	params	base	head	Δ
OrderAvroBench.monocleReadStreet	size=512	29,098.8	22,448.2	-22.9%
OrderAvroBench.naiveModifyStreet	size=64	5,555.1	6,351.6	+14.3%
OrderAvroBench.naiveModifyNames	size=64	7,026.4	7,787.6	+10.8%
AvroVulcanBench.fieldGet_bridged	-	84.6	91.9	+8.6%
AvroVulcanBench.fieldGet_native	-	90.2	84.5	-6.3%
OrderAvroBench.eoModifyNames	size=512	33,502.8	31,437.6	-6.2%
OrderAvroBench.monocleModifyNames	size=8	1,422.6	1,335.9	-6.1%
AvroJsonBridgeBench.naiveWideToJson	-	1,667.0	1,584.8	-4.9%
OrderAvroBench.eoModifyNames	size=8	562.5	539.2	-4.1%
OrderAvroBench.naiveModifyNames	size=8	1,043.5	1,018.4	-2.4%
AvroBytesBench.naivePassthroughPayload	-	3,942.5	4,021.3	+2.0%
AvroBytesBench.naiveReadCountry	-	1,458.4	1,429.8	-2.0%
AvroVulcanBench.encode_bridged	-	208.4	212.5	+2.0%
OrderAvroBench.monocleReadStreet	size=8	449.5	440.9	-1.9%
AvroJsonBridgeBench.naiveClickToJson	-	2,536.9	2,490.1	-1.8%
AvroBytesBench.prunedReadCountry	-	822.2	807.1	-1.8%
OrderAvroBench.monocleReadStreet	size=64	3,708.9	3,647.4	-1.7%
AvroVulcanBench.decode_bridged	-	187.1	184.0	-1.7%
OrderAvroBench.naiveReadStreet	size=8	448.7	441.5	-1.6%
AvroJsonBridgeBench.eoClickToJson	-	2,608.0	2,567.9	-1.5%
AvroBytesBench.prunedReadPartner	-	584.2	593.1	+1.5%
AvroBytesBench.eoSliceGraftPayload	-	268.7	272.8	+1.5%
OrderAvroBench.eoModifyStreet	size=8	119.2	117.5	-1.5%
AvroVulcanBench.rootGet_bridged	-	357.5	352.5	-1.4%
AvroJsonBridgeBench.naiveWideToAvro	-	1,152.4	1,136.6	-1.4%
AvroVulcanBench.decode_vulcanRaw	-	181.5	179.3	-1.2%
OrderAvroBench.eoModifyStreet	size=64	119.0	117.6	-1.2%
AvroBytesBench.naiveModifyCountry	-	2,554.3	2,584.4	+1.2%
OrderAvroBench.naiveReadStreet	size=512	28,952.6	28,612.6	-1.2%
AvroBytesBench.eoModifyCountry	-	592.9	585.9	-1.2%
AvroBytesBench.eoReadPartner	-	178.1	176.2	-1.1%
OrderAvroBench.naiveModifyNames	size=512	60,119.2	60,781.4	+1.1%
OrderAvroBench.monocleModifyNames	size=512	92,317.6	93,306.0	+1.1%
OrderAvroBench.monocleModifyStreet	size=8	881.9	872.7	-1.0%
AvroBytesBench.naiveReadPartner	-	1,635.4	1,618.9	-1.0%
OrderAvroBench.monocleModifyStreet	size=64	6,332.3	6,389.8	+0.9%
OrderAvroBench.eoModifyNames	size=64	3,844.7	3,812.5	-0.8%
AvroBytesBench.eoModifyPartner	-	641.7	636.4	-0.8%
AvroJsonBridgeBench.naiveClickToAvro	-	1,535.1	1,547.3	+0.8%
AvroVulcanBench.decode_native	-	15.0	15.1	+0.7%
AvroVulcanBench.encode_native	-	12.2	12.3	+0.7%
OrderAvroBench.naiveModifyStreet	size=512	48,825.6	49,101.7	+0.6%
AvroJsonBridgeBench.eoWideToAvro	-	1,343.1	1,349.9	+0.5%
AvroJsonBridgeBench.eoClickToAvro	-	3,374.4	3,391.2	+0.5%
AvroVulcanBench.rootGet_native	-	143.2	142.5	-0.5%
AvroVulcanBench.encode_vulcanRaw	-	210.1	209.2	-0.4%
OrderAvroBench.monocleModifyStreet	size=512	48,669.7	48,885.1	+0.4%
OrderAvroBench.monocleModifyNames	size=64	9,796.5	9,753.8	-0.4%
AvroJsonBridgeBench.eoWideToJson	-	560.1	557.9	-0.4%
OrderAvroBench.eoModifyStreet	size=512	118.3	117.8	-0.4%
AvroBytesBench.eoReadCountry	-	150.1	150.7	+0.4%
AvroBytesBench.naiveModifyPartner	-	2,771.8	2,780.3	+0.3%
OrderAvroBench.naiveReadStreet	size=64	3,662.9	3,652.4	-0.3%
OrderAvroBench.eoReadStreet	size=8	36.1	36.0	-0.2%
OrderAvroBench.eoReadStreet	size=64	36.1	36.0	-0.2%
OrderAvroBench.eoReadStreet	size=512	36.1	36.1	+0.1%
AvroBytesBench.eoGraftPayload	-	130.9	131.0	+0.1%
OrderAvroBench.naiveModifyStreet	size=8	873.8	873.9	+0.0%

_{base_sha: 75c7eaa712a23c7503b51858dcdfc61347e600c8 · head_sha: d9e4ddaebc15dca435c5f63840bbdcf03f3ce4d2 · jdk: temurin-21 · runner: ubuntu-22.04 · jmh_params: -i 3 -wi 2 -f 1 -t 1 -foe true -prof gc -rf json · profile: pr:-i3-wi2-f1-t1-gc}