perf: refcount + Phase-J + walker hardening combined (rebased on master)

AGENTS.md

@@ -20,6 +20,18 @@
 
 ---
 
+## ⚠️ Resource Management: Avoid Fork Exhaustion ⚠️
+
+**Do NOT spawn excessive parallel processes.** Running too many background shells, subagents, or parallel builds at once can exhaust the system's process table (fork bomb), forcing a reboot and losing work.
+
+- **Limit parallel operations**: Run at most 2-3 concurrent processes at a time
+- **Avoid unnecessary background shells**: Use foreground execution when you don't need parallelism
+- **Wait for processes to finish** before starting new ones when possible
+- **Never run `make` in parallel with other heavy processes** (builds already use multiple threads internally)
+- **Clean up**: Kill background shells when they're no longer needed
+
+---
+
 ## Project Rules
 
 ### Progress Tracking for Multi-Phase Work
@@ -60,6 +72,10 @@ Example format at the end of a design doc:
 - Keep docs updated as implementation progresses
 - Reference related docs and skills at the end
 
+### Sandbox Tests
+
+- `dev/sandbox/destroy_weaken/` — Tests for DESTROY and weaken behavior (cascading cleanup, scope exit timing, blessed-without-DESTROY, etc.). Run with `./jperl` or `perl` for comparison.
+
 ### Partially Implemented Features
 
 | Feature | Status |

build.gradle

@@ -231,9 +231,10 @@ tasks.withType(JavaCompile).configureEach {
     options.compilerArgs << '-Xlint:deprecation'
 }
 
-// Test execution configuration with native access
+// Test execution configuration with native access and adequate heap
 tasks.withType(Test).configureEach {
     jvmArgs += '--enable-native-access=ALL-UNNAMED'
+    maxHeapSize = '1g'
 }
 
 // Enable native access for all Java execution tasks

dev/bench/README.md

@@ -0,0 +1,54 @@
+# PerlOnJava microbenchmarks
+
+Tiny workloads to catch per-call / per-op regressions that CPAN test
+suites don't surface cleanly. The headline goal is **parity with
+system `perl`** on every benchmark here (≤ 1.0× wallclock).
+
+## Run
+
+```bash
+# Fast: jperl only (default 3 runs per bench)
+dev/bench/run_baseline.sh
+
+# Side-by-side with system perl (gives ratio + parity marker)
+COMPARE=perl dev/bench/run_baseline.sh
+
+# Other knobs
+BENCH_RUNS=5 dev/bench/run_baseline.sh
+PERL=/opt/homebrew/bin/perl COMPARE=perl dev/bench/run_baseline.sh
+SKIP_LIFE=1 dev/bench/run_baseline.sh
+```
+
+Outputs for `<sha>`:
+
+- `results/baseline-<sha>.json` — machine-readable
+- `results/baseline-<sha>.md`   — human-readable markdown table
+
+With `COMPARE=perl` the markdown has a `ratio` column and a parity
+marker: **✅** (≤1.0×), **≈** (≤1.2×), **❌** (>1.2×).
+
+## Workloads
+
+| File | Measures |
+|---|---|
+| `benchmark_anon_simple.pl` | anon-sub creation churn (no blessing) |
+| `benchmark_closure.pl` | closure capture + invoke |
+| `benchmark_eval_string.pl` | `eval "..."` compile+run overhead |
+| `benchmark_global.pl` | package-global variable access |
+| `benchmark_lexical.pl` | `my` variable access |
+| `benchmark_method.pl` | OO method dispatch (inline cache hot) |
+| `benchmark_refcount_anon.pl` | anon-sub + refcount traffic (plain refs) |
+| `benchmark_refcount_bless.pl` | anon-sub + blessed refs (walker / DESTROY machinery) |
+| `benchmark_regex.pl` | regex compile+match on hot path |
+| `benchmark_string.pl` | concat / substr / index |
+| `benchmark_memory*.pl` | memory footprint (not in the baseline loop) |
+| `examples/life_bitpacked.pl` | real workload (Conway bit-packed) — reports Mcells/s instead of wallclock seconds |
+
+## Historical baselines
+
+`results/` keeps per-sha snapshots. Treat anything before 2026-04-21
+(PR #526 merge) as the old single-column format (jperl-only, no
+`perl` comparison, no markdown).
+
+See [`dev/design/next_steps.md`](../design/next_steps.md) §0 for the
+parity plan and current gap analysis.

dev/bench/benchmark_anon_simple.pl

@@ -0,0 +1,45 @@
+#!/usr/bin/env perl
+# benchmark_anon_simple.pl
+# Measures the overhead of anon array/hash literal construction for
+# SIMPLE elements (no sub/method calls). These paths should skip the
+# MortalList.suppressFlush wrapper entirely after the J2 optimization.
+
+use strict;
+use warnings;
+use Benchmark qw(timethese);
+
+my $N = $ENV{BENCH_N} || 1_000_000;
+
+sub arr_int {
+    my $a = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+    return scalar @$a;
+}
+
+sub arr_str {
+    my $a = [ "one", "two", "three", "four" ];
+    return scalar @$a;
+}
+
+sub arr_var {
+    my ($x, $y) = (10, 20);
+    my $a = [ $x, $y, $x + $y, $x * $y ];
+    return scalar @$a;
+}
+
+sub hash_simple {
+    my $h = { a => 1, b => 2, c => 3, d => 4, e => 5 };
+    return scalar keys %$h;
+}
+
+sub nested_simple {
+    my $x = { a => [1,2,3], b => [4,5,6], c => { x => 10, y => 20 } };
+    return 1;
+}
+
+timethese($N, {
+    'arr_int'       => \&arr_int,
+    'arr_str'       => \&arr_str,
+    'arr_var'       => \&arr_var,
+    'hash_simple'   => \&hash_simple,
+    'nested_simple' => \&nested_simple,
+});

dev/bench/benchmark_refcount_anon.pl

@@ -0,0 +1,53 @@
+#!/usr/bin/env perl
+# benchmark_refcount_anon.pl
+# Stresses anon array/hash literal construction, exercising the
+# suppressFlush bytecode added in feature/refcount-alignment.
+# Should be sensitive to regressions in EmitLiteral.java's per-literal
+# overhead and to changes in MortalList.flush / createReferenceWithTrackedElements.
+
+use strict;
+use warnings;
+use Benchmark qw(timethese cmpthese);
+
+{ package Obj;
+  sub new { my ($c,$id)=@_; bless { id => $id, tags => [1,2,3] }, $c }
+  sub DESTROY {}  # keep blessed-with-DESTROY path hot
+}
+
+my $N = $ENV{BENCH_N} || 100_000;
+
+sub array_of_scalars {
+    my $arr = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+    return scalar @$arr;
+}
+
+sub array_of_blessed {
+    my $arr = [ Obj->new(1), Obj->new(2), Obj->new(3) ];
+    return scalar @$arr;
+}
+
+sub hash_of_scalars {
+    my $h = { a => 1, b => 2, c => 3, d => 4 };
+    return scalar keys %$h;
+}
+
+sub hash_of_blessed {
+    my $h = { a => Obj->new(1), b => Obj->new(2), c => Obj->new(3) };
+    return scalar keys %$h;
+}
+
+sub nested_literal {
+    my $x = {
+        list => [ Obj->new(1), Obj->new(2) ],
+        map  => { one => Obj->new(10), two => Obj->new(20) },
+    };
+    return 1;
+}
+
+timethese($N, {
+    'array_of_scalars' => \&array_of_scalars,
+    'array_of_blessed' => \&array_of_blessed,
+    'hash_of_scalars'  => \&hash_of_scalars,
+    'hash_of_blessed'  => \&hash_of_blessed,
+    'nested_literal'   => \&nested_literal,
+});

dev/bench/benchmark_refcount_bless.pl

@@ -0,0 +1,60 @@
+#!/usr/bin/env perl
+# benchmark_refcount_bless.pl
+# Stresses the bless / DESTROY / MortalList path.
+# Sensitive to changes in ReferenceOperators.bless, RuntimeScalar.setLargeRefCounted,
+# and MortalList.flush throughput.
+
+use strict;
+use warnings;
+use Benchmark qw(timethese);
+
+{ package WithDestroy;
+  sub new { bless { id => $_[1] }, $_[0] }
+  sub DESTROY {}
+}
+
+{ package NoDestroy;
+  sub new { bless { id => $_[1] }, $_[0] }
+}
+
+my $N = $ENV{BENCH_N} || 100_000;
+
+sub bless_and_drop_destroy {
+    # Blessed temp, never stored — exercises mortal flush immediately.
+    WithDestroy->new(1);
+    return 1;
+}
+
+sub bless_and_drop_nodestroy {
+    NoDestroy->new(1);
+    return 1;
+}
+
+sub bless_store_drop {
+    my $o = WithDestroy->new(1);
+    return 1;
+}
+
+sub bless_hash_store {
+    my $o = WithDestroy->new(1);
+    my %h;
+    $h{obj} = $o;
+    return 1;
+}
+
+sub bless_pass_through_subs {
+    # Passes a blessed temp through two my-list assignments.
+    # This is the setFromList fast-path we modified.
+    my $outer = sub { my ($a) = @_; $a };
+    my $inner = sub { WithDestroy->new(99) };
+    my $r = $outer->($inner->());
+    return 1;
+}
+
+timethese($N, {
+    'bless_drop_destroy'       => \&bless_and_drop_destroy,
+    'bless_drop_nodestroy'     => \&bless_and_drop_nodestroy,
+    'bless_store_drop'         => \&bless_store_drop,
+    'bless_hash_store'         => \&bless_hash_store,
+    'bless_pass_through_subs'  => \&bless_pass_through_subs,
+});

dev/bench/results/baseline-02f2ab55a.json

@@ -0,0 +1,17 @@
+{
+  "git_sha": "02f2ab55a",
+  "date":    "2026-04-20T20:47:22Z",
+  "runs":    3,
+  "jperl":   "/Users/fglock/projects/PerlOnJava3/jperl",
+  "benchmarks": {
+    "benchmark_closure": [9.952,9.059,8.233],
+    "benchmark_eval_string": [14.938,14.669,14.736],
+    "benchmark_global": [14.609,14.519,14.382],
+    "benchmark_lexical": [4.103,3.961,4.094],
+    "benchmark_method": [4.725,4.740,4.726],
+    "benchmark_refcount_anon": [2.534,2.559,2.528],
+    "benchmark_refcount_bless": [1.370,1.360,1.389],
+    "benchmark_regex": [2.637,2.706,2.735],
+    "benchmark_string": [3.969,3.975,3.961]
+  }
+}

dev/bench/results/baseline-1400475d3.json

@@ -0,0 +1,21 @@
+{
+  "git_sha":      "1400475d3",
+  "date":         "2026-04-21T18:41:58Z",
+  "runs":         3,
+  "jperl":        "/Users/fglock/projects/PerlOnJava3/jperl",
+  "perl":         "perl",
+  "perl_version": "5.042000",
+  "benchmarks":   {
+    "benchmark_anon_simple": { "unit": "s", "jperl": [7.625,7.526,7.247], "perl": [1.451,1.459,1.459] },
+    "benchmark_closure": { "unit": "s", "jperl": [10.232,9.053,8.900], "perl": [8.096,8.085,8.053] },
+    "benchmark_eval_string": { "unit": "s", "jperl": [14.690,14.424,14.569], "perl": [3.325,3.302,3.414] },
+    "benchmark_global": { "unit": "s", "jperl": [14.939,14.632,14.958], "perl": [11.147,11.210,11.098] },
+    "benchmark_lexical": { "unit": "s", "jperl": [4.060,4.091,4.043], "perl": [10.672,10.816,10.761] },
+    "benchmark_method": { "unit": "s", "jperl": [2.636,2.613,2.583], "perl": [1.513,1.526,1.523] },
+    "benchmark_refcount_anon": { "unit": "s", "jperl": [1.869,1.850,1.776], "perl": [0.451,0.456,0.442] },
+    "benchmark_refcount_bless": { "unit": "s", "jperl": [1.313,1.315,1.353], "perl": [0.198,0.204,0.198] },
+    "benchmark_regex": { "unit": "s", "jperl": [2.750,2.757,2.765], "perl": [1.999,2.010,2.060] },
+    "benchmark_string": { "unit": "s", "jperl": [3.988,4.130,4.132], "perl": [6.896,6.993,6.947] },
+    "life_bitpacked": { "unit": "Mcells/s", "jperl": [8.03,7.98,8.19], "perl": [20.76,21.08,21.11] }
+  }
+}

dev/bench/results/baseline-1400475d3.md

@@ -0,0 +1,23 @@
+# Benchmark baseline — 1400475d3
+
+**Date:** 2026-04-21T18:41:58Z
+**Runs per benchmark:** 3
+**jperl:** `/Users/fglock/projects/PerlOnJava3/jperl`
+**perl:** `perl` (5.042000)
+
+For "time" benches lower = faster; ratio is `jperl / perl`.
+For "Mcells/s" (life_bitpacked) higher = faster; ratio is `perl / jperl`.
+
+| Benchmark | unit | jperl | perl | ratio | parity? |
+|---|---|---:|---:|---:|:---:|
+| `benchmark_anon_simple` | s | 7.466 | 1.456 | **5.13×** | ❌ |
+| `benchmark_closure` | s | 9.395 | 8.078 | **1.16×** | ≈ |
+| `benchmark_eval_string` | s | 14.561 | 3.347 | **4.35×** | ❌ |
+| `benchmark_global` | s | 14.843 | 11.152 | **1.33×** | ❌ |
+| `benchmark_lexical` | s | 4.065 | 10.750 | **0.38×** | ✅ |
+| `benchmark_method` | s | 2.611 | 1.521 | **1.72×** | ❌ |
+| `benchmark_refcount_anon` | s | 1.832 | 0.450 | **4.07×** | ❌ |
+| `benchmark_refcount_bless` | s | 1.327 | 0.200 | **6.63×** | ❌ |
+| `benchmark_regex` | s | 2.757 | 2.023 | **1.36×** | ❌ |
+| `benchmark_string` | s | 4.083 | 6.945 | **0.59×** | ✅ |
+| `life_bitpacked` | Mcells/s | 8.067 | 20.983 | **2.60×** | ❌ |

dev/bench/results/baseline-6d37287f1.json

@@ -0,0 +1,17 @@
+{
+  "git_sha": "6d37287f1",
+  "date":    "2026-04-20T20:06:40Z",
+  "runs":    3,
+  "jperl":   "/Users/fglock/projects/PerlOnJava3/jperl",
+  "benchmarks": {
+    "benchmark_closure": [8.324,9.181,9.147],
+    "benchmark_eval_string": [14.746,14.986,15.144],
+    "benchmark_global": [14.636,14.746,14.610],
+    "benchmark_lexical": [4.168,4.090,4.083],
+    "benchmark_method": [4.744,4.730,4.778],
+    "benchmark_refcount_anon": [2.561,2.599,2.617],
+    "benchmark_refcount_bless": [1.383,1.387,1.396],
+    "benchmark_regex": [2.636,2.625,2.663],
+    "benchmark_string": [3.935,3.982,3.946]
+  }
+}

dev/bench/results/baseline-b7d05b77e.json

@@ -0,0 +1,21 @@
+{
+  "git_sha":      "b7d05b77e",
+  "date":         "2026-04-21T19:52:51Z",
+  "runs":         3,
+  "jperl":        "/Users/fglock/projects/PerlOnJava3/jperl",
+  "perl":         "perl",
+  "perl_version": "5.042000",
+  "benchmarks":   {
+    "benchmark_anon_simple": { "unit": "s", "jperl": [7.180,7.071,7.069], "perl": [1.417,1.452,1.449] },
+    "benchmark_closure": { "unit": "s", "jperl": [9.667,9.665,9.723], "perl": [7.794,7.750,7.618] },
+    "benchmark_eval_string": { "unit": "s", "jperl": [14.481,14.317,14.491], "perl": [3.061,3.086,3.054] },
+    "benchmark_global": { "unit": "s", "jperl": [14.385,14.523,14.539], "perl": [10.592,9.285,10.525] },
+    "benchmark_lexical": { "unit": "s", "jperl": [3.923,3.938,3.911], "perl": [10.297,10.158,10.291] },
+    "benchmark_method": { "unit": "s", "jperl": [2.526,2.528,2.499], "perl": [1.458,1.450,1.447] },
+    "benchmark_refcount_anon": { "unit": "s", "jperl": [1.735,1.725,1.709], "perl": [0.445,0.450,0.446] },
+    "benchmark_refcount_bless": { "unit": "s", "jperl": [1.233,1.241,1.234], "perl": [0.197,0.198,0.197] },
+    "benchmark_regex": { "unit": "s", "jperl": [2.655,2.677,2.678], "perl": [2.044,2.008,2.024] },
+    "benchmark_string": { "unit": "s", "jperl": [4.016,4.021,4.092], "perl": [6.873,6.707,6.729] },
+    "life_bitpacked": { "unit": "Mcells/s", "jperl": [8.49,8.49,8.41], "perl": [21.41,21.63,21.60] }
+  }
+}

dev/bench/results/baseline-b7d05b77e.md

@@ -0,0 +1,23 @@
+# Benchmark baseline — b7d05b77e
+
+**Date:** 2026-04-21T19:52:51Z
+**Runs per benchmark:** 3
+**jperl:** `/Users/fglock/projects/PerlOnJava3/jperl`
+**perl:** `perl` (5.042000)
+
+For "time" benches lower = faster; ratio is `jperl / perl`.
+For "Mcells/s" (life_bitpacked) higher = faster; ratio is `perl / jperl`.
+
+| Benchmark | unit | jperl | perl | ratio | parity? |
+|---|---|---:|---:|---:|:---:|
+| `benchmark_anon_simple` | s | 7.107 | 1.439 | **4.94×** | ❌ |
+| `benchmark_closure` | s | 9.685 | 7.721 | **1.25×** | ❌ |
+| `benchmark_eval_string` | s | 14.430 | 3.067 | **4.70×** | ❌ |
+| `benchmark_global` | s | 14.482 | 10.134 | **1.43×** | ❌ |
+| `benchmark_lexical` | s | 3.924 | 10.249 | **0.38×** | ✅ |
+| `benchmark_method` | s | 2.518 | 1.452 | **1.73×** | ❌ |
+| `benchmark_refcount_anon` | s | 1.723 | 0.447 | **3.85×** | ❌ |
+| `benchmark_refcount_bless` | s | 1.236 | 0.197 | **6.27×** | ❌ |
+| `benchmark_regex` | s | 2.670 | 2.025 | **1.32×** | ❌ |
+| `benchmark_string` | s | 4.043 | 6.770 | **0.60×** | ✅ |
+| `life_bitpacked` | Mcells/s | 8.463 | 21.547 | **2.55×** | ❌ |