Add instruction-count benchmark for reified collections

perfcount.c (perf_event_open wrapper) + perfbench.sh compare bench/baseline
(plain) vs bench/reified (no-defaults native generics) on the same fork binary.
Because reified has no defaults, each branch runs its own workload file
(collbench_{baseline,reified}.php) — identical operations, only the
`new ArrayCollection` line differs; reified uses a concrete <int, Item>
monomorph so T/TKey checks fire on add/set/get/filter/partition.

Result (opcache off, deterministic): +0.079% instructions, checksum match.
(opcache on is unreliable on this fork due to persistent-SHM churn.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: withinboredom

bench/.gitignore

@@ -0,0 +1 @@
+/perfcount

bench/collbench_baseline.php

@@ -0,0 +1,52 @@
+<?php
+// Baseline-branch workload: plain ArrayCollection (docblock generics, no
+// reification). Identical operations to collbench_reified.php; only the
+// `new ArrayCollection` construction line differs (bare, no type args).
+//
+//   php bench/collbench_baseline.php [ITERS] [SIZE]
+declare(strict_types=1);
+require getenv('BENCH_AUTOLOAD') ?: __DIR__ . '/../vendor/autoload.php';
+
+use Doctrine\Common\Collections\ArrayCollection;
+
+final class Item
+{
+    public function __construct(public int $v)
+    {
+    }
+}
+
+$ITERS = (int) ($argv[1] ?? 2000);
+$SIZE  = (int) ($argv[2] ?? 500);
+
+/** @var array<int, Item> $data */
+$data = [];
+for ($i = 0; $i < $SIZE; $i++) {
+    $data[$i] = new Item(($i * 7) % 101);
+}
+
+$checksum = 0;
+for ($it = 0; $it < $ITERS; $it++) {
+    $c = new ArrayCollection($data);                 // <-- only line that differs from reified
+    $c->add(new Item($it % 13));
+    $c->set(0, new Item(1));
+    $g  = $c->get(5);
+    $ck = $c->containsKey(3);
+    $ct = $c->contains($data[2]);
+    $f  = $c->filter(static fn (Item $v, int $k): bool => $v->v % 2 === 0);
+    $fr = $c->first();
+    $la = $c->last();
+    $sl = $c->slice(0, 10);
+    [$m, $n] = $c->partition(static fn (int $k, Item $v): bool => $v->v > 50);
+
+    $checksum += $c->count()
+        + ($g instanceof Item ? $g->v : 0)
+        + ($ck ? 1 : 0) + ($ct ? 1 : 0)
+        + $f->count()
+        + ($fr instanceof Item ? $fr->v : 0)
+        + ($la instanceof Item ? $la->v : 0)
+        + count($sl)
+        + $m->count() + $n->count();
+}
+
+printf("class=%s  iters=%d size=%d  (checksum=%d)\n", (new ArrayCollection())::class, $ITERS, $SIZE, $checksum);

bench/collbench_reified.php

@@ -0,0 +1,53 @@
+<?php
+// Reified-branch workload: ArrayCollection<int, Item> — a CONCRETE monomorph so
+// the reified TKey/T checks actually fire on add/set/get/filter/etc.
+// Identical operations to collbench_baseline.php; only the `new ArrayCollection`
+// construction line differs (explicit ::<int, Item> args, no defaults).
+//
+//   php bench/collbench_reified.php [ITERS] [SIZE]
+declare(strict_types=1);
+require getenv('BENCH_AUTOLOAD') ?: __DIR__ . '/../vendor/autoload.php';
+
+use Doctrine\Common\Collections\ArrayCollection;
+
+final class Item
+{
+    public function __construct(public int $v)
+    {
+    }
+}
+
+$ITERS = (int) ($argv[1] ?? 2000);
+$SIZE  = (int) ($argv[2] ?? 500);
+
+/** @var array<int, Item> $data */
+$data = [];
+for ($i = 0; $i < $SIZE; $i++) {
+    $data[$i] = new Item(($i * 7) % 101);
+}
+
+$checksum = 0;
+for ($it = 0; $it < $ITERS; $it++) {
+    $c = new ArrayCollection::<int, Item>($data);   // <-- only line that differs from baseline
+    $c->add(new Item($it % 13));
+    $c->set(0, new Item(1));
+    $g  = $c->get(5);
+    $ck = $c->containsKey(3);
+    $ct = $c->contains($data[2]);
+    $f  = $c->filter(static fn (Item $v, int $k): bool => $v->v % 2 === 0);
+    $fr = $c->first();
+    $la = $c->last();
+    $sl = $c->slice(0, 10);
+    [$m, $n] = $c->partition(static fn (int $k, Item $v): bool => $v->v > 50);
+
+    $checksum += $c->count()
+        + ($g instanceof Item ? $g->v : 0)
+        + ($ck ? 1 : 0) + ($ct ? 1 : 0)
+        + $f->count()
+        + ($fr instanceof Item ? $fr->v : 0)
+        + ($la instanceof Item ? $la->v : 0)
+        + count($sl)
+        + $m->count() + $n->count();
+}
+
+printf("class=%s  iters=%d size=%d  (checksum=%d)\n", (new ArrayCollection::<int, Item>())::class, $ITERS, $SIZE, $checksum);

bench/perfbench.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# Instruction-count comparison: bench/baseline (plain Collections) vs
+# bench/reified (native reified generics, no defaults, concrete <int,Item>
+# monomorph). Same fork binary; via perf_event_open (bench/perfcount).
+#
+# Because reified has NO defaults, construction syntax differs per branch, so
+# each branch runs its OWN workload file (identical operations, only the
+# `new ArrayCollection` line differs). Workloads are pinned to /tmp so they
+# survive `git checkout`.
+#
+#   gcc -O2 -o bench/perfcount bench/perfcount.c
+#   [PHP=...] [OPCACHE=on|off] [ITERS=] [SIZE=] [N=] bench/perfbench.sh
+set -uo pipefail
+REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+PHP="${PHP:-/home/withinboredom/code/php-src/sapi/cli/php}"
+PC="$REPO/bench/perfcount"
+ITERS="${ITERS:-2000}"; SIZE="${SIZE:-500}"; N="${N:-5}"
+cd "$REPO" || exit 1
+[ -x "$PC" ] || { echo "build first: gcc -O2 -o bench/perfcount bench/perfcount.c" >&2; exit 1; }
+
+case "${OPCACHE:-on}" in
+  off) FLAGS=(-d opcache.enable_cli=0); OPMODE="opcache OFF" ;;
+  *)   FLAGS=(-d opcache.enable_cli=1 -d opcache.jit=disable -d opcache.jit_buffer_size=0 -d opcache.validate_timestamps=1); OPMODE="opcache ON" ;;
+esac
+
+# Pin workloads outside the repo so branch switches can't delete them.
+cp "$REPO/bench/collbench_baseline.php" /tmp/.cb_baseline.php
+cp "$REPO/bench/collbench_reified.php"  /tmp/.cb_reified.php
+export BENCH_AUTOLOAD="$REPO/vendor/autoload.php"
+
+median() { sort -n | awk '{a[NR]=$1} END{print a[int((NR+1)/2)]}'; }
+
+echo "### $OPMODE | ITERS=$ITERS SIZE=$SIZE | N=$N runs/branch" >&2
+declare -A INS CHK
+for spec in "baseline:bench/baseline:/tmp/.cb_baseline.php" "reified:bench/reified:/tmp/.cb_reified.php"; do
+  label="${spec%%:*}"; rest="${spec#*:}"; ref="${rest%%:*}"; work="${rest#*:}"
+  git checkout -q "$ref" || { echo "checkout $ref failed" >&2; exit 1; }
+  "$PHP" "${FLAGS[@]}" -r 'opcache_reset();' >/dev/null 2>&1 || true
+  "$PHP" "${FLAGS[@]}" "$work" "$ITERS" "$SIZE" >/dev/null 2>&1   # prime
+  echo "=== $label ($(git rev-parse --short HEAD)) ===" >&2
+  ins_list=()
+  for i in $(seq 1 "$N"); do
+    "$PC" "$PHP" "${FLAGS[@]}" "$work" "$ITERS" "$SIZE" >/tmp/.pcout 2>/tmp/.pcerr
+    ins="$(grep -oE 'instructions=[0-9]+' /tmp/.pcerr | cut -d= -f2)"
+    ins_list+=("$ins"); echo "  run $i: instructions=$ins" >&2
+  done
+  CHK["$label"]="$(grep -oE 'checksum=[0-9]+' /tmp/.pcout | cut -d= -f2)"
+  INS["$label"]="$(printf '%s\n' "${ins_list[@]}" | median)"
+done
+git checkout -q bench/reified
+
+echo "============================================================"
+b="${INS[baseline]}"; r="${INS[reified]}"
+echo "checksum baseline=${CHK[baseline]}  reified=${CHK[reified]}  $([ "${CHK[baseline]}" = "${CHK[reified]}" ] && echo MATCH || echo MISMATCH!!)"
+awk -v b="$b" -v r="$r" 'BEGIN{ printf "median instructions  baseline=%d  reified=%d  delta=%+.3f%%\n", b, r, (r-b)/b*100 }'
+echo "($OPMODE; restored to bench/reified)"

bench/perfcount.c

@@ -0,0 +1,90 @@
+// Minimal perf_event_open wrapper: counts userspace HW events for a child process.
+// No `perf` binary and no root needed when /proc/sys/kernel/perf_event_paranoid <= 2
+// (we set exclude_kernel). Works on WSL2 when the guest exposes the PMU
+// (check: ls /sys/devices/cpu/events should list `instructions`, `cycles`, ...).
+//
+//   gcc -O2 -o bench/perfcount bench/perfcount.c
+//   bench/perfcount <cmd> [args...]
+//
+// Prints one line to stderr:
+//   PERF instructions=<n> cycles=<n> branch-misses=<n> cache-misses=<n>
+//
+// Instruction counts are frequency-independent, so they're stable on battery,
+// under load, and across machines -- far better than wall-clock for resolving
+// a sub-percent engine cost.
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/ioctl.h>
+#include <linux/perf_event.h>
+#include <asm/unistd.h>
+
+static long perf_open(struct perf_event_attr *a, pid_t pid) {
+    return syscall(__NR_perf_event_open, a, pid, -1, -1, 0);
+}
+
+static int mkcounter(unsigned type, unsigned long long config, pid_t pid) {
+    struct perf_event_attr a;
+    memset(&a, 0, sizeof(a));
+    a.type = type;
+    a.size = sizeof(a);
+    a.config = config;
+    a.disabled = 1;            // start off...
+    a.enable_on_exec = 1;      // ...auto-enable when the child execs
+    a.exclude_kernel = 1;      // userspace only (allowed at paranoid=2)
+    a.exclude_hv = 1;
+    a.inherit = 1;             // follow into the exec'd image
+    int fd = (int) perf_open(&a, pid);
+    if (fd < 0) fprintf(stderr, "perf_open(type=%u,config=%llu) failed: %s\n", type, config, strerror(errno));
+    return fd;
+}
+
+static long long readval(int fd) {
+    long long v = -1;
+    if (fd >= 0 && read(fd, &v, sizeof(v)) != sizeof(v)) v = -1;
+    return v;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) { fprintf(stderr, "usage: %s <cmd> [args...]\n", argv[0]); return 2; }
+
+    int pfd[2];
+    if (pipe(pfd) != 0) { perror("pipe"); return 3; }
+
+    pid_t pid = fork();
+    if (pid < 0) { perror("fork"); return 3; }
+
+    if (pid == 0) {
+        // child: wait for parent to arm counters, then exec
+        close(pfd[1]);
+        char b; if (read(pfd[0], &b, 1) < 0) _exit(126);
+        close(pfd[0]);
+        execvp(argv[1], &argv[1]);
+        perror("execvp");
+        _exit(127);
+    }
+
+    // parent: arm counters against the (still-blocked) child
+    close(pfd[0]);
+    int f_ins = mkcounter(PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS,  pid);
+    int f_cyc = mkcounter(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES,    pid);
+    int f_brm = mkcounter(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES, pid);
+    int f_chm = mkcounter(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES,  pid);
+
+    // release the child
+    char go = 1; if (write(pfd[1], &go, 1) < 0) { /* child will EOF and exit */ }
+    close(pfd[1]);
+
+    int status = 0;
+    waitpid(pid, &status, 0);
+
+    fprintf(stderr, "PERF instructions=%lld cycles=%lld branch-misses=%lld cache-misses=%lld\n",
+            readval(f_ins), readval(f_cyc), readval(f_brm), readval(f_chm));
+
+    if (WIFEXITED(status)) return WEXITSTATUS(status);
+    return 1;
+}