test(core.utils): e2e real NVRTC compile through persistent caches

Parametrized over SQLiteProgramCache and FileStreamProgramCache: compile
a trivial CUDA C++ kernel with Program.compile("cubin"), store the
ObjectCode under a key produced by make_program_cache_key, close and
reopen the cache handle, retrieve the entry, and confirm the
deserialised ObjectCode still yields a working Kernel via get_kernel.

Covers the full user flow (compile → persist → reopen → driver load)
that the existing fake-ObjectCode tests do not exercise.

Author: cpcloud

cuda_core/tests/test_program_cache.py

@@ -584,3 +584,73 @@ def test_filestream_cache_unbounded_by_default(tmp_path):
         for i in range(20):
             cache[f"k{i}".encode()] = _fake_object_code(b"X" * 1024, name=f"n{i}")
         assert len(cache) == 20
+
+
+# ---------------------------------------------------------------------------
+# End-to-end: real NVRTC compilation through persistent cache
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "backend",
+    [
+        pytest.param("sqlite", marks=needs_sqlite3),
+        pytest.param("filestream"),
+    ],
+)
+def test_cache_roundtrip_with_real_compilation(backend, tmp_path, init_cuda):
+    """Compile a real kernel, persist it, reopen the cache, and reload the kernel.
+
+    Exercises the full user workflow: NVRTC compile → persistent store → fresh
+    process (simulated by closing and reopening the cache handle) → driver-side
+    module load from the deserialised ``ObjectCode``.
+    """
+    from cuda.core import Program, ProgramOptions
+    from cuda.core._module import Kernel
+    from cuda.core.utils import (
+        FileStreamProgramCache,
+        SQLiteProgramCache,
+        make_program_cache_key,
+    )
+
+    code = 'extern "C" __global__ void my_kernel() {}'
+    code_type = "c++"
+    target_type = "cubin"
+    options = ProgramOptions(name="cached_kernel")
+
+    program = Program(code, code_type, options=options)
+    try:
+        compiled = program.compile(target_type)
+    finally:
+        program.close()
+    assert isinstance(compiled.get_kernel("my_kernel"), Kernel)
+
+    key = make_program_cache_key(
+        code=code,
+        code_type=code_type,
+        options=options,
+        target_type=target_type,
+    )
+
+    if backend == "sqlite":
+        path = tmp_path / "cache.db"
+        cache_cls = SQLiteProgramCache
+    else:
+        path = tmp_path / "fc"
+        cache_cls = FileStreamProgramCache
+
+    # First "process": compile and store.
+    with cache_cls(path) as cache:
+        assert key not in cache
+        cache[key] = compiled
+
+    # Second "process": reopen a fresh handle and retrieve.
+    with cache_cls(path) as cache:
+        assert key in cache
+        cached = cache[key]
+
+    assert cached.code_type == target_type
+    assert cached.name == "cached_kernel"
+    assert bytes(cached.code) == bytes(compiled.code)
+    # The deserialised ObjectCode must still be usable against the driver.
+    assert isinstance(cached.get_kernel("my_kernel"), Kernel)