story: DGR-030 Add accelerator build presets and native CI matrix

tests/test_llama_cpp_dependency.py

@@ -334,3 +334,157 @@ def test_ctest_lane_raises_an_actionable_error_for_a_failing_named_test(tmp_path
         assert "meshnet-fixture-fail" in str(error)
     else:
         raise AssertionError("a failing named CTest lane must raise DependencyError")
+
+
+def test_accelerator_presets_isolate_one_backend_without_touching_the_cpu_default() -> None:
+    dependency = _load_dependency_module()
+    lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    presets = lock["accelerator_presets"]
+
+    assert set(presets) == {"cuda", "rocm", "vulkan", "metal"}
+    base_flags = list(lock["build"]["configure_flags"])
+    base_values = dict(flag[len("-D"):].split("=", 1) for flag in base_flags)
+
+    for name, preset in presets.items():
+        flags = dependency.accelerator_configure_flags(lock, name)
+
+        # The CPU default's own flag list is never mutated by building a preset.
+        assert lock["build"]["configure_flags"] == base_flags
+
+        new_values = dict(flag[len("-D"):].split("=", 1) for flag in flags)
+        backend_flag = preset["backend_flag"]
+        assert base_values[backend_flag] == "OFF"
+        assert new_values[backend_flag] == "ON"
+        for other_flag, value in base_values.items():
+            if other_flag != backend_flag:
+                assert new_values[other_flag] == value, f"{name}: {other_flag} drifted from the CPU default"
+
+
+def test_accelerator_configure_flags_rejects_an_unknown_lane() -> None:
+    dependency = _load_dependency_module()
+    lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    try:
+        dependency.accelerator_configure_flags(lock, "bogus")
+    except dependency.DependencyError as error:
+        assert "unknown accelerator lane" in str(error)
+    else:
+        raise AssertionError("an unknown accelerator lane must be refused")
+
+
+def test_accelerator_status_reports_unavailable_sdks_without_raising(monkeypatch) -> None:
+    dependency = _load_dependency_module()
+    lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    monkeypatch.setattr(dependency.shutil, "which", lambda name: None)
+
+    for name in ("cuda", "rocm", "vulkan"):
+        env_var = lock["accelerator_presets"][name]["sdk_probe"]["env_var"]
+        monkeypatch.delenv(env_var, raising=False)
+        binary = lock["accelerator_presets"][name]["sdk_probe"]["binary"]
+        assert dependency.accelerator_status(name, lock) == {
+            "lane": name,
+            "available": False,
+            "reason": f"{binary} is unavailable on PATH",
+        }
+
+    monkeypatch.setattr(dependency.sys, "platform", "linux")
+    assert dependency.accelerator_status("metal", lock) == {
+        "lane": "metal",
+        "available": False,
+        "reason": "platform 'linux' is not 'darwin'",
+    }
+
+
+def test_accelerator_status_honors_an_explicit_sdk_override(tmp_path, monkeypatch) -> None:
+    dependency = _load_dependency_module()
+    lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    fake_nvcc = tmp_path / "nvcc"
+    fake_nvcc.write_text("#!/bin/sh\nexit 0\n")
+    fake_nvcc.chmod(0o755)
+    monkeypatch.setenv("CUDACXX", str(fake_nvcc))
+
+    assert dependency.accelerator_status("cuda", lock) == {
+        "lane": "cuda",
+        "available": True,
+        "sdk_binary": str(fake_nvcc),
+    }
+
+
+def test_accelerator_status_rejects_an_unknown_lane() -> None:
+    dependency = _load_dependency_module()
+    lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    try:
+        dependency.accelerator_status("bogus", lock)
+    except dependency.DependencyError as error:
+        assert "unknown accelerator lane" in str(error)
+    else:
+        raise AssertionError("an unknown accelerator lane must be refused")
+
+
+def test_accelerator_build_refuses_to_compile_an_unavailable_lane(tmp_path, monkeypatch) -> None:
+    dependency = _load_dependency_module()
+    source = tmp_path / "source"
+    (source / "cmake").mkdir(parents=True)
+    (source / "cmake" / "meshnet-patch-stack.cmake").write_text("# marker\n")
+    monkeypatch.setattr(dependency, "_verify_source", lambda *a, **k: None)
+    monkeypatch.setattr(dependency, "_verify_patched_source", lambda *a, **k: None)
+    monkeypatch.setattr(dependency.shutil, "which", lambda name: None)
+    monkeypatch.delenv("CUDACXX", raising=False)
+
+    build_dir = tmp_path / "build-cuda"
+    try:
+        dependency.accelerator_build(source, "cuda", build_dir)
+    except dependency.DependencyError as error:
+        assert "SDK is unavailable" in str(error)
+    else:
+        raise AssertionError("accelerator_build must refuse to compile an unavailable lane")
+    assert not build_dir.exists()
+
+
+@requires_cmake
+def test_accelerator_build_compiles_the_available_lane_with_isolated_evidence(tmp_path, monkeypatch) -> None:
+    dependency = _load_dependency_module()
+
+    # A tiny synthetic project stands in for the patched llama.cpp checkout —
+    # it only needs the meshnet patch-stack marker and one target, proving
+    # accelerator_build's configure/build/evidence wiring without a multi-minute
+    # llama.cpp compile or a real GPU SDK.
+    source = tmp_path / "source"
+    (source / "cmake").mkdir(parents=True)
+    (source / "cmake" / "meshnet-patch-stack.cmake").write_text("# marker\n")
+    (source / "CMakeLists.txt").write_text(
+        "cmake_minimum_required(VERSION 3.14)\n"
+        "project(accelerator_lane_fixture NONE)\n"
+        "option(GGML_CUDA \"\" OFF)\n"
+        "if(GGML_CUDA)\n"
+        "  file(WRITE ${CMAKE_BINARY_DIR}/lane-flag-on.txt \"on\")\n"
+        "endif()\n"
+        "add_custom_target(fixture-target ALL COMMAND ${CMAKE_COMMAND} -E true)\n"
+    )
+
+    base_lock = json.loads((LLAMA_DIR / "UPSTREAM_LOCK.json").read_text())
+    fake_lock = dict(base_lock)
+    fake_lock["build"] = {
+        **base_lock["build"],
+        "generator": "Unix Makefiles",
+        "configure_flags": ["-DGGML_CUDA=OFF"],
+        "native_targets": ["fixture-target"],
+    }
+    monkeypatch.setattr(dependency, "_load_lock", lambda: fake_lock)
+    monkeypatch.setattr(dependency, "_patches", lambda lock: [])
+    monkeypatch.setattr(dependency, "_verify_source", lambda *a, **k: None)
+    monkeypatch.setattr(dependency, "_verify_patched_source", lambda *a, **k: None)
+    monkeypatch.setenv("CUDACXX", str(dependency._cmake()))
+
+    build_dir = tmp_path / "build-cuda"
+    result = dependency.accelerator_build(source, "cuda", build_dir)
+
+    assert result == build_dir
+    assert (build_dir / "lane-flag-on.txt").is_file()
+    metadata = json.loads((build_dir / "meshnet-build-metadata.json").read_text())
+    assert metadata["lane"] == "cuda"
+    assert metadata["backend_flag"] == "GGML_CUDA"
+    assert metadata["configure_flags"] == ["-DGGML_CUDA=ON"]
+    assert metadata["hardware_execution"] is False
+    assert metadata["hardware_certified"] is False
+    assert metadata["semantic_certification"] is False
+    assert "registered-dark" in metadata["note"]