Resolve compiler math libraries before native preparation (#88)

Select the CUDA math library required by compiled-forward eager precision
before constructing recorded preparation sessions or entering standalone
operator preparation. Native program discovery and materialization then use
the same compiler options across serial and overlapping graph catalogs.

Inductor initializes toolkit libdevice when Flare's emulate_precision_casts
option first compiles a forward. Previously, b12x could memoize discovery with
Triton's bundled library first, then request another library's program key
while runtime compilation was forbidden. The two library files differ in
content; retaining their distinct identities is required.

Implemented in shared preparation without changing numerical options, kernel
selection, cache equivalence or compilation guards. Qualified with 80 CPU
checks, including two library-selection regressions that fail on prerequisite
a2c9278 and pass with this correction. The regressions prohibit CUDA
initialization and perform no compilation. GPU serial-to-overlap preparation
and native replay remain unqualified pending an assigned validation window.

Design-Signed-Off-By: Codex (GPT-6); design-review=babb

Author: voipmonitor

ignition/preparation/tuning.py

@@ -27,6 +27,19 @@
 _REQUESTS_PER_JOB = 192
 
 
+def _prepare_compiler_toolchain():
+    """Resolve forward math libraries before native program identities are recorded."""
+    from torch._inductor import config
+    from torch._inductor.runtime.compile_tasks import _set_triton_libdevice_path
+
+    from .compilation import _OPTIONS
+
+    # Inductor selects the CUDA toolkit's libdevice for eager precision. Native
+    # discovery and later materialization must see that same library identity.
+    with config.patch(emulate_precision_casts=_OPTIONS["emulate_precision_casts"]):
+        _set_triton_libdevice_path()
+
+
 def with_autotune_effort(prepare):
     """Apply the preparation config's effort throughout bootstrap declarations."""
     @wraps(prepare)
@@ -65,6 +78,7 @@ def __init__(self, *, device, checkpoint: str, workload_schema: str,
                         numerical_policy=numerical_policy)
         self.autotune_effort = AutotuneEffort(autotune_effort).value
         self.native_dense_activations = native_dense_activations
+        _prepare_compiler_toolchain()
         with b12x_autotune_effort(self.autotune_effort):
             super().__init__(device=device, autotune=self.autotune_effort != "off", compile_workers=0,
                              namespace=identity, race_budget=race_budget, prime=False,
@@ -476,6 +490,7 @@ def declare(session, requests, *, coordinator=None):
     if isinstance(session, RecordedPreparationSession):
         session.declare(requests, coordinator=coordinator)
     else:
+        _prepare_compiler_toolchain()
         options = {} if coordinator is None else {"coordinator": coordinator}
         session.prepare(requests, **options)
 

tests/preparation/test_toolchain.py

@@ -0,0 +1,76 @@
+"""Native discovery and compiled forwards share one CUDA math-library identity."""
+
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+import pytest
+
+import ignition
+
+
+@pytest.mark.parametrize("session_kind", ["recorded", "standalone"])
+def test_discovery_options_survive_inductor_precision_initialization(session_kind):
+    # A subprocess preserves the unset-library startup condition independently
+    # of other tests that have already initialized Inductor.
+    source = r'''
+from pathlib import Path
+import sys
+from unittest.mock import patch
+
+import torch
+assert not torch.cuda.is_initialized()
+def reject_cuda(*args, **kwargs):
+    raise RuntimeError("this compiler-identity check must not initialize CUDA")
+torch.cuda._lazy_init = reject_cuda
+
+from torch.utils.cpp_extension import CUDA_HOME
+if CUDA_HOME is None:
+    raise SystemExit(77)
+toolkit_library = Path(CUDA_HOME) / "nvvm/libdevice/libdevice.10.bc"
+if not toolkit_library.is_file():
+    raise SystemExit(77)
+
+from triton.backends.nvidia.compiler import CUDAOptions
+from torch._inductor import config
+from torch._inductor.runtime.compile_tasks import _set_triton_libdevice_path
+from b12x.preparation import PreparationSession
+from ignition.preparation.compilation import _OPTIONS
+from ignition.preparation.tuning import RecordedPreparationSession, declare
+
+observed = []
+if sys.argv[1] == "recorded":
+    # Only the GPU-owning base constructor is replaced. Flare's constructor
+    # and the real Inductor/Triton library selection remain under test.
+    def base_initialize(self, **kwargs):
+        observed.append(CUDAOptions())
+    with patch.object(PreparationSession, "__init__", base_initialize):
+        RecordedPreparationSession(device=0, checkpoint="compiler-library",
+            workload_schema="compiler-library", numerical_policy="default",
+            compile_workers=1)
+else:
+    class Standalone:
+        def prepare(self, requests):
+            observed.append(CUDAOptions())
+    declare(Standalone(), ())
+
+before = observed[0]
+with config.patch(emulate_precision_casts=_OPTIONS["emulate_precision_casts"]):
+    _set_triton_libdevice_path()
+after = CUDAOptions()
+assert before.extern_libs == after.extern_libs, (
+    "native discovery", before.extern_libs, "compiled forward", after.extern_libs)
+assert Path(dict(before.extern_libs)["libdevice"]) == toolkit_library, (
+    before.extern_libs, toolkit_library)
+assert before.hash() == after.hash(), (before.hash(), after.hash())
+assert not torch.cuda.is_initialized()
+'''
+    environment = dict(os.environ, CUDA_VISIBLE_DEVICES="")
+    environment.pop("TRITON_LIBDEVICE_PATH", None)
+    result = subprocess.run([sys.executable, "-c", source, session_kind],
+        cwd=Path(ignition.__file__).resolve().parents[1], env=environment,
+        capture_output=True, text=True)
+    if result.returncode == 77:
+        pytest.skip("requires the CUDA toolkit's libdevice bitcode")
+    assert result.returncode == 0, result.stdout + result.stderr