[fglock]

Summary

Reduces per-match regex overhead in the hot path ($i =~ /42/ benchmark).
Async-profiler showed the Joni regex engine was only ~2% of CPU — the gap
was in runtime plumbing: ThreadLocal operations, object allocations, redundant
lookups.

Round 1 — +67% throughput

• Short-circuit emitWarningsOnUse when warning list is empty (saves 4 ThreadLocal reads/match)
• Guard ACTIVE_DEBUG_MODE save/restore behind lexicalDebugMode != 0 (saves 2 ThreadLocal ops/match)
• Defer RuntimeList allocation to LIST context only (eliminates allocation in SCALAR path)
• Eliminate double resolveRegex call in matchRegex → matchRegexDirect
• Use matcherNoRegion and pre-allocate captures Region in JoniRegexPattern
• Skip package/source-lifecycle save/restore when values unchanged

Round 2 — +101% total throughput

• Eliminate Integer boxing in callsite warning ThreadLocals (int[]/String[] holders)
• Use callsiteId directly as regex cache key, removing string-concatenation and extra HashMap lookup
• Pass regexState to capture-group update methods to avoid redundant state() ThreadLocal calls
• Cache regexState in updateReplacementMatchState (was calling state() 8+ times)

Round 3 — +111% total throughput

• Skip expensive buildCharToByte/buildByteToChar for ASCII-only strings (identity mapping)
• Inline warningsOnUse.isEmpty() check at call sites to avoid method call overhead
• Check regex callsite cache before reading package/lifecycle ThreadLocals, saving 2 TL reads per match

Benchmark results

dev/bench/benchmark_regex.pl — $i =~ /42/ in 400-iteration loop, 100k calls:

	Rate (iterations/s)	vs native Perl
Baseline	~10,453/s	3.8x slower
Round 1	~17,430/s	2.3x slower
Round 2	~21,000/s	1.9x slower
Round 3	~22,100/s	1.8x slower
Native Perl	~39,683/s	—

Test plan

• make — all unit tests pass (all 3 rounds)
• Benchmark shows consistent improvement across multiple runs
• Async-profiler confirms overhead reduction in targeted methods

Closes #1904

🤖 Generated with Claude Code