fixup! feat(core.utils): backend-aware linker fingerprint collapses driver-ignored fields

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -259,18 +259,34 @@ def _gate_identity(v):
 }
 
 
-def _linker_option_fingerprint(options: ProgramOptions) -> list[bytes]:
-    """Stable byte fingerprint of ProgramOptions fields consumed by the Linker.
-
-    Each field is first passed through the gate the Linker itself uses so
-    that equivalent inputs (e.g. ``debug=False`` / ``None``) produce the
-    same bytes. Without this, callers hitting the same linker behavior
-    would get different cache keys and needlessly re-compile.
+# LinkerOptions fields the ``cuLink`` driver backend silently ignores
+# (emits only a DeprecationWarning; no actual flag reaches the compiler).
+# When the driver backend is active, collapse them to a single sentinel in
+# the fingerprint so nvJitLink<->driver parity of ``ObjectCode`` doesn't
+# cause cache misses from otherwise-equivalent configurations.
+_DRIVER_IGNORED_LINKER_FIELDS = frozenset({"ftz", "prec_div", "prec_sqrt", "fma"})
+
+
+def _linker_option_fingerprint(options: ProgramOptions, *, use_driver_linker: bool | None) -> list[bytes]:
+    """Backend-aware fingerprint of ProgramOptions fields consumed by the Linker.
+
+    Each field passes through the gate the Linker itself uses so equivalent
+    inputs (e.g. ``debug=False`` / ``None``) hash to the same bytes. When
+    the driver (cuLink) linker backend is in use, fields it silently
+    ignores collapse to one sentinel so those options don't perturb the
+    key on driver-backed hosts either. ``use_driver_linker=None`` means we
+    couldn't probe the backend; we don't collapse driver-ignored fields in
+    that case, to stay conservative.
     """
-    return [
-        f"{name}={_LINKER_FIELD_GATES[name](getattr(options, name, None))!r}".encode()
-        for name in _LINKER_RELEVANT_FIELDS
-    ]
+    parts = []
+    driver_ignored = use_driver_linker is True
+    for name in _LINKER_RELEVANT_FIELDS:
+        if driver_ignored and name in _DRIVER_IGNORED_LINKER_FIELDS:
+            parts.append(f"{name}=<driver-ignored>".encode())
+            continue
+        gated = _LINKER_FIELD_GATES[name](getattr(options, name, None))
+        parts.append(f"{name}={gated!r}".encode())
+    return parts
 
 
 # ProgramOptions fields that map to LinkerOptions fields the cuLink (driver)
@@ -499,6 +515,7 @@ def make_program_cache_key(
     # store a key for a compilation that can't succeed in this environment.
     # If the probe fails we can't tell which backend will run, so skip -- the
     # failed-probe branch below already taints the key.
+    use_driver_linker: bool | None = None
     if backend == "linker":
         try:
             from cuda.core._linker import _decide_nvjitlink_or_driver
@@ -535,7 +552,7 @@ def make_program_cache_key(
     # misses on PTX. For nvrtc/nvvm backends, ProgramOptions.as_bytes gives
     # the real compile-time flag surface.
     if backend == "linker":
-        option_bytes = _linker_option_fingerprint(options)
+        option_bytes = _linker_option_fingerprint(options, use_driver_linker=use_driver_linker)
     else:
         try:
             option_bytes = options.as_bytes(backend, target_type)

cuda_core/tests/test_program_cache.py

@@ -373,6 +373,38 @@ def test_make_program_cache_key_ptx_linker_equivalent_options_hash_same(a, b, mo
     assert k_a == k_b
 
 
+@pytest.mark.parametrize(
+    "field, a, b",
+    [
+        pytest.param("ftz", True, False, id="ftz"),
+        pytest.param("prec_div", True, False, id="prec_div"),
+        pytest.param("prec_sqrt", True, False, id="prec_sqrt"),
+        pytest.param("fma", True, False, id="fma"),
+    ],
+)
+def test_make_program_cache_key_ptx_driver_ignored_fields_collapse(field, a, b, monkeypatch):
+    """The driver (cuLink) linker silently ignores ftz/prec_div/prec_sqrt/fma
+    (only emits a DeprecationWarning). Under the driver backend, those
+    fields must not perturb the PTX cache key -- two otherwise-equivalent
+    compiles differing only in these flags produce identical ObjectCode."""
+    from cuda.core import _linker
+
+    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)  # driver
+    k_a = _make_key(code=".version 7.0", code_type="ptx", options=_opts(**{field: a}))
+    k_b = _make_key(code=".version 7.0", code_type="ptx", options=_opts(**{field: b}))
+    assert k_a == k_b
+
+
+def test_make_program_cache_key_ptx_driver_ignored_fields_still_matter_under_nvjitlink(monkeypatch):
+    """nvJitLink does honour those fields; they must still differentiate keys there."""
+    from cuda.core import _linker
+
+    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: False)  # nvJitLink
+    k_a = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ftz=True))
+    k_b = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ftz=False))
+    assert k_a != k_b
+
+
 def test_make_program_cache_key_nvvm_use_libdevice_false_equals_none():
     """Program_init gates ``use_libdevice`` on truthiness, so False and None
     compile identically and must hash the same way."""