fixup! feat(core.utils): drop direct driver-version probe in linker branch (nvJitLink)

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -645,13 +645,12 @@ def _probe(label: str, fn):
             nv_major, nv_minor = nvrtc_ver
             _update("nvrtc", f"{nv_major}.{nv_minor}".encode("ascii"))
     elif backend == "linker":
-        # Only the linker (PTX inputs) actually invokes the driver for
-        # codegen via cuLink, so the driver version belongs only here.
-        # Keying NVRTC/NVVM on the driver would invalidate caches across
-        # benign driver upgrades that don't affect compiled bytes.
-        driver_ver = _probe("driver", _driver_version)
-        if driver_ver is not None:
-            _update("driver", str(driver_ver).encode("ascii"))
+        # Only cuLink (driver-backed linker) goes through the CUDA driver
+        # for codegen. nvJitLink is a separate library, so a driver upgrade
+        # under it does not change the compiled bytes -- skip the driver
+        # version there. ``_linker_backend_and_version`` already returns the
+        # driver version when the driver backend is active, so the bytes
+        # are still in the digest via ``linker_version``.
         linker = _probe("linker", _linker_backend_and_version)
         if linker is not None:
             lb_name, lb_version = linker

cuda_core/tests/test_program_cache.py

@@ -732,6 +732,20 @@ def test_make_program_cache_key_accepts_side_effect_options_for_ptx(option_kw):
     _make_key(code=".version 7.0", code_type="ptx", options=_opts(**option_kw))  # no raise
 
 
+def test_make_program_cache_key_driver_version_does_not_perturb_ptx_under_nvjitlink(monkeypatch):
+    """nvJitLink does NOT route PTX compilation through cuLink, so a
+    changing driver version must not invalidate PTX cache keys when
+    nvJitLink is the active linker backend."""
+    from cuda.core.utils import _program_cache
+
+    monkeypatch.setattr(_program_cache, "_linker_backend_and_version", lambda: ("nvJitLink", "12030"))
+    monkeypatch.setattr(_program_cache, "_driver_version", lambda: 13200)
+    k_a = _make_key(code=".version 7.0", code_type="ptx")
+    monkeypatch.setattr(_program_cache, "_driver_version", lambda: 13300)
+    k_b = _make_key(code=".version 7.0", code_type="ptx")
+    assert k_a == k_b
+
+
 @pytest.mark.parametrize(
     "code_type, code, target_type",
     [
@@ -761,11 +775,6 @@ def _broken():
 @pytest.mark.parametrize(
     "probe_name, code_type, code",
     [
-        # Driver version is only consumed on the linker (PTX) path now; NVRTC
-        # and NVVM compile bytes don't depend on the driver, so a failing
-        # driver probe should NOT perturb their cache keys (separately
-        # verified by test_..._driver_probe_failure_does_not_perturb_non_linker).
-        pytest.param("_driver_version", "ptx", ".ptx", id="driver"),
         pytest.param("_nvrtc_version", "c++", "a", id="nvrtc"),
         pytest.param("_cuda_core_version", "c++", "a", id="cuda_core"),
         pytest.param("_linker_backend_and_version", "ptx", ".ptx", id="linker"),
@@ -775,7 +784,9 @@ def test_make_program_cache_key_fails_closed_on_probe_failure(probe_name, code_t
     """A failed probe (a) must produce a key that differs from a working
     probe (so environments never silently share cache entries), and (b)
     must produce a *stable* key across calls -- otherwise the persistent
-    cache could not be reused in broken environments."""
+    cache could not be reused in broken environments. ``_driver_version``
+    is exercised separately because it's only invoked transitively from
+    ``_linker_backend_and_version`` on the cuLink driver path."""
     from cuda.core.utils import _program_cache
 
     def _broken():
@@ -789,6 +800,25 @@ def _broken():
     assert k_broken1 == k_broken2  # stable: same failure -> same key
 
 
+def test_make_program_cache_key_driver_probe_failure_taints_ptx_under_cuLink(monkeypatch):
+    """When the driver linker is active, _linker_backend_and_version
+    invokes _driver_version internally; a failing driver probe propagates
+    through the linker probe and must perturb the PTX key."""
+    from cuda.core.utils import _program_cache
+
+    def _broken():
+        raise RuntimeError("driver probe failed")
+
+    # Force the cuLink driver path so _linker_backend_and_version reads driver_version.
+    from cuda.core import _linker
+
+    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)
+    k_ok = _make_key(code=".ptx", code_type="ptx")
+    monkeypatch.setattr(_program_cache, "_driver_version", _broken)
+    k_broken = _make_key(code=".ptx", code_type="ptx")
+    assert k_ok != k_broken
+
+
 # ---------------------------------------------------------------------------
 # SQLiteProgramCache -- basic CRUD
 # ---------------------------------------------------------------------------
@@ -1085,7 +1115,7 @@ def reader(thread_id: int):
         for t in threads:
             t.join(timeout=30)
         assert not any(t.is_alive() for t in threads)
-    assert errors == []
+    assert not errors
 
 
 @needs_sqlite3
@@ -1436,7 +1466,7 @@ def test_filestream_cache_clear_preserves_young_tmp_files(tmp_path):
     # Filenames are hash-like (no extension), so use a file filter rather
     # than a "*.*" glob.
     remaining_entries = [p for p in (root / "entries").rglob("*") if p.is_file()]
-    assert remaining_entries == []
+    assert not remaining_entries
     assert young_tmp.exists()
     assert not ancient_tmp.exists()