fixup! feat(core.utils): NVVM fingerprint goes through _get_nvvm_module

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -344,18 +344,22 @@ def _linker_backend_and_version() -> tuple[str, str]:
 def _nvvm_fingerprint() -> str:
     """Stable identifier for the loaded NVVM toolchain.
 
-    Combines the libNVVM library version (``cuda.bindings.nvvm.version()``)
-    with the IR version reported by ``ir_version()``. The library version is
-    the primary invalidation lever: a libNVVM patch upgrade can change
-    codegen while keeping the same IR major/minor, so keying only on the IR
-    pair would silently reuse stale entries. Paired with cuda-core, the IR
-    pair adds defence in depth without making the key any less stable.
+    Combines the libNVVM library version (``module.version()``) with the IR
+    version reported by ``module.ir_version()``. The library version is the
+    primary invalidation lever: a libNVVM patch upgrade can change codegen
+    while keeping the same IR major/minor, so keying only on the IR pair
+    would silently reuse stale entries. Paired with cuda-core, the IR pair
+    adds defence in depth without making the key any less stable.
+
+    Both calls go through ``_get_nvvm_module()`` so this fingerprint follows
+    the same availability / cuda-bindings-version gate that real NVVM
+    compilation does -- if NVVM is unusable at compile time, the probe
+    fails the same way and ``_probe`` mixes the failure label into the key.
     """
-    from cuda.bindings import nvvm
     from cuda.core._program import _get_nvvm_module
 
     module = _get_nvvm_module()
-    lib_major, lib_minor = nvvm.version()
+    lib_major, lib_minor = module.version()
     major, minor, debug_major, debug_minor = module.ir_version()
     return f"lib={lib_major}.{lib_minor};ir={major}.{minor}.{debug_major}.{debug_minor}"
 

cuda_core/tests/test_program_cache.py

@@ -504,19 +504,53 @@ def test_make_program_cache_key_nvvm_use_libdevice_false_equals_none():
 
 
 def test_make_program_cache_key_nvvm_library_version_changes_key(monkeypatch):
-    """Updating libNVVM (different ``cuda.bindings.nvvm.version()``) must
-    invalidate NVVM cache entries -- a patch upgrade can change codegen
-    without bumping the IR version, so keying only on IR would silently
-    return stale entries."""
-    from cuda.core.utils import _program_cache
+    """Updating libNVVM (different ``module.version()``) must invalidate
+    NVVM cache entries even when the IR version stays constant; a patch
+    upgrade can change codegen without bumping the IR pair."""
+
+    class _FakeNVVM:
+        def __init__(self, lib_version):
+            self._lib_version = lib_version
+
+        def version(self):
+            return self._lib_version
 
-    monkeypatch.setattr(_program_cache, "_nvvm_fingerprint", lambda: "lib=12.3;ir=1.8.3.0")
+        def ir_version(self):
+            return (1, 8, 3, 0)  # constant -- only the lib version varies
+
+    fake_old = _FakeNVVM((12, 3))
+    fake_new = _FakeNVVM((12, 4))
+    from cuda.core import _program
+
+    monkeypatch.setattr(_program, "_get_nvvm_module", lambda: fake_old)
     k_old = _make_key(code="abc", code_type="nvvm", target_type="ptx")
-    monkeypatch.setattr(_program_cache, "_nvvm_fingerprint", lambda: "lib=12.4;ir=1.8.3.0")
+    monkeypatch.setattr(_program, "_get_nvvm_module", lambda: fake_new)
     k_new = _make_key(code="abc", code_type="nvvm", target_type="ptx")
     assert k_old != k_new
 
 
+def test_make_program_cache_key_nvvm_fingerprint_uses_get_nvvm_module(monkeypatch):
+    """The fingerprint must call _get_nvvm_module() rather than importing
+    cuda.bindings.nvvm directly -- otherwise it bypasses the availability
+    /cuda-bindings-version gate and could disagree with the actual NVVM
+    compile path."""
+    sentinel_called = {"n": 0}
+
+    class _SentinelNVVM:
+        def version(self):
+            sentinel_called["n"] += 1
+            return (12, 9)
+
+        def ir_version(self):
+            return (1, 8, 3, 0)
+
+    from cuda.core import _program
+
+    monkeypatch.setattr(_program, "_get_nvvm_module", lambda: _SentinelNVVM())
+    _make_key(code="abc", code_type="nvvm", target_type="ptx")
+    assert sentinel_called["n"] == 1
+
+
 def test_make_program_cache_key_nvvm_probe_changes_key(monkeypatch):
     """NVVM keys must reflect the NVVM toolchain identity (IR version)
     so an upgraded libNVVM does not silently reuse pre-upgrade entries."""