fixup! feat(core.utils): honor cross-patch sharing; clarify size cap + name_expressions

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -373,12 +373,6 @@ def _nvvm_fingerprint() -> str:
     return f"lib={lib_major}.{lib_minor};ir={major}.{minor}.{debug_major}.{debug_minor}"
 
 
-def _cuda_core_version() -> str:
-    from cuda.core._version import __version__
-
-    return str(__version__)
-
-
 # ProgramOptions fields that reference external files whose *contents* the
 # cache key cannot observe without reading the filesystem. Callers that set
 # any of these must supply an ``extra_digest`` covering the dependency surface
@@ -453,7 +447,7 @@ def make_program_cache_key(
     code_type: str,
     options: ProgramOptions,
     target_type: str,
-    name_expressions: Sequence[str] = (),
+    name_expressions: Sequence[str | bytes | bytearray] = (),
     extra_digest: bytes | None = None,
 ) -> bytes:
     """Build a stable cache key from compile inputs.
@@ -472,6 +466,11 @@ def make_program_cache_key(
         One of ``"ptx"``, ``"cubin"``, ``"ltoir"``.
     name_expressions:
         Optional iterable of mangled-name lookups. Order is not significant.
+        Elements may be ``str``, ``bytes``, or ``bytearray``; ``"foo"`` and
+        ``b"foo"`` produce distinct keys because ``Program.compile`` records
+        the original Python object as the ``ObjectCode.symbol_mapping`` key,
+        and ``get_kernel`` lookups must use the same type the cache key
+        recorded.
     extra_digest:
         Caller-supplied bytes mixed into the key. Required whenever
         :class:`cuda.core.ProgramOptions` sets any option that pulls in
@@ -669,9 +668,6 @@ def _probe(label: str, fn):
             return None
 
     _update("schema", str(_KEY_SCHEMA_VERSION).encode("ascii"))
-    cuda_core_ver = _probe("cuda_core", _cuda_core_version)
-    if cuda_core_ver is not None:
-        _update("cuda_core", cuda_core_ver.encode("ascii"))
     if backend == "nvrtc":
         nvrtc_ver = _probe("nvrtc", _nvrtc_version)
         if nvrtc_ver is not None:
@@ -775,9 +771,16 @@ class SQLiteProgramCache(ProgramCacheResource):
         Filesystem path to the sqlite3 database. The parent directory is
         created if missing.
     max_size_bytes:
-        Optional size cap in bytes. When the sum of stored payload sizes
+        Optional cap on the sum of stored payload sizes. When that total
         exceeds the cap, the least-recently-used entries are evicted until
-        the total is at or below the cap. ``None`` means unbounded.
+        the logical total is at or below the cap; ``None`` means unbounded.
+        Real on-disk usage tracks the logical total *at quiescent points*:
+        WAL frames and freed pages are reclaimed opportunistically via
+        ``wal_checkpoint(TRUNCATE)`` + ``VACUUM`` after each eviction, but
+        ``sqlite3`` skips both under active readers or writers. With
+        concurrent access, the on-disk file can grow above the cap until
+        readers release; :class:`FileStreamProgramCache` is the right
+        backend for multi-process workloads with strict on-disk bounds.
     """
 
     def __init__(

cuda_core/tests/test_program_cache.py

@@ -855,6 +855,26 @@ 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
 
 
+@pytest.mark.parametrize(
+    "code_type, code, target_type",
+    [
+        pytest.param("c++", "a", "cubin", id="nvrtc"),
+        pytest.param("ptx", ".version 7.0", "cubin", id="linker"),
+        pytest.param("nvvm", "abc", "ptx", id="nvvm"),
+    ],
+)
+def test_make_program_cache_key_survives_cuda_core_version_change(code_type, code, target_type, monkeypatch):
+    """The docstring promises cross-patch sharing within a schema version, so
+    cuda.core's own ``__version__`` must NOT be mixed into the digest."""
+    import cuda.core._version as _version_mod
+
+    monkeypatch.setattr(_version_mod, "__version__", "0.0.0")
+    k_a = _make_key(code=code, code_type=code_type, target_type=target_type)
+    monkeypatch.setattr(_version_mod, "__version__", "999.999.999")
+    k_b = _make_key(code=code, code_type=code_type, target_type=target_type)
+    assert k_a == k_b
+
+
 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
@@ -899,7 +919,6 @@ def _broken():
     "probe_name, code_type, code",
     [
         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"),
     ],
 )