fp-stability: auto-install Verrou on first use (download prebuilt), hard-fail if it can't

Running ./mfc.sh fp-stability with no Verrou present now installs it via the bootstrap (downloads the pinned prebuilt from verrou-dist; source build as fallback) and proceeds, instead of SKIP+exit-0; a failed install is now a hard error. _find_verrou no longer accepts a bare system valgrind on PATH (it has no 'verrou' tool and would only fail at run time) — that case reads as 'Verrou absent' so it gets installed. CI drops the separate Install/Verify Verrou steps; the run does it. Tests added for the discovery logic.

Author: sbryngelson

.github/workflows/fp-stability.yml

@@ -78,16 +78,9 @@ jobs:
             build-essential automake python3 python3-numpy libc6-dbg \
             cmake gfortran zstd
 
-      - name: Install Verrou (prebuilt artifact, or source build as fallback)
-        if: steps.cache-verrou.outputs.cache-hit != 'true'
-        run: bash toolchain/bootstrap/verrou.sh
-
-      - name: Verify Verrou
-        # Source env.sh first: a prebuilt (relocated) tree needs VALGRIND_LIB; a
-        # source build works either way. (fp-stability sets this itself at runtime.)
-        run: |
-          [ -f ~/.local/verrou/env.sh ] && . ~/.local/verrou/env.sh
-          ~/.local/verrou/bin/valgrind --tool=verrou --version
+      # Verrou is installed by `fp-stability` itself on first use (downloads the
+      # prebuilt artifact; aborts if that fails). The cache above restores it across
+      # runs so the download only happens on a cache miss.
 
       - name: Build MFC (debug, serial)
         # FFLAGS=-fno-inline prevents gfortran from inlining small functions into

toolchain/mfc/cli/commands.py

@@ -908,9 +908,11 @@
         "(~30x slower, and run many times), so it must be a small, short proxy — large "
         "grids or long runs are rejected with guidance; serial .dat I/O is forced. "
         "Example: ./mfc.sh fp-stability my_case.py\n\n"
-        "Requires a Verrou-enabled Valgrind at $VERROU_HOME/bin/valgrind "
-        "(defaults to $HOME/.local/verrou). The simulation and pre_process "
-        "binaries must be serial (no-MPI, no-GPU) debug builds.\n\n"
+        "Uses a Verrou-enabled Valgrind at $VERROU_HOME/bin/valgrind (defaults to "
+        "$HOME/.local/verrou); if absent it is installed automatically (a pinned, "
+        "hash-verified prebuilt is downloaded, with a source build as fallback) — "
+        "aborts if that install fails. The simulation and pre_process binaries must "
+        "be serial (no-MPI, no-GPU) debug builds.\n\n"
         "Analysis passes (skip with --no-* flags):\n"
         "  float proxy    One run with --rounding-mode=float (single-precision sensitivity)\n"
         "  vprec sweep    Runs at mantissa bits [52, 23, 16, 10] (precision floor curve)\n"

toolchain/mfc/fp_stability.py

@@ -73,6 +73,7 @@
 import math
 import os
 import shutil
+import subprocess
 import sys
 import tempfile
 import time
@@ -658,13 +659,26 @@ def _load_user_case(input_path: str) -> dict:
     }
 
 
+def _install_verrou() -> str:
+    """Verrou is absent: install it via the bootstrap (downloads a pinned, hash-verified
+    prebuilt; source build as fallback) and return the valgrind path. Aborts on failure —
+    fp-stability cannot run without Verrou, so this is a hard error, not a skip."""
+    script = os.path.join(MFC_ROOT_DIR, "toolchain", "bootstrap", "verrou.sh")
+    cons.print("[bold]Verrou not found — installing it (downloads a prebuilt artifact, ~seconds; source build as fallback)...[/bold]")
+    if subprocess.run(["bash", script], check=False).returncode != 0:
+        raise MFCException("Verrou install failed (see output above). Fix the issue and re-run, install manually with `bash toolchain/bootstrap/verrou.sh`, or pass --verrou-binary PATH.")
+    verrou_bin = _find_verrou()
+    if not verrou_bin or not os.path.isfile(verrou_bin):
+        raise MFCException("Verrou install reported success but no valgrind binary was found under $VERROU_HOME.")
+    return verrou_bin
+
+
 def fp_stability():
     verrou_bin = ARG("verrou_binary") or _find_verrou()
     if not verrou_bin or not os.path.isfile(verrou_bin):
-        cons.print("[bold yellow]SKIP[/bold yellow]: Verrou not found (it is a compiled Valgrind tool, not a pip package).")
-        cons.print("  Install it (Linux; ~20 min source build) with:  [bold]bash toolchain/bootstrap/verrou.sh[/bold]")
-        cons.print("  Or point at an existing build with --verrou-binary PATH or $VERROU_HOME.")
-        sys.exit(0)
+        if ARG("verrou_binary"):
+            raise MFCException(f"--verrou-binary {ARG('verrou_binary')!r} not found or not executable.")
+        verrou_bin = _install_verrou()
 
     sim_bin = ARG("sim_binary") or _find_binary("simulation")
     if not sim_bin or not os.path.isfile(sim_bin):

toolchain/mfc/fp_stability_runners.py

@@ -32,12 +32,26 @@
 from .printer import cons
 
 
+def _has_verrou_tool(valgrind_bin: str) -> bool:
+    """True if this valgrind actually provides the 'verrou' tool. A plain system
+    valgrind does not — accepting one would only fail later at run time."""
+    try:
+        return subprocess.run([valgrind_bin, "--tool=verrou", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False).returncode == 0
+    except OSError:
+        return False
+
+
 def _find_verrou() -> str:
     verrou_home = os.environ.get("VERROU_HOME", os.path.join(os.path.expanduser("~"), ".local", "verrou"))
     candidate = os.path.join(verrou_home, "bin", "valgrind")
     if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
         return candidate
-    return shutil.which("valgrind") or ""
+    # Fall back to a valgrind on PATH only if it is Verrou-enabled; a bare system
+    # valgrind must read as "Verrou absent" so it gets installed, not misused.
+    path_vg = shutil.which("valgrind")
+    if path_vg and _has_verrou_tool(path_vg):
+        return path_vg
+    return ""
 
 
 def _find_binary(name: str) -> str:

toolchain/mfc/test_fp_stability.py

@@ -379,3 +379,49 @@ def test_emit_annotations_downgrade_unconfirmed(tmp_path, monkeypatch, capsys):
     report._emit_github_annotations([r])
     out = capsys.readouterr().out
     assert "::notice" in out and "::warning" not in out  # unconfirmed -> notice, not warning
+
+
+# --- Verrou discovery: a bare system valgrind must read as "Verrou absent" ---
+
+
+def test_find_verrou_prefers_verrou_home_candidate(tmp_path, monkeypatch):
+    from mfc import fp_stability_runners as runners
+
+    vbin = tmp_path / "bin" / "valgrind"
+    vbin.parent.mkdir(parents=True)
+    vbin.write_text("#!/bin/sh\n")
+    vbin.chmod(0o755)
+    monkeypatch.setenv("VERROU_HOME", str(tmp_path))
+    assert runners._find_verrou() == str(vbin)
+
+
+def test_find_verrou_rejects_non_verrou_path_valgrind(tmp_path, monkeypatch):
+    from mfc import fp_stability_runners as runners
+
+    # VERROU_HOME has no valgrind; a plain valgrind is on PATH but lacks the tool.
+    monkeypatch.setenv("VERROU_HOME", str(tmp_path))
+    monkeypatch.setattr(runners.shutil, "which", lambda _name: "/usr/bin/valgrind")
+    monkeypatch.setattr(runners, "_has_verrou_tool", lambda _bin: False)
+    assert runners._find_verrou() == ""
+
+
+def test_find_verrou_accepts_verrou_enabled_path_valgrind(tmp_path, monkeypatch):
+    from mfc import fp_stability_runners as runners
+
+    monkeypatch.setenv("VERROU_HOME", str(tmp_path))
+    monkeypatch.setattr(runners.shutil, "which", lambda _name: "/opt/verrou/bin/valgrind")
+    monkeypatch.setattr(runners, "_has_verrou_tool", lambda _bin: True)
+    assert runners._find_verrou() == "/opt/verrou/bin/valgrind"
+
+
+def test_has_verrou_tool_reflects_exit_code(monkeypatch):
+    from mfc import fp_stability_runners as runners
+
+    class _R:
+        def __init__(self, rc):
+            self.returncode = rc
+
+    monkeypatch.setattr(runners.subprocess, "run", lambda *a, **k: _R(0))
+    assert runners._has_verrou_tool("/any/valgrind") is True
+    monkeypatch.setattr(runners.subprocess, "run", lambda *a, **k: _R(1))
+    assert runners._has_verrou_tool("/any/valgrind") is False