results: jobs/20261010-004932-large-base-pp/** index/episodes.jsonl leaderboard/*

.gitattributes

@@ -69,3 +69,4 @@ results/jobs/20261009-100135-large-ilqr-fast/gautschi/1/episodes.json filter=lfs
 results/jobs/20261009-100135-large-ilqr-fast/gautschi/3/episodes.json filter=lfs diff=lfs merge=lfs -text
 results/jobs/20261009-100135-large-ilqr-fast/gautschi/2/episodes.json filter=lfs diff=lfs merge=lfs -text
 results/index/episodes.jsonl filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261010-004932-large-base-pp/episodes.jsonl filter=lfs diff=lfs merge=lfs -text

results/index/episodes.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6f197aa385821a73d4027f90b988070076dd3fdbfd507b9dadcb33b99a45579f
-size 17149774
+oid sha256:ea45e36706d978ccfbf4646b1b2ed12264bc3140bdb049e1352e8a0a27677bf0
+size 22078010

results/jobs/20261010-004932-large-base-pp/episodes.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e85410e1b6cc60ea8331df173e28ed7102f05ceea5392630ce7e13a6a79cdca
+size 42247742

results/jobs/20261010-004932-large-base-pp/gautschi/0/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/0/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 -J AutoSim-large-large-base-pp-1 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/0/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/0/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/0/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/0/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/0/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/1/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/1/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 -J AutoSim-large-large-base-pp-2 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/1/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/1/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/1/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/1/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/1/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/2/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/2/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 --dependency=afterany:16935259 -J AutoSim-large-large-base-pp-3 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/2/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/2/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/2/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/2/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/2/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/3/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/3/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 --dependency=afterany:16935260 -J AutoSim-large-large-base-pp-4 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/3/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/3/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/3/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/3/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/3/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/4/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/4/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 --dependency=afterany:16935261 -J AutoSim-large-large-base-pp-5 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/4/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/4/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/4/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/4/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/4/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/5/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/5/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 160 --dependency=afterany:16935262 -J AutoSim-large-large-base-pp-6 --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/5/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/5/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/5/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/5/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/5/done.txt

results/jobs/20261010-004932-large-base-pp/gautschi/6/done.txt

@@ -0,0 +1,74 @@
+2b2a36cfdf36d3a2dadd53adb140ada168677b93f31bde05fa2ed9c4e4c0540e
+1229754def0dfd2455692ce517ecc5c2d713414d8248fc0cf66f887722bbcaeb
+8ea413382661ca6a17b78f96741c49efeee965a053e9708a2d79cccdd3bcba99
+5ee4be4ca8f246ce42557086965d0c1fe2cc5b587782cff446b5e613e52b5d79
+664fe3b03b9b67cdd55f11ac1119569594a1e83b11209bcbb8134de0236a3f86
+99157b39e7c300effec89ce74a2c86a699c2b4db68b181a13c776261a7f6c8f0
+2ac094352cceb12b9ebd39679de205421400e8108cece977559b691f0be77b6d
+7b22d154c03e3dd6430fba5e2a7a6a1b78d885d8909e17f83457fcafff43b0b4
+725316674a5da1c1969528e49995eb3cd56d7ee69fce4ed85ac7605d27b61f65
+c89ad49f600b31f4a1e66e5355101a16a4c31a453a2ee1de6d7626889b1d80c0
+7ae31779989b754095c0292c6a9d236ab4f72b8aafe0152171d6ba996fb3e8b7
+22c3114388caa5a0da6200f40bef68b998e657493b033714fe54671bcd121d66
+ef0caf869bdb04b6c35f737f3e9570e91bcb1169baf738b07e8b683efea60f48
+c59deeb0fa7c5cd22476db7e3bc7d45991ef659fee484dae08d1f036063e386b
+c60b5638937e5c6e3383da163ab14b9727b0f3e22db2865a3ccf68b2d9eb37ab
+e7c7a5cae547adffd85ab8dd6d9eff77106ca4c40e49452a92156633350bc737
+9005e089c20cf382336851e0e5d2781807c0bbd25d3a2a49302c60c5c4892bab
+f4cb2f40765322df1d66c1abfccff2411adbfcb6ea3cf0e88f0c02221fc37881
+79a7ac58db214d009118d5e2f007576f2b0abcb5d881326f7cc36dbf3097fb9f
+6f9784f49444ec2cf99868f1bf661aab61c4b9f2a57a4738e980acfae766ccc3
+158afd377def08e598fd9ee7b1cd727f2d1f063e837096010f83fceecf30ee2c
+4ea4764676b02c94f352869d608c33009adc7bb63a6b97e801fb4078d66c074b
+104f74aeb5282bd798ab5568143dd50b76260f25c3e24e0428e315597651be9a
+ce0d632f51422b82ee7c7a094ff2b46f4d246a333a2a65e9a503573a449c27e6
+4fd3b190b96c7ccb51ae48aa6cf7d2539968a3017ed3528cb61bb6ce4074621f
+2bc34509921e66f1c1b7338ba7c37eacc979635e9bd5a0ee803d257859d22be7
+da9cfde3b5ca896631bac4800a25e7eb871f6806ccf3f78374f9108700a1db61
+3634651042b54e78c0ae07565f4fef707b414b9459d45361c0ac3e1d974ce9e7
+557c788aac207eed6d4ee8e30f5c8fb19f89129401f34c5cee73ecc3d6fa6c7d
+fe1928288710c221f4910aee78fff862b794338f7370ad29e8fab04685f1ade1
+3ccfa0d4ae70e3ec037a1fbf346a64428d1c4bb0a08ee8458e2e02e03795390f
+6e9daae1fd72593fa647f67586c98b8a696b890787fa4c57f5bb6de6f483ee39
+c0e785ac7c8ff946f3f0f3c3cc4b325471ca39cb1cfddfceeb6dfa125c88be9a
+2d71ea4f409eab814bced7d43b4cb5b5d0bcd399487f0e543ff6d5a046923e49
+dc2e5fbcc2b56b5f98af77d3eaa98084f6f749509663c739428034d473ac136e
+bb9e5477916686b1097d6b013eca82e38a769a7a3fb54e949d9b5218eb919d71
+bce585562d61d058db18eb9d8057f42e98796c0e08ee0aa03011911b5dbb4d76
+3fbc252cb1570a9f8baf17be88fd9ce0937a87dde93f6b1e39fc1c311bd4aa7b
+4b11646c3b3ed5b9aef077f5a55b15c240539ac1884764689bc959584b8d0607
+afee91cd3d60a5cdd8dfffa7e5bcf9599112dd5ea1c4e0549669e3297423832e
+4451591f40e86be32267e9dcace9a0291e519f28afd3c0e82a99bff508e7b7bc
+2c409a32d6e7000021c9352713624313b0ed6cab93d1c2f3ee65fe6422199588
+d31a9e6ec1325cec8d10bae8c9b1587b91de46fc48b07c928be7eee988bd4f9d
+512319f47306075b1c95300409fb60db05ad6d1dd71a8f8a133c1c32bd3b991b
+46301a5ff7f5fc790edab4db39edc3acf3a4a17f265f6cef500c2c3d83dae806
+e9928b63548393244c7324c1101c39117ff38b5256894f203e2cb21ae58d8e3b
+163edec3e568fa214e41181a36089ae73903b69e003cdabbbc0e30aad7c2e2d0
+b8a35a59ae463d8f450b1ebd765010a054f968f8c0937d5ec2cb4d15192337e0
+98fd223f46e73d3f47cb3634eda5a7fa859982a730cb361a475fdc73b827e218
+14667dac539804e59280857be0a30a550e1bdba60dc4526c48e598f525ba79a5
+406f64ab9ffa5a48171e5c51570d8069c472e807472ca80bca77be752e95b108
+c7f3ab7859d26566049073f0d940cba4cd048c778462103851cd4d91392e76a7
+e1e9eafef5399eb6b4f7a62158a3cf596f2401f43a4f44f84d8af3fb215a9e4c
+d22b61a27c325b7f460340be6a1b987c0876f8a63da2a3bbecd7aa4dc9807c46
+96e24bd6d4efe175bea773247651f3b1e4881b31713a746cc87c0435d310a03c
+763356d25fb3329ec3127063c220ff0ab5411e3704db814604f98abec50012cd
+40b8824f9a06cd6e640cb6b440d361ff1ff056ecb0b43e8fdf181013731c48fe
+33206dad235e25e67442ad727ee53daa096b8d143fc81ccce93e43c73a6ed103
+8b4255f5b252feedf56e1c7f05f639bf5e5e1439288ba3729b7013a9206bf9d6
+6dba0a2503b169a6c7ae55dad47fcab7fbc21a8eaac05bf869de224bee004f9f
+b85a006132992bc9d681fb05dbcde8bcfdd575452ed44020c25b5c4689055760
+6cc6555ea29e64461325459623a8e5aa425970c40b38ef31a671fc5c833f0b16
+ae8f51d0447114029d44fa914a8d3a262e298350fb54eed98d80dafe77ddb8b9
+16e09adf55d183fb6e58ff5971dfb9f898568774c4eed83e3b187d79c0e77ae0
+abcc8640186e5657084ee85bf352551483b70a42f79b44978ba185d5739162a1
+614d9373a83fd822de4bc212f123f534d9a66f0a48633eb70002753aaeca5ee8
+bb3355a5737c7056314fb7bac9612838ae68cd7931b82ff4286b026e9e87ca5b
+a445198e40f590424cf24a3e9943b1cf3361ef388b089fb05420a3505b75d04a
+42655f5b1b9a224f749dfd813995ce8fdbdcf5875ab594f0bc200dc1ca54b4e5
+dee0a4a34a5a6114bf2cef93d65a794678bc26e8fd70668f826a0bfd5ee7e265
+10cc54f80022304301ea4c0a04a1ed17ba7d182eaaaaed65b35bf3a90408dee7
+63c8de0be7f36ba50693d7b228800b89eac3294340b018826c79d4a0c5558559
+12bfa6c96d2f753518ff55d0faae99181d34d2deb4524319bf2b17579110507f
+7b46a60ea518ccad25ce2b98e6d653c40d4beee1968b1de092624e93ba3ac978

results/jobs/20261010-004932-large-base-pp/gautschi/6/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261010-004932-large-base-pp/gautschi/6/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 96 --time 43 -J AutoSim-large --comment 20261010-004932-large-base-pp -o AutoSim/jobs/20261010-004932-large-base-pp/6/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261010-004932-large-base-pp/6/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261010-004932-large-base-pp/6/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261010-004932-large-base-pp --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8 --stack $HOME/AutoSim/stacks/6a151d28cddda9c8df227e423881bdf39602629d6b4bb56085c692d72a9a8858 --workers 48 --work $W --timeline $HOME/AutoSim/jobs/20261010-004932-large-base-pp/6/timeline.jsonl --done $HOME/AutoSim/jobs/20261010-004932-large-base-pp/6/done.txt

results/jobs/20261010-004932-large-base-pp/job.json

@@ -0,0 +1,43 @@
+{
+ "id": "20261010-004932-large-base-pp",
+ "tier": "large",
+ "tier_version": 3,
+ "recipe": {
+  "name": "large-base-pp",
+  "source": {
+   "repo": "AutonomousKart",
+   "ref": "worktree:base"
+  },
+  "params": {
+   "pathfinder_node": {
+    "planner": "pure_pursuit",
+    "mpc.num_samples": 16
+   }
+  },
+  "sim": {},
+  "notes": "Base kart stack (main + sim plumbing), pure pursuit; telemetry MPPI at 16 samples (pure pursuit never reads it)"
+ },
+ "user": "shay",
+ "notes": "large v3: base kart stack, pure pursuit; telemetry MPPI at 16 samples",
+ "where": "gautschi",
+ "status": "done",
+ "submitted_at": "2026-10-10T07:49:32.884+00:00",
+ "started_at": "2026-10-10T07:49:32.887+00:00",
+ "finished_at": "2026-10-10T11:07:15.186+00:00",
+ "total": 32076,
+ "done": 32076,
+ "errors": 0,
+ "build_log": null,
+ "workers": 96,
+ "slurm_id": "16937439",
+ "slurm_ids": [
+  "16935259",
+  "16935260",
+  "16935261",
+  "16935262",
+  "16935263",
+  "16935264",
+  "16937439"
+ ],
+ "engine_version": "ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8"
+}

results/jobs/20261010-004932-large-base-pp/summary.json

@@ -0,0 +1,156 @@
+{
+ "cte_p50": {
+  "value": 0.20565471936067686,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.1898834728712325,
+   "kart2": 0.2768902336333262,
+   "kart3": 0.16406644335089404
+  }
+ },
+ "cte_p90": {
+  "value": 0.9635387754101902,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.7848562080683432,
+   "kart2": 1.3700147221026526,
+   "kart3": 0.7846854665459303
+  }
+ },
+ "cte_p99": {
+  "value": 2.804877485802955,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 2.2731121753260966,
+   "kart2": 3.183635606183875,
+   "kart3": 2.5797542921543437
+  }
+ },
+ "recovery_rate": {
+  "value": 0.67955666227235,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.6944908180300501,
+   "kart2": 0.6173279833556249,
+   "kart3": 0.7269957343083485
+  }
+ },
+ "recovery_s_median": {
+  "value": 1.4499999999999993,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 1.5417499999999995,
+   "kart2": 1.3000000000000007,
+   "kart3": 1.5667499999999999
+  }
+ },
+ "safety": {
+  "value": 0.6025979219033603,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.6456645819393636,
+   "kart2": 0.5281777623427075,
+   "kart3": 0.6309927830539249
+  }
+ },
+ "unsafe_lat": {
+  "value": 0.0010049864888014358,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.001716471609186446,
+   "kart2": 9.379175679449877e-06,
+   "kart3": 0.0012545715102572096
+  }
+ },
+ "unsafe_rate": {
+  "value": 0.2971438285827366,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.24780852461581263,
+   "kart2": 0.3733912036299106,
+   "kart3": 0.27306880468287714
+  }
+ },
+ "unsafe_travel": {
+  "value": 0.0,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.0,
+   "kart2": 0.0,
+   "kart3": 0.0
+  }
+ },
+ "unsafe_spin": {
+  "value": 7.995099629596404e-05,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.00016779202871435711,
+   "kart2": 0.0,
+   "kart3": 7.043197625332553e-05
+  }
+ },
+ "unsafe_off": {
+  "value": 0.14749416833141615,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.14809511447718166,
+   "kart2": 0.15778324447377667,
+   "kart3": 0.13725752291009716
+  }
+ },
+ "osc_10": {
+  "value": 26.18430644531543,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 28.982701015917673,
+   "kart2": 20.457527276926637,
+   "kart3": 28.86579783493766
+  }
+ },
+ "osc_20": {
+  "value": 11.721327407270053,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 13.932371186257976,
+   "kart2": 6.694048206287416,
+   "kart3": 14.311674730409129
+  }
+ },
+ "osc_30": {
+  "value": 6.226702731202782,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 7.8751441159666316,
+   "kart2": 2.3952218359208803,
+   "kart3": 8.236217208707775
+  }
+ },
+ "laps_pct": {
+  "value": 43.18244170096022,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 38.43621399176955,
+   "kart2": 44.44444444444444,
+   "kart3": 46.666666666666664
+  }
+ },
+ "failures": {
+  "value": 8711,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 2991,
+   "kart2": 3559,
+   "kart3": 2161
+  }
+ },
+ "n": {
+  "value": 32076,
+  "worst_kart": null,
+  "per_kart": {}
+ },
+ "errors": {
+  "value": 0,
+  "worst_kart": null,
+  "per_kart": {}
+ }
+}

results/leaderboard/large-3__ded6f8168dff.json

@@ -44,5 +44,51 @@
    "n": 32076,
    "errors": 0
   }
+ },
+ {
+  "job_id": "20261010-004932-large-base-pp",
+  "recipe": "large-base-pp",
+  "notes": "large v3: base kart stack, pure pursuit; telemetry MPPI at 16 samples",
+  "user": "shay",
+  "ran_at": "2026-10-10T11:07:15.186+00:00",
+  "duration_s": 11862.299,
+  "cte_p50": 0.20565471936067686,
+  "cte_p90": 0.9635387754101902,
+  "cte_p99": 2.804877485802955,
+  "recovery_rate": 0.67955666227235,
+  "recovery_s_median": 1.4499999999999993,
+  "safety": 0.6025979219033603,
+  "unsafe_lat": 0.0010049864888014358,
+  "unsafe_rate": 0.2971438285827366,
+  "unsafe_travel": 0.0,
+  "unsafe_spin": 7.995099629596404e-05,
+  "unsafe_off": 0.14749416833141615,
+  "osc_10": 26.18430644531543,
+  "osc_20": 11.721327407270053,
+  "osc_30": 6.226702731202782,
+  "laps_pct": 43.18244170096022,
+  "failures": 8711,
+  "n": 32076,
+  "errors": 0,
+  "worst": {
+   "cte_p50": 0.2768902336333262,
+   "cte_p90": 1.3700147221026526,
+   "cte_p99": 3.183635606183875,
+   "recovery_rate": 0.6173279833556249,
+   "recovery_s_median": 1.5667499999999999,
+   "safety": 0.5281777623427075,
+   "unsafe_lat": 0.001716471609186446,
+   "unsafe_rate": 0.3733912036299106,
+   "unsafe_travel": 0.0,
+   "unsafe_spin": 0.00016779202871435711,
+   "unsafe_off": 0.15778324447377667,
+   "osc_10": 28.982701015917673,
+   "osc_20": 14.311674730409129,
+   "osc_30": 8.236217208707775,
+   "laps_pct": 38.43621399176955,
+   "failures": 3559,
+   "n": 32076,
+   "errors": 0
+  }
  }
 ]