WIP: Multiplicity — per-runtime isolation for concurrent Perl interpreters

[fglock]

Status: WIP — Implementation complete, pending optimization

The implementation is fully functional and passes all tests:

• make passes (all unit tests green)
• 122/126 unit tests pass with 126 concurrent interpreters (only tie_*.t remain — pre-existing DESTROY TODO)
• Per-runtime isolation for: global variables, I/O handles, regex state, caller stack, dynamic scope, CWD, $$, method caches, special blocks

Pending: Performance optimization before merge. Benchmarks show 5-7% general slowdown from ThreadLocal routing (acceptable), but closure (-34%) and method dispatch (-27%) have larger regressions that should be addressed first. See the optimization plan in dev/design/concurrency.md.

---

Summary

Implements multiplicity for PerlOnJava — a PerlRuntime class with ThreadLocal-based isolation so multiple independent Perl interpreters can coexist within the same JVM process. This follows the JRuby-inspired design in dev/design/concurrency.md (Phases 0-5).

What changed

• PerlRuntime.java — ThreadLocal-based runtime context holder. Each thread gets its own independent Perl interpreter state via PerlRuntime.current().
• All mutable runtime state migrated from static fields into PerlRuntime instance fields:
  • CallerStack — caller() function data
  • DynamicVariableManager — Perl local variable stack
  • RuntimeScalar.dynamicStateStack — dynamic state save/restore
  • SpecialBlock — END/INIT/CHECK blocks
  • RuntimeIO — stdout/stderr/stdin, selected handle, last-accessed handles
  • InheritanceResolver — MRO caches, method cache, overload cache, ISA tracking
  • GlobalVariable — all 17 symbol table maps (variables, arrays, hashes, code refs, IO refs, formats, aliases, etc.)
  • RuntimeRegex — 14 regex state fields ($1, $&, match positions, etc.)
  • RuntimeCode — eval caches, method handle cache, anonymous/interpreted subs
  • 16 local save/restore stacks — GlobalRuntimeScalar, GlobalRuntimeArray, GlobalRuntimeHash, RuntimeGlob, etc.
• Per-runtime CWD — chdir() updates PerlRuntime.current().cwd instead of JVM-global System.setProperty("user.dir")
• Per-runtime $$ — unique PID per interpreter via AtomicLong counter
• Pipe thread binding — background stderr/stdout consumer threads inherit parent PerlRuntime
• Compilation thread safety — ReentrantLock COMPILE_LOCK serializes parsing/emitting

Key design decisions

• Zero API change for callers — Original static method signatures preserved. Methods delegate to PerlRuntime.current() internally.
• Public accessor methods for cross-package access (e.g., GlobalVariable.getGlobalVariablesMap())
• Safety net — PerlLanguageProvider.ensureRuntimeInitialized() prevents "no runtime bound" errors

Benchmark comparison (master vs branch)

Benchmark	Change	Notes
lexical	-4.9%	Within ThreadLocal overhead budget
global	-5.4%	Within ThreadLocal overhead budget
eval_string	-4.8%	Within ThreadLocal overhead budget
regex	-7.0%	Within ThreadLocal overhead budget
string	+6.5%	Improved
closure	-34.1%	Needs optimization (14-17 ThreadLocal lookups/call)
method	-26.9%	Needs optimization (12-14 lookups on cache miss)
memory	unchanged

See dev/design/concurrency.md for the three-tier optimization plan.

Test plan

• make passes (all unit tests)
• 126-interpreter stress test: 122/126 pass
• directory.t + glob.t pass concurrently (CWD isolation)
• io_read.t + io_seek.t + io_pipe.t pass concurrently (PID/pipe isolation)
• Benchmarks run and compared against master
• Optimize closure/method ThreadLocal hotspots (Tier 1-2)
• Re-benchmark after optimization

Generated with Devin