results: jobs/20261009-100135-large-ilqr-fast/** index/episodes.jsonl leaderboard/*

.gitattributes

@@ -63,3 +63,9 @@ results/jobs/20261006-203943-pure-pursuit/episodes.jsonl filter=lfs diff=lfs mer
 results/jobs/20261008-135505-best-stack/episodes.jsonl filter=lfs diff=lfs merge=lfs -text
 results/jobs/20261008-135505-best-stack/gautschi/0/episodes.json filter=lfs diff=lfs merge=lfs -text
 results/jobs/20261008-135505-best-stack/gautschi/1/episodes.json filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261009-100135-large-ilqr-fast/episodes.jsonl filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261009-100135-large-ilqr-fast/gautschi/0/episodes.json filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261009-100135-large-ilqr-fast/gautschi/1/episodes.json filter=lfs diff=lfs merge=lfs -text
+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/20261009-100135-large-ilqr-fast/episodes.jsonl

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

results/jobs/20261009-100135-large-ilqr-fast/gautschi/0/episodes.json

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

results/jobs/20261009-100135-large-ilqr-fast/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/20261009-100135-large-ilqr-fast/gautschi/0/sbatch.sh

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

results/jobs/20261009-100135-large-ilqr-fast/gautschi/1/episodes.json

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

results/jobs/20261009-100135-large-ilqr-fast/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/20261009-100135-large-ilqr-fast/gautschi/1/sbatch.sh

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

results/jobs/20261009-100135-large-ilqr-fast/gautschi/2/episodes.json

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

results/jobs/20261009-100135-large-ilqr-fast/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/20261009-100135-large-ilqr-fast/gautschi/2/sbatch.sh

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

results/jobs/20261009-100135-large-ilqr-fast/gautschi/3/episodes.json

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

results/jobs/20261009-100135-large-ilqr-fast/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/20261009-100135-large-ilqr-fast/gautschi/3/sbatch.sh

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

results/jobs/20261009-100135-large-ilqr-fast/job.json

@@ -0,0 +1,40 @@
+{
+ "id": "20261009-100135-large-ilqr-fast",
+ "tier": "large",
+ "tier_version": 3,
+ "recipe": {
+  "name": "large-ilqr-fast",
+  "source": {
+   "repo": "AutonomousKart",
+   "ref": "worktree:ilqr-fast"
+  },
+  "params": {
+   "pathfinder_node": {
+    "planner": "ilqr",
+    "mpc.num_samples": 16
+   }
+  },
+  "sim": {},
+  "notes": "Gradient MPC (tuned iLQR) on the best stack; telemetry MPPI at 16 samples (iLQR never reads it)"
+ },
+ "user": "shay",
+ "notes": "large v3: gradient MPC (tuned iLQR, numpy fallback on highmem) on the best stack",
+ "where": "gautschi",
+ "status": "done",
+ "submitted_at": "2026-10-09T14:01:35.060+00:00",
+ "started_at": "2026-10-09T14:01:35.061+00:00",
+ "finished_at": "2026-10-10T01:23:26.136+00:00",
+ "total": 32076,
+ "done": 32076,
+ "errors": 0,
+ "build_log": null,
+ "workers": 96,
+ "slurm_id": "16923599",
+ "slurm_ids": [
+  "16923599",
+  "16923600",
+  "16923601",
+  "16923602"
+ ],
+ "engine_version": "ded6f8168dff9c052caad6fa1d16ca257ed3716e49b4cd161aa09ae1c01f4af8"
+}

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0000.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0001.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0002.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0003.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0004.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0005.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0006.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0007.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0008.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0009.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0010.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0011.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0012.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0013.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0014.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0015.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0016.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0017.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0018.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0019.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0020.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0021.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0022.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0023.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0024.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0025.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0026.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0027.jsonl.gz

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

results/jobs/20261009-100135-large-ilqr-fast/logs/shard-0028.jsonl.gz

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