From a1952dac7444cf7c1c355cd59607b3383d1e63b4 Mon Sep 17 00:00:00 2001 From: mithilesh gaurihar Date: Wed, 8 Jul 2026 11:51:47 -0700 Subject: [PATCH 1/2] Make the concurrency harness run on Windows (portability) + document the RR-side caveat MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The concurrency suite was authored for macOS/Linux; on Windows several harness-level assumptions break before any measurement runs. None of these touch the benchmark's methodology or the RocketRide-vs-LangChain numbers — they only let the suite execute on Windows and report honestly. Portability fixes: - harness/__init__.py: force UTF-8 on stdout/stderr. The runners print unicode (→, ×, …); on the legacy cp1252 Windows console a bare print() raises UnicodeEncodeError and aborts a run mid-benchmark (hit in data-isolation). No-op on POSIX. - config.py / nodes/workload/IInstance.py / concurrent-processing/run.py: default the params file and sqlite dirs to the OS temp dir instead of hardcoded /tmp (absent on Windows). Harness and node defaults kept in sync; still overridable via $ROCKETRIDE_BENCH_PARAMS / $BENCH_DB_DIR. Verified out-of-the-box (data-isolation 0-lost with no env set). - config.py: resolve engine.exe on Windows so provenance()/engine_version() work instead of silently recording "unknown". - scripts/provision.sh: add the Windows (win64 .zip) engine branch — the pinned server-v3.2.1 release already ships it; the script just never wired it up — plus the venv Scripts/ layout. - scripts/start_engine.sh: use engine.exe on Windows and actually forward --port=$PORT (previously computed for the health check but never passed to the engine). Honesty fix: - concurrent-processing/run.py: the VERDICT console line hardcoded "ok" for the RR cell regardless of the real status. results.json always recorded the true rr_topM_ok; the print now matches it (shows CHECK when node errors occur). Docs: - concurrent-work/harness/REPRODUCE-WINDOWS.md: Windows setup, what reproduces, and — flagged openly — the one RR-side result that does NOT reproduce clean on Windows: the concurrent-processing cell throws sqlite3.ProgrammingError (thread-affinity) because the node caches a module-level sqlite connection and the v3.2.1 engine dispatches a pipe's objects to different OS threads even at threads=1 (macOS/Linux use one thread per pipe). Process isolation still holds; only thread-affine resources are affected (data-isolation, which uses a GIL-safe list.append, reproduces 0-lost). Includes A/B/C fix options for the team to decide; this PR intentionally does NOT change RR-side numbers or the benchmark's claim. Co-Authored-By: Claude Opus 4.8 --- concurrent-work/harness/REPRODUCE-WINDOWS.md | 83 +++++++++++++++++++ .../concurrent-processing/run.py | 14 +++- .../rocketride-bench/harness/__init__.py | 11 +++ .../rocketride-bench/harness/config.py | 13 ++- .../nodes/workload/IInstance.py | 10 ++- .../rocketride-bench/scripts/provision.sh | 40 ++++++--- .../rocketride-bench/scripts/start_engine.sh | 13 +-- 7 files changed, 157 insertions(+), 27 deletions(-) create mode 100644 concurrent-work/harness/REPRODUCE-WINDOWS.md diff --git a/concurrent-work/harness/REPRODUCE-WINDOWS.md b/concurrent-work/harness/REPRODUCE-WINDOWS.md new file mode 100644 index 0000000..12bdbee --- /dev/null +++ b/concurrent-work/harness/REPRODUCE-WINDOWS.md @@ -0,0 +1,83 @@ +# Reproducing the concurrency benchmarks on Windows + +The suite was authored on macOS/Linux (see [`REPRODUCE.md`](REPRODUCE.md)). This note covers the +Windows-specific setup, what reproduces, and **one RocketRide-side result that does not reproduce +clean on Windows** — documented honestly here rather than left for a re-runner to trip over. + +Everything below uses the pinned engine (`server-v3.2.1`) and pinned LangChain (`langchain-core +0.3.86`), exactly like the Mac runs. + +## Setup (git-bash / MSYS) + +```bash +cd rocketride-bench +bash scripts/provision.sh --competitors # now supports Windows: pulls the win64 .zip engine + # + builds .venv (Scripts/ layout) + real LangChain +ROCKETRIDE_PORT=5565 bash scripts/start_engine.sh # engine.exe ai/eaas.py --port=5565 +``` + +Notes specific to Windows: +- The pinned release ships a **`win64.zip`** engine; `provision.sh` now unzips it to `./engine` + (the binary is `engine.exe`). The macOS/Linux path still downloads the `.tar.gz`. +- If the **RocketRide VS Code extension** is installed, its own engine may already hold + `:5565`. Start the benchmark engine on a **free port** and point the harness at it: + ```bash + ROCKETRIDE_PORT=5566 bash scripts/start_engine.sh + export ROCKETRIDE_URI="ws://localhost:5566" + ``` +- The runners force UTF-8 stdout (`harness/__init__.py`), so their unicode output no longer + crashes the legacy-codepage (cp1252) Windows console. +- Temp paths default to the OS temp dir (`%LOCALAPPDATA%\Temp`) instead of `/tmp`. Override the + shared params/db locations with `$ROCKETRIDE_BENCH_PARAMS` / `$BENCH_DB_DIR` if the engine and + harness resolve different temp dirs (e.g. run under different accounts). + +## What reproduces on Windows + +| Bench | Result | +|---|---| +| `lines-of-code` | ✅ 6.0× fewer lines, 3.6× fewer chars | +| `authoring-effort` | ✅ RR 0 imperative lines + validates; LC 14–17 lines, 5 hidden facts | +| `fault-isolation` | ✅ RR isolation holds 10/10; in-process LangChain dies (exit 134, 0/4) | +| `data-isolation` | ✅ RR 0 lost / 0 leaked; LangChain silently drops 44–88% of 256 | +| `concurrent-processing` (LangChain side) | ✅ `.batch` shared-conn crashes 64/64 (`sqlite3.ProgrammingError`); `.abatch`/seq serialize (~6.8s) | +| `concurrent-processing` (**RocketRide side**) | ⚠️ **does not reproduce clean — see below** | + +## Known caveat: `concurrent-processing` RocketRide cell on Windows + +On macOS/Linux the RR cell is `0 errors, 72/72 rows, status=ok`. On Windows it reports +`status=check` with ~8–12 of 72 docs raising: + +``` +sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread. +``` + +**Why:** process isolation still holds (M pipes = M distinct PIDs), but the synthetic workload +node caches a **module-level sqlite connection** (`conn="module"`), which is thread-affine. On +macOS/Linux an RR pipe runs its objects on **one** worker thread, so the cached connection is +always used on its creating thread. On Windows the v3.2.1 engine dispatches successive objects to +**different** OS threads even at `threads=1`, so the cached connection is reused off-thread and +raises. The repo's own appendix "honesty cell" (`1 pipe × threadCount=4` → 31 errors) already +demonstrates this mechanism; it was simply never flagged as OS-dependent for the `threads=1` +headline path. + +RR still degrades **partially** here (the surviving pipes complete), versus LangChain's `.batch` +which loses **all 64** — but it is not the clean `0 errors` the headline reports. Note this is +specific to **thread-affine resources**: `data-isolation` uses module-level state too (a plain +`list.append`, which is GIL-safe) and reproduces `0 lost` on Windows. + +### Fix options (for the RocketRide team to decide) + +This PR ships only the OS-portability fixes above; it does **not** change the RR-side numbers or +the benchmark's claim. The threading caveat can be resolved in one of three ways: + +- **A — make the node correct (thread-local connection).** Use `threading.local()` for the + headline cell's sqlite connection so RR passes `0 errors` on every OS (Mac numbers unchanged); + keep `conn="module"` in the appendix so the trap is still shown. Concedes that RR node authors + need connection-handling care too. +- **B — disclose + scope.** Keep the naive-both idiom; on Windows report the degraded RR result + transparently and scope the `0 errors` row to macOS/Linux, noting the real fix is in the engine + (make `threads=1` mean one OS thread per pipe on Windows). Preserves the stronger claim, bounded. +- **C — engine fix.** Make the v3.2.1+ engine run one worker thread per pipe on Windows, which + restores the naive-idiom-safety headline everywhere. Not in this repo. + +A (benchmark) + C (engine) is the eventual end state. See the PR description for the full analysis. diff --git a/concurrent-work/harness/rocketride-bench/groups/scale-and-concurrency/concurrent-processing/run.py b/concurrent-work/harness/rocketride-bench/groups/scale-and-concurrency/concurrent-processing/run.py index 2928435..8a9519b 100644 --- a/concurrent-work/harness/rocketride-bench/groups/scale-and-concurrency/concurrent-processing/run.py +++ b/concurrent-work/harness/rocketride-bench/groups/scale-and-concurrency/concurrent-processing/run.py @@ -39,7 +39,9 @@ N_DOCS = 64 IO_S = 0.100 MS = [int(x) for x in os.environ.get("BENCH_MS", "8,16,64").split(",")] # env-configurable; default = upstream -DB_DIR = "/tmp/rr_bench_sqlite" +# OS temp dir (no /tmp on Windows); override with $BENCH_DB_DIR. The harness and the node both +# read/write these sqlite files, so the path must be valid on the host running both. +DB_DIR = os.environ.get("BENCH_DB_DIR", os.path.join(tempfile.gettempdir(), "rr_bench_sqlite")) PIPE = os.path.join(HERE, "pipeline.pipe") TRACE = os.path.join(HERE, "trace") @@ -205,10 +207,14 @@ async def main(): subprocess.run([sys.executable, os.path.join(REPO, "scripts", "make_diagrams.py"), PIPE, os.path.join(HERE, "canvas")]) vm = out["verdict_metrics"] - print("\nVERDICT @ top M: RR(top M) %.2fs ok | LC .batch(shared) %s (%s) | " + # Reflect the ACTUAL RR status (results.json already records rr_topM_ok) instead of a + # hardcoded "ok" — on Windows the RR cell can be `check` (see rr64["status"]), and the + # console line was the only place that masked it. + rr_status = "ok" if vm["rr_topM_ok"] else "CHECK (node errors — see rocketride[].status)" + print("\nVERDICT @ top M: RR(top M) %.2fs %s | LC .batch(shared) %s (%s) | " "LC .abatch(blocking) %.1fs | LC seq %.1fs" - % (vm["rr_topM_wall_s"], vm["lc_batch_shared_status"], vm["lc_batch_shared_error"], - vm["lc_abatch_blocking_wall_s"], vm["lc_seq_wall_s"])) + % (vm["rr_topM_wall_s"], rr_status, vm["lc_batch_shared_status"], + vm["lc_batch_shared_error"], vm["lc_abatch_blocking_wall_s"], vm["lc_seq_wall_s"])) if __name__ == "__main__": diff --git a/concurrent-work/harness/rocketride-bench/harness/__init__.py b/concurrent-work/harness/rocketride-bench/harness/__init__.py index c38b0d1..5fc5ccf 100644 --- a/concurrent-work/harness/rocketride-bench/harness/__init__.py +++ b/concurrent-work/harness/rocketride-bench/harness/__init__.py @@ -4,3 +4,14 @@ server + SDK + tracer). It never reimplements engine behavior. See the repo README and NOTICE for the "what's RocketRide vs what's ours" breakdown. """ +# Force UTF-8 on stdout/stderr so the runners' unicode (→, ×, …) prints on any console. +# Windows defaults to a legacy codepage (cp1252), where a bare `print("… → …")` raises +# UnicodeEncodeError and aborts a run mid-benchmark. Guarded + idempotent; no-op on POSIX, +# which is already UTF-8. reconfigure() exists on TextIOWrapper (Py3.7+). +import sys as _sys + +for _stream in (_sys.stdout, _sys.stderr): + try: + _stream.reconfigure(encoding="utf-8") + except (AttributeError, ValueError): + pass diff --git a/concurrent-work/harness/rocketride-bench/harness/config.py b/concurrent-work/harness/rocketride-bench/harness/config.py index 6e9e0f3..c577c4e 100644 --- a/concurrent-work/harness/rocketride-bench/harness/config.py +++ b/concurrent-work/harness/rocketride-bench/harness/config.py @@ -13,13 +13,16 @@ import platform import subprocess import sys +import tempfile HARNESS_DIR = os.path.dirname(os.path.abspath(__file__)) REPO_DIR = os.path.dirname(HARNESS_DIR) -# Engine: env-first, else the provisioned ./engine inside the repo. +# Engine: env-first, else the provisioned ./engine inside the repo. The prebuilt binary is +# `engine.exe` on Windows and `engine` elsewhere — pick the right name so provenance() and +# engine_version() find it instead of silently recording "unknown". ENGINE_DIR = os.environ.get("ENGINE_DIR") or os.path.join(REPO_DIR, "engine") -ENGINE = os.path.join(ENGINE_DIR, "engine") +ENGINE = os.path.join(ENGINE_DIR, "engine.exe" if os.name == "nt" else "engine") # Direct-connect server (the headline product path). URI = os.environ.get("ROCKETRIDE_URI", "ws://localhost:5565") @@ -30,7 +33,11 @@ RESULTS_DIR = os.path.join(REPO_DIR, "results") DATA_DIR = os.path.join(REPO_DIR, "data") NODES_DIR = os.path.join(REPO_DIR, "nodes") -BENCH_PARAMS = os.environ.get("ROCKETRIDE_BENCH_PARAMS", "/tmp/rr_bench_params.json") +# Params file the harness writes and the workload node reads. Default to the OS temp dir so it +# is writable on Windows too (there is no /tmp); keep the node's fallback (nodes/workload/ +# IInstance.py) in sync. Override with $ROCKETRIDE_BENCH_PARAMS to pin an explicit shared path. +BENCH_PARAMS = os.environ.get("ROCKETRIDE_BENCH_PARAMS", + os.path.join(tempfile.gettempdir(), "rr_bench_params.json")) def engine_present(): diff --git a/concurrent-work/harness/rocketride-bench/nodes/workload/IInstance.py b/concurrent-work/harness/rocketride-bench/nodes/workload/IInstance.py index 920f0b4..cce8e1e 100644 --- a/concurrent-work/harness/rocketride-bench/nodes/workload/IInstance.py +++ b/concurrent-work/harness/rocketride-bench/nodes/workload/IInstance.py @@ -30,12 +30,18 @@ import json import os import sys +import tempfile import time import threading from rocketlib import IInstanceBase _PARAMS = None +# Cross-platform fallbacks (no /tmp on Windows). The harness normally passes explicit paths via +# $ROCKETRIDE_BENCH_PARAMS and the `db` param, so these only bite the local-binary floor path; +# kept in sync with harness/config.py so both sides resolve the same file when unset. +_DEFAULT_PARAMS = os.path.join(tempfile.gettempdir(), "rr_bench_params.json") +_DEFAULT_DB = os.path.join(tempfile.gettempdir(), "rr_bench_sqlite", "%d.db") def _params(): @@ -43,7 +49,7 @@ def _params(): if _PARAMS is not None: return _PARAMS path = os.environ.get("ROCKETRIDE_BENCH_PARAMS") or os.environ.get("BENCH_PARAMS") \ - or "/tmp/rr_bench_params.json" + or _DEFAULT_PARAMS p = {} try: with open(path) as f: @@ -57,7 +63,7 @@ def _params(): p.setdefault("url", os.environ.get("BENCH_URL", "http://127.0.0.1:8799/")) p.setdefault("label", os.environ.get("BENCH_LABEL", "")) # scale-and-concurrency params - p.setdefault("db", os.environ.get("BENCH_DB", "/tmp/rr_bench_sqlite/%d.db")) + p.setdefault("db", os.environ.get("BENCH_DB", _DEFAULT_DB)) p.setdefault("io_ms", float(os.environ.get("BENCH_IO_MS", "0") or 0)) p.setdefault("pdf", os.environ.get("BENCH_PDF", "")) p.setdefault("conn", os.environ.get("BENCH_CONN", "module")) # "module" | "per_call" diff --git a/concurrent-work/harness/rocketride-bench/scripts/provision.sh b/concurrent-work/harness/rocketride-bench/scripts/provision.sh index b27d094..00838b5 100644 --- a/concurrent-work/harness/rocketride-bench/scripts/provision.sh +++ b/concurrent-work/harness/rocketride-bench/scripts/provision.sh @@ -7,46 +7,60 @@ REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)" RR_ENGINE_VERSION="${RR_ENGINE_VERSION:-3.2.1}" ENGINE_DIR="${ENGINE_DIR:-$REPO_DIR/engine}" +# Engine binary name differs on Windows (git-bash/MSYS): engine.exe vs engine. +case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) ENGINE_BIN=engine.exe ;; *) ENGINE_BIN=engine ;; esac + # 1) Engine: use an existing one, else download the prebuilt for this OS/arch. -if [ -x "$ENGINE_DIR/engine" ]; then - echo "engine present: $ENGINE_DIR/engine" +if [ -x "$ENGINE_DIR/$ENGINE_BIN" ]; then + echo "engine present: $ENGINE_DIR/$ENGINE_BIN" else os="$(uname -s)"; arch="$(uname -m)" + ext=tar.gz case "$os/$arch" in Darwin/arm64) plat=darwin-arm64 ;; Darwin/x86_64) plat=darwin-x64 ;; Linux/*) plat=linux-x64 ;; + # Windows via git-bash/MSYS/Cygwin: the release ships a .zip (not .tar.gz) that extracts + # engine.exe at the archive root (no leading component to strip). + MINGW*/*|MSYS*/*|CYGWIN*/*) plat=win64; ext=zip ;; *) echo "unsupported $os/$arch; use Docker (ghcr.io/rocketride-org/rocketride-engine)"; exit 1 ;; esac - asset="rocketride-server-v${RR_ENGINE_VERSION}-${plat}.tar.gz" + asset="rocketride-server-v${RR_ENGINE_VERSION}-${plat}.${ext}" url="https://github.com/rocketride-org/rocketride-server/releases/download/server-v${RR_ENGINE_VERSION}/${asset}" echo "downloading $url" mkdir -p "$ENGINE_DIR" - curl -fL "$url" -o "/tmp/$asset" - tar -xzf "/tmp/$asset" -C "$ENGINE_DIR" --strip-components=1 + tmp_asset="${TMPDIR:-/tmp}/$asset" + curl -fL "$url" -o "$tmp_asset" + if [ "$ext" = "zip" ]; then + unzip -oq "$tmp_asset" -d "$ENGINE_DIR" # win64.zip: engine.exe at the root + else + tar -xzf "$tmp_asset" -C "$ENGINE_DIR" --strip-components=1 + fi echo "extracted engine -> $ENGINE_DIR" fi -( cd "$ENGINE_DIR" && ./engine --version 2>&1 | head -1 ) || true +( cd "$ENGINE_DIR" && "./$ENGINE_BIN" --version 2>&1 | head -1 ) || true # NOTE: native prebuilts exist for darwin-arm64/darwin-x64/linux-x64/win64. On Apple Silicon the # Docker image (linux-x64) runs under emulation — for fair Mac numbers use the darwin-arm64 # prebuilt; for fair Docker numbers run on a linux-x64 host and containerize the competitors too. -# 2) Harness venv. -if [ ! -x "$REPO_DIR/.venv/bin/python" ]; then +# 2) Harness venv. venv lays python under Scripts/ on Windows, bin/ elsewhere. +case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) VENV_PY="$REPO_DIR/.venv/Scripts/python.exe" ;; + *) VENV_PY="$REPO_DIR/.venv/bin/python" ;; esac +if [ ! -x "$VENV_PY" ]; then echo "creating venv" python3 -m venv "$REPO_DIR/.venv" fi -"$REPO_DIR/.venv/bin/python" -m pip install --quiet --upgrade pip -"$REPO_DIR/.venv/bin/python" -m pip install --quiet -r "$REPO_DIR/requirements.txt" -echo "venv ready: $REPO_DIR/.venv ($("$REPO_DIR/.venv/bin/python" -c 'import rocketride; print("rocketride", rocketride.__version__)'))" +"$VENV_PY" -m pip install --quiet --upgrade pip +"$VENV_PY" -m pip install --quiet -r "$REPO_DIR/requirements.txt" +echo "venv ready: $REPO_DIR/.venv ($("$VENV_PY" -c 'import rocketride; print("rocketride", rocketride.__version__)'))" # 3) Optional: the REAL LangChain competitor baseline for the Tier-1 head-to-heads (no infra, no # creds — the model is a fixed-latency mock). `make provision-competitors` does the same thing. if [ "${1:-}" = "--competitors" ]; then echo "installing competitor baselines (real LangChain)" - "$REPO_DIR/.venv/bin/python" -m pip install --quiet -r "$REPO_DIR/requirements-competitors.txt" - echo "competitors ready: $("$REPO_DIR/.venv/bin/python" -c 'import langchain_core; print("langchain-core", langchain_core.__version__)')" + "$VENV_PY" -m pip install --quiet -r "$REPO_DIR/requirements-competitors.txt" + echo "competitors ready: $("$VENV_PY" -c 'import langchain_core; print("langchain-core", langchain_core.__version__)')" fi echo diff --git a/concurrent-work/harness/rocketride-bench/scripts/start_engine.sh b/concurrent-work/harness/rocketride-bench/scripts/start_engine.sh index 66957cf..e93e740 100644 --- a/concurrent-work/harness/rocketride-bench/scripts/start_engine.sh +++ b/concurrent-work/harness/rocketride-bench/scripts/start_engine.sh @@ -10,8 +10,11 @@ PORT="${ROCKETRIDE_PORT:-5565}" LOG="${ENGINE_LOG:-$REPO_DIR/results/engine.log}" PIDFILE="$REPO_DIR/results/engine.pid" -if [ ! -x "$ENGINE_DIR/engine" ]; then - echo "RocketRide runtime not found at $ENGINE_DIR/engine" >&2 +# Engine binary name is engine.exe on Windows (git-bash/MSYS), engine elsewhere. +case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) ENGINE_BIN=engine.exe ;; *) ENGINE_BIN=engine ;; esac + +if [ ! -x "$ENGINE_DIR/$ENGINE_BIN" ]; then + echo "RocketRide runtime not found at $ENGINE_DIR/$ENGINE_BIN" >&2 echo " set \$ENGINE_DIR or run scripts/provision.sh to download the pinned prebuilt." >&2 exit 1 fi @@ -28,8 +31,8 @@ done mkdir -p "$(dirname "$LOG")" cd "$ENGINE_DIR" -echo "starting: $ENGINE_DIR/engine ai/eaas.py --host=0.0.0.0 (port $PORT)" -nohup ./engine ai/eaas.py --host=0.0.0.0 >"$LOG" 2>&1 & +echo "starting: $ENGINE_DIR/$ENGINE_BIN ai/eaas.py --host=0.0.0.0 --port=$PORT" +nohup "./$ENGINE_BIN" ai/eaas.py --host=0.0.0.0 --port="$PORT" >"$LOG" 2>&1 & echo $! > "$PIDFILE" # Readiness = the HTTP server answers at all. /ping returns 401 without auth (that's still a @@ -38,7 +41,7 @@ for _ in $(seq 1 60); do code="$(curl -s -o /dev/null -w '%{http_code}' "http://localhost:$PORT/ping" 2>/dev/null || echo 000)" if [ "$code" != "000" ]; then echo "engine healthy on :$PORT (HTTP $code, pid $(cat "$PIDFILE"))" - ./engine --version 2>&1 | head -1 + "./$ENGINE_BIN" --version 2>&1 | head -1 exit 0 fi sleep 0.5 From 93acfa0e646164ad1477b61862e16e2ded057ff0 Mon Sep 17 00:00:00 2001 From: mithilesh gaurihar Date: Wed, 8 Jul 2026 16:07:55 -0700 Subject: [PATCH 2/2] Add full Windows 10x run-data (runs-windows/) + the orchestrator that produced it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Complete input/output evidence from re-running the concurrency suite on Windows 11, laid out like the macOS concurrent-work/runs/ tree so a reviewer/agent has everything in one place — including the RR-side result that does NOT reproduce clean on Windows. New: - harness/run_isolated_windows.py — Windows counterpart to run_isolated.sh (engine lifecycle on port 5566 via psutil, .venv/Scripts python, ROCKETRIDE_URI, restart+prime per warm-pool rep). run_isolated.sh can't drive Windows: it targets runs/, hardcodes port 5565 (held by the VS Code extension), and uses lsof / .venv/bin/python / --host=0.0.0.0. - runs-windows/ (834 KB) — 10x reps per bench (fault-isolation, concurrent-processing, data-isolation) + static authoring-effort, mirroring the runs/ convention: per-run results.json (metrics + full provenance) + run.log; gzipped native trace kept for run-01 only. Plus README.md (Windows scorecard + provenance + the caveat), COMMANDS.md (exact repro), per-bench REPORT.md, and lines-of-code.run.log. Provenance embedded in every results.json: Windows-11, Intel 10c/12t, engine 3.2.1.30 (sha256 b844140a…, the win64 prebuilt), langchain-core 0.3.86. Outcomes across the 10 reps (all captured, nothing hidden): - fault-isolation: RR isolation holds 10/10; in-process LangChain loses all 0/4 (exit 134) 10/10. - data-isolation: RR 0 lost / 0 leaked 10/10; LangChain shared dict silently loses 100–225 of 256. - concurrent-processing: LangChain .batch(shared) crashes 0/64 (sqlite3.ProgrammingError) 10/10; RR cell status=check 10/10 — the documented Windows caveat (module-level sqlite connection is thread-affine and the v3.2.1 engine runs a pipe's objects on different OS threads even at threads=1). Process isolation still holds; RR degrades partially vs LangChain's total loss. - authoring-effort: RR 0 imperative lines + validates; LangChain 14–17 lines, 5 hidden decisions. Data-only: no benchmark logic changed; the caveat is documented in runs-windows/README.md and harness/REPRODUCE-WINDOWS.md with A/B/C fix options for the team to decide. Co-Authored-By: Claude Opus 4.8 --- .../harness/run_isolated_windows.py | 206 ++++++++++++++++++ concurrent-work/runs-windows/COMMANDS.md | 66 ++++++ concurrent-work/runs-windows/README.md | 63 ++++++ .../runs-windows/authoring-effort/REPORT.md | 29 +++ .../authoring-effort/results.json | 88 ++++++++ .../runs-windows/authoring-effort/run.log | 7 + .../concurrent-processing/REPORT.md | 50 +++++ .../concurrent-processing/run-01/results.json | 131 +++++++++++ .../concurrent-processing/run-01/run.log | 16 ++ .../run-01/trace/rr.appendix_t4.jsonl.gz | Bin 0 -> 10732 bytes .../run-01/trace/rr.m16.jsonl.gz | Bin 0 -> 74618 bytes .../run-01/trace/rr.m8.jsonl.gz | Bin 0 -> 37114 bytes .../concurrent-processing/run-02/results.json | 131 +++++++++++ .../concurrent-processing/run-02/run.log | 16 ++ .../concurrent-processing/run-03/results.json | 131 +++++++++++ .../concurrent-processing/run-03/run.log | 16 ++ .../concurrent-processing/run-04/results.json | 131 +++++++++++ .../concurrent-processing/run-04/run.log | 16 ++ .../concurrent-processing/run-05/results.json | 131 +++++++++++ .../concurrent-processing/run-05/run.log | 16 ++ .../concurrent-processing/run-06/results.json | 131 +++++++++++ .../concurrent-processing/run-06/run.log | 16 ++ .../concurrent-processing/run-07/results.json | 131 +++++++++++ .../concurrent-processing/run-07/run.log | 16 ++ .../concurrent-processing/run-08/results.json | 131 +++++++++++ .../concurrent-processing/run-08/run.log | 16 ++ .../concurrent-processing/run-09/results.json | 131 +++++++++++ .../concurrent-processing/run-09/run.log | 16 ++ .../concurrent-processing/run-10/results.json | 131 +++++++++++ .../concurrent-processing/run-10/run.log | 16 ++ .../runs-windows/data-isolation/REPORT.md | 35 +++ .../data-isolation/run-01/results.json | 102 +++++++++ .../data-isolation/run-01/run.log | 12 + .../run-01/trace/rr.iso.jsonl.gz | Bin 0 -> 444183 bytes .../data-isolation/run-02/results.json | 102 +++++++++ .../data-isolation/run-02/run.log | 12 + .../data-isolation/run-03/results.json | 102 +++++++++ .../data-isolation/run-03/run.log | 12 + .../data-isolation/run-04/results.json | 102 +++++++++ .../data-isolation/run-04/run.log | 12 + .../data-isolation/run-05/results.json | 102 +++++++++ .../data-isolation/run-05/run.log | 12 + .../data-isolation/run-06/results.json | 102 +++++++++ .../data-isolation/run-06/run.log | 12 + .../data-isolation/run-07/results.json | 102 +++++++++ .../data-isolation/run-07/run.log | 12 + .../data-isolation/run-08/results.json | 102 +++++++++ .../data-isolation/run-08/run.log | 12 + .../data-isolation/run-09/results.json | 102 +++++++++ .../data-isolation/run-09/run.log | 12 + .../data-isolation/run-10/results.json | 102 +++++++++ .../data-isolation/run-10/run.log | 12 + .../runs-windows/fault-isolation/REPORT.md | 26 +++ .../fault-isolation/run-01/results.json | 43 ++++ .../fault-isolation/run-01/run.log | 4 + .../fault-isolation/run-02/results.json | 43 ++++ .../fault-isolation/run-02/run.log | 4 + .../fault-isolation/run-03/results.json | 43 ++++ .../fault-isolation/run-03/run.log | 4 + .../fault-isolation/run-04/results.json | 43 ++++ .../fault-isolation/run-04/run.log | 4 + .../fault-isolation/run-05/results.json | 43 ++++ .../fault-isolation/run-05/run.log | 4 + .../fault-isolation/run-06/results.json | 43 ++++ .../fault-isolation/run-06/run.log | 4 + .../fault-isolation/run-07/results.json | 43 ++++ .../fault-isolation/run-07/run.log | 4 + .../fault-isolation/run-08/results.json | 43 ++++ .../fault-isolation/run-08/run.log | 4 + .../fault-isolation/run-09/results.json | 43 ++++ .../fault-isolation/run-09/run.log | 4 + .../fault-isolation/run-10/results.json | 43 ++++ .../fault-isolation/run-10/run.log | 4 + .../runs-windows/lines-of-code.run.log | 22 ++ 74 files changed, 3672 insertions(+) create mode 100644 concurrent-work/harness/run_isolated_windows.py create mode 100644 concurrent-work/runs-windows/COMMANDS.md create mode 100644 concurrent-work/runs-windows/README.md create mode 100644 concurrent-work/runs-windows/authoring-effort/REPORT.md create mode 100644 concurrent-work/runs-windows/authoring-effort/results.json create mode 100644 concurrent-work/runs-windows/authoring-effort/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/REPORT.md create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-01/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-01/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.appendix_t4.jsonl.gz create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m16.jsonl.gz create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m8.jsonl.gz create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-02/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-02/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-03/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-03/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-04/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-04/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-05/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-05/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-06/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-06/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-07/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-07/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-08/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-08/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-09/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-09/run.log create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-10/results.json create mode 100644 concurrent-work/runs-windows/concurrent-processing/run-10/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/REPORT.md create mode 100644 concurrent-work/runs-windows/data-isolation/run-01/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-01/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-01/trace/rr.iso.jsonl.gz create mode 100644 concurrent-work/runs-windows/data-isolation/run-02/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-02/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-03/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-03/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-04/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-04/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-05/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-05/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-06/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-06/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-07/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-07/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-08/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-08/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-09/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-09/run.log create mode 100644 concurrent-work/runs-windows/data-isolation/run-10/results.json create mode 100644 concurrent-work/runs-windows/data-isolation/run-10/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/REPORT.md create mode 100644 concurrent-work/runs-windows/fault-isolation/run-01/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-01/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-02/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-02/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-03/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-03/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-04/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-04/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-05/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-05/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-06/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-06/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-07/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-07/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-08/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-08/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-09/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-09/run.log create mode 100644 concurrent-work/runs-windows/fault-isolation/run-10/results.json create mode 100644 concurrent-work/runs-windows/fault-isolation/run-10/run.log create mode 100644 concurrent-work/runs-windows/lines-of-code.run.log diff --git a/concurrent-work/harness/run_isolated_windows.py b/concurrent-work/harness/run_isolated_windows.py new file mode 100644 index 0000000..64d5be0 --- /dev/null +++ b/concurrent-work/harness/run_isolated_windows.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Windows-native 10x runner for the concurrency benchmarks — the counterpart to run_isolated.sh. + +run_isolated.sh can't drive a Windows run: it writes into ../runs/ (the committed macOS tree), +hardcodes port 5565 (often held by the VS Code extension's engine), and uses lsof / .venv/bin/python +/ --host=0.0.0.0. This driver mirrors its logic on Windows: + + - engine lifecycle on a FREE port (default 5566) via psutil (find listener -> terminate tree -> + relaunch engine.exe ai/eaas.py --host=127.0.0.1 --port=PORT -> poll /ping -> record pid), + - .venv/Scripts/python.exe for the benches, ROCKETRIDE_URI pointed at the chosen port, + - fault-isolation xREPS back-to-back (no restart), authoring-effort x1 (static), + concurrent-processing xREPS @ M={8,16} and data-isolation xREPS @ M=32, each warm-pool rep on a + freshly-restarted+primed engine (retry up to MAX_ATTEMPTS), + - outputs into ../runs-windows//run-NN/ (results.json + captured run.log); trace/ kept for + run-01 only (gzip it afterwards to match the committed convention). + +Env: REPS (default 10), MAX_ATTEMPTS (5), ROCKETRIDE_PORT (5566), RESTART=1 (set 0 to reuse a single +warm engine — the disclosed fallback; correctness outcomes are restart-independent, only warm-pool +timing hygiene differs). + +Run: ./.venv/Scripts/python.exe ../run_isolated_windows.py + (from rocketride-bench/, with the engine provisioned + competitors installed) +""" +import json +import os +import shutil +import subprocess +import sys +import time +import urllib.request + +import psutil + +HERE = os.path.dirname(os.path.abspath(__file__)) # concurrent-work/harness +BR = os.path.join(HERE, "rocketride-bench") +RUNS_WIN = os.path.join(HERE, "..", "runs-windows") +ENGINE_DIR = os.environ.get("ENGINE_DIR") or os.path.join(BR, "engine") +ENGINE_EXE = os.path.join(ENGINE_DIR, "engine.exe") +PY = os.environ.get("BENCH_PY") or os.path.join(BR, ".venv", "Scripts", "python.exe") +PORT = int(os.environ.get("ROCKETRIDE_PORT", "5566")) +URI = "ws://localhost:%d" % PORT +REPS = int(os.environ.get("REPS", "10")) +MAX_ATTEMPTS = int(os.environ.get("MAX_ATTEMPTS", "5")) +DO_RESTART = os.environ.get("RESTART", "1") != "0" +PARAMS = os.path.join(BR, "results", "bench_params.json") # explicit shared path (engine + harness) +ENGINE_LOG = os.path.join(BR, "results", "engine_win.log") + +CRASH = "groups/robustness-and-isolation/fault-isolation" +PICK = "groups/scale-and-concurrency/concurrent-processing" +INST = "groups/scale-and-concurrency/data-isolation" +AUTH = "groups/scale-and-concurrency/authoring-effort" + +# One environment shared by the engine (so task subprocesses inherit the params path + URI) and the +# bench runners (so config.URI / the node's params path agree). +BASE_ENV = dict(os.environ) +BASE_ENV["ROCKETRIDE_URI"] = URI +BASE_ENV["ROCKETRIDE_PORT"] = str(PORT) +BASE_ENV["ROCKETRIDE_BENCH_PARAMS"] = PARAMS +BASE_ENV["ENGINE_DIR"] = ENGINE_DIR +BASE_ENV["PYTHONIOENCODING"] = "utf-8" + +_engine_proc = None + + +def _listener_pid(port): + for c in psutil.net_connections(kind="inet"): + if c.laddr and c.laddr.port == port and c.status == "LISTEN": + return c.pid + return None + + +def stop_engine(): + global _engine_proc + pid = _listener_pid(PORT) + if pid: + try: + p = psutil.Process(pid) + for k in p.children(recursive=True): + try: + k.terminate() + except psutil.Error: + pass + p.terminate() + psutil.wait_procs([p], timeout=8) + except psutil.Error: + pass + _engine_proc = None + + +def _healthy(): + try: + urllib.request.urlopen("http://localhost:%d/ping" % PORT, timeout=2) + return True + except urllib.error.HTTPError: # 401 etc. == a live server + return True + except Exception: # connection refused == not up yet + return False + + +def start_engine(timeout_s=90): + global _engine_proc + os.makedirs(os.path.dirname(ENGINE_LOG), exist_ok=True) + logf = open(ENGINE_LOG, "ab") + _engine_proc = subprocess.Popen( + [ENGINE_EXE, "ai/eaas.py", "--host=127.0.0.1", "--port=%d" % PORT], + cwd=ENGINE_DIR, stdout=logf, stderr=logf, env=BASE_ENV) + t0 = time.time() + while time.time() - t0 < timeout_s: + if _healthy(): + pid = _listener_pid(PORT) + if pid: + with open(os.path.join(BR, "results", "engine.pid"), "w") as f: + f.write(str(pid)) + return True + time.sleep(1.0) + return False + + +def restart(): + stop_engine() + time.sleep(2) + if not start_engine(): + print(" [engine did not come healthy after restart]", flush=True) + time.sleep(3) + + +def prime(): + """Wake the engine's pipe machinery with one quick single-pipe run.""" + try: + subprocess.run([PY, os.path.join(BR, CRASH, "run.py")], + cwd=BR, env=BASE_ENV, stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, timeout=90) + except subprocess.SubprocessError: + pass + + +def copy_out(rel, out_dir, keep_trace): + src = os.path.join(BR, rel, "results.json") + if not os.path.isfile(src): + return False + shutil.copy(src, out_dir) + tr = os.path.join(BR, rel, "trace") + if keep_trace and os.path.isdir(tr): + shutil.copytree(tr, os.path.join(out_dir, "trace"), dirs_exist_ok=True) + return True + + +def run_bench(rel, key, run_name, env_extra, restart_first, keep_trace, flat=False): + out = os.path.join(RUNS_WIN, key) if flat else os.path.join(RUNS_WIN, key, run_name) + os.makedirs(out, exist_ok=True) + env = dict(BASE_ENV) + env.update(env_extra or {}) + for attempt in range(1, MAX_ATTEMPTS + 1): + if restart_first and DO_RESTART: + restart() + prime() + with open(os.path.join(out, "run.log"), "w", encoding="utf-8") as log: + try: + rc = subprocess.run([PY, os.path.join(BR, rel, "run.py")], cwd=BR, env=env, + stdout=log, stderr=subprocess.STDOUT, timeout=360).returncode + except subprocess.TimeoutExpired: + rc = -1 + log.write("\n[TIMEOUT after 360s]\n") + if rc == 0 and copy_out(rel, out, keep_trace): + print(" OK %s %s (attempt %d)" % (key, run_name, attempt), flush=True) + return True + print(" ...retry %s %s (attempt %d, rc=%s)" % (key, run_name, attempt, rc), flush=True) + print(" FAIL %s %s after %d attempts" % (key, run_name, MAX_ATTEMPTS), flush=True) + return False + + +def main(): + for tool in (ENGINE_EXE, PY): + if not os.path.exists(tool): + sys.exit("missing %s — provision the engine + venv first" % tool) + os.makedirs(RUNS_WIN, exist_ok=True) + + print("=== starting engine on :%d ===" % PORT, flush=True) + stop_engine() # clear any stale listener on our port first + time.sleep(1) + if not start_engine(): + sys.exit("engine did not become healthy on :%d" % PORT) + + print("=== fault-isolation x%d (back-to-back, no restart) ===" % REPS, flush=True) + for r in range(1, REPS + 1): + run_bench(CRASH, "fault-isolation", "run-%02d" % r, {}, False, False) + + print("=== authoring-effort x1 (static) ===", flush=True) + run_bench(AUTH, "authoring-effort", "", {}, False, False, flat=True) + + print("=== concurrent-processing x%d @ M={8,16} (restart+prime+retry) ===" % REPS, flush=True) + for r in range(1, REPS + 1): + keep = (r == 1) # trace kept for run-01 only (convention) + run_bench(PICK, "concurrent-processing", "run-%02d" % r, {"BENCH_MS": "8,16"}, True, keep) + + print("=== data-isolation x%d @ M=32 (restart+prime+retry) ===" % REPS, flush=True) + for r in range(1, REPS + 1): + keep = (r == 1) + run_bench(INST, "data-isolation", "run-%02d" % r, {"BENCH_M": "32"}, True, keep) + + stop_engine() + print("=== 10x RUN DONE -> %s ===" % os.path.abspath(RUNS_WIN), flush=True) + + +if __name__ == "__main__": + main() diff --git a/concurrent-work/runs-windows/COMMANDS.md b/concurrent-work/runs-windows/COMMANDS.md new file mode 100644 index 0000000..d99bfee --- /dev/null +++ b/concurrent-work/runs-windows/COMMANDS.md @@ -0,0 +1,66 @@ +# Exact commands that produced this data (Windows) + +All paths relative to `concurrent-work/harness/rocketride-bench/` unless noted. Run from git-bash / MSYS. + +## 1. Provision (Windows) + +The pinned `server-v3.2.1` release ships a `win64.zip` engine (the upstream `provision.sh` now wires it +up — see the PR). It was fetched + extracted to `./engine/engine.exe`, and the venv built with the real +LangChain competitor: + +```bash +bash scripts/provision.sh --competitors # win64 engine + .venv (Scripts/) + langchain-core 0.3.86 +``` +- Engine asset: `https://github.com/rocketride-org/rocketride-server/releases/download/server-v3.2.1/rocketride-server-v3.2.1-win64.zip` +- Engine sha256: `b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e` +- Pins: engine `3.2.1.30`, `langchain-core==0.3.86`, `rocketride==1.2.0`. + +The benchmark-only workload node is installed into the engine bundle (as `start_engine.sh` does): +```bash +cp -R nodes/workload engine/nodes/ +``` + +## 2. Run all 10× reps + +```bash +# from concurrent-work/harness/rocketride-bench/ +./.venv/Scripts/python.exe ../run_isolated_windows.py +``` + +`run_isolated_windows.py` (committed under `harness/`) mirrors `run_isolated.sh` on Windows: +- engine lifecycle on **port 5566** via psutil (the VS Code extension's engine usually holds 5565); +- `.venv/Scripts/python.exe`; `ROCKETRIDE_URI=ws://localhost:5566`; UTF-8 stdout; +- `fault-isolation` ×10 (no restart), `authoring-effort` ×1 (static), + `concurrent-processing` ×10 @ `BENCH_MS=8,16`, `data-isolation` ×10 @ `BENCH_M=32`, + each warm-pool rep on a freshly restarted + primed engine (retry ≤ 5); +- outputs → `../runs-windows//run-NN/{results.json,run.log}`. + +Env knobs: `REPS` (default 10), `MAX_ATTEMPTS` (5), `ROCKETRIDE_PORT` (5566), +`RESTART=0` (disclosed fallback: reuse a single warm engine — correctness is restart-independent). + +## 3. Post-processing + +Traces (`run.py` writes `trace/` every rep) were gzipped for **run-01 only** and dropped elsewhere, per +the `../runs/` convention: +```bash +gzip -f runs-windows/concurrent-processing/run-01/trace/*.jsonl +gzip -f runs-windows/data-isolation/run-01/trace/*.jsonl +``` + +## 4. lines-of-code (OS-independent) + +```bash +python lines-of-code/measure.py # from repo root; regenerates lines-of-code/results.json +``` +This only counts committed artifacts, so Windows output is identical to the committed +`lines-of-code/results.json` (6.0× fewer lines, 3.6× fewer chars). Console captured in +`lines-of-code.run.log`. + +## Single-bench invocations (what the orchestrator runs per rep) + +```bash +ROCKETRIDE_URI=ws://localhost:5566 BENCH_MS=8,16 ./.venv/Scripts/python.exe groups/scale-and-concurrency/concurrent-processing/run.py +ROCKETRIDE_URI=ws://localhost:5566 BENCH_M=32 ./.venv/Scripts/python.exe groups/scale-and-concurrency/data-isolation/run.py +ROCKETRIDE_URI=ws://localhost:5566 ./.venv/Scripts/python.exe groups/robustness-and-isolation/fault-isolation/run.py +ROCKETRIDE_URI=ws://localhost:5566 ./.venv/Scripts/python.exe groups/scale-and-concurrency/authoring-effort/run.py +``` diff --git a/concurrent-work/runs-windows/README.md b/concurrent-work/runs-windows/README.md new file mode 100644 index 0000000..e36d261 --- /dev/null +++ b/concurrent-work/runs-windows/README.md @@ -0,0 +1,63 @@ +# concurrent-work — Windows reproduction (10× reps) + +This is a **full re-run of the concurrency suite on Windows 11**, laid out exactly like the macOS +`../runs/` tree so results are directly comparable. It exists so a reviewer (human or agent) has the +complete input→output evidence in one place — including the **one RocketRide-side result that does not +reproduce clean on Windows** (`concurrent-processing`), which is captured here in full rather than +hidden. + +- **Inputs** are the committed benchmark data (`../harness/rocketride-bench/data/`, + `groups/**/demo-data/`) and the generated `.pipe` configs — unchanged from upstream. +- **Outputs** are per-run `results.json` (metrics + provenance) + full console `run.log`, with a native + `trace/` (gzipped) kept for `run-01` of the two trace-bearing benches, matching the `../runs/` + convention. +- Produced by [`../harness/run_isolated_windows.py`](../harness/run_isolated_windows.py) — the + Windows counterpart to `run_isolated.sh`. See [`COMMANDS.md`](COMMANDS.md) for exact invocations, and + [`../harness/REPRODUCE-WINDOWS.md`](../harness/REPRODUCE-WINDOWS.md) for setup + the caveat's root cause. + +## Provenance + +| | | +|---|---| +| OS | Windows-11 (10.0.26200) | +| CPU | Intel64 Family 6 Model 186 (Raptor Lake), 10 physical / 12 logical cores | +| RAM | 15.55 GiB | +| Python (harness) | 3.12.3 | +| Engine | `3.2.1.30` (hash `114509c6`, stamped 2026-05-29), the pinned **`win64`** prebuilt | +| Engine sha256 | `b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e` | +| LangChain | `langchain-core 0.3.86` (real, out-of-process — the same pin as upstream) | +| Reps | 10× each for crash / pick / instance; authoring is static (×1) | + +Full provenance is embedded in **every** `results.json` (`provenance` + `langchain_provenance` blocks). + +## Scorecard — Windows, stock vs stock (10 reps) + +| Benchmark | Stock LangChain (default idiom) | Stock RocketRide (default) | +|---|---|---| +| [concurrent-processing](concurrent-processing/REPORT.md) | `.batch` (shared conn) **CRASHES 0/64** (`sqlite3.ProgrammingError`) in **10/10**; `.abatch`/seq serialize **~6.7 s** | ⚠️ **`status=check` in 10/10** — partial sqlite thread-affinity errors (2–18 docs/rep). Process isolation holds; see caveat below | +| [fault-isolation](fault-isolation/REPORT.md) | in-process `.abatch` **loses ALL 0/4** to one crash (exit 134) in 10/10 | ✅ **survives 10/10** — only the crashing run dies, server + siblings live | +| [data-isolation](data-isolation/REPORT.md) | one shared dict, 32 workers → **silently loses 100–225 of 256** (39–88%) | ✅ **0 lost / 0 leaked, 10/10** — each pipe its own process | +| [authoring-effort](authoring-effort/REPORT.md) | **14–17** imperative lines + up to **5** hidden decisions | ✅ **0** imperative concurrency lines (validated `.pipe`) | +| lines-of-code (OS-independent) | ~689 lines, 8–11 files | **123 lines, 1 file** — 6.0× fewer lines, 3.6× fewer chars | + +## The Windows caveat (concurrent-processing) + +On macOS/Linux the RR `concurrent-processing` cell is `0 errors, 72/72, status=ok`. On **Windows it is +`status=check` in all 10 reps**: the workload node caches a **module-level sqlite connection** (the naive +idiom, `conn="module"`), and the v3.2.1 engine dispatches a pipe's objects to **different OS threads even +at `threads=1`**, so the thread-affine connection raises `sqlite3.ProgrammingError` on some docs +(node_errors per rep across this run: `5, 18, 7, 15, 8, 9, 11, 2, 5, 10`). **Process isolation still +holds** (M pipes = M PIDs); RR degrades *partially* (surviving pipes complete) versus LangChain's `.batch` +which loses **all 64**. Only *thread-affine* resources are affected — `data-isolation` uses a GIL-safe +`list.append` and reproduces `0 lost` here. The repo's own appendix honesty cell (`1 pipe × threadCount=4`) +shows the same **31 errors** on this run — the mechanism was always disclosed, just not flagged as +OS-dependent. Fix options (A: thread-local node conn · B: scope to mac/linux · C: engine per-pipe +threading) are in [`../harness/REPRODUCE-WINDOWS.md`](../harness/REPRODUCE-WINDOWS.md); this data set does +**not** change the RR numbers or the claim — it documents them. + +## Deviation from `../runs/` method (disclosed) + +Each warm-pool rep runs on a **freshly restarted + primed engine**, same as `run_isolated.sh`. The engine +runs on **port 5566** (not 5565) because the RocketRide VS Code extension's engine commonly holds 5565; +this affects nothing measured. Absolute wall-clock differs from the macOS numbers (different hardware) — +per upstream, **ratios and correctness outcomes reproduce; absolute values vary**. diff --git a/concurrent-work/runs-windows/authoring-effort/REPORT.md b/concurrent-work/runs-windows/authoring-effort/REPORT.md new file mode 100644 index 0000000..f0b74a8 --- /dev/null +++ b/concurrent-work/runs-windows/authoring-effort/REPORT.md @@ -0,0 +1,29 @@ +# authoring-effort · Windows (static) — reproduces clean + +> **Verdict on Windows: ✅ 0 imperative concurrency lines, `.pipe` validates.** The RocketRide artifact is +> one declarative `.pipe` with **0 imperative concurrency lines**, and it **validates against the engine** +> on Windows. The LangChain side needs **14–17 imperative lines** and up to **5** pieces of hidden +> knowledge — and, as `concurrent-processing` shows, its three natural idioms crash / silently serialize / +> run slow. Static + deterministic, so a single run (no reps), matching the macOS layout. + +## Method +Identical to `../../runs/authoring-effort/REPORT.md`. Counts imperative lines + decision points in the +four LangChain idiom files (`lc/concurrent_*.py`) and validates the RR `.pipe` against the live engine +(`validate()` over the direct-connect server). Engine on port 5566. + +## Results +| Side | Imperative concurrency lines | Hidden decisions | Validated | +|---|---:|---:|---| +| **Stock RocketRide** (`rr/workflow.pipe`) | **0** | **0** | ✅ PASS (against engine 3.2.1.30) | +| LangChain `concurrent_batch.py` | 14 | 3 | — | +| LangChain `concurrent_abatch.py` | 17 | 4 | — | +| LangChain `concurrent_seq.py` | 14 | 1 | — | +| LangChain `concurrent_percall.py` (the correct one) | 17 | **5** | — | + +The correct LangChain version requires knowing thread-affinity + per-call state discipline the API never +surfaces; RocketRide authors zero concurrency code (claim is about imperative concurrency lines, not token +count — token count favors LangChain, disclosed upstream). + +## Provenance +Single static run (`results.json` + `run.log`); `validate()` ran against the Windows engine on port 5566 +(`rocketride.validate.ran = true, ok = true`). langchain-core `0.3.86` present. diff --git a/concurrent-work/runs-windows/authoring-effort/results.json b/concurrent-work/runs-windows/authoring-effort/results.json new file mode 100644 index 0000000..4f9e42a --- /dev/null +++ b/concurrent-work/runs-windows/authoring-effort/results.json @@ -0,0 +1,88 @@ +{ + "benchmark": "authoring-effort", + "hypothesis": "RR authoring carries zero imperative concurrency code and validates offline; LangChain authoring forces an unguided 3-way concurrency choice where one crashes, one silently serializes, one is slow (measured in concurrent-processing)", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "file": "rr/workflow.pipe", + "imperative_lines": 0, + "components": 2, + "decision_points": 0, + "note": "concurrency/isolation owned by the runtime (M pipes, ttl= are RUN-time args, not authored code); each pipeline runs as its own process, so isolation is per-pipe by construction; artifact is schema-validated", + "validate": { + "ran": true, + "ok": true, + "errors": null + } + }, + "langchain": [ + { + "file": "lc/concurrent_batch.py", + "imperative_lines": 14, + "decision_points": 3, + "decisions": [ + "batch vs abatch vs loop", + "max_concurrency value", + ".batch uses threads (implicit)" + ] + }, + { + "file": "lc/concurrent_abatch.py", + "imperative_lines": 17, + "decision_points": 4, + "decisions": [ + "batch vs abatch vs loop", + "max_concurrency value", + "sync vs async chain legs", + "blocking-sync-in-async serializes (implicit, silent)" + ] + }, + { + "file": "lc/concurrent_seq.py", + "imperative_lines": 14, + "decision_points": 1, + "decisions": [ + "batch vs abatch vs loop (gave up concurrency)" + ] + }, + { + "file": "lc/concurrent_percall.py", + "imperative_lines": 17, + "decision_points": 5, + "decisions": [ + "batch vs abatch vs loop", + "max_concurrency value", + ".batch uses threads (implicit)", + "sqlite conns are thread-affine (library doc)", + "therefore: state per call, never captured (discipline)" + ] + } + ], + "scope": { + "note": "this claim is about imperative concurrency lines, not token count" + }, + "verdict_metrics": { + "rr_imperative_lines": 0, + "lc_imperative_lines_min": 14, + "lc_imperative_lines_max": 17, + "lc_decision_points_correct_version": 5, + "lc_natural_idioms_delivering_concurrency": 0, + "lc_idiom_outcomes": { + "batch": "crashes", + "abatch": "silently_serializes", + "seq": "slow_correct" + } + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/authoring-effort/run.log b/concurrent-work/runs-windows/authoring-effort/run.log new file mode 100644 index 0000000..a1dff94 --- /dev/null +++ b/concurrent-work/runs-windows/authoring-effort/run.log @@ -0,0 +1,7 @@ +RR: rr/workflow.pipe — 0 imperative lines, 2 components, validate: PASS +LC: lc/concurrent_batch.py 14 imperative lines, 3 decision points +LC: lc/concurrent_abatch.py 17 imperative lines, 4 decision points +LC: lc/concurrent_seq.py 14 imperative lines, 1 decision points +LC: lc/concurrent_percall.py 17 imperative lines, 5 decision points + +VERDICT: the correct LC version needs 5 pieces of hidden knowledge; one crashes, one silently serializes, one is slow (see concurrent-processing). RR authors zero concurrency code (this claim is about imperative concurrency lines, not token count). diff --git a/concurrent-work/runs-windows/concurrent-processing/REPORT.md b/concurrent-work/runs-windows/concurrent-processing/REPORT.md new file mode 100644 index 0000000..91c5f95 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/REPORT.md @@ -0,0 +1,50 @@ +# concurrent-processing · Windows (10 reps) — the RR-side caveat + +> **Verdict on Windows: ⚠️ RocketRide is NOT clean here.** Same per-doc work (sqlite +> `INSERT`+`SELECT`+`commit` + 100 ms wait, AST-parity-gated) over 64 docs. The LangChain side behaves +> exactly as on macOS — `.batch` (shared conn) **CRASHES 0/64** (`sqlite3.ProgrammingError`) in **10/10**, +> `.abatch`/seq serialize (~6.7 s). **But the RocketRide cell reports `status=check` in all 10 reps**: +> the naive module-level sqlite connection hits the *same* thread-affinity error on Windows, because the +> v3.2.1 engine runs a pipe's objects on different OS threads even at `threads=1`. Process isolation still +> holds (M pipes = M PIDs); RR degrades **partially** (surviving pipes complete) vs LangChain's **total** +> 0/64. This differs from the macOS result (`0 errors, 72/72, ok`). + +## Method +Identical to `../../runs/concurrent-processing/REPORT.md` — AST-parity-gated per-doc work, RR at +M∈{8,16} warm pipes with the **naive module-level connection** (`conn="module"`), real LangChain +(`lc_version 0.3.86`) with its three idioms. **10 fresh reps**, each on a restarted + primed engine on +Windows (`../../harness/run_isolated_windows.py`), port 5566. + +## Results *(10 reps; Windows 11, Intel 10c/12t, langchain-core 0.3.86, engine 3.2.1.30)* +| Configuration | Wall (64 docs) | Outcome | +|---|---:|---| +| Stock RocketRide, 16 warm pipes | ~2.59 s (median) | ⚠️ **`status=check` 10/10** — node_errors per rep: `5,18,7,15,8,9,11,2,5,10` (`sqlite3.ProgrammingError`) | +| Stock RocketRide, 8 warm pipes | ~1.31 s (median) | ⚠️ same thread-affinity errors | +| Stock LangChain `.batch` (shared conn) | ~0.05 s | ❌ **CRASH 0/64** (`sqlite3.ProgrammingError`) — 10/10 | +| Stock LangChain `.abatch` (blocking) | ~6.7 s | ⚠️ **SERIALIZED** | +| Stock LangChain sequential loop | ~6.9 s | ⚠️ **SLOW** | +| RR appendix — 1 pipe × threadCount=4 (naive conn) | — | ❌ **31 errors** (same trap; shown on Windows exactly as on macOS) | + +## Root cause (why RR is not clean on Windows) +The workload node caches one sqlite connection at module level. SQLite connections are **thread-affine**. +On macOS/Linux an RR pipe runs its objects on **one** worker thread, so the cached connection is always +used on its creating thread (safe → 0 errors). On **Windows the engine dispatches successive objects to +different OS threads even at `threads=1`**, so the connection is reused off-thread and raises +`sqlite3.ProgrammingError` on some docs. The appendix honesty cell (`1 pipe × threadCount=4` → 31 errors) +demonstrates the identical mechanism and reproduces here — it was always disclosed, just not flagged as +OS-dependent for the `threads=1` headline path. + +Only **thread-affine** resources are affected — `data-isolation` (module-level `list.append`, GIL-safe) +reproduces `0 lost` on Windows. RR still beats LangChain here (partial vs total loss), but this is **not** +the clean "0 errors" macOS headline. + +## Fix options (team decision — not applied in this data set) +A) node uses a thread-local connection → 0 errors on every OS (Mac numbers unchanged); +B) keep naive-both, scope the "0 errors" row to macOS/Linux and report Windows degradation; +C) engine fix: make `threads=1` mean one OS thread per pipe on Windows. +Details in [`../../harness/REPRODUCE-WINDOWS.md`](../../harness/REPRODUCE-WINDOWS.md). + +## Provenance +10 reps (`run-01/ … run-10/`), each on a restarted + primed engine on port 5566; real LangChain +`0.3.86` per row; AST parity gate PASS; native trace gzipped in `run-01/trace/`. Raw per-doc markers +(PID, thread id, the exact sqlite errors) are in that trace. diff --git a/concurrent-work/runs-windows/concurrent-processing/run-01/results.json b/concurrent-work/runs-windows/concurrent-processing/run-01/results.json new file mode 100644 index 0000000..5bd6e87 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-01/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.422, + "warm_s": 15.16, + "p50_ms": 169.24, + "p99_ms": 256.87, + "markers": 72, + "marker_pids": 8, + "node_errors": 2, + "sqlite_rows": 70, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.487, + "warm_s": 28.23, + "p50_ms": 588.37, + "p99_ms": 925.31, + "markers": 80, + "marker_pids": 16, + "node_errors": 3, + "sqlite_rows": 147, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.07202149997465312, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 3804 and this is thread id 23036.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.704501100000925, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.84342629997991, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 2184 and this is thre" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.487, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.7, + "lc_seq_wall_s": 6.84, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-01/run.log b/concurrent-work/runs-windows/concurrent-processing/run-01/run.log new file mode 100644 index 0000000..7f03c17 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-01/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.422s p50= 169.2ms p99= 256.9ms markers=72/72 errs=2 rows=70/72 [check] + M=16 wall= 2.487s p50= 588.4ms p99= 925.3ms markers=80/80 errs=3 rows=147/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.07s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.70s ok=64 err= 0 + LC seq status=ok wall= 6.84s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.49s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 6.8s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.appendix_t4.jsonl.gz b/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.appendix_t4.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..4f90fac2da3ac6a50a4d344fac79a11b8d10dd00 GIT binary patch literal 10732 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 literal 0 HcmV?d00001 diff --git a/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m16.jsonl.gz b/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m16.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..a76917a5ed70611357d3359b624b2161e50f998e GIT binary patch literal 74618 zcmZ6Rb8u!)_~m0K6Ki7Iwr$(CZQHhOPV&Y!Cwb#!VrOC}JKx>Q4`D0}49l#74G6f43xho~2ZN2Pqk|pDWxlTC=0wW)F4o!&(Tg?KPiFt>KFF-d zbt5dwwbm1a;}GvGJZyAn@(rpCi4vAnv_pU+yZyS#P(}Arvu}ooiEJpbf))XabLszBd_n6nR0-gKrYs!owMn@mc4_61*hXB z;EC?tJm4L=?^jH$LIr2P);|RJTw1GY-{*hF@)X|mtoH;5U9bIo;*gP6*sP)r%BB*_G*BUZRT}fU}f7h>Ge8{)A54d#H zRossfcHYk<+(7fS^t}%pmin9TzJILGjn^2=#<;sWG;irK(&mA58Wz2(uAAP}KF6+% zUp%M2mpbYsGSq%-yKjnL?>hNae7d|wa@K2Z5;%T~O}7hh2A+7X%nmbgKH3SqTLyT} z2Xg<;aK6UR*_NZtGaDU_W8k>(x$SE{_fX;gxTfd!g6*zp+v-x))gq~0E#lDv^P;>T zrb1byO4g^MHm`PP&yJH-Ib&`jAylLgNx;ZwsPtNOh!>rGY@22F-Nq}RpQbRs|2Mgr6}FCQ7LzujH=;FL^B`WQY|i0 z5$jVCcblo5yU-!zClnVQacSD{6dWIkX||B5g2R&khhhwBj;g`&3TPVBklGJ}=xB-P zQ!&_7jL05bMH-TEp>UiFu-{p5N;Ft1=zk%oytV8U=%oMARbp164GFDPQU*1|t3{H1 zw?0%%hD)&kiB=kSoF_NNbYzBLRx@Uib7HCiQW%q>Xr)Y+^&foHa#2j;)ThDNlG37H zK#BxLIV(0fH7q#_a(1!5E_H1Z^Isq*!4$DS>h>$1^`#G?a^~Bh|gwOcc{yhqt2SFQlTIqMK0Y zQ0kWT@6DujzYM61Hk#!N zzPH8)ol%PEzcOHQ|FLPhkJ~cR)IcMsn8CCJZoKKb_OI>`W=3dfwnZH@VaBMVdp=De zBMQeqI>!A3%wR3`s|Wk&&P*$7`P*;Q3A6o;v!$&tCf~iTM{eBmX=a;4o2avih&hNk z@F)i4Isp~~Y_=egR!idsn!aNPwF0OF!>Ao>PE5U7W0YG;M8E&t(P5lA9W=GMUT zwp5mQ)$k;@py^K*5<%W#4I%=Va_^Z%?ca5;X
  • |BtUFljOlT>jO2;;5eFcNLB*2 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 R0LB$F_untE+sk-x{{tsos3HIW literal 0 HcmV?d00001 diff --git a/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m8.jsonl.gz b/concurrent-work/runs-windows/concurrent-processing/run-01/trace/rr.m8.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..cdb3bae010ba5d0974fa43988c35538ae45ff2b4 GIT binary patch literal 37114 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 b^F6OG{p|KZe@3{Vm$>{tz{k|w&wL61g3N=E literal 0 HcmV?d00001 diff --git a/concurrent-work/runs-windows/concurrent-processing/run-02/results.json b/concurrent-work/runs-windows/concurrent-processing/run-02/results.json new file mode 100644 index 0000000..74dff1b --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-02/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.268, + "warm_s": 13.96, + "p50_ms": 142.78, + "p99_ms": 219.03, + "markers": 72, + "marker_pids": 8, + "node_errors": 14, + "sqlite_rows": 58, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 1.487, + "warm_s": 26.25, + "p50_ms": 363.63, + "p99_ms": 429.54, + "markers": 80, + "marker_pids": 16, + "node_errors": 4, + "sqlite_rows": 134, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.02544219995616004, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 9676 and this is thread id 21756.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.678910699964035, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.875936200027354, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 27416 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 1.487, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.68, + "lc_seq_wall_s": 6.88, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-02/run.log b/concurrent-work/runs-windows/concurrent-processing/run-02/run.log new file mode 100644 index 0000000..150a781 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-02/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.268s p50= 142.8ms p99= 219.0ms markers=72/72 errs=14 rows=58/72 [check] + M=16 wall= 1.487s p50= 363.6ms p99= 429.5ms markers=80/80 errs=4 rows=134/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.03s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.68s ok=64 err= 0 + LC seq status=ok wall= 6.88s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 1.49s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 6.9s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-03/results.json b/concurrent-work/runs-windows/concurrent-processing/run-03/results.json new file mode 100644 index 0000000..081d081 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-03/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.134, + "warm_s": 14.36, + "p50_ms": 136.7, + "p99_ms": 180.86, + "markers": 72, + "marker_pids": 8, + "node_errors": 5, + "sqlite_rows": 67, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.244, + "warm_s": 26.49, + "p50_ms": 556.86, + "p99_ms": 609.49, + "markers": 80, + "marker_pids": 16, + "node_errors": 2, + "sqlite_rows": 145, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.03077309997752309, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 5760 and this is thread id 15504.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.749166599998716, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.907986800011713, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 10404 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.244, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.75, + "lc_seq_wall_s": 6.91, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-03/run.log b/concurrent-work/runs-windows/concurrent-processing/run-03/run.log new file mode 100644 index 0000000..4925a5d --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-03/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.134s p50= 136.7ms p99= 180.9ms markers=72/72 errs=5 rows=67/72 [check] + M=16 wall= 2.244s p50= 556.9ms p99= 609.5ms markers=80/80 errs=2 rows=145/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.03s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.75s ok=64 err= 0 + LC seq status=ok wall= 6.91s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.24s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.8s | LC seq 6.9s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-04/results.json b/concurrent-work/runs-windows/concurrent-processing/run-04/results.json new file mode 100644 index 0000000..94f5299 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-04/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.349, + "warm_s": 18.61, + "p50_ms": 160.79, + "p99_ms": 191.63, + "markers": 72, + "marker_pids": 8, + "node_errors": 7, + "sqlite_rows": 65, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 3.432, + "warm_s": 32.0, + "p50_ms": 797.47, + "p99_ms": 1486.19, + "markers": 80, + "marker_pids": 16, + "node_errors": 8, + "sqlite_rows": 137, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.05078969994792715, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 26968 and this is thread id 14664.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.734708099975251, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.9535108000272885, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 8064 and this is thre" + }, + "verdict_metrics": { + "rr_topM_wall_s": 3.432, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.73, + "lc_seq_wall_s": 6.95, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-04/run.log b/concurrent-work/runs-windows/concurrent-processing/run-04/run.log new file mode 100644 index 0000000..5926e4d --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-04/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.349s p50= 160.8ms p99= 191.6ms markers=72/72 errs=7 rows=65/72 [check] + M=16 wall= 3.432s p50= 797.5ms p99=1486.2ms markers=80/80 errs=8 rows=137/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.05s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.73s ok=64 err= 0 + LC seq status=ok wall= 6.95s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 3.43s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 7.0s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-05/results.json b/concurrent-work/runs-windows/concurrent-processing/run-05/results.json new file mode 100644 index 0000000..296d7c3 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-05/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.554, + "warm_s": 16.86, + "p50_ms": 186.09, + "p99_ms": 235.48, + "markers": 72, + "marker_pids": 8, + "node_errors": 4, + "sqlite_rows": 68, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 3.502, + "warm_s": 28.58, + "p50_ms": 925.46, + "p99_ms": 1196.6, + "markers": 80, + "marker_pids": 16, + "node_errors": 4, + "sqlite_rows": 144, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.02280640002572909, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 25408 and this is thread id 23416.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.76732169999741, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.818126900005154, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 27688 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 3.502, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.77, + "lc_seq_wall_s": 6.82, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-05/run.log b/concurrent-work/runs-windows/concurrent-processing/run-05/run.log new file mode 100644 index 0000000..b60d558 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-05/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.554s p50= 186.1ms p99= 235.5ms markers=72/72 errs=4 rows=68/72 [check] + M=16 wall= 3.502s p50= 925.5ms p99=1196.6ms markers=80/80 errs=4 rows=144/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.02s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.77s ok=64 err= 0 + LC seq status=ok wall= 6.82s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 3.50s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.8s | LC seq 6.8s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-06/results.json b/concurrent-work/runs-windows/concurrent-processing/run-06/results.json new file mode 100644 index 0000000..de71857 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-06/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.273, + "warm_s": 18.61, + "p50_ms": 150.06, + "p99_ms": 190.45, + "markers": 72, + "marker_pids": 8, + "node_errors": 9, + "sqlite_rows": 63, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.324, + "warm_s": 29.69, + "p50_ms": 520.96, + "p99_ms": 687.41, + "markers": 80, + "marker_pids": 16, + "node_errors": 0, + "sqlite_rows": 143, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.02463030000217259, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 17504 and this is thread id 28092.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.7381943999789655, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 7.052462599996943, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 21740 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.324, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.74, + "lc_seq_wall_s": 7.05, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-06/run.log b/concurrent-work/runs-windows/concurrent-processing/run-06/run.log new file mode 100644 index 0000000..8c1cecb --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-06/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.273s p50= 150.1ms p99= 190.4ms markers=72/72 errs=9 rows=63/72 [check] + M=16 wall= 2.324s p50= 521.0ms p99= 687.4ms markers=80/80 errs=0 rows=143/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.02s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.74s ok=64 err= 0 + LC seq status=ok wall= 7.05s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.32s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 7.0s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-07/results.json b/concurrent-work/runs-windows/concurrent-processing/run-07/results.json new file mode 100644 index 0000000..d61278c --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-07/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.15, + "warm_s": 15.4, + "p50_ms": 138.5, + "p99_ms": 183.4, + "markers": 72, + "marker_pids": 8, + "node_errors": 10, + "sqlite_rows": 62, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.529, + "warm_s": 29.02, + "p50_ms": 581.5, + "p99_ms": 839.48, + "markers": 80, + "marker_pids": 16, + "node_errors": 1, + "sqlite_rows": 141, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.03265460004331544, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 27884 and this is thread id 11108.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.770614699984435, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.915475099987816, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 19716 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.529, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.77, + "lc_seq_wall_s": 6.92, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-07/run.log b/concurrent-work/runs-windows/concurrent-processing/run-07/run.log new file mode 100644 index 0000000..d587139 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-07/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.150s p50= 138.5ms p99= 183.4ms markers=72/72 errs=10 rows=62/72 [check] + M=16 wall= 2.529s p50= 581.5ms p99= 839.5ms markers=80/80 errs=1 rows=141/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.03s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.77s ok=64 err= 0 + LC seq status=ok wall= 6.92s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.53s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.8s | LC seq 6.9s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-08/results.json b/concurrent-work/runs-windows/concurrent-processing/run-08/results.json new file mode 100644 index 0000000..6f139f3 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-08/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.267, + "warm_s": 18.18, + "p50_ms": 150.62, + "p99_ms": 196.12, + "markers": 72, + "marker_pids": 8, + "node_errors": 0, + "sqlite_rows": 72, + "rows_expected": 72, + "status": "ok" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.66, + "warm_s": 28.36, + "p50_ms": 648.93, + "p99_ms": 868.63, + "markers": 80, + "marker_pids": 16, + "node_errors": 2, + "sqlite_rows": 150, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.031055300030857325, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 14212 and this is thread id 26788.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.67555009998614, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.956492300028913, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 22824 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.66, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.68, + "lc_seq_wall_s": 6.96, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-08/run.log b/concurrent-work/runs-windows/concurrent-processing/run-08/run.log new file mode 100644 index 0000000..26d5f1f --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-08/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.267s p50= 150.6ms p99= 196.1ms markers=72/72 errs=0 rows=72/72 [ok] + M=16 wall= 2.660s p50= 648.9ms p99= 868.6ms markers=80/80 errs=2 rows=150/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.03s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.68s ok=64 err= 0 + LC seq status=ok wall= 6.96s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.66s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 7.0s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-09/results.json b/concurrent-work/runs-windows/concurrent-processing/run-09/results.json new file mode 100644 index 0000000..aa99bdf --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-09/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.598, + "warm_s": 15.85, + "p50_ms": 188.69, + "p99_ms": 246.29, + "markers": 72, + "marker_pids": 8, + "node_errors": 3, + "sqlite_rows": 69, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.917, + "warm_s": 27.74, + "p50_ms": 683.05, + "p99_ms": 787.95, + "markers": 80, + "marker_pids": 16, + "node_errors": 2, + "sqlite_rows": 147, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.03623570001218468, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 26664 and this is thread id 15988.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.70997049997095, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.9088501000078395, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 16184 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.917, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.71, + "lc_seq_wall_s": 6.91, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-09/run.log b/concurrent-work/runs-windows/concurrent-processing/run-09/run.log new file mode 100644 index 0000000..f9353fc --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-09/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.598s p50= 188.7ms p99= 246.3ms markers=72/72 errs=3 rows=69/72 [check] + M=16 wall= 2.917s p50= 683.0ms p99= 788.0ms markers=80/80 errs=2 rows=147/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.04s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.71s ok=64 err= 0 + LC seq status=ok wall= 6.91s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.92s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 6.9s diff --git a/concurrent-work/runs-windows/concurrent-processing/run-10/results.json b/concurrent-work/runs-windows/concurrent-processing/run-10/results.json new file mode 100644 index 0000000..b9b94f4 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-10/results.json @@ -0,0 +1,131 @@ +{ + "benchmark": "concurrent-processing", + "hypothesis": "64 docs of stateful per-doc work: LangChain's idioms crash, serialize, or run sequential; RR's warm per-pipe topology is fast AND safe", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 64, + "io_s": 0.1, + "Ms": [ + 8, + 16 + ], + "max_concurrency": 64, + "work": "sqlite INSERT+SELECT+commit + blocking sleep(io_s), AST-identical (parity-gated)" + }, + "parity_gate": "PASS", + "rocketride": [ + { + "M": 8, + "n_docs": 64, + "wall_s": 1.389, + "warm_s": 16.83, + "p50_ms": 152.0, + "p99_ms": 238.15, + "markers": 72, + "marker_pids": 8, + "node_errors": 8, + "sqlite_rows": 64, + "rows_expected": 72, + "status": "check" + }, + { + "M": 16, + "n_docs": 64, + "wall_s": 2.677, + "warm_s": 29.71, + "p50_ms": 654.46, + "p99_ms": 738.02, + "markers": 80, + "marker_pids": 16, + "node_errors": 2, + "sqlite_rows": 142, + "rows_expected": 80, + "status": "check" + } + ], + "langchain": { + "batch_shared": { + "mode": "batch_shared", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 0.026168700016569346, + "n_ok": 0, + "n_err": 64, + "status": "crash", + "error_type": "sqlite3.ProgrammingError", + "error_example": "SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 10300 and this is thread id 1972.", + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "abatch_blocking": { + "mode": "abatch_blocking", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.669205099984538, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + "seq": { + "mode": "seq", + "n": 64, + "io_s": 0.1, + "max_concurrency": 64, + "wall_s": 6.904610500030685, + "n_ok": 64, + "n_err": 0, + "status": "ok", + "error_type": null, + "error_example": null, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + }, + "rr_appendix_threads4": { + "topology": "1 pipe x threadCount=4, 32 files, naive module-level conn", + "markers": 32, + "distinct_tids": 4, + "node_errors": 31, + "error_example": "RRBENCH_ERR\tProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 25708 and this is thr" + }, + "verdict_metrics": { + "rr_topM_wall_s": 2.677, + "rr_topM_ok": false, + "lc_batch_shared_status": "crash", + "lc_batch_shared_error": "sqlite3.ProgrammingError", + "lc_abatch_blocking_wall_s": 6.67, + "lc_seq_wall_s": 6.9, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/concurrent-processing/run-10/run.log b/concurrent-work/runs-windows/concurrent-processing/run-10/run.log new file mode 100644 index 0000000..555e690 --- /dev/null +++ b/concurrent-work/runs-windows/concurrent-processing/run-10/run.log @@ -0,0 +1,16 @@ +parity gate: PASS (per-doc work AST-identical both sides) +real LangChain proven: 0.3.86 (D:\Coding\rr\rocketride-benchmark\concurrent-work\harness\rocketride-bench\.venv\Scripts\python.exe) + +RR warm pools (N=64 docs, 100 ms work): + M= 8 wall= 1.389s p50= 152.0ms p99= 238.2ms markers=72/72 errs=8 rows=64/72 [check] + M=16 wall= 2.677s p50= 654.5ms p99= 738.0ms markers=80/80 errs=2 rows=142/80 [check] + +LangChain (same chain object, n=64, io=100 ms, mc=64): + LC batch_shared status=crash wall= 0.03s ok= 0 err=64 sqlite3.ProgrammingError + LC abatch_blocking status=ok wall= 6.67s ok=64 err= 0 + LC seq status=ok wall= 6.90s ok=64 err= 0 +wrote: canvas.mmd canvas.dot + +appendix (1 pipe x threads=4, shared module conn): markers=32 tids=4 errors=31 + +VERDICT @ top M: RR(top M) 2.68s CHECK (node errors — see rocketride[].status) | LC .batch(shared) crash (sqlite3.ProgrammingError) | LC .abatch(blocking) 6.7s | LC seq 6.9s diff --git a/concurrent-work/runs-windows/data-isolation/REPORT.md b/concurrent-work/runs-windows/data-isolation/REPORT.md new file mode 100644 index 0000000..02769b0 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/REPORT.md @@ -0,0 +1,35 @@ +# data-isolation · Windows (10 reps) — reproduces clean + +> **Verdict on Windows: ✅ RocketRide 0 lost / 0 leaked, 10/10.** 256 named docs through 32 warm pipes: +> every pipe ends holding exactly its own docs — **0 lost, 0 leaked in all 10 reps**. The SAME naive +> shared-dict idiom in LangChain (`.batch`, 32 workers, non-atomic read→busy(gap)→write) **silently loses +> 100–225 of 256 updates (39–88%)** with no exception. This bench reproduces the macOS result faithfully +> on Windows because the per-pipe accumulator is a GIL-safe `list.append` — no thread-affine resource, so +> the Windows engine's multi-thread-per-pipe behavior (which breaks `concurrent-processing`) does not +> affect it. + +## Method +Identical to `../../runs/data-isolation/REPORT.md`. RR: 256 docs round-robin through M=32 warm pipes +(`iso_accumulate` appends each doc's name to a module-level per-process list; the harness verifies each +PID's final state from `RRBENCH_STATE` trace lines). LangChain (real, `0.3.86`): one shared dict, 32 +`.batch` workers, the suite's `busy(gap)` loop in the read→write window, swept over gaps {20k, 50k, 100k}. +**10 fresh reps**, restarted + primed engine, Windows, port 5566. + +## Results *(10 reps; Windows 11, engine 3.2.1.30, langchain-core 0.3.86)* +| Configuration | Outcome | +|---|---| +| **Stock RocketRide, 32 warm pipes** | ✅ **0 lost / 0 leaked, 32/32 clean partitions — 10/10 reps** (wall ~33.5 s median, 256 docs) | +| LangChain shared dict, gap=20k | ❌ silently loses **100–174** of 256 | +| LangChain shared dict, gap=50k | ❌ silently loses **134–211** of 256 | +| LangChain shared dict, gap=100k | ❌ silently loses **167–225** of 256 | + +Across the sweep the LangChain shared-dict idiom drops **39–88%** of updates with **no error raised** +(the counter under-counts while the list still appends). RocketRide's per-pipe process isolation makes +the naive per-pipe accumulator correct by construction. + +## Provenance +10 reps (`run-01/ … run-10/`), each on a restarted + primed engine (port 5566); real LangChain `0.3.86` +per row; native trace gzipped in `run-01/trace/rr.iso.jsonl.gz` (every pipe's final `RRBENCH_STATE`). +The 38–84% figure in the macOS headline is a function of the injected `busy(gap)` window (disclosed); the +*silent lost-update race* is the structural result, the exact % is a dial — the gap sweep is shown so the +range is explicit. diff --git a/concurrent-work/runs-windows/data-isolation/run-01/results.json b/concurrent-work/runs-windows/data-isolation/run-01/results.json new file mode 100644 index 0000000..af01106 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-01/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 25.738, + "warm_s": 66.33, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.3510181000456214, + "expected": 256, + "observed_counter": 115, + "lost_updates": 141, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9521291999844834, + "expected": 256, + "observed_counter": 89, + "lost_updates": 167, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 2.523222199990414, + "expected": 256, + "observed_counter": 51, + "lost_updates": 205, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 205, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 141, + "50000": 167, + "100000": 205 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-01/run.log b/concurrent-work/runs-windows/data-isolation/run-01/run.log new file mode 100644 index 0000000..f176d9d --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-01/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=25.74s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=115 lost=141 (wall 0.35s) + LC shared dict gap=50000 expected=256 observed=89 lost=167 (wall 0.95s) + LC shared dict gap=100000 expected=256 observed=51 lost=205 (wall 2.52s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 205/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-01/trace/rr.iso.jsonl.gz b/concurrent-work/runs-windows/data-isolation/run-01/trace/rr.iso.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..eacc1230a37856e1d8054bcf64cce0492670838e GIT binary patch literal 444183 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%0A3<7m)&E46`vpY$~&c@gj->j%mDHCMmB^815J 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 z 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

    HE?CDs2i+JcV?Za(?{MHZB6Mcwj$ z{r?!PB@bZz{{qW*JQPRE;{KS@Iu7`9eDx`g?TO!X@7&&5Fyzx;%*?kB<3#_hX~>x9 z7TZ|wC(H&%{cykGI~*;&e11C$NqVgqn%e+o zUOh@~cKm=N>@7f$Wg^O>2(uD!6l_bSl`S!9Ntdx!U%uQ?CFyMos;We!MqPn2d^*zr z(}uLhmvGwuX-12kXv0Png#%j6FyslJsqCHmJCt+6YiGhTAIO_-!WEY?knKF&K?9$W14XK<~3TL&Wpe8(PclkwC?smryuO z)BU8ed4`qwn5Wb4Yu=XOiaF^+`sZ%SvORBdfKu+yO4G}_AVPgm)!Y|tC*bo+yzgHD zsbkurEo8&q;2P`dS9fow-H8Jv_f^~EdK4Ji%j}d`xUWQ>{6kB7ErI-P1*pz6_HEh7 zitB4%0txX!f%*e0MO-?Y1^Q`}KwTYPCjD=o`8I7b^lYwz!PW?p6f@c4YJb&jSg_uC zbEeN*d}968L2T6voJC;1dD_faf-DL{D z8);5gw+tQoF3wK<)IQ&os{eb1-tdQWd^zHSyO-jX%lCW&hpFrPw&Gmmn(tj76ql_9 z2r@|>aqvm*+9wW$d8h3^=c(RAm31sIS{5#+MGR2Q;$s8VpRWxbqTW6f%q(&J8hJoN zYVb?*Csehm`zxts%iS?^wnarGjiaXx>GO~2^kbbQ{aVc!fZYS>Zd>O7i2>ww+(d{p zHln+P;pm(C+_SrLzd4sOf`~p-ruZpG-i)Yf$cnEs6z;8BTrwx?$}X`=6t8_s;&?cRF~YRI2di?%Xv1 zDh{&}_@J1Cs1|0+%kOkHt8bc?E@m`;pRECn%;N}ww5sQTkPC_mF?m=IgXSh{{Ojt&F=#=5&tho5N+3qM7a@~*c1@Y zLL-fN;Ok<;Uc4B^eGNMlnawcpm*D{|bNxG!Gx9$@HxVW|sT3v6M-Y>We#F#{rP48( zEm-~nrn_2*I~ON56v9QG1fsmTNaR<0xyC?)feXj4Z+Pzi^C#N*-FH9FcrdJYkKFJScwecIzKohjl|RS7Z_dMg*Ies8XV%eZFbd3NIimV{3i?Mun_HZ^5g zXKMBKODUO$Gmf&-<(M%wI}GM}&&@S&_WY9^84(&NWsHX7D^vFd9+@$N)$&po+?OoV zQyxE@(bV_nnz}^khp!_S;jGwrs?_VCRhq8ks---(N-;j=xZ+~D0|>2PT}Ba%^{nch7GNZ@A~vcDeEL%4!p41-QzZ6tcE#8aCeK{=zf<~D8)jw+KOELQtR z{5K0Qb5cJ>GQEA+{aO_Wvf?>!xMJ#e#ol)c1j;M~r!xJj3hW&c`?&h)xs{ z|Ht+wtSmR>YMIZ-FDU%ih}3XgWB7#d&05!f z+JVi=yxFdMHA#}Via&|}=^UPf*ddZ$j>J5JYIjyS^_cA&)B$o9fi$58yD|qEU~yv3 zb-!AYRzjCknKit=H-|1Wp2cq82E%A1^tDv%ZWd3TqAYYQ%Ma3JE0lphg53E(xbU|W zt*@M{Aar!L<8MP{-^a52t9DOsArCq zoFZ!p*jnVc_DUxo>()4=rn491pJkvuQwD!xRY2X3ym&(ZoV?NO8mB$Yi&CX#rfr^^E-GdV^AYXr3HxcBuC+Der zxuyq6rg81rhodB!^F?EH8O1ZVbbB%vNoNaCuzNPUWj%z)HEPCLuMD zy+3k3?}f;kpVo^~egc+vQKfbF`|F*$Ub$bLh#v%(c-lQcFwm=*x7}$`6o7tV`7)Z; z%%l>{GH!zQIO~v4P>rUMu>!=Tn4QEtasSyTBya(UxIf$Eb=sa(L|J!o%HnPBTd$it z;MHzlm0kopiN_wDWSxI(0=fX0CMdyI;VmC|bVvL9&-?F&-M~&NuaEZ0ty6!HsNVxw z&szTB;%a2^yU*QJ%ieaz$z6ochmWu4O{H#mV9mqkj%NCN9@5jkQ{Yp*UxeRuc{MA= zjTmHG^Rvg>i|4BL*i;1Yj`iW-@dog6#Mt{3Ob+bre74dt0t9;B1c=y7#?3 zU-^UWN|6moURZ8dWE@_;#FfxJ`d)-9OfT&f9oRrSSLi@g2Jxc@WIk zITXw+IdNkfZXs4wPI)$LaSEhhX*+R$Yza3zT;dVB+`U`x*JxHwdMiGsSQBl+)XqQ0 z#C^a##lX(KDhI9$ns)RB_M`iko!xxrq1xOOW<7J3Tz~b!pWAHmt8qH#Xq*+TTNE|) z1iJ16KXM(N1|x$n1pSFhAi2;D-Rq6kkLyUA!10HOgFoNOH=D2hluoj%y#$3w`!;$$ zvJPQZx)aiFXV2gMA#qY%^ZWPqKApWC@KAhlE-fMPVDx|7@0={X<_=G|fb2Qfayg9k z{g@vhq7jbUa0Ky_y1f3`24imKWc(Q`hJDto?;oU9Z5BMe1e~Nz5mA{nQ-xAYFkS~s z8y-E79g(wj=^Od4;Q05CQb2LOW(oE0z6&2j*7e>-)qx%hXs^ya{NKEJ3DArT-np{D zb=(s71*CH-p7x`bSy}R`YBw0Zb^ttdADPbOVkaR!oCnGhwpklO`4}D7`L*fxFJh~T z+1c9M2P!vVxyh9YGF8=w98JP+*m_L;^v_t96`jg@G;oI@_O(**WJni+oA6xhna&cE zLtnTFQ7fOOOKpuN32|;5I(pZ|ebttml}4D!0dDQ@gXOD;TBku28ubKj^Z*nLH zY4=$YC=vI4BNiJq{WGZMm4qAUB6_YChV>XDecRyqIg320BLB=y0JKHs)LDJ>8xwTu z%pfRkj$_I;VCYcf`j1HwxoS-KbvChtZcjbvpGXr|7uPER0iW&k-q${Fkl$UI28&iG zz17oX%r;XG3}#nN`e3&sKWeC4u$N7-B6>wl-Qa=ixGt$NtWb?+&K_^Gt}k{X!9)1` zx3Oa(KbH2K((SY=jdcy!3z$9Ln9yB0V60ugi9_!WBpR+qnule?VU|q+39iRPR%rQc zng@#D59lbPH=dOEU2#-PQm-{`g-s1gCyQu$#7U0AA-jjp0WyF4i%zhSlrY zOD`CP5*8Wz- zKkoGZ!u5tJ6B^VKmyT%MIm`lYjM?s(3qKKw)(O*aKtZ7*!!yscA43*GB9y!Mz2bE5 zNgVFVeF{_>L)$G`4&40T*|JBJZ@O{ypm_|pAI`4Q&=}4TFdR{1wvCIq#P=&ioPt`19GAwZ z+&G+2tQAEYxSUl8mA#U^=HH+YDR$ig_FK!d20&oMq*3`{1>ai(>^X3` z|BS_5r$fa~q`FwU;T~Iis14-mQixG!W1Z0e*Lj%OmoTx*XSfxOelEyS$DyvQJ+Cf0od6LmPu|vK znVH9~pT=kvO9wlaW#L0*ui0jh!AWGW_;rr7Eq>%)-b^l-E&-;2HmeM`ji=3s)QCAc z%_rr`Vv>7u??1xI%;B$#3hHELLTZk9&@{l1=~MOblJpT@kzKhO;Ug13e&cftF4qYqf?Xbzj)`l!fy zvbaH?d<1Z321*uv596(YFIuZ-><*qIE$i2IKwrG-6M5_hF{OmcT6SZmP*($flvK#H z-h#n^+&>XVPWwrjnpmmrqn*|g8<>%W9C7#PnOa%~#PCNvBhJ=Y2>Q4Crz&MTCK=nh z!g;L*smXj}Df<|CR^^icj`7%E!&1aw|5#>URp+?=?Sv`M;rRURf=zCLE{irINC^SE zo7?rD->TL~!6FM4925Giy=fHc(XzY#X6i%E!h_jyXkBlNj;J z@1ulsC{u0|!aP7feK8#BDrUm3_{sl$N)(YlfBswaKT?HCP4BpzDNkyxp|o49uZl(V zUoLWEz8rAy6ynMpJGxUCP*A)0ju!)DiM#g7!sq@o&fB_{9Xs4Ee3}*|cV)5iSBbrT z^n-Ckj$KP_!C!-?!y?JO8M=nb7&Spm5TH8;=(PS5u^t?w;);pey>~V?ndG7GoFU3* zReRDf9q;C+qpWou5d5m+g`xD%1&Yq)B+07aK(H#~Zf$Pu&tpiQ;I8xGk*gjkL33Zh zKqfLd=Rj?vgqsI&q6v#-kkW3;9rZb!!0i%enQ-=qWYjlq-Odd}ci?~6;uM-t>-SUT)ZgommCILrw$UVkQmvL99vQq_Fp9Za@IEFcc=HRk62Pm)VYDdBBLGj@0 zY1N#P;juUQ6;KX6C?k2HVBs%qvJrPAP;>odO;0*02(j6Y)n$Namh2#=3*)yJa;Y9u z{WRu#7G(doj{6oDU?jQbAvdXu*MGObfdomGhgo7($82@uQ|+`f7zpL>Sm5N-oO`9Y z$Zt-TET5|-<;G4({HF~pMvrZMn#$3^58<8YvMzN8wY9b5+28d{ewTpD)Fm4-)1|PV zQW|@9p8qWTeV(_;kwtQGVY`So_V07et##pw*w1JRB}zbJp+WzT(}u}geBLG!cn+_lRGot;Lk08gEE zR?Au$EgZ_s_d_-h+Iy}ckruz+lqlDbgCyUiF2sN@u}l;wXkVJbAdhbR`JZPcb&O@xF- zc(x}N8CmmU)|8dK$fM$+B5=`H^gAiXXk&Fk;YampEcRpPH)`#eLDnf+EUSBupz(qg zf^etZoGQ0X2HC#olA{5bf_{maSZns5lonl&pn&65ky^s$RL3&rUX>g>tFR+BcExC> z($rk_A(=kgutvOm?C&`tY7;E2aJ4j(7+Bj3C&#D^FY)(uX~GYzCaU*lz{WBL-^MU( zbMQg<6735)*R<^%UjdfL=cb<%Q5UB;uG2ctGPStZ|+=34@hF}#`>`sIhVQ9V!?UM1kDb{)2QnLcIL@a zZlB>cC6{BoN`76EkU(;7FG?=I>F6U#u_9r%lCMNnKI{RG}@GF3Ks>lb`AZFB981Tp^*_}tLKZqjFTS`P&^4Ghg1)--L@QO( zUX(c%*tyU7KvsE`8uxH82>fHA;9-(Xad^|S8rHF*^_Qn^aMLPHub|6~`Xh4I)6}GW z7W>4ev+ElxpmIu6ixT2hbge|itXFy0h_+~vhH2DLk3*@zzLV%SFrjmpll9w$Dbgix zJlTk7j|Pf84r%+((N+L0(lqFLAz3Nn6Fxu_C z7qXYd1(87hA!Gpf$sl+xsm+&$omfmvyP;8%FjX-5cUMCxXq;II>gF%sZbegmJ%`D~ zX=_$p@UV|cR!I!4%J|q>0T$^VWsf)9Xn-keC>TAG)+n_V#O#6O@JzZY?Nu4-H6F zxi{8JF;qc$SR+d#jkBG6U2Ojy0D#J{njZxgC%kPWCOhx}WJNguD#k}W@T9km+u5U@ z6C+azE-pAO#84LtWxryaC*=k@JsP@M zKqYYFrR$V_cy@fdbM%L@M?1MSNlBi7S~CnJc3vl!#eCmm{kR(Wc)C))_;{Yf6n(oo zxC2+8`@#>e=7WuTNAkhiC$~@cF9z*D9=OduSOPKe{)nvc>}zGvV%Hfm~98~!6SN-tpjk!aG=ki zw`Bc3{(5JVr%99NM&*&#-_(6q&JFcAtfik-I#Zpj5MDV`RXkTkC%5j(^&o@c^{#{U z@w*5lbM|3h30~`y-+YPikW-;_fqFDpQIy6Ut3I8Z$>w|^%4Ila;2fgs(p%&ow5W0U z^*03nz#|xP7deN9uqAbKe3hkBUHkgk?|)3-5lVxfOfk#^x^i?2b^XYqx-+Eae_ow2 zLvEL4IAl2Cd$Y#Z!IfeCj+-gR^lm-M68(R;m0F5taCUOW z)KgPU@BFNCIU078;7<|6_p3z-CXjxRpaQ$OLG-Dt`Z9wqb~07aKTyneHMfwTrj_jZ z|5h!p@wu1>mYU^}kh>5B_JeSecT>TRxp2?=hEhT1U5BNw@r6xe4;gzMy$AH$v>efpM(e!bnC5 zjr??fSwNI(UD(fLwy<`$?$~tiT=b~8_VRhIvBfDeV zXs%J`TM_9BG7}yO9%JY^Re9rQ_g>C5p&AK6ncy5#BQn)m^PMKWmhgGxlN6QH>S8+( zuTXYmoi%19&ApElbZuM(uQ-(~^NNIRR}V<-TXpftx4(uoq2l!`hBHXA)T0H{m}d1~ zN|zAd6BA7z_Ct&#^Nibt2b3^FdX!FmWnzwyJp`zh=zIk>=B!ut%-3R5%Uxv~aKC*L zx_z)Z-FVnGtOA#t5q8HSa8F?`ElbLd#9{bIfjPgq2p69~wwx1f|EZ^l6B46xi)jn%W~55k|0llG$VJAR$&b z0Ueo!hCJB-*7cn^J{0E@Y_uWoDsmUEUp9=JHYvle#f5;~Eg%rpIw9tzYN*8`v*nFo z^vtTSj@y(Q9#tNvs-M~SKeVPw=zZ>p$jP!PruBzi z6aTy#{e^9(IkrjZmUmWA_f2c#D?~(p+mRO~GuJ8W=F1G+tQ_hUYGEmH(6{_GoWf76 zi>tsDK=4QwD;UvWwS6dp4x`$C@?q`|QlSlH> z%TeT~oe3kI8ap-70QPp>1WOT?oNBstP1&_+Q{#1r%^Zn{M)z>|aU9Ai38SZ6FX0w& zzMhlhGw`MhrwUYl=N-0rH{xnrP$$O0Yxo85)wR+i&Hv0##H5$p?%@cbkrcXLz%IQS z1yAAB2waAsIdC;aezzc5$HHg9LA?GI$~))3@d&s7*Y|rU|GjyQR*{L? zC{cNBTC{XUjWucKhByhO)ob=A87`Cj;Qw_MA!<|L2UQRiAsTH4dd4 z!IULJZ>}0=L6|<>oayJIZr~eYf90|VOCoWn^zCgy(rD0Ve-aL{z#h121)1@d#urM6 zhv74u57eXDs0f)bn|OAjxpO2f{)&~YH?ygYeH)Pdv@PmS%);eZ_^G^%qgwk>2vKO~ zl60)UZK2;NCD9tyfcVP-cB}ZHZm7BQLF!#pEP)XTfNuVQMFzskxqQ;8I%x+PT$U*q z$pg6%7jn{oc-SKC#plClo?zd}dqzz%B8lw&H_H2C=&))3_$`c=KEg3NpR1gWN6S6m zvF`sH1O~MqD=1FP*IEel4(x_JUBGSF^kKwxJuN>jvd=c_Je>9~2U;~rB3MX;I_jS;?OH4O_HZsl0>1JF zt~svWj(a}zRR4Xy?R#mzJTGf`YWJK3u5LPdPj&;lgoT=W0!AWKdmWyxKGxG#&*IZQ z#nfvXiJn)~HtBYDcJ_7#rk*=Gep>&C#?RR}cpaP)y%~SY{J5JN)ckP0n{uI?st2zM z>%X6r1GA?l+g{C917oz^^N)Y=Y`#I5;EFd24R4>0Ps)8}`T{z8*Wcf7w$qNCR)J@% z4-bzgfLFh?jkl!y|CM-vJzek5=d63}FQ}qv>v~W3N1+RO!gFovw4L9oN|&G`;!Q_? zMK8O5T{aA4G@@_}aJ^#+RK9rE%J+Y~+fH9qrZ8|}rfpN+tz2LZV|ljkZZDT7V7xd;1jDMSpZloblfItpZISIsymK z1Iq?4&LE(w4;}i-ynTkH*AHEL4o>G)fV4mZhYz>hg!UTDkLIXUgn8Ii7sw){@O ze1Q_2(V_)RT)b*}M-N#|+*U@B@)el)S^>`WD%?y!c!XM7zdybiIILc^Ag)}38HyMG>6j%%9J|Y8u_*U z3&ziLAq>OgxoZAj=5&V!>;#HFo7k`A8K!e3r-QbUHvrsSGJ}_gOBel zk><~*wvIIFd3%-bMl_wHj%AUDW*;QOQ7a7-RE6z09c-gZiu&K(g613MzN6#1AUims zx0*GBGgNwt2f`@YS+ zpjV@mIq&<-2LZKm%OMDcLX0k_1HQ(qv&uMk_n8vH7{3Bcn^D!sB^mpA1n{@Ay!48P zf4xT$UCI9vIYj?t>^arV-U9(-vsrKJMP>eD?Qh4~Xc_HrFu=BG0zF4D7f?B_Bwe&f zO{^b+iQqr{xRXil0T_GM=-VA#s1Q-my0g42o~rQi=*3hJiabUX^-!1>T?-_b<4nTN z&PN{rpNoj~i7MY_@iOg;Y`sN#*3w}K3#F7q7MA2^Ju4|#iAw}BE{dqm?$XalgMFkc zXLNmOeb5!BrFi?F(G|wWSACD>NLo$!F(Xqqd5bbAePVg+)TeP!FG*puBx;L`dboA| zvQYZuyRNp8@qGd7W+;Xb)H0Gu?r{vni1sYIE1%tT8%6H3asp|}hBl`7vFq`eRj$t8 zbhpoW?_x;_a;C%3_0;LIR*cC`w0#2OL3a^c^3c0Ai|)CivhCScvuAb62h#F=3I}3k znoZi}IR0fbo#YE=%Ju}EVW6l!95jU!CpQ-9gU&D(+o5Vrx)v5wg&}oS2NHqL%|W09 z#Vd{B)Rhw5tVUVSh@x?T?bXoSQ{M|4Iqj&&hNTR%1Ob!3t;M5mNED{n%hQ+xT; zEc#<{V+W3y3?q%-X@X_oR7ISDy*MJ(Jp;#SNuUESMQi0>heQR1RipWd+z1oDAfZFa zA+YXyxpHn#-&f1_giL>$LJ`t;*nJna)p@};Bt z%gZ@Xz5A*gZmN7ogTxI6?moTM!3@#i>rl(Y*kU?71O$15`X`2IG)TXJ#UcRNwC{Y6 z$?GFGq`jK)v65Y@dWyjd(KXZmSyk{6z0uB!&|Hqg6@KGyh!ysB;(aY6Xn(4J8hyCn z`dzl1(`Pqd@^`b{boqUyWHnmu1QK+;l4g;zkiBOyv4~FY<2u)<@v6?L3$Eu=vH$_< z>yX9O9MQjZtw!yKbOr{xZ3n8k1+yz-9R+tX9ZXu!-cJ@8d;Q;o#o;URUidJPmj~L| zz3P*zaXXCsRNUJep6AK6(k|yfmb6w=VekiB0k&BsRtScl)GPu?m#DQ3o59u(u#!_V z-Rujk>~O8k{Y)yC5UkMPeOZ2Pp4y2|9{SceWsvz_IRJ`G9x{Jb{)yt6{4WWJ&eqOa`KG-T6^yw)rP_ltl$O5#*6*J6Xa@!{> zR4e7BJPEUq)&a?4$r^m6Qqg+bTC3x3ZN!!~%w#BymbhUzyIjrv9)S)M`@Cl~XGx%S zx2YWs=OV2eLP3!tR{)kB4Ji|K4)i%?7tNxS!orVGGezVIa4O|(7S6YNhTtP^n!~vD z)xhusgec`<=8hRn5DT#aEC?BzcOx~3^gQeNp1jLh)bJtz?S=f(L>mSM-JSGb1Jl6v zvc;jdFiS>RaeE2xmTv7iZJbG<-e5>(c&~2S|28-_&u>6v#^0OGEL3A>>H1S2Fi^O^MZE>M&FftR`Yx|1H->h z@{{o{_HcB_b_x*U3*xGOY&&lGXrAWfoDaU`8a{Z*)q|}vOhy8kn#)gU;-IIF+|lM} z-T4l&><9OYiAeyfa9;s)%hqg3;Y;qgi&mq(1j2yhj$xfn%CH5T&Hc3imwq{k`uh08 z@WH#IpDb5Fpfftif3s8@={mIKTrBax=t>?afTZ^x*8^ieKclb*nR8i3^nh~w8aTR4 z?8|o1+~Umn4!KvW*>{6)j(*AwhX&yJwto4Cp1D`LArNbk-}=?YjLjj1jpMVmI<! z9nJ!^3@0SbasJ>fBGw(sDRap5$ck*woYQScMS-RjT09$dIHX3#Rd=?h@=+X`Quo9U zv6T>&czuOHU-@)>pDmHh0t zZIo%9AQ`cAT&fxeV49S6qAv-E)R~=HM3<{y zm8%7)uE1*|;$*-KklmJX29PA$km{DxIgnPVVQI=SjDW%k>(@MOtU|NCy{Rqvt7Xux zK)J@|3X2rd{b5~mbIhl;gurX|a_LPM$F+n)Kogab7D->>-m1nCkp2w^-`+(yoe9VXqB!Eh- zIw9q?o@>=v&hJzKx4+7r;vy`RZXv&Y;R>$wLhFN9Sq@h4`a)-~16g}<5&?VCv2{ih zLZreux}5eb4=V3qron)Ce&mjBP_`tIE01+W+#}L()+K)cJkRHHq&S~32~sawk4P#Y z1^UNlAfjO2m`Lt=MuxYY;K~4OicRil-0uk&z(`%x&@yd^MSWg$42%4@d!L+{7uo=Osb}mm&yw;U|(Ry6z*L5YJ|C}HHXSDdWb;u3>($7k!Px>A({q3xVb)i0M z8u(hK58p8{1si8cA~Zx#KRybYGnw}}dx*j3m=BOwQadnB`i{bCe|$TMi6EXPJg zgVD`+>r2!O(&rWbY12FF$BZRFwE(Pi*t#+e1gr01hQ8`*$veEx1T4$TQ{dpme-NSI zkddZa1Ao-~shkJ&+3bdPedsSBGd-uRds>CbBfUq-p<5h zPWc~Bat( z4zfI(Zz1F^FCWdG4!}5S*?Vo2yETmi8V(M#4TPJf{&Q1AAm`GEIESnji90~w@qheg z)C{9aD|nK#CLYTTB8+3sI;vq=$x2Xc{J*RqkYQ4%d} zHj9|HizPcKOBb!{NFzw6kf$wVr7PM(M03(;e5J*S-1)(qL?v)+mXFyqn1!a?emPaZ%+cL>xSgrSWE~jde?v7M9 zk0L618)Rr2vCT*_XECS8J%-p+{ZH8X+mzH<7r&r4x@PE{ zJu?)hWHKsHj!v#qo+%024Q_H2@glI;ai(vrv?y@*!~gx|L}7rd+bXLl#HP$R3utw8 z6~GPWc&{jKhSepzrB$<=U?9RZOwo!#Uu*!?o9=NlL(Q5ZAU!&-)X@AJ7kgkSNRv>! zs{ce|Na{(Bt_6SwkPEP#dtIkFUe2;9?ERV6sCPI_nYqGm+B)GULYN03VZ(EgQQ>Ii z92QBs{Iht7GiI=A$kEyyU4O9F6NlY8JpRSA$K2Km+9;#bSHF0?U7W~`MqQ9KtNu%P zg}LoP>m`0{dZ+J`)w0}?#;=VZX6K5od(kSA^a`$kFh+yzZ{)p$h`k{DElQ*rm+ab9 z`{H6^zUW_X!yBseB%7sNd>gztwNU z%XK6`ZrJ>SZM(vk?v|~d?9TBFtgtzoKRteKq+$x^q!%*A{J+k$fBhTOKK#UgLcc>Q zjSXE4i|I%A7dFoCfT^jqR)eJY=vboC&T8$GfC^8rW=5lUVNDR>WOG4IaR+}<3NVd; zl33#AEA?rLGhVw?#u4K#J;G=}zNVjWJ6eF9#Ikszm`2m)e|_N)x=9RB6ZcCyeefRj zyOa8>ikAE)QXgKwfqYjEKhu-SHsWFH7x^iyJk_dHgA1JqZ0)ZQwebuY?Ias}utpkIi|uYmOCt->_ix;nA^Hru7!m-|JrJih3$v}2ZQ6v4 zh6O0(GRO@G}TG4(jm8zOu(ukB~MfJwWY^$+ymO8=204fX*9Z>TI(~y z%l^+IyrN`$C$m%BO8SjY0ONr)G0!-`FJoX={49OytN~mxw>Z=<{a_1-S{%bM*dZfJ zn_|dige-yb<9{NmQLaiu%6varGUM6Aq{m!o?n63%;7$=07Rm`3>dD(im8byVd$DU< z`R=zek=Rs7fojII9h8ANu%tf7Y0C-ampAJ8l&lw%ry|LI#LZvW%zn>i*IWE>`dv_y z3U(~RI!=>~O0#mH#NV78A?HU_L|N3~#E^i_H)eAfo0;V$G3Vah#h)QKQEG_M5KSzy&(h4b~USNI@DH%EU8HfM2vBb7B$Ci)#(2E*CkVtHLgR% zu$Nksb`x?##w$JVO*IZ^(sKNNfwgIdI;1YCCQW|`%=u7Mi*4~G3@Z(y_JbuKiY8~^ zlcPdDjk?Xo?Au*(^j0P*(DmT-3Y6B$+#zOK5fwl|m!sm@&-BC(vB5KTffZ+Z&ZA9G zA`|aIgVrbb8r9XPaGMvP;4w?aB41UNVe#<#p)Mo0K_U(ObZh)1!V*NB^Fkv~@N*BZ z%J9oE#$C*E<_$865`9A<)l?YTt<1VxdWio?})C)T0DVK?k# zc}avEREAM`lW%aHwRB^pEc7%^WvQ?Hsra>3%l-Da+>+{z^sD(r+~>IdLETx@6su=X#^ zm6Fpa<5a7;@uuv4;Co6A?oXzEeSXvtfpg0?az zSpgHR5>7$X!Yf!8DrcF6rd!F;Hr|2?yW-8KWv1)j9>y~Og>HOZc{k64Z>@k&pYd|+R(0Jr4dK78%H@1)pL4LS>FuBzzS91j;toF} zwh+P{lueDIc8W`;@umQgi%-IjS-v$nSm7H@J^JcX6SpYj3kRF8f?#@Ct{-@$2`$>v zab()gy3Ko&n;?}>h(yqvoV5I?bV=#}*`Rq8W;zpI+<>I4f}O`E>Gd0bJBke_?^gl| zN~_?27C?{+j*&vm1NkBHYtb;yMJvLK-(^UmjKFAFE?ZOE+ZDVV?H@e*Dxvw_kWWuA zaa3Ab?Q*Sg@`}a#a9FTqEOQSqTED=PqsBA>TPx#4rx4S{lMf^i4H6oZe;aR-0$7{p z5_1lNPPqMq&7d6OD$?bs_-3HNH&0!Ep;kx%Dje`6N=-Hgk~jF_FrWXE7B17mq8oD# z7u9)3JWvi5!oH<(SKMH+*A!j%aukFP5Dd@?k8~C)1v?&o)*6-rtQP4j=jNP2I2-MO zL% zK1TLVC_|>~3pCB!XV#7h$Z#J;YE+(OB{s{KDe^LN%bnp!XOP3_FdPEAMzuo%y?Cw< zJ^z*u%|YtwJ-t zkAB`-J}}NbvICUsXlq~qLxKw{NO|C40R#P^;5*785%9v5UIlc&{3Kn+UxAbHXj2&9 z8hXpLLFkPeos5x+T6oM;Jg-IgRpr_~v<+9TGwTx6K{B@)OH9e^9@dpp_y45USPGlw zeE*b7KK>yKXlH%yvqVlduTSx-bX+I3#8B^v9>N2b(~jgm1D|&3ta#uh=A3weu^Yco zU7Hgiw0xNDo6C>Zh&lmrMi>Y%bJhi;332h|n&qWVM!kWK4-O*Qgrb`*Pt*SIe1Sez zn1Q_;A7@n`TqB!naBIQrD=!;Sk1M1`T0k_7xy5!0(Kc}4#)aAQ-i)^sXUoNZw2K>n z_Qt0(z}@+NJ4vtY24I~ue>u>1WZt^(;=j^W8}G{ok{MgCq5s>GzRR+gU44BYU{hGG z9Slah2wWh_*?D-KgVe58-$*`=-riLIt6kk&GX=c0iGGUw@Co#N>s)F7SjwQdV$9wn z(~r7%f8YE_no7ic_Pe`N7dbTQ^8+q_yx&~qURPgve2lO2zx(J1_R3wnPfYm(d!Mb= zjQn4o&o@^$&oN%-@3qGtlqs@6#N(IOiXBn8?klEX+wv%l>!jy;=Z`b>m%I0WVC}x^ zhud?fr{$N7gz~k(XXmQ7kh+;#jJP;Z=ZX)w5p%in`R$?y{?&m(lw$jkWcY>d{rarU zs)~t0jokgg+}oV6USyN3>^zT;tO!Fy!Bw4fMwA7!V}JAL(Wj65tEfoNMnY`2O?_aG z+}UPxR9|23aIM^TH=-Omr3VMVyla@L6jduS; zr!bh~E>!$k@Hxb(ST?ENptsD8%Qk$%&QeP0IjnmdzJKYbeSBw_1Uvn_Xg7L7`G_Y^ z_lnva~P zAHZJ?Ps6LJ+AOt}G?beQ>sztygX@V+vT?KmhreooQRW|qWtYun^UfPKT#xlIZyIV| z>*U~|DOb4vapnJ+h6DNS7y5@;l<#K$N96J)xs?rY1zqv6nMdewEw*dvCq-DmYbv%; z_rR=ioK)L}y9!KhSA_i7kX%NxJDbV~`bPTl8C=Lo)t+rvt(R1^S5m?knsl&bpN z*tMNm=#|5@``^1yni9I^mY@-~(Q=xt85baz-hFl^tKa&XwGM+baWmCW{77-*t65I; zG<<%`kzTPwtjJ--=R$qlXwf=B&yAISB_{nVkX=CjuYRw?0IyQ;8_bC)8-b|u$sK4S z2CUQk*{~Sl$NP<1y~)AyiXnDAyCtHWcX^2EAc1(_&{588^O!zi3y=N9-JRdb?)CRy zC8--|4$pIv&Z#4J%jdB5Tv%aRh9MZ3wVTN*t%){}rzcZ?4 z0f$K0byCrlHhRaD;oRbZHC9o~^TZkojk}!eWCr@UVw|6Ew+p8eBK8JT~iP%=UMe8^oTaT44f6Zsxpy zOt}ukwc;&haVaB%?Z2GUZ79b8k)gg>p?XXz3BH%!eRZHXImszM3y@m@4%@7D)}g3? zy#;gYY-Mx`2fJKB#1|#5bp;-9U-2RG;X`nGa5p8AY}AWaXpgPMEI z;K!&h)kS3VW+sa1X&(0FOwQhS@C~k*Rzqv&e;LuT(0$X&RYk-mOcW+0<*c2JD=9KX znD=V{T#Ybr2=YInn8!(abxRqTiKb|JnWKdWPRJF9L_>bQJJt-kH%VhdB((E zU_NtPPOD(*S9RuB??;nsa>f&KL|9d)%y&??&zgFQL954?#sVZnH8Gr!gkHQ5Tr+Rg zf3vq~-yYDH28)H|Nz0}y~%T%l#XdgS3t?QO14>#YQOy#N)k z1SJnx--7w~&*A?=*jq-$(FN_IAp{6caF^ijZo%E%gS)#2cPGK!-Q7d5po81sKDbSQ z4BW|kzHi<0@BHhTuHId%x@y<+RQIl3!;kA9yhwxlGFo8PMn~SAs zTg%7g@^0xG?A)k$oMMD*v1?Vw`8AY3!??`wi_Ez3#{*N(>(*E~=x!1!VS`gQgq?JE zwfoj3mvI(Bfij>{dgtCl=Stg}cGJ43We+WfPYf#T%?1r_qb~#&TNu86X};`P6~veo zAGgfym39~>R3!wmyRAZ(Y?auBxTWt*9=g#!!SvoTzcf@os!7#tkQpCM59e1XNnG-E zL`wIt$s9QjoH)8>!du}2PzbFuCVIDFIwh!MK7SE1A#nE2{$s>sFKqDr9^0LCwA(<+ zj3>-*;@<>tthYAfbgx@_2g)(1@HYTtrLP8|8}S@dwrj-`K8Yr%Bq$hdlv>aE)=ZH7 zRCN|$HJjl@m3ob0UE;aU7!5YV+g#SQzR<<_23Fc)Ups=UmYD(4d zTmrWPgw5M-)y7Qt@-E01h@$X9d9@SYx#y807i^WJL#XeQQ&J2`!dhvl*-hc$OOu*MF&CQs`c&^Qu;3S5Nb( zn3u)*n^X=8b}-YLUi9Rp%N#QOQz5rp%URLSBubVO5?(!=l5tFWxHeQy&<0x)D=b@P!Nx z`#2@8{S13!4k1{RZvhC#&Alz|^@hVb{&i7(Hop0I7ZZJ}fiLDHs;)Ioi#_l12n26d zO^G9J#tLyRmUf!;I*NgCms5*~S@=yv3d85jEXwF&Qrv6QaA~-Mg#3jyYm@H^f3a{) zz=tQuk7q~;gy8K?Y>Yl5Qm26Ctk5|LdQ6}rg`G8tgv(lHP)B9OH1&;4U;8bOE? zFBp0HPDB4`a!6m1Q7qWDl|9}-i_i^56Scdsv&z+tJz4YvDgA{G?j?-qK-SF(V$RZa z)^fJPD99kz*ZtVt$?*fv7LitMV|Dh#vpE4bEp+Sb-ZmRtTH;ARBhbcT7ktuj)^FEiV72Jtk{^WF$%`_ zL>|dv_8SxtBlS3xtt5ZvKS?!mKI=hs(tO}Og_@5#dl;S#s`Kh>=-eDGeO!tvj@r1w z+=_?TBloXj8ExXKub;5^@l0wryd_7b0S!=DKMhfkok!g+0Ypd2+o}(T=4=J!{5fG^ zPp~#HpxwLGwF&LPc|!eHN^IeKSJxYESlzv8t%yorRN7X4@>pncja5oN{Y>J zGduz{D1$(I91R0?&sL8W?kRO6H_LZ`R7NW5l#J+9M0bYwnSKKg#)PUzLn#jm+xz6jn++Hs7aku$I%0##qgGPcO>>|$D%vXpzl&loV`;MP044D@v>5?;4 zkkyU6x*NdTg%i(C*U1yH{860edF*f;$%vl%UT|}M3bsD~9+08DJ zl`V(ww1OXBC9PJ=gMkw%T@r~h$_4gcUv3(5PE1xPvqwU$Ypara{4?^RQDF!ONhctI zied~S;F#jdSfF`FT^mhEn@OEqFzXoQn}6+88|flP_6y_eOzCV@)WBS0zc9i%n>4r- zGL1~EfPu`5gx1}_9p$_iSFEe2_fd3) zcn+BUdu;~YwqWt5lO}w7OE%bVXB5>^sD1F7lhp|#6KG#55+R+uMt4T2EJKm8TQHYX zELiF^?Bkv%WE-_Flt(&U6ngM@D{Vl-ivGncb3^ zK$rysMQcV&;Wef1`&rG0Z+IH?B&u5R8t?MfL(!b|O?&VSuNwiO(BW^;?yWq2PqZ90 zB8R(`zO8mngH#H^FlL-QJ>)dj3A`vrF*UpSee zk~DiD^Db<#Db~(Lyo`+;Pln^*kR3cc>S zEk%-2`3*?j(=wx@0eR2vXwmv0tDee~BHvGr}W9!aC?*v}&LnS>;hDOsseaZ;$l z!Wmi%2r5f0%)cKW1`3bga3VhHVD^zccoM~mYxV(8@AKTL2LcASGI2@<=Gem+3|6_W zBA(Bnjte zi7C-vI>@8op$Y*Vho zxh=Up4GH=Sis@t+84`IG^WWeOtTlWediL>7M+B_j-KA4Ed7#Ay@84{6m;dDQB1HD; zbKX&9#X0{OKfyS zE8HMM6QvzxKtmWQC0sD)XY8juCH~&`l=BMNqFrgSFxS!oZVri7<5X%`+t1!?k{tRv zNoF)cyTV}00^f_jd&>c}`{E0D{Cw{0Wan4Yd75qeiy2vuDDF=x$t2wmbu(!Fwk$7h z9wg4+{RHQP&G1^EdzFc&wCA!{!YrDq198>$I>OH}p3*U_v7tznt za$r}<({Z!Wv%BZ=iSru3!%lnl9CVE4vZjAyc)?v2vd_KWi|6RKDMK9hyKOM-Go@9?*OeR7_D4gbYZbEABF=mrbKy zwZPLb|MkOdybg_geSB3>1y9I?lJM(fs3UqYH1EFANQ^?$NY<|gPEZ}2>jQPUzPoH- ztDvCNV#f%PjY4Y?SDE;vqs5j{;gOT@UqZDMxmnPZA7igA_|VK_WblY*2+gBn*?<$) zb*4=Ha?%+TJzpAxt5nyqg%j=0-QCR3(g6#sdRYGTYM(NC-l9jPdhx<(idc#RBLzDe z(jk(Rt6QXBD}Ilu#%4Mbb6CD?;CwbGPFGct`Mm#oe!l`4{Sh1lwU!bWBl4FCCq_A~@~59d87VgR;U1H=9$VU^x(q!aT; zX!Tf5r4}CtaI$Y!M5qxrSr+e;fIZtq5Rg!bpIh2!1>Fow32cy2Vs9-BwL7!uP0(Zw zORRnw3od~l+y-T&BretU`1gsUPjQd9+1js%5fLsjnn^?S(YMf>44ei*!Nzdy*|#KT zJ%>xB0>xGVhoq3_A~5U|r=OttJ+56PH;(i;oWV?8!+B3G$C<0 zS3&-EqGS1<`5FCODT*xE!`aVa?7g!^P)Fk*yW3?r%d@-<57U5=y;Imn)V=PUSFj*g zi1@c1NOqvL3;2+M8ar+|Ys~MViGB09Z1_!yXgF}a5r6U&YvDrVD4zTF1_yc5uv{>! z)-(M00q#p3Fj2hrCg@(4}xQ|tP3yTC8vM%sKBIA`Cf&r(K%ygbKJM-M_-ZgNxie-V4V&Q z+6Pqs*B41X>4&3jO;OXVnXMh2YO**K&FUyU2;FNnrLgS7hPLdnxDA?GUr&=3%nhPZ z*64kg02Zv(SGN2VGrPG8b_Y#}k|sJEgi>3UoL`ooU*!u69^@n7?(K!M?+tIkB)fZ0 zCNKG8fl}b>?p9CQ`YT+w7!LX?4a57BZ<8cHm9l_g>}Xlz>tyzu%Df)f+>c z`ln+>x>rL|;ivbjwyhq&iJfb+^}UKBgVA2>t=`UzgH+q1n5{%lHv+@g`hLSHpzTm@ zRH*rm%W$v|g z3&#s&iu91w#rp95d>F{$JCK<%5;i{rsMshZ{nxnRb@nqONRm$1m7 z*?BKgB>H)uEG#nd`x>X$k~(9{1b@b&;h#stVDS9kuppTdP4pUO!em&IY?E=n7yC;z z>DF=ONoNSdV*|S0(xr4T7Gg;s?VI8QecpV!Z|bEvWt;r*kTbVsHxAb`o8+-c0$n2D zshsj*BI}O?B^M+Hj?WUsrsHKBUfIOK!T9-`Ji^N}6&XrS%Raq72s~|Dv>YpT-Ua&%2 z7LP0+Kds^4{OR-%UjFXe@A0}_T8|>UU6$ww{!lZPy?y2>Mfj!;4)6%RgTonX^p#pZkMQ9+6Gj58}PSS^%vdI-V#%1a1!;=z2sMV+&E? zqtimBB;iJ9q)9S#^bLo;0EP&JO84`SX~ojr~fQCBMBZdA={7 zeS&$rW>=^*k?<2pi2Y&31_#>|p7br4VkZjg^BAV(-|Y$GD>;H|85-+!7-32fqay|1 zhcVG**;f$@^gwF5d(}`E`QIjHlEPL86;#d-e{;oeZ%~R0tM2oc*tEdl)udKOgWE$(ToK?^}JFY1PtlpdnJ82?MvZOyL*Eqqg0Q`~-w=*$E~mFE5~s_E>d>)bR@}L2Ab-5C zct{K#-v=YZyvxNDJTU=bk~)XX`P7Mjkl5h_`uwRT5cxj zR}ZYOYkmJtS*4LeT(qgWn_s|v{_;Fo*E+DWm8&Pil1#h+>u8HfKSGDT<5xLcyOt*^ znkI)u%p9#~lOq4aeBjO{bpaX`#N}y2h zH1=Ghh<^Tk;c;VE1yZ#Q$vZgqS9YY}_?77#ABe4!)p%P9fPC(GGro`DRBL`NzdCnS z1K66we`+6CxmN#xooxA{cD4}R7mM_;-b@EmB2Vx1yrKL3ELAB^CjEK1x>r)x0j??; zu_zpK@ueoKZ996_1LyNs-t&*=sD3jmK$>UnX)+UixE`rH2Y1D;@{vE%$ZfbkqSf&# zN7u}9CWmIqeS;SYJPS6T=l*g*E{$wQR;Khhq-m-?xi9i|AlyoFLBr>MVvY>Y9~Tro zCk_8KgFpNPH8@x_RP>yIrlik{uuJPOXHP`93-ag0pDfY?zxM*uXxV!E1{Xz+_qfl$ zB^Pk5gF5v$;L;>jaN=3%EN_zp$jNA&_Hx6lwMrbvgqhY-d)ucvs~+1*6}XBEYNOF< z|G4JpOHFp0t>(6}H~4B9_Cx`uC)^SfcQ(5KfXHL$X>$0(UT0rEBa92{u;}|4RPpGg zwWvJv3e&owW$N_@cR*C2eE_JyB|lO)L^$17IWV32kZuk>+(RCB$GYP?O7|#F1{ON< zZ?G5kb29UTET6{|u2WC*I+s}fij<4?561S=@6VQ{lG+V}RODto!wRypY!#CZ041C$ z*%>IS451fy92iO{=ZUSm!SK`FPH2@ko|X zg#;xahAne?q=kX&d^B#3R6|`?Nq#MJ_w|U)oedSbYX7BI3I+s%RM*|C{g$t+(H6+I ztw)sJ#?zi?qiAfNcO0(%1V;zq0t^zT;R3y%S(=?g6cmWfSb!w?x1Z9QWQvt)7b~jF z65p(^HvNeB>zV)Rg!|^Ff`V>xQZn8h6I00&AGppL842S`XCTTE5For>oqncIIQSH& zb+Po49DY1RswRy6WZUGYQx`~3VV!;ORh=wU1actzwqd7TB)jsou1;%ftn}jJzZuoT z!%y9C(K%}L;++3{;c0wke|cCN_O$syM7FBDX8>!yN4&bU`$!y~-e>iPbl#AF3Fi_$ zZ~LreWYmf;P5|(860unOwtD|qe88&_f~X@=X*?$}>6v!Y!hjYZk3VUZk=+(2vp#FU zZh8|Tv)k$&KjV_U$?9*NeMx1%e*7{4PZu{QSpAdCV}ALB4s;Oxr4U>(1$ngin9xex zL(G2F88-sYyY6xJ*_H=COrbXEYe_U;Crx_+qdI->#^#EUi{4MO!;H-hU-RE(k$>X7 z=P$`d4~h*LUhgqY2QW^!$-KqbHt3T1%!VuGq0X0{C@dHi9Fyx~N#iB$O+BQ4ESg@! zC;5xP%2ky|T<7*pNj^Y2~)EwiqhAvc!BJT z1NPB*!aFm^goBAwhB#fly0|()Qc5ds8Mf?ekv=l?K z+{x(1v=a}EBbNa{t{*4j|vO{4tpL9v(mFUo@MR7b^%DgsXcV)zHCr$`2QN|_<)3o{c z-LjmvKa9~49uHK%M=>>pQZkppPqdFd9(=2#`%}RDEoF4xVJZKEx`}|IlUS_B4?=DO zvR#e+C4NqXQ1ASefe4(tX^dWZl>YrT1CJ9kfX3+2g11u>2Ev?@xvDT8#7DG9A;t z2&iNf>sYh(=VQno|7XCb1J%A?Oih@!BHXg=+~XDS=f3o!y>M*v!P#}|XbsfEYBDoSD^+{7br zG+K%hf+Fvb3DS<~`N;H8%)ja%Y|_>`9_Eohqu&6d zIbxGMvru-jgrq8DSIDih3jgOom75OX_m|21AD|EwwAE0C2b9)Z#5MQ=Vq2#%7%?Q~ zK>cbg5pH8zY`Vm}V_|N%rvsPtq0K#Jj+YtO1u|()ASV1;3x)Ko#|bm&0%PqSJ|X&Z zweDepE+^Wit!r+jYbM*`=d`Q8;-}~b9)Y$Ns>nwFInM)edYW^}f7+CEgP<=1xfB{A zej33V z+$}T^;(9?_O;rt7s~$p)?@6X9{@lD1Za)8v-Cd+nUqf&Cqj_c21L9gdV|H*rRc@gBVo1XSGb^*`QL6_FDBP(#PD6IoJd=O3qquXPi^{=l{v zoL%!T>L-t6h1Dxx7R%Qnp}yZBy-S_xqkwiS8`t5-Hy6_}o~Cv+He@&9S5I5a?sFtX znAO;)#u1Zp*B@%*Qgs|wO-}fm|LH-p2+KJ`fPlKZ#$5_OoW*1Bf&iptpRmRQ2Yr0> ze%vzB`%4QE%Dr#}2O1I&hbS$6mC(VF^AE6KXIfU+zCkZ9qJ3JF)#4wiC8dX6ZU+73 zlfW$S_rV8|W-E30rr5@Paahc18}4gIDqT4k+7mi+7CvTq^nl=JDm`Vz+k?D!b2+^& z<~mxrAT+`*vVUt^3#(b&8tGOVAo3d_u8aRuW!aDWP%q>`66#7LCrjURJ}u7!*I?cn z{Dg@Q(j-t1y}}<;^Xq-@V5_6`j_;kRx9@oLPU6O}W%4u>yq!xb@1& zkAQA46?@Afu|na1;alr4b-chMSIF+oU1`pJ?0leihyMfc>{3hc%{kfw*m|556ytC& z!f_#K0URX30#rBMna9_+Uc{h#7dS7_93B()YL;?O*@v(-O%2;?0uR zhx_wm(@VrQ`it`&2*pkovOkt&`!H;^FjCO(yEPX72o&{Z-L?DPy*r81qaUp2JP%x& z_In#Y+O3Xb58P5Tc>}T6@ounLhPsN@L1qQyYLMQxY&0F)aZXJWS19>5x zqAJ1u;D_pg?Z2sy0=>bj=cV8R@1z=ocDc8$-hdchUpW$5F=NQS^IJ{@Rbg<4_TECFVANoTRaL;Uk zh({kcjliY<%=Z|>vVJfJ4aKvuLBpNsnoxi|*rXu9^X~56zx$b8^!Z`qrD8MSxiI&_ zcfJn=AOo^+p|H(~q)SI%fAJo05_Le&x%5gh-@x;K87v?rg?`1$N_~4>kh z%@GwwQJKve_&d;Q>`m6;7p!m6t^jzH$ll&H0W&Hmnm@BX)m(u8tl(^2(H8y9&M4|> z)dT)|c+CFubTfR+6`1YCdZxd=63mf*n%d(5ZhXGot)Inn^}nbfnsW-@7~2l;22VWY zcB_yXi*^jOZv0>N~igy$pK&lXHyoy6$`7*8lC%G&RH5bq!QN(U9l5ki;Pp z4WvsC01}Cwtk5C`Mcj9Gbpa=X{1lBrIu`A3ioHK?{-)kZ@Pf^=MQUz9>zHIKIZ-_o zg2Rt1oq@)8ptv@O+~Z*z(5^rO0lncudKD5~w{I`l8dx#x7+n`@M5Zy@NyfdfkFQH> zWcJy$1fDw^-!9c)=?fLz3(?pg@!0}m+_)%_1RP0%DE!fhg3)5K?;OgoFh`2LJ6#+>PM<% zLiBki4?FQ3D-cxlMnI2_-fl?2<(mZR*tq(<6f&{RQz?vBF%pl*3=NIU3j0N!=@UxG zsT13bC%xVfV|2ES0Ffu0niiqKx;VDJur2PHq?FQ1I$Dpxi8#U-6bL!e$CO3TdDv}2 zlUN2JP1{@qPhD2Yiuf^?UFDFemonyhN4atHblyTV%to%h>bvtzCx{Rl{(84ny`9SY zDwZ}GCo!Z8qXp>PIAgo$qf}K`2zS+cu-iUk`^zPlg}cZ$ z@~-=e7DcYnSZ1=e31ZWJ5v|aZ&ref#v?7Lp=amNk#%BA8rcPM|Ri02pa;7gDQYpaV zThWVEdR(I+rqFI=^0l5KD7WgMi0n`{1mk|Cax& zMA&H(zG8S%^lH1=64cD_zZ; zTZ!6U99}h9KD7D1B``B?zd0FboAhL~pQp`D#`#`LgXR-I&uW1;EVB3G_-}uW!g>!b zKvccf5q?xmvgM_D3tSSX>HFBGEio)pu_u@w=%dIm;BctvG+P=(e^zn$D=zret~)Zr zinDbt0@uHw$+!cRom{eLWD5#JHLC9%ijbKfNAp*cB|OXavf(R{^so9hV^H~bz9Jd) z;ttNGIv>QKa?cADVuoSsU-vCSPZ^hqDZC$o9^~#hB;)dpN9v%hYO_6--;GMqAe?3` zt2eR*s%PSRU{t&3f%`)%$s+4PqmdXc^FY;a22ZAz=iTyLyr~6|qFt%+ zN5#UjqNkqh)zS`LgGeS{&koAqD!Gu1IoiL5f{9KTZ zT~=XCZatX14+`fvm+f~7*)%2cDv$y8u z9CEGviWz>_3Q3DNL%F|Y<_bgeNp3ur?f23u3W3tCkIYF}ZDpj6%#taGsa{3Z9&X+J zTv(kEEc3ns)_q9E%5+tgLttv?0*0&3YzCC%ee~6;27ouprpngN(ENoF}{|* zaT!3tFjxBXZacYDw@N~G9r|t6jXWtEsP=zRpT(ffta!`S`)i9u1t7vw6W@h@X1hSM zh|h%Nj=)-`_*_w_&Fusn#U2!Xnzx_hW(VNm3J{c)gMQPNJp3~blxG$G1H#CF8q7kM z3Fr~OA9F4gJ!qBDn=-2w9clDg?Ekbe8vO7?dL}dtus1zHWY-*1fCw8DiceSgP4J)#7r`^B*}wlE z&{qxpM#~^s99Y3K&4VIbG-?k=Lpd^gm%kpFuR44~y#LwP=8=RABIZLW%}7%`<5KRw z(DZd-TpGwol!pu9TlS$0o3)%h;{&L&^w!ZLLAe7RBqX~YudtB*%RgVQDfoeeqE`72 z`AGo--a|=DIVf2|3fTI7F+iWiD2mvHu4BIv0qW$*rvi(zVb_Hb@6JS+zt>A7>V*6~ zVVm{0L%N;V&7AiELS6e@a5Cf+-8=&YJv3q_zKi~J{CP<4NAGxAW7kqY4UAnZaG1Q0 zUwJX4_u!ji{|44bg{bNRDvWzH9+bWifRZ!v^@ELTH$SB z!fN~C;(qvFl79AkA^R-lGq6H>ng@GJeIFGQYb+MZ(hYW**@>Cin77iuSZ(X=xD*W~ zEI*HDAqyOaT!+A2Ae0NTbbc~^(oK7ZlbSkV8<<`sgf{cpyxx$|7Lv6cDB zLp`Z1(llk?6A24XHZ-Q=z~#M_bXe-#xgh$v;H9A`lm*ws=d>&JSsFi&?|m(CAvylN zfmH0yd4uF>)Z3()cOPiUks_92FLhK2>Jd$85s>T~|IAOfET#e;1s+Ao5_YEe zO?JxrRm6HNXxB!iVYUw?6?k6hm7awvoUIST;`}pEX3RgfcGGz1mCFLER$X6 zP!2Y;V0q%Xp7wihx*{KX=I0TV)3g=)EL8tDF-=a;A_&#B;18<4A!eniB;L!8Mf;Wh zs~+SA*!7C9nyveC8*@Tq4^%IKD$`}=CMQg6v+erzS;B+8D;d5#B0 zT-@3Bj4?X#^N3hXNg6^g+o5YbRDr-TJo#YqinwkFzRmWH`?CG@NO>vrf2A=fHdIf~ zoA-lmYQ4YeLE=^^L$kFk5%EZD@^3z9q$kr{f{j$}m4Z$bl%Av>`=QFcMhwt1&S=Qw z{}`b9uv&5Mq$cXv=a#G9VK^nRXBI!4tc5=FZV*jz-c=@M%pF%IA4;#)#(^VoS1oz< zZ_aQ~%zsh0D~82yq(Qo+tpcs_KnsjXt$~&Qr8?;bm;)ib|4nsvmHO#p2Fnss*(#{1 zj?mH+j0%7s{(l3{?l+0@{{-GL!qb6|k?*puurbuv7hM$TjyaZweeDriw>)yj9-_u( z)12lR<-tJU<&t-e;7zm0AEM8rb_MBf4kuw2`ri46{bEdrmwt8K;RQh` zbE0ZkM(=$&10fA#ty>Pm>4>9{)<;ngRh>3^&2hutz8&{2M4@1}*Qa1R7!17Me-(mU z09R^WgYFd8LD#RQcP5WBj$_d76~hf?fAqC-J`oV4xOQbu0^#7}^6V*-NQV#z)F(67 zLbd}b>D6cqEV%V*d2E<^m^-qWv{FXKS>NL0hiMmHRyxSG-}r>vf`v%>e|5lC0a0#q z1|ZtM2m}~avHf~+_kFbGbbn!cAa}ok>@LZ9lK0Iisn7rIF?eBN z!&@}?j_jhq1nqB80(7mNNzfmb2hF~tQtBRAIkN;hexHKwkJt52!wWrR>$3v|e<2$t z7w*qT!J{PuqL8O_71014r1*5q0&0N~3@svlhg1NZo#p_VPYV2VQkvt|MdI&^wMsA{(?F|5!2)1npXvGUrU{y0_q*%b-Mdq7ncRNq=Z6>TjBk8c(r904 zj`|{v4jUk*V^<+olz9H15CJ{FZ)6Dho%7EA$bTV;fdSCUxOEMg73WLIM(c~UkB5DK z@6pZNMuC4zk$#Yj!qcDKQ=rOAj47D?a)u~K@XO2AnTezz5jC$^PwwruVdSG!^G4J# zQkznpdUmC0fx3CNq=vjm_s4HUX?c;hHNPuJsnDC9#k_ioc#5%NT<-84`=#rU5Z!sO zCN1IC#27;%8X?43STSk1Q`s$48SmB+nxQ((zj250|x%Z<^;m4$gNlg}s`Fn`%cTx_b ze%IVjCZ- zJ`Wz?OhTF3MVT_f7cuO@Jz_EbaJP?ah~SM&sv-;0o*a z(=oix*mJ)2u}CoWw>X=HmsG`!PuTHav0yHL6W8mU-pX67P<{_Gy&B?MZ+DP*)Bp(L zIpwmXKt^*LwV>_+6OORT3+u0dHYHxF!*#zt{h;ShJGXbf+dbORuX0;6p?&&MJ(Lj* zGlPlURHzJag>vo<3NHGC6QJ^J;?P=~e2(|LoW$yqXR)%DBcvgHC8Y#reOh)rD%^GE z-W+j>v#PMR&$$?9iLw~r>e2#M`nMvksYGBH%X;aF`&W}F-1EU<`C=`dSJbkoe1mrI zwxRyLOu=qC`tgO31HIE3#+y)%Xpe%Uop?eFWn?jRr3v#gQ)e)b&n9Cp;bI2YWg;u@ zYxPX4eEY~lRl>pxQcTP}%4JVth_@Kn956HHcK@!w{m8qa!=3OL;2uZ~3?sme4+?w4 z>|+At30;X-4F%1;4tkPit=!bVm|s0_UE`fP9Y_-hB3qxjF@ zaCy+mq`qvhd6YVgiP)}kdKor*^`t&U-@>FN?_u`K<8l9^k@Is8xgbdzgirG2Td$Ln z?9?Gk*7j_$qhvf168*@D*)OB3ftHl>#Dudi<}BA8HeLZ`Mw-FBaoxNx8FQB;;Smh@ zI)xC;_bU-LV^StPUiVsO2a+3-NS5j_Stx@_8cN2g+xQn^N4xy0e$kK9bNLFpPO24| zs6DzDSR`sPEMWcKKb`Owne^f56KcOy)$hMAR+758mM|Ty*lcU{35&m|T~F?+nG_ir z!(8}5*V7Ecp%LVpTP%z=96Cj@#d)_fY_iV~F3pJ8Rr$8Jz3O$M|EB+G6U8&1<%H;c z-*Dgr9=m+(+a37mO|C!wrSJVE2ul@WM&}=*M!VfbkM=XIucm0j^%mwr<}uv`^g(lk z;C!@DsP|&S*Wv?v*($f#3^taQE3y08r(U4F5eyjq7dKV1F|1Vzc9t+V(PF;&VF0+B z#EZx~%41t@Q4}30gE1L6I=)Jjtis%Yy(VRB=6}upt~hj^VHbB7ts-1-bH9#y!@{EHscYRcV2aEKQ% zqU_}ks8uD>df!?X27GO0dWS7ke>)uCr_qSVU0NvT73iLL#78vhc=4`%Yya9>^~_(v zq@4eDb&RiOapJP}L+GSSzsMlPqTB3dQoBZw6jTSSh&{Eb?n4VXq9A8~RentoM z!d&vG^u}riADM3xy~erVUCp%LccNW_T9onDwudzCcl4@A2F6EGyF)6=W$|hOu6Lviw9HbyEsTp9F;=j2eD)K z&NteCb8mRC;A7K1HN}NcOPGDl$jPBo=J1^f?Zz0VGb93JYG-Py=H|j$RMdf z(vco}(~w?ykQB(~UlRQ3oITeW--l#%rJ``JI1Grf(`lA(NALQ1TFA2AvKbG*@C$p$ zk9O^g$CO5agD5PkVSRQbe`#w42PQ=dcNS)OBDoS^>l#wC`^gewNR6R9gH2fGxF;+B zqVYW9T99>5#q;I>n)kj*#eU;2_Yiif&TQtj1yjbr7v68CZ#+?AR7)Udqjy!r8Qm&1&5DBhoF>unsF;MKy&0*2L-D%^MKdq_UBz>D zwLR=I_^!9^bBugzhFze~h89cp6zSKctdje(N*tJ};%@WVs)r0L;)eTSfH@h8N5a)` zUjjzk6~Y$Avc=7?tv=0dOZ#o}^pczhx^VyrZ!%x)X#Z!Xqc1+J1$XOoW1rT|U^BJY z=;m_ngur{g>A~3H8$O8@hO9Z!cRtvNcWa9#2VF^>DIm+hZhDsGx9%pn9flR;X-Xr& zi;P0=w9n;Wvc0?e?RpM)%|3iiVmO`3O|N7I97x7_55O(zfJYOrXV*rn%XR77%u*q_ z?h+akjENXh)4mBsT?liSTUlc>%5$o2fkg@W6&6jz{dHy@I6KJx`%eMF(#9UKiS;mc z60ahwosYl?>85t#!^2Z~T#zSOm&};yZ6q)z-F6-mMAa_hQol^-Y2QS;NgO>gwFd*9 z-nmQ*|Kv^+p9n+wW6>z;$o-(D0wkLFD<~K7 z){DO!CT4ch1O>LrQETGo968u`L{#@VAS0Bkb>t~+2HVE@jZMh;=LDyK&QBZ?GHW{P zLGDVBVmzzTM(pX5N^?XkxpR%y8^Nr0 zEM+ZqnG{hpu1ZVBA==U^?gqY}f2m#9Z*a|qICRTC27-<8cObAPnu6O1>!yi#+A+RM zkrhyA=`@UOP1#P1Cq1k3;{M~3FR6ZZ2iE6fiW8#QTNo1JIqI8Kcii1ZIRDx6qK2+h z$0t}1_-tvnJ4yahxvqyQjYq?9a&Ui}!&sJM%%e+_GlDk&eq@PUwb`|gub!RfAicYe z^)7pHL3_WFayQ1$vu(++T4N=b5i#KEGF%}te;87#5UD%_c~i@zoC;v7n{6BK>EDQ) z`Lk5&s@>Xf)iy-QE2CIeRB|U*Vag*%_7Tp-W3X4LwIDid%>r~kPSC>pgx5rR0dx#| zAWBuX?TS;sq5mU5favjgD)2Y+TzUvGt}R7W_rtR7=8}lpeYD#qOF-XoEJpNuY1@cT zH9Q=YlZ7llpsSDUZIknCVyuEFw5fC0{q}PibfQmRrC#cB?)Sz&<%$huZUiC#DW7aHy~ zA+uN{DJb>^|#jKCJU$D~MdpD*v zGKcv+6Nf+#kkqdsyCqXAXN#0KTORGau~o@T@PmbM__n`%0~kbl@^{CY#5UOf(iOTo zZ?SR&6xtC*ZYOJW>#`ThTPKbv6)#GsQRSr-lAcJU-BMcai=87EhxTGZ*Mh0p(_*Lq#0?2F&I9A61+ zC%?*;CM=$H&z|9(*Ikj3u;z7>EJ@TfmoeVT_3j8SjBRJ4LhO*e6CGb`?)YO_i-1(( zG3r~JhFA#uMG1TD2|S@|34@3_S{M=#MJS@diY<$m93$p;tSX zPnlQtjcR93P}A5VDqtSx@yVVnOZI14u8xhQC>3B7sh|uNHQEs>%=G9Sd2f;<-h_s$ z=U-^=$FdN{F$4y#e@Z~p1DrFSRf2+XkN9paOL((eV83lJ3=sPlwg2oAeQZ5ff=J~e z#3P5q>+A#sBGEI!b7;%)`|t!B+pb(CmNS*6CAIhSh}a++fTzC>KSj?2J+lLL0*F#b z$;~~gMr{86m`ZPEH5`2XrE3W{qp<(`tdFapkCEEy#gtQmJ~ra;)#w-;f49N}qRzOA z-BMjvkQuLyqx%#S;NxywF6TbueLEHO#Cy@`48*QJTbgj9%C3Vk-9t{ zku{qu5*3#i!AtSHr8?16nmxVgtdzp`IxH4sj)A8_G?aihOi=w-^bqx#8q!zik8fjJ zT^D?Al(v7g2m||=?gH=!@r=#C!8~$Z`!w>Ra@`I(;B|Lbx65;ka$fhaW~qPA1pda( zdX?(n+K+2jm$#HFc%`DmANu&IgRCi%N4bW(<|H*%8L2uRgNLttNK=Q#OTtEAB7wO7 zm09*a4gjgq3!7kCr~8%NF1u){9h|}|U8f(p`!`bmw{IaMBot7>YdtL3V$`;z02HfLDK?6T8E z6FR|~6DPw{l;h5afeEh_SZ|!ogzT`-(Vqh8A%IB0np z)j0hrLHNn`*+~ZeW{j_%IWKAY55EvD(#OweVlwKP4u&>X7)tyt~wb`C4G%H^E0 z-ATNFU;EP$VS&qb^T)u&do;%|#Ifz?jPlgeB*n(gUf1(NjDg=5|2&p57|6R7!bnx2D<4q9^upE;AeX@F(Z%LdOGo(Y zfH$3LTZJ~Ke672me_j+11cVoza&3^dWQ;+jc8addUq*0?;Gu220uz514CExDRSBTTFkxeV@8zZCQdZX{eN~TNn*GCciFeU@o2_>$ z^RPB4Nz0jbIoR(YM$Yzofv=gV^95MKRanlWRK?8sP&bse$oYVJK@wB4<{;k-8`uHF z3#xGajaz}lwkH22&jv94RmpmmO^u)$h%Ije_;g9Ja+OVSgb%2`Nw3zc`hzzzIJESn z$SQ&6OfzhO>oqi(2V-ou4)hv~X{?_YquoT3fwNmsDL6W-$f~9JQ^pIB!I=Oc-i7Ha z3CEOxH@eh3UzPGWUDUk46_#`84ljrp8$fKZZ=tAFvCb>G=FJ)XC+Uk7eMVTt06Qit z`rn(}YNe_ymRN{(pn1DflM^m041~io?x&?)apZ3tc^TQWP^Kb#0!kH*KZA2xgREBC z)VRYFDk?zh@5aN%2Z2cs22WK(uIlGr~Qrjx1NEWy4~<$^=^S!M0x`vS#J*;I-P+q<9Vv`g#TDt3_z@_zPP2unGYop7RWj zYvhM!LC=8qBWM-f=z)wB|MxG|YwZ_RHF+eAb>x7Fwd6PLd$YnMe6&>bUHkz9y75{n z!Hf|_vfFvsXXVuYRl*-Hm-9*x8nFC|jN_j*MyzhpRG+y!z?lPO6lZD{4Fq^;nF_aY z?aesmESxbXTT$2Qw$Qf6!=$ER=RD{m9p&c-Ct+i55LDCK1fFazB7s{Fzm#yucIor# z@S=6tDv{KTZ#TcPxjBn@M~F9^IsgV&LS|Mbahs;-L>FKxs43>C^6D~unlR}_)xzO# z4appOX3Q!VnWRD_As^xO;`f&$>*9f8r!eF0UqRs zd1l)vpi+tuUI%8TE$Ck zA*pLZ(4pra2_q}=f!gCg^sNRKWdZZw|A~Nw)@yI7-28#en|T+}C{V|m5d5ZVdjFNi zIfmj8hQVtd%_08*z}Y%Eolh7vB0Uqt)=q+_C)s*Rk& z4L61}WzY;@^!*NM&G@dxZhgy{yRs>;k|kqJ2XD<~WR6nK8q| zLZEB$?`SWK8M`1sxbF%E_7BKmQ>QkdB_`8(js)dXj0WXP%lzRpondnJxcWGHqZ^>g z%m+T@eNWkSqv5kLmFwrhr%`a<*=c=Y75?<}&T!ZcsR%1DR!KcR?D)C;H-|nN1>|S*K*DKk)&Rp zaE}seiEPxU5q^d~Xt6v)Ak<5$(iHd|Nrl!0b|yVa>Q{Ir9hs__sQVYNDXaQ6KEO@D zh8+FV{)pb2?IA{7$p7(tK#viQE?<#&r{FDhWlA^7@JHIKl)n=kx>m0nw%D6 z47l}HSUa~%RJO@de~mF74^fz{X<7xX;>Zp0`^M7q?;P^h6^9f0h|(l(Vo=;5TGn@n zkaf_y>}p&l%9kKGv+{|Zb3z+wTFb`Ot;yXT>ED&ER?fGY^r#0sUxy5Wqf&TQd1&Vf zd1t9+(JD;N@V1bO?qw1+QFGmamFo96s^Z(8OJPJiY%~DsW|R1Y9DbUJc}={sSSV;n zszwE{FBc}|Z`yGRSEdD1;GeoGdl{yJDNrA(Dk-~WslExc=0N{jcuMHZ)Sy-y(HT1r zED&sppUmvs2=xja)7q9-Y3h!<S-5vj`c*N;)t$*nYT~-RbTtMTw zMg*2C0F=g>HB^(FD1uw?gg0*qf5ke-1SGgx)m4F(0xCQ(m-b zho^$Xq*5Fh%Ai%HKoucs1?E&L)0V~NLobaU(lM5?cAwu@+pWGim#ifFb!jT-we?ZA5Vn3WHPD4gU$8oau$zT2Z@VCIc%d-D(9)Cg?{<^!&Tn3YE z1XFnJme+Fm-OQtNml*<4tiS5=B;HJJf@3`kFF3jo<@tHX+^43) zTLG-uEtFrgH}h8i`73WH_6p`1&y1IfV4$R2z7tUEviIT)p2tOX-Ev_qM-j% zzv{uqL&5MLNiaWKJt3_YCdy)p z9*W8RMSTs^nih-$NQ3#It?1V`HSnqf zOh>4q5FT_JwGoSA@(V@`rx(i>xg%r;r%=ylcUb8dn<%{@l9u$?EH{S|aarlgnFqjy zH_>?mCVg9MoGOCTK!a5s;ZMpsLeQK(*|F>#`nz@}e{Oal`lQA=T|QyCLQ|^jZZyqo zfqd3L5j26U_Do$7^rl}@f3nf#Q~(o)hW9FC zxGIz`ht;s`s9P9=CP%=dpIej(UD@X%vj~DKBy2_0l@G@sbl&c4;$RzdB zvul15RZ*ogg(5eGHe1ApDnEv%oZ1>MZIeh|H~Q|uVwUEM247CBid3_Rv3OI~I*@N@ zcg0arXQ%w%TA^V_8fq0#^Tcd$>^X1KJbl#?XJmDami#zbx_M3TmEDr?Z76w$tA;fertTbaeHHX zWt;+Z8_6*@!++m;d`&%(-(Prjd)*24f3a(@Y|rg(z2r#reeLOpyFMJ{d}p*D$viRu zAB2DoA3Q%N4tM00!u&Tv_CD8NjwZRpVXz-t9*KaS912w*Cnq~6_hst>{Lr1B^AcR6 zk8cB<+aZFFrPs$7JAZpNJ~pq+Z(qYF?M^?2*DvM?R-bxo=i)r@Y)eQccI-c12K<4v zgGrZmSAxK#kDK`c(BZQEgFkimnhmF5m;T=L`om?jH%QOpa_8jXYVz=5=VQ|U$v|K6 z?RYrz;AZc&WKqU7Y>neV@v`jN*4pz3$6BYnD#jiho__Zj9xb@}f$vw!DF`%2X1ro- zdw$Z#-c(`Kx#U^59LRRmKQ$y_GRkgzxTq=gy{)ypeBc6N=I)_w3))B)pQ@3bXw@i| zm?KSIY@S)(-AAUX9#8e2=O(cN_wGVUud^R&;yMg>Z^qB|*2WwBU!I#m{s5SjLrc8S zgHN}P=Z}2ejjGu2CKG^pk#<>9ChDQ?6{^_V|2$MePA=QJeTSAii9ap|a(GTRZ z&VLowJbdvgNo1F|dDOZy7IoJnMV56t>i>Oj`&H4FFY*)*PY#x2>xD?b+ts~+@8xjs z^`z+nK)8MVGWW(ltQu?3`usd#zHIgYwAf4AALHU-fauO*dxw7mS}A11`-|hTx^YHO z5{f}f*jQemAXv+Hd78rXp_KWXjRB$w3l8O%|YqN^==w|`i{O7Amq%{lDBfz%@P z5h|Ry5n(l3<(|4<$SUg^zlUJ3g)Z%=LsX)%%ThOzi{*1SN-l(J!u*wAX6`mDOPL9! zn5~{Yn;4UEEpVdVP!m!UYOny^Yd1EkWLM9^=h(vOS?s(=FIt~7bT&3>gTu%@KWXm9 zb|KgLS=7P2rK-`oY?x9#lSWD(Cd34F+8>*Aq?!6S^BzP#ZwTrYs(?#V7}}r0fAcI` zV9a?JDaMZHcnsl`Ew(OD?}gj-mP=@ryh16qz&hwc?W~CvE<%Ark2@!qt+ilx)?5gz z*aAwn^lSB>u}?%%LJzm}BlX)LR~2sgQq(PM5bDq+*`@LCQGOOnr(yw-ZhlcDJykGE z<1Z3K79Qf}`P8{O!wvGBv`jcv|MH?5?DqZ1`9l8ghAap$33U!tW_IQTm~;tr#OCD5 z`sTP{hEu< zQ>U889#wk0e9D-ct-t1{)Q_ZXMP7*|w_E|FnMd7nmMz+k;bP!2>T;1|E2&%hEr->7 zm05zLaBh$ImkcAVSPrhL3DO2eHQRy??hDCx`evsRJEp~x(_#)qa+mykQo~@tn%FQv z0;OO^X*Qk5My<5+kBk=hn}tO&Xw|rtZ^=L?LnC771?mUS4^*KyxRtg?;t`#!oFA}l zvga3Qtw$cND9ojSkNtkoCzH%IW@r-f);_eGltg9|xKdQ64S8mypf-4?j%kwUBwc6; z+mxP)ZNBY_<0zZj*PEP*t|&B}z+AzLVd2tf7cQr_mGLM~ncJ4KfYnj%){j0cICa5_ z(odfKKYg6KkL7WcEy|9y?<$TuvXf`^_M|7>!bW9uYIpEB=6Fb3e~SUhKErTDTTTC1 z*AyQ+eSbx?%S*f;*V&g;|1(A5lTs)0B94&Otdv~_rB#S~f<>T8)bCayr!nZOhTT4b z-u}xgJ3YDrO?*`WH(f*{Z@B=hk{)x9g0_S^fYLR^>z4}$g|37P;L+vYOHay}rjYlh z$WS~pL=OpfzDOxeuHqxZ)SO=aduU|QX-%{AOqw4K+Z4MHG&?98Zk*T(W$+-6nR7xa zg%GClx>z`T(GAicm*Y@34DS|Hd-JiHa`!iL@{Xp^e2Q4OWHYkeh;H?cK1qI?V)ZV& zF~LY059d!~!YZSgKOD39yXN3mMFcS&*`TS`{dm>7R6~!zdAPT2(mp;fn{G9C9Des$ z<@hsI+xo->oRp%e6*AW_%5qj3>Fhe`Qv}{bo+SPhCZz91*lI8v)NoE?2m3SKMN?FT zl;_JdOhh?M*wDC!Z{cl!Z7X-+kru|nEHG)88bwg?&e7*^209G;zD@rMnO*RY>2^N`T+G;OaODDKNlz}j#{ezph5%vV=It%ExRm-QASy8L1a%5>~U(dE9TijTH$6c`8T=j|MwZ2KtpQd5n%qa z7kx&w)jS3Q+q{m&+fmRxF03YkGPtIFM}t7o{(BnrGm>2T57u_lTsIr_g)F#;p{UFz zU2U#N0z*ZOG%wmfvAJ#a3H`b3D; zinahKvKy%2wx*tX+0{yB;F4pl#Kog%D}SDSK=rTH1P zL93Rx%;Me2p$9!?=04ITf>osfHAdtDu4xo%@EW-0$1v1xa5!suGX_EPXjWjLMmdpY z{~2^`rli0QNq+FP*Hg#}aXCy(FnkCxDvN5hzff6#ce^0M5)sVs4wZOPr)DCWTbNZI|xXFT{LP3K$f~ba?N!?}DYcY)vPd>1&;B2;%Iet}E z)wIp_cY}6{)FzcBnUUUA1Y0nPLSvB9Hk*$H?=qr5@FH>faZz5W7Wa2t?gYQt9E?G? z3VF7TB;o?8o@4N9SIJn-n_(KCSx5cNua&8Bt|GER!$`|M%OJI;LO*W$doOC+{v%1W zl)8T7LHz7j{%?2Fwu{QyN~5%!6fg|W@8#@ztI3DoGiz?i*p$9>@|O`weN)MZ1mhy# z*AHr)^d0Pr_$J3>CcsExeyFueHm(Iz!b{2Q!7t+G73?~h)kctFSZSgy3N@_G%B}_Q z0K)MINatgjJ8d?sU!}CvWRxPThV)nCOO^emvsN&F4}AH(7D4<-W5?BC;kJ}H7!7#1 zHDxA)>{b!?$}n>e5@_~Xa%d&mYgtbvj!X9&74v@)O593+3-ug_{`c+*3r1sKEnx1V z{~KWqm2%4}attO<4m~aUN5;fWk+;t|VrF82&z|I7^wEI}CA43E|B4f}=GLv(FNQh6 z&>r6byU{~$o0QpX50zRO;ePrS&%#k8=!Em^S#XhYu7onWg_C`r?I=kDZ3ZiF0nTvi z+GTq#^-%NGv%6}XCQ;n!|Bs{=klQ99kkxb$-NriNziq5j-$78mXr)R(S<1?YoTTH`+EaCzlH0Im+3S)TQT9?yP8QqV37J1HiZ^Qd- ztoxNiO>u4wnl6E2+~KNh|FzzK4dzH=VY+5uzGm2gQH62%m(F%Q;Vt1}GuXyf^rI@) zAw_c>s_)-53F!q+BkZ>g9RG6osg|5s+XrOm)Lx;g#m4;!Aq5G9ebYf91sFr2{BnrU z-!SO7_<1vjuq@5;oV3)s0r;{*tJ!|KHq%O+%)B4`~ z5mf*%r7kZaw-b!)A#LS=E3!*@jVW-4DwSA5Bz+L}48=~?_{JHr0tcHTQmpgfKQ77EKH;B8NVxa^s78=r6!roG z=RvkBQN4vtvHon3v4q-9(OaWm5N&&&zWOxZlqvhdv*R~KFifZt7SMD8DoR*BOevG(tlJ`(_3?g49XMEF`LfcP#bvs zd#$LxRzMYsmj*p#7wWbb1Ql7Jhp7Bsp`knjwA?mU$rZNyTdh9-#C7`sk4x)yCFc^e zqiL{Qm6qCi*Cq?r2mo69)kV$lRN!(mRT+nC|9^a(53eom>$RmJ2~wYugT6WBi<+uf zcKPw(;#{DCYhgQ+bAoc^*qqB=H?|rL`cP zY?HQsV`UOOEb?aewVo92>IWQ%x-!^rz-LRaW5%O7AvvKk* zd-!{><6kE1;r4N0&Vt{Bd|;!si-66N)yJ&KNrWWw{vw$~v%zU#13ibUFAduR8!5Z zKG7z6S|fM+k=J%p7c@C}KRHn7;qE-J^j@O`V145KygRFTbNd8-dcArqe(JunUOn7S zFR#B&z8ctH*$KFA0{*etbI9d-A~8eoN2o=x%!{-PYIh_XAx$$A!ZS?)z2wJYOrAWukQ?OEuBM7?;s^ zQ~9J2LfZSjr(E2Jzdhd^a%%K|9`6qA?^lOY-CH*NJT%BU__bsMxvU)O(P@A}YIy`@ zR9k)*Kao)~Yu5evH{bj)K-<<|o4eX7{Zhb4Ht*xEYuoh#Z__^BXWNgL-N-X9 z7S#p?_sDN&45pRo22X_orv_;DM3sv7zUYrlFvhvJ4~H~cTZJ2`9qtA!j3pneeG-p5 z^1ctMAA`q_m#Ssc@C^_*OvIvos@G@^S+E_4!JRHrK|C8yD6L-G@7fExEz^WV_h@VFF0(zYi$;=ExP!` zii1i0GHO%TGp8?`z;^jcH-BCKDgZCotynHzPVdyrcjExeC@P@2P$68raS+Si!E0Cj`4G z(UyHfwZZ^reH>A(g2kd4a#%u9rvA{@fM|$Ru1};{q1v2emi~S19|SR2gv9>iLw9S) zKN)~;xAfq&p7)4Ysx>x~L#+nglvpO_PRt04Y)>chZUJctWAWWsdjjDZ%Gdi_;hwlm zcw!qpeV%-PRVvCx@-j))2!(g2n9_uM5Elw2z4;&CKV4a+eFh8z^JOH84F+E+1N9ZA zYPrGaNhCSH31_0I^AwAi!LjE$N^WDSmz}V?pVAZ*1hNV@kV1@sJr?iZ@2UcFRGe}? z_nI>3{Vm@Z;i#aXM+Kv$+>@*X-Kq;@aBYoROAEy7IAH2kR-uF#%^|vU;f`NR+DT?Q zeg*1JLVER4al;??S%d)_0{!j^W1+e>h+*Ng=I9{228e%WNsN}KoQ>zlq28LF?pRlm zyUblO`t%9){HJOTL>J=FK2pL2D1eYc)C=ju=Fgl9HP?CaZF6OtOzLV!P~ui#AW%xN zpq+m7RqPq#M2EPGQ9v52Gg=s&sYV`Cen#cRi%iB0Vs7|b7{V1M@O$_gPiji94dnN# zdKuVw{b>=et{-#r^YPuebX}MWg=y~HG#n4d&osl`A~}G|taU{H*g{_0tgX!tKARRi z^2S5_;08(bZ>lTRC}%KcLf?+|S!=UFfzgH?8^haF~$vS2Ns%J1b>mJ5?}DI;K=i z_3Eh;XK*Q@=mOkE4MJf;mFm^f-QhG6H57P9L}XMLbE-~UCA$q!u720Eb4BgEqC62# zSXW}9&wb;ijUWR54?>D~|6FY`r1Fd6-Qp#yE$O@n7jVj>FiQMU<~8x zF@U0U%$aqnC_6;R5_Gv1Kt8hkew54Y=*X<~bHjJ?h<1WA@VN|wVk;?HnJ}rqu;3TI z7bOWlOSzrXNiaELI%t-x)16ubwXV~n`j8h(YF92zP+|%}>J~np)tDPTE-TPE zCOX#Hp~4yALhOrupgU52mPoOsfqGj^RvSX?8FTG49#3ztU1g#SnxUZDCu>qxI^=`- zX)6PyTN(T33&wKhj@LuejZAuCd_pRKHkejCFghq#K^95pv7&60*X0|9RiDEFHH-=W zn&{3eZ8frk-qhgz-XOxYl@?0fG@k)MPhXqswaR@8fGU*YAXb&t>1X*LVI8w%)S!NIz5MvL+Dqy7qS?1 zh$22UX;8hzV>hmsSjRZVEP?O@eK8K~nu(KVz#vjZ*lMwiCEXPZvaOoAC_lv2?<_JZ zTZ)8kj`l)vTEu}pXXB?7si$|+GzqUMnZY8Kzid(^SfPA?yKt)lbJBM*UbNr`^~@C# zN^(7dKQr8>|H6y#N7g9pY+s?&OKp7bqV6V-)AN3e$&Gz8Q*|IKyje4S5R_gmgO;*a zz1_n4_g5RMI4K5yfHol-PJ|MQk?>?v6_e0Gz6fif-Xf7Bj4)Po{jPzfHCU`;Kcva6 z|CaGb>5JGmWZ2SeKf4XCv%h~$tP!bv2tj`7ZtC22=9{nY(hjivi??n_twbtFS#XzJ zqcg2REa?kydrrdvguLdxE>ax4xt(m?O&6g(+_PqoiR+K3eBiJQd{rs4>*4qLa13BcOl4V^SIiwFqW!hFKC^>8(!57#hMU-i zr*uO#RgeX9)BHO>+n5*wY^uo0_iQc;TTFx)^}vb1eywfBCFy^^%fi$Bc5L+Zu7lm- z$8oU@^xZg~?g9D~)^PNS(q(Phnx{fLyvPDlSrOodn^jG>AX$RP#9;5)t85SsA~$xVARXV>;5HR$99%WNaj57K{JLl=^K64aBksA#ZuYC!^Fso$GSa0HTzVg}(H&8<#ywSIdy+ zH({-sL{!sYMohBxHTvFXgs8*^Lzy{jkLeaM6*Kc}vP>#`l$1tA$B(?SBK{B%7D`Hp z-`EMt@vDU^d){yx#QVhV6FGs>QL@tapMUOzNX*IBoW$%yjgvLpPM=Z=J&%%i2m3A_ zgUPv&!}~ow1g7>{1DtxkD(rT`urhPq;%6CbZAK+=88rS#W^$pHSf`$v?GU1NyN419 zp(+Fc9Jj8QWEF_Jc6~$%f+ub`zQ;!-BqO04H&ZNYKNwFWu6fLn!xaiSNTB$N1-q*2 zB~Toz6_jETO?Q+sAy@YEP0$x4pJuu(h;mKnfRThf7j|!8O9K3^VUCu@mNC_1*OgcT zWSz6xjC?3AvS20?-bHH`>LUmlg6^DxMT@o>gOa2anb;$b@rw+$&UidgGOI?WR#wC{ zbW8KB7QabnQ$rAYjXD~gd5z_?3j3*gLBFUAA+H|b{~#F*A(z;vLnRPB2Zx@TU}UF@61rq$884ANk6k@K+&cN~uvJ zNBt@GzdBsJQcjuW(LDAwj7Jkc0}to3trJB^@5OO@sPpkm9mn=T;98=T5f<0%shUf3 zL%b|3dgCC1c*G1($TD8yOH)S^N$v38P$7k}D2s`kzp- z@Y(z&Ml;ci7Pipg`1?|=M{+O;kD9)LU;JEd+YO*f9sQh?&bYZgWAvA$n=;PPB|g~n zlJ|MV$zAhn8v5cf;+f02e~EV9e~-V@HkxM$&{!Q&p=gc)ARf(w=#`c1u1pQJGo zFAt+CO>9f@!=fsvL0znh+tc@k>r-#YN@;@J>i2^vJ@&Kd(VyiN8rfPYyB|Zq>yO~x zl`8T;9(|@7j$e~`ZrzEZFA&LA5AgrUMjAG8vpX2I6ZeJ{3D8tirvqOOd~1?0Kx1j~r`Yz1 zYc6A7PwCYC1eCw-g~m6xxdAp&3f8hIdPsefzGqgv>OhvJL7F_UB%*~zQHdW%m`R7q z+kXDk?`3vW+GA=fdX?%XI}o1>-+jiS5O_vEURJ9SW>(w|fUs6Oql%MW%`0dSePKO* zp2f@3VVOSu8pR1$*vR6gVy5|+(u(o*OAe)q+n3|a!Mnnw<#$pp=sSM#ZJ6WK$KKr{ zne^B%u4&GxP^~<9>#j(h7fj+>&dlYR;|O@8mQ>Ov`f>W}BwaDgn!%%)YxfmhOx$=W zR5(U`3`XEQ$BDvj1 z&!G0t+%D^N$Dfk*pDfeakin>AKLx@y3?T~5>sY(&U$4;Aw6+qf+COdV6MP&eakz>M5$Ic7ACgX|qFQaa^k#@ZeJhu z9TV1(GaN26l1kx&cH&$vCNByLo@TzPV4*YDaql_XZF#;YRt7$fByY;mCsaXSW|CB) zKg9l*D!uz7tFy;s?*r_Ogf+U1pK3}2N9}PU8cA7{<~K!gNp*FOG8dLQuAoBX(;(5ib#o(3MlxsQ^^`VDnbTx_7){dmT!XA-M~@t0!W8-DA;wpH0G1q?l86y>uIS=$XEhTze+dhVSdZLy}sBNEOZB`I_9(Vgl;`vb@bPBqVrl1S_BE0ijEFR``D@$h6un0Evy|A z>kE?41nh6R5CAWQX-rjh1ODP?H3(FuSKc#o6z?~h(^p_#mOx4^L{T>t>Bgj4$;Ad# zrPmM*d~P{DH}Nn3D!ARL&t5$+_8&$1t>xDvi=HU-#c{<}_z<4`(zu8dPHKerNqP3U zzmUBJzETjor`qKBcyu+YgnOmj6=n}6f^5URF zfaPJJ+-hp{j=#O~R&`UPQ$uhPl352cI-S_XCZp-+3!2K~xB08zOduZx+%7M~Gj^ME z&X2VAT3_Xv*xctgw}sr>HqMM6$U7h?-s)&4Q*yQ|?o8@$iwul(Nhq{kl7))ehWomb zuon)f#0zqtlScz|dZKkoI!I$3n0Hg`?`A0Up*GqZ;9Sd5%`gQ&NId1s%HvU~Rg4|l z+F{w#t(V`Pxh4rldmOUD{7OKq#Rx)6>ZbkgN^ksuzS>TkB&0-s<@XcO@K^KksqhvH zUzQ$V1$`GV4+|cu!$?HNZl~}`o|A$e)}Q@lZu15A!{Xl{te3?RJ>$4bbmvW5XT_>U z(QV7n)b?r(owdTeMQ+4{&IWYt6NxYz8)&N>CNo|$j;R+coDpE;nNX@$=k*tp@`+N- ziDpo>VhDRX&c#XbKJQZy_Ky-qosV`V*MxC1mPyg-czyCPO&;D~<)?7bLVpU%48a?=E3iv;isK6a*ix_#$s{Gdg2y*4I6D`f)1bI_V>8XWN3ls)()5 z1VubyiV*=MuJ~&>bt-0$?p<8&4OqVFy;@*9K6VqNru} zs;mC3ukx{Z$hCzk-lAl-7Ia)Vn!9BQ6I;z1JatwGe7*Dt0A?=-|LI$wVCOB! z=#CM-Q%<#Z=M$>ot|=|-SP|U_x-859O@Y3%F!|XIL2xWnlqA1+3Ccy*=XQe1xx+bH z*&{f**8V+fVHluxt?k4L-6;o}A9;3>@Vs^A0II*xO;p(lyPJ03Z^{`@c=G>#uAjus z|7o>JEGBuV!|5Hnb98Uxq6{=`a5L_}&-|ERm*u|pzzT)X# z*X90iKd}o~mYX5}S>ECihiYdm6d#3 zC)GAs{6A(JAt(@iJhOh^75zMy{90ZtI<{9 z5cuq#-y-fsfBE@xM&J{-j*`Z7jvQJGhApk}h(5;qU1v;+lprF!FuyH%j zZ5J#GMotR&_-03MgY!e0WWzLHs{Y*$+G=2=w1F7n-QI*Y+|udQD?7>({=4PpZ;=Yg z_*i1~iOu12CV;$Mjg*s3w17|o@$LGgbhxX6R(z zsadI&=_|X4_|sk1W|ar6+;PNEXR%`$Lz*O`%-sRDjgut}PM-7X5SPsf7E5TG@^^jU zS}LVGlVCJ<_W4Ig?54(RD2dffho|M#h)fSt`&}p)Xx>>pS5aZ)i?Y2dcg}L9b85Hd zk(fUfi9nHtInjj{!Ybgwy<>LUzE8E{5fky#Mwr24v)zyNovLK{ZzH!+R|O0%=S?v=BXg=svGUd)!fFu?7%(jsKi#vGjqBVE#$Omul8is(??SG?H(o!Ti949%tRF=a7@Tg%U;+kOX z0$(;ySUeKu{BraY&y`YodDE_sbY7NIA-*`$6z)&9UK6pr_lrpbh6Ij=5nroem!)Lg z&(jF3xgz?A%ah1Sb?gIn4B-4MMgvN^jj+3-zs*BuSRmSHfnx8!GgF;o1(_}R(X=gF zDuxiv%5ZXP0A4|L=DDd?Y?%QY-fBSE`aD`Df6b0K+9+iq-W>rj&s*r(Q#pWCq9%?5 zkc;P>LnV}B%xn~NUMFtH9X?y(*yk^mgzXhRS159l*6GZReL1{p7R*lG+y+@BmSZVN z1?ZzJG-^zlXj626E#J2uomsX^>+zwYzdVv!%f^-NXkt%d@1OqY_m-iE4vWb(aIVA+ zT_##<`1(Gr8!k^cJoP~O;dRCC0@GH%f>o2a5&Mp2hYb0mJn7ic<3hU?$8h6pN3@y^ z22$i9!{oMD>KNUv2fLNdp#u&vNw*_=U`3%xLc{D(W$OGlmv9A9WWE|$vnftXNCVWN z=jU772&C*VzgbUyg3W*C)@bW91QidgN`N2{sp8;rcYcfW?6<+@xJ;~E5;4I3N{x_9 z3crtJvZ4OA30{HdqMv?|gd|z=;%5H*3{>f3!B9JTg z>>wF26Pxi@UJbF;sinDQ5*`=a7xDR5^TIPjzZQ42cE96?lV0t$K878jRXeE+2z0QH zLeTE}QlPzda(vrq{K(+~9_$%kkz!!;*apxkk$t=Q@-sD+vz)$h&~|HTn0?i>auRx= zE+9O#?g4jAv)@D^AOia$JFIj3pvw^-c$kWJ{J#YD)vX?YI~F2FJ2z zo)c6@jCB$|afpT6<#v||IB>KVSZ-pwgg>;v*gX>IVz07k_=+z~o{`&#x>)$1iLbvO z6^!d;SxwB-BK*=IC~w{}c9k$pJbrngaStEKyMV2%2P3Sa zvRlUX-Nt1V!8kbod8zlp?;5CX|5h|zQLT8iK_<_t3A;dw-EX?&V#wwiU!8W1uKY!i zV*5LI{=l+*%#FP)J9Wd(utz)}CUlwE+!yu~Plh$CH3Cm11%BtN$7>7{%#eD7YumUh zj40#GtcTP}-!ovv#Mzv(P%4<4T6M=VED!qyI88K&WsDG@u4g`$qFb8{HM}3{p)N>1T*?ZT{u(v*}KVj57LT1#^OWrB0pcXCU!H$mO`H-E*ezFCH7>x^J?66NCYOA}pbveL4t6^D4(Eb~U z=%|YQjfvB6nk<{rGwMl%ogZBVTkGtB;j*1Wv^!e4^IWuh6oHu|^s2!Y4I8z_V<61Tbm>3>^ zjMQ-zWyMrlR9LgK-TetR3?k6=!vhAYCsc?gtCL3l@MMq3A#~ub+I8ZI9It6O$!*hB zIJk8s9QDGY<2O)-$J$%D$a~CqH?(K z^E^8@_Sj+%ckGO87lktBI`z9kojzbPwrfrs%C_BVzx1RY&W=dFpHJS3Y6|eyixZ8~ zD>a7td{2)Apa;+XxHNp$kuAoNJ10<^@#!6;A{S+SPViahHU1oCL~JOH9+~z^20XHl^1xI3=gM64>(A z(MgCvxb9!ufcfLU0HssjCnwA1KNISk3e!Ls^N;UVr^GpHS1cNuTzuA0-?^bT)KG7e==|?clIQJ&ZI@vYbi2*p=7SA+dW7K<;Bn|yXs}Ds>D^9$Y9F&mk zKJzw7#4faZT;2k(c8`@J$@r$!<1-81L_9kWJU3}iu;~OW=ea9>Rir&geU!X@sTx#o zS57iJ{qSm7h{ZxbR~_q%mu#0txq#ofkS){870503O<{B>b(58K7RD=kpVge;9C-1hR4_Y7!EL8x7v|5)*cCHf`C~NhoU{H7y(-HoodWCqG%3EGY`LxVDh*tsXtE9IvkI}1 zlr(UqWEAp-)^{0s%M-F6EgdxMmjy)40@K^9Yn9dJhy}jy^r#mf;tIVBw9qlpM(S@c$~+-cTCuUOPu*GX zd3HNIF*h{0c84V+vAcj2_FS}Ur~0E|f%7z| z7ORYqh_ZbC4oRjOe8^aZM7JGRJX2`QxV=L870}yOS9$Rf&QWu*I(5fX4GqY$FoocE<&EM-mbOhLLZa+wihF^@2*p zt~L_ek6{Y7duF{#t*+r`e=aeQno(HJ9POE0h%qLOF9rIMp*r08bS{Iivdny1^uken zN9jeIs+)92X~+$KEMFy+&py|dDw%W?**X@>JWk)^4#KON#gU&>ejq|VU4w8J+93G; z9(ZR+34z1|vs)5_QsA0Tp4Hilge1&b=l0-!1#--P43O?I>F7 zvH;-tmzQ*&2bGg)(L%xQ2vv3fWwx|BhcG(=eE`9^u|7`(OHeL?Pw*%Huh-+-QG1l+ zx{VFC+rSjUY_e#DgmPu5@(Ht{7_6dYZ#=@PBNIL8sL#wHW`dXe+eV#rz0>_z?Hz9R zAM1{wc0Fb7IoenALU(#cCz$L5QGe!}O3OQ~PJ zSqfy0y0DD^C>hue$du5|rf+Z0465v1nmbxid(v?EQ_SvhtDAUx5T|AdQZa!kmX_@j zhZBPoH}j1_@&|$pz435*{A`qsxQug2WupffjWU!@S#*&EWxdiX(pVlT6rxGMG;q?1cL+dyz_H;roA3 zBu+<*=3zP>RSwbfs&&ssFKGV83&?udJnMx|RnvN8f}VDT2r6#+$k8%`H7+O;u<4>d z^^|K=ctzccizC7>tOsNX9^%VO7&iPANMH}BlZiL#{ap}45oPIO$y8Pl>orGW>`#Kh zc#I^fYJ)vL+^qei2w<*w8#x_hX+|sBQ)iKt*=VvgWKj~rER%H|sKx!|PO%PDpnpRh zp8vBwIrDhaKr;J+&cgYgJ>y1Pk(D}Sobjcb_=fQOCB1SrF8horLu^cLed0&LoqrQM z!cKxI;SkfEPt+-ZrOAuf*=b2L2tIr8B!FUJ!cieD49?#r$H1l3t;m`DItEYwbHxk) zKtwlJ;29%puB)R*LVMNgIVBW^ryTzV%C321m2+Q-)QheNaGrR2{49jTp8to6duYg2 zB5`B-y`V`p))duRSND}e^JgK_P>2YeaKHT&+j7rHn<%dJr&|Fsa8{Ti1{sTX-L!Ub z&hUl>oeTGfumHG`aycsDCiPt^sTgCezkctqQ^RJR>VQoE`Uu2@V_=t*Az~I)MG==y#OwU`ys~$*V~by z&WF|?IiO2Af?laFah82}CKg+u&vCLgaItJ{lt;Vm-WUrrZNhN**TaTL+y7TKMb2*vIyv~<`AU7kGDs@(RdzV)5 zSlZFl{wq|sg^FAZX&+ZRtl2%Pg-X9DE#TitCT>Rr<(2lNFfw)$p#`e+D4mIIuA)-b zHdwgXfpK(qj}b3riSfbfB*IZ}h1m-fCJxU=C|myMvAXLD4ce4~%tn=C_m_oFux5T* zgBWa`t3>r<-;pg>_e6@}paD9FWMi-cz+;1xu_m>pD#N*%Q(xCN&Ggz}N}VZl2>-B8 zn5Jbd-L+J5n+Yoci%+OTohIsz%(P^(hyG2;V66JoUIbT%StkZ_x?CNWJaBlne5+iT zgn2W9t8)9q9(?a}+fHtLdvH9=a!nvGQz@4D683}HD)sk2@tAYmr8>7Gc$gjjO$2=P z*CMwD4Kz;+hNrcjSjS&RnBCJ6ORjto>_B!5xuxBnBm0WN7P<(I#U2b!6T<|d`Y+R3 z)ru#p=0c5|t!d1L*J}v!F0*sk+Jx>Zr)l)pw{=e%K5jpZ!5rdra%|E+f!i9Qs)xYS zEN5O-s`|NTzmTaclUD-o^s+1nWhm@NdB0O$-DQLVL;?j=f-ot zNc@GsN5h9qCXsU`ls+9+VmOMy8ZqL^DYPW5=;~x{lVt+gmc)F0`}awr8yT~3BB)^?=kV18;Hr{1%&eu(REeOCjh;428j>Z` z;z*`gFnk$U1ag>WLE}r${8^>M`mRomnbuEjSlYl&MB23KAW0nd6`ppCP6EYke?u^C zcmBhzQWZ~IRQ-V)q_HL#1Ad{UTC4W=tC|zbl70<~R3u{T>F58$Ekbq1MSK_5KfXx7 zc+Uuf{LWUfFj` z3`(kth-ZFy80lM2?SHcrS{hhn7|GS~vy(zUMT+M?`Ix$ZX9`y8?K*_{u_2>wg7Y74 z!c4bhE3S$gD>}Z3F)R8)8vGMblRjw|Ydfl&foua9Hcem%VKqp3jBs2f(GRib;f}SD z!*d*)U-LoyVul~x`!-DsYclOtYm`rY?1~{T$~8t}km=@GgmtifXwidQN;)6fOq)`T z!SqX4opikuwbOxlju_n5&i=H<50av03U%H-dvdr2Kw80lx4h^o{NLj1ey<=_Bh${U zDg#y^Y*`H2P=sH$0DnQPWJbe#>>q|vjtwF~IlY^8O8)m>H7|OSK7`<=12PQM{K!P| zsfm1l$~zhaT{;M%$6vUFT&EYUA4=dzO8os#smrLs4GDUFyL)hZfw=r>#OXw`=C7Ow zcORfY*K=X

    0Aa!pI%>Tmb$7oy)gvM2umIP0GFOT=`s3Xmn`6?m!96Av#urN3?M zYUfvc8s*3MB16|iBvoKcmTmHF^qGGJE7%@`h-#>yhhR|nEewyp_lp~byf~FT`)A-T zr+raUz}hrO>cLeHEGMH*j4U<=i2s0{NKTsV$9&ztB2dp+BITU>rJ|?!rg7>NfevZ1 zldNVin@!W~J_wngVT8)^_DGAG3D8Fgk7&5pwx}2nei}pxWHAGbGTp}1hEp=c0%+j= zFu-FRhl!JM>fu2ARV6#kL+>q#6XEEvqHw#eASXWQUtvUHa1mXgND{D*tN3NB%b;rs z1M@xaU-7$cs3g1^>H0P5`aKi~W{l`FxOGz1Z3SCzQ=FanA0+B8n>Y)?NCzT_z*lla zS$7FmWi&1r1`Es6Ul7*qRsmZBV$J65{`|feFd4{dj#w!BzVilnV8z`s_r7Ee@nejk zK7Gvs>we!;rZr6YZ@ zzZIV>yfxTcr9V~tcv-PH7yWzI?crwfXkT`v60yt6aTySHiumFAfv~A{hTL7)(hwlq&weHvS zACJMj3CS~*|=Ni&IA4F8$TFV|aTwqoGxLheek-d25e!F+u zd{OE;!{zDvfFbAqF^v~69rPn05=d;`G0C!PPcU@-~(>+QxR#l=&@DYUxbvwap%ShSIiW2eXi&JHoF7XSQm?w(dvoUU6f@T`dveKw)J zr~Lc^x}RLIcO88`@hw`>{J81A&uo(tVA9UJgM8oPw>_Tme64(E;U>*GL6YG4R~PWS3!76;nCT6y`LSb#UZlGhbt}pSe(@5cK2QL zl6ilVeJL)AeBB?94#wtwbL!t(xa@j=1xbFgPDs)q6gUf`AsKcJKI;lt@}q$kE39CE zb%n-pE8K83di}ewc7NR0_f-y^sUw}1mi~>g6?$UFvkFn$d$d%maVvZ@0I+g)H?&4= z@GMe%GrEx-@_PQ6jrzKu(Yk(>N+rBK4aJ?e2-)n`-=zl*LmMZsI8CUCyQSUaL|k8};}XLNUvLNfG4I$@#_W81chF6pHAW-otJRQetEWw{%0N`9rvo zWL{{cbt(n-S@FF;E{LZHDHRH=naLKpz>Dy!Iofy4L@EdUL?^uTgmn~@AY+NHhtJX) zwEBX;96MC8L`l!MhCYqz;}`ixF#&S@;wU7`#?JP`W(~y21rPU+<>*p&#N-~BN?L~M z)ce!9T<(2i4OvHp>Wm2)HO3NxUVoBuXjmEqHE8Q_H5wa+RUaLzh^l|DMq|zzTz)ZxFqg5L*YF*$5=YvixzN3V z0@d=fv)P0}>o9Lq@-4y#4?edU`K}(3xy_gi#wg}a`q`h6hu}Nb)V>e0n>Uir>+lNh zf=oVahK&zFgWM=jYhUdYc5_!-+=SlcN-R@{CAk5XH|^^`EtPP-zl4qacraYrP|6bA z!;h9v3YW$_qWel|Tu_iWXIR@v^N2#xWr_APY?5$?;AlE1o(Irh#Y2## zL*(f!TV^p;ZFG;V6@#WrA)(Aay9u+CGtd978X*zCm|m(GEFHSO2%~o;G%_umAWz(D zLeF=cPD9@QK6P3BuoSaR>^u^Ne~9>CD$Ko*x^1977y8e~U*moAqesrwpL} zXnAz5QylX*)Tl0GY=mLP`22#^MMJ938$5qu-F-ph&t6H2-!QloiupxiTM5Ql<3wH2 zJA{^bqHJ?0W{|(70y>isUdI4qv@);avl7dnxwzdqhqS+=rz{KHd1NL{tr|a!CvI|Y z3W}UXllPAcHKvTEuibmRoE>P`8^6lWV`YQ4cB-CkH92ET>uxBz(Zvcb(4cLpxfTee z2{pZSfu(t+(eqE78RX~Y5Gjq_2Go|c5DGt;;!hSnlUoJ~W11#|e-W%o-%7KV+hOl& z7qQ% zJ?o#1ki0KJ4CaoS!MD|m*}w%)2>fJ1*{}Am7BNd9pSR{uZfy7Zzs)BQRl3Pb!Zd*FHqj1cXZ*+Ar=Bn5mYzE-KpNJkwXH-cOR`xoYqoX;5F~cObMJiR3YDf?5$Cv{dAn0=X=`KP`^uZ??Y{r{!LtfH6={U50gHI zo0~BATj<`B!Iq3XRqo_azX7%|O5=xc7>=~qzTEzV@t*2(^$lgN=@jZPO=ZgSm0bdA zgi>3r*r;_(Cvct%qtN^Mb0s>vK

    KZKy~^g%39>2}>5#j2`mzE>zSvw<}`>&gJYm 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 pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 24.636, + "warm_s": 64.76, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.32824090000940487, + "expected": 256, + "observed_counter": 102, + "lost_updates": 154, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9443491999991238, + "expected": 256, + "observed_counter": 67, + "lost_updates": 189, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.8337629999732599, + "expected": 256, + "observed_counter": 44, + "lost_updates": 212, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 212, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 154, + "50000": 189, + "100000": 212 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-02/run.log b/concurrent-work/runs-windows/data-isolation/run-02/run.log new file mode 100644 index 0000000..4c778ee --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-02/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=24.64s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=102 lost=154 (wall 0.33s) + LC shared dict gap=50000 expected=256 observed=67 lost=189 (wall 0.94s) + LC shared dict gap=100000 expected=256 observed=44 lost=212 (wall 1.83s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 212/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-03/results.json b/concurrent-work/runs-windows/data-isolation/run-03/results.json new file mode 100644 index 0000000..f1ddf27 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-03/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 34.165, + "warm_s": 66.77, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.8102629000204615, + "expected": 256, + "observed_counter": 119, + "lost_updates": 137, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 1.003217899997253, + "expected": 256, + "observed_counter": 61, + "lost_updates": 195, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.8840077000204474, + "expected": 256, + "observed_counter": 31, + "lost_updates": 225, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 225, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 137, + "50000": 195, + "100000": 225 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-03/run.log b/concurrent-work/runs-windows/data-isolation/run-03/run.log new file mode 100644 index 0000000..c4a53e7 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-03/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=34.16s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=119 lost=137 (wall 0.81s) + LC shared dict gap=50000 expected=256 observed=61 lost=195 (wall 1.00s) + LC shared dict gap=100000 expected=256 observed=31 lost=225 (wall 1.88s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 225/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-04/results.json b/concurrent-work/runs-windows/data-isolation/run-04/results.json new file mode 100644 index 0000000..81d9497 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-04/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 35.747, + "warm_s": 75.05, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.4864744999795221, + "expected": 256, + "observed_counter": 109, + "lost_updates": 147, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9318084000260569, + "expected": 256, + "observed_counter": 45, + "lost_updates": 211, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.8783838999806903, + "expected": 256, + "observed_counter": 38, + "lost_updates": 218, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 218, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 147, + "50000": 211, + "100000": 218 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-04/run.log b/concurrent-work/runs-windows/data-isolation/run-04/run.log new file mode 100644 index 0000000..f172b35 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-04/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=35.75s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=109 lost=147 (wall 0.49s) + LC shared dict gap=50000 expected=256 observed=45 lost=211 (wall 0.93s) + LC shared dict gap=100000 expected=256 observed=38 lost=218 (wall 1.88s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 218/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-05/results.json b/concurrent-work/runs-windows/data-isolation/run-05/results.json new file mode 100644 index 0000000..d3cf5e6 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-05/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 35.922, + "warm_s": 68.01, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.5205256000044756, + "expected": 256, + "observed_counter": 91, + "lost_updates": 165, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 1.034551399992779, + "expected": 256, + "observed_counter": 122, + "lost_updates": 134, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.913001400011126, + "expected": 256, + "observed_counter": 89, + "lost_updates": 167, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 167, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 165, + "50000": 134, + "100000": 167 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-05/run.log b/concurrent-work/runs-windows/data-isolation/run-05/run.log new file mode 100644 index 0000000..b5eec7a --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-05/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=35.92s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=91 lost=165 (wall 0.52s) + LC shared dict gap=50000 expected=256 observed=122 lost=134 (wall 1.03s) + LC shared dict gap=100000 expected=256 observed=89 lost=167 (wall 1.91s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 167/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-06/results.json b/concurrent-work/runs-windows/data-isolation/run-06/results.json new file mode 100644 index 0000000..142d21e --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-06/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 34.882, + "warm_s": 70.31, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.5623634000075981, + "expected": 256, + "observed_counter": 139, + "lost_updates": 117, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9558547000051476, + "expected": 256, + "observed_counter": 92, + "lost_updates": 164, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.837772099999711, + "expected": 256, + "observed_counter": 45, + "lost_updates": 211, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 211, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 117, + "50000": 164, + "100000": 211 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-06/run.log b/concurrent-work/runs-windows/data-isolation/run-06/run.log new file mode 100644 index 0000000..78e9767 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-06/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=34.88s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=139 lost=117 (wall 0.56s) + LC shared dict gap=50000 expected=256 observed=92 lost=164 (wall 0.96s) + LC shared dict gap=100000 expected=256 observed=45 lost=211 (wall 1.84s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 211/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-07/results.json b/concurrent-work/runs-windows/data-isolation/run-07/results.json new file mode 100644 index 0000000..b8fde04 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-07/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 35.916, + "warm_s": 69.72, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.5922722999821417, + "expected": 256, + "observed_counter": 83, + "lost_updates": 173, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 1.0073009000043385, + "expected": 256, + "observed_counter": 97, + "lost_updates": 159, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 2.15319520002231, + "expected": 256, + "observed_counter": 77, + "lost_updates": 179, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 179, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 173, + "50000": 159, + "100000": 179 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-07/run.log b/concurrent-work/runs-windows/data-isolation/run-07/run.log new file mode 100644 index 0000000..a4da0f4 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-07/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=35.92s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=83 lost=173 (wall 0.59s) + LC shared dict gap=50000 expected=256 observed=97 lost=159 (wall 1.01s) + LC shared dict gap=100000 expected=256 observed=77 lost=179 (wall 2.15s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 179/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-08/results.json b/concurrent-work/runs-windows/data-isolation/run-08/results.json new file mode 100644 index 0000000..0d1c73b --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-08/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 32.813, + "warm_s": 70.98, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.4943479999783449, + "expected": 256, + "observed_counter": 82, + "lost_updates": 174, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9710740000009537, + "expected": 256, + "observed_counter": 55, + "lost_updates": 201, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.8476726000080816, + "expected": 256, + "observed_counter": 42, + "lost_updates": 214, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 214, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 174, + "50000": 201, + "100000": 214 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-08/run.log b/concurrent-work/runs-windows/data-isolation/run-08/run.log new file mode 100644 index 0000000..e6c0416 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-08/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=32.81s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=82 lost=174 (wall 0.49s) + LC shared dict gap=50000 expected=256 observed=55 lost=201 (wall 0.97s) + LC shared dict gap=100000 expected=256 observed=42 lost=214 (wall 1.85s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 214/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-09/results.json b/concurrent-work/runs-windows/data-isolation/run-09/results.json new file mode 100644 index 0000000..2a7e6c3 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-09/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 32.858, + "warm_s": 71.24, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.3674897000310011, + "expected": 256, + "observed_counter": 156, + "lost_updates": 100, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.928164699987974, + "expected": 256, + "observed_counter": 88, + "lost_updates": 168, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.9698561999830417, + "expected": 256, + "observed_counter": 75, + "lost_updates": 181, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 181, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 100, + "50000": 168, + "100000": 181 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-09/run.log b/concurrent-work/runs-windows/data-isolation/run-09/run.log new file mode 100644 index 0000000..580aaa4 --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-09/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=32.86s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=156 lost=100 (wall 0.37s) + LC shared dict gap=50000 expected=256 observed=88 lost=168 (wall 0.93s) + LC shared dict gap=100000 expected=256 observed=75 lost=181 (wall 1.97s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 181/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/data-isolation/run-10/results.json b/concurrent-work/runs-windows/data-isolation/run-10/results.json new file mode 100644 index 0000000..66888cf --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-10/results.json @@ -0,0 +1,102 @@ +{ + "benchmark": "data-isolation", + "hypothesis": "per-pipe instance data is isolated by construction; a naive shared GLOBAL dict under 64 LangChain workers silently loses updates", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "langchain_provenance": { + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "kind": "probe" + }, + "params": { + "n_docs": 256, + "M": 32, + "gaps": [ + 20000, + 50000, + 100000 + ], + "rr_routing": "round-robin doc i -> pipe i % M; identity from objinfo name" + }, + "rocketride": { + "M": 32, + "n_docs": 256, + "wall_s": 29.183, + "warm_s": 69.74, + "pipes_reporting": 32, + "pipes_with_clean_partition": 32, + "docs_lost": 0, + "docs_duplicated_or_leaked": 0, + "status": "ok" + }, + "langchain": [ + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 20000, + "wall_s": 0.4107062999974005, + "expected": 256, + "observed_counter": 126, + "lost_updates": 130, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 50000, + "wall_s": 0.9345452999696136, + "expected": 256, + "observed_counter": 116, + "lost_updates": 140, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + }, + { + "n": 256, + "max_concurrency": 32, + "gap_iters": 100000, + "wall_s": 1.8097565000061877, + "expected": 256, + "observed_counter": 63, + "lost_updates": 193, + "items_len": 256, + "lc_version": "0.3.86", + "kind": "probe", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py" + } + ], + "verdict_metrics": { + "rr_docs_lost": 0, + "rr_docs_duplicated_or_leaked": 0, + "rr_clean": true, + "lc_max_lost_updates": 193, + "lc_max_lost_gap_iters": 100000, + "lc_lost_by_gap": { + "20000": 130, + "50000": 140, + "100000": 193 + }, + "lc_version": "0.3.86" + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/data-isolation/run-10/run.log b/concurrent-work/runs-windows/data-isolation/run-10/run.log new file mode 100644 index 0000000..20d395f --- /dev/null +++ b/concurrent-work/runs-windows/data-isolation/run-10/run.log @@ -0,0 +1,12 @@ +real LangChain proven: 0.3.86 + +RR: 256 named docs → 32 warm pipes (instance data = per-pipe local copy): + pipes=32/32 clean partitions=32 lost=0 leaked=0 [ok] wall=29.18s + +LangChain: ONE shared dict, 32 workers, non-atomic read→busy(gap)→write: + LC shared dict gap=20000 expected=256 observed=126 lost=130 (wall 0.41s) + LC shared dict gap=50000 expected=256 observed=116 lost=140 (wall 0.93s) + LC shared dict gap=100000 expected=256 observed=63 lost=193 (wall 1.81s) +wrote: canvas.mmd canvas.dot + +VERDICT: RR 64 pipes — 0 lost / 0 leaked (ok). LangChain shared dict — up to 193/256 updates silently lost (gap=100000). diff --git a/concurrent-work/runs-windows/fault-isolation/REPORT.md b/concurrent-work/runs-windows/fault-isolation/REPORT.md new file mode 100644 index 0000000..142e409 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/REPORT.md @@ -0,0 +1,26 @@ +# fault-isolation · Windows (10 reps) — reproduces clean + +> **Verdict on Windows: ✅ RocketRide survives 10/10.** A node that hard-crashes (`os._exit(134)`, +> simulating a native/segfault crash) kills **only that run's subprocess** — the server and sibling runs +> survive, and a fresh healthy run works immediately after, in **all 10 reps**. The in-process baseline — +> **real LangChain** `.abatch` running 4 tasks in one interpreter — loses **everything (0/4)** to one +> such crash (process dies, **exit 134**) in **10/10**. Process-per-run isolation reproduces faithfully on +> Windows. + +## Method +Identical to `../../runs/fault-isolation/REPORT.md`. RocketRide: a healthy run, then a `mode="crash"` run +whose node `os._exit(134)`s its own task subprocess, then another healthy run — checking the server pid +is unchanged and new runs still complete. In-process baseline: real `langchain_core` `RunnableLambda.abatch` +over 4 legs, one of which `os._exit(134)`s the shared interpreter. **10 reps back-to-back** (no restart +needed — `ttl=0`), Windows, port 5566. + +## Results *(10 reps; Windows 11, engine 3.2.1.30, langchain-core 0.3.86)* +| Side | Outcome | +|---|---| +| **Stock RocketRide** | ✅ `rr_isolation_holds` **true in 10/10** — healthy-before ✓, crash isolated (server survived), healthy-after ✓ | +| In-process LangChain `.abatch` (healthy control) | ✓ completes 4/4 | +| In-process LangChain `.abatch` (one leg crashes) | ❌ **loses ALL 0/4** — process dies, **exit 134**, in 10/10 | + +## Provenance +10 reps (`run-01/ … run-10/`), back-to-back on the standing engine (port 5566); real LangChain `0.3.86` +proven per rep (`in_process_baseline.lc_version`); no trace for this bench (matches the macOS convention). diff --git a/concurrent-work/runs-windows/fault-isolation/run-01/results.json b/concurrent-work/runs-windows/fault-isolation/run-01/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-01/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-01/run.log b/concurrent-work/runs-windows/fault-isolation/run-01/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-01/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-02/results.json b/concurrent-work/runs-windows/fault-isolation/run-02/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-02/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-02/run.log b/concurrent-work/runs-windows/fault-isolation/run-02/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-02/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-03/results.json b/concurrent-work/runs-windows/fault-isolation/run-03/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-03/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-03/run.log b/concurrent-work/runs-windows/fault-isolation/run-03/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-03/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-04/results.json b/concurrent-work/runs-windows/fault-isolation/run-04/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-04/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-04/run.log b/concurrent-work/runs-windows/fault-isolation/run-04/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-04/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-05/results.json b/concurrent-work/runs-windows/fault-isolation/run-05/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-05/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-05/run.log b/concurrent-work/runs-windows/fault-isolation/run-05/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-05/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-06/results.json b/concurrent-work/runs-windows/fault-isolation/run-06/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-06/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-06/run.log b/concurrent-work/runs-windows/fault-isolation/run-06/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-06/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-07/results.json b/concurrent-work/runs-windows/fault-isolation/run-07/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-07/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-07/run.log b/concurrent-work/runs-windows/fault-isolation/run-07/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-07/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-08/results.json b/concurrent-work/runs-windows/fault-isolation/run-08/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-08/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-08/run.log b/concurrent-work/runs-windows/fault-isolation/run-08/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-08/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-09/results.json b/concurrent-work/runs-windows/fault-isolation/run-09/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-09/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-09/run.log b/concurrent-work/runs-windows/fault-isolation/run-09/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-09/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/fault-isolation/run-10/results.json b/concurrent-work/runs-windows/fault-isolation/run-10/results.json new file mode 100644 index 0000000..34b92b8 --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-10/results.json @@ -0,0 +1,43 @@ +{ + "benchmark": "fault-isolation", + "old_id": "D5", + "hypothesis": "a hard node crash is isolated to its run; the server + siblings survive", + "provenance": { + "engine_dir": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\engine", + "engine_version": "Version: 3.2.1.30 hash: 114509c6 stamp: 2026-05-29T19:19:06Z", + "uri": "ws://localhost:5566", + "cpu_brand": "Intel64 Family 6 Model 186 Stepping 3, GenuineIntel", + "machine": "Windows-11-10.0.26200-SP0", + "arch": "AMD64", + "physical_cores": 10, + "logical_cores": 12, + "total_ram_gib": 15.55, + "python": "3.12.3", + "engine_sha256": "b844140ae82cc18e9b5767b44b897aed2f772ea5228cfd053d727324bad7dc5e", + "engine_size_bytes": 84793856 + }, + "rocketride": { + "server_pid_before": 19204, + "healthy_before_ok": true, + "crash_run_completed": false, + "server_survived_crash": true, + "healthy_after_ok": true + }, + "in_process_baseline": { + "framework": "langchain", + "tasks": 4, + "lc_version": "0.3.86", + "lc_python": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Scripts\\python.exe", + "langchain_core_file": "D:\\Coding\\rr\\rocketride-benchmark\\concurrent-work\\harness\\rocketride-bench\\.venv\\Lib\\site-packages\\langchain_core\\__init__.py", + "healthy_completed": 4, + "completed": 0, + "process_exit_code": 134, + "died": true + }, + "verdict_metrics": { + "rr_isolation_holds": true, + "inproc_framework": "langchain", + "inproc_healthy_ok": true, + "inproc_lost_all": true + } +} \ No newline at end of file diff --git a/concurrent-work/runs-windows/fault-isolation/run-10/run.log b/concurrent-work/runs-windows/fault-isolation/run-10/run.log new file mode 100644 index 0000000..d2ef7ac --- /dev/null +++ b/concurrent-work/runs-windows/fault-isolation/run-10/run.log @@ -0,0 +1,4 @@ +wrote: canvas.mmd canvas.dot +RocketRide: healthy-before=True crash-run-completed=False server-survived=True healthy-after=True +In-process baseline (langchain): healthy 4/4, crash-run 0/4, exit 134 (process DIED) +VERDICT: RR isolation holds = True ; in-process lost all = True diff --git a/concurrent-work/runs-windows/lines-of-code.run.log b/concurrent-work/runs-windows/lines-of-code.run.log new file mode 100644 index 0000000..bd82247 --- /dev/null +++ b/concurrent-work/runs-windows/lines-of-code.run.log @@ -0,0 +1,22 @@ +{ + "n_builds": 5, + "workflow": "meeting-notes assistant (transcript -> executive summary + follow-up email)", + "rocketride_lines": { + "min": 104, + "median": 123, + "max": 136 + }, + "langchain_lines": { + "min": 682, + "median": 689, + "max": 930 + }, + "line_ratio_lc_over_rr": { + "min": 5.0, + "median": 6.0, + "max": 7.6 + }, + "rocketride_chars_median": 7010, + "langchain_chars_median": 25158, + "char_ratio_lc_over_rr_median": 3.6 +}