feat(core.utils): add persistent program caches (sqlite + filestream)

Convert cuda.core.utils to a package and add persistent, on-disk caches
for compiled ObjectCode produced by Program.compile.

Public API (cuda.core.utils):
  * ProgramCacheResource  -- abstract bytes|str -> ObjectCode mapping
    with context manager and pickle-safety warning. Path-backed
    ObjectCode is rejected at write time (would store only the path).
  * SQLiteProgramCache    -- single-file sqlite3 backend (WAL mode,
    autocommit) with LRU eviction against an optional size cap. A
    threading.RLock serialises connection use so one cache object is
    safe across threads. wal_checkpoint(TRUNCATE) + VACUUM run after
    evictions so the size cap bounds real on-disk usage, not just
    logical payload. Schema-version mismatch on open wipes entries.
  * FileStreamProgramCache -- directory of atomically-written entries
    (tmp + os.replace) safe across concurrent processes, with
    best-effort size enforcement by mtime. Windows-only PermissionError
    from os.replace is swallowed as a cache miss; other platforms
    re-raise. Schema-version mismatch on open wipes entries.
  * make_program_cache_key -- stable 32-byte blake2b key over code,
    code_type, ProgramOptions (including options.name), target_type,
    name expressions (normalised str/bytes), cuda core/driver/NVRTC
    versions, linker backend+version for PTX inputs, NVVM-specific
    fields (extra_sources, use_libdevice), and an optional extra_digest
    that callers MUST supply when options pull in external file content
    (include_path, pre_include, pch, use_pch, pch_dir).

sqlite3 is imported lazily so the package is usable on interpreters
built without libsqlite3.

Tests: single-process CRUD, LRU/size-cap (logical and on-disk),
corruption, schema-mismatch, threaded access (SQLite), multiprocess
stress (FileStream), Windows vs POSIX PermissionError behaviour, and
an end-to-end test that compiles a real CUDA C++ kernel, stores the
ObjectCode, reopens the cache, and calls get_kernel on the deserialised
copy. Public API is documented in cuda_core/docs/source/api.rst.

Author: cpcloud

cuda_core/cuda/core/utils.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from cuda.core._memoryview import (
+    StridedMemoryView,
+    args_viewable_as_strided_memory,
+)
+
+__all__ = [
+    "FileStreamProgramCache",
+    "ProgramCacheResource",
+    "SQLiteProgramCache",
+    "StridedMemoryView",
+    "args_viewable_as_strided_memory",
+    "make_program_cache_key",
+]
+
+# Lazily expose the program-cache APIs so ``from cuda.core.utils import
+# StridedMemoryView`` stays lightweight -- the cache backends pull in driver,
+# NVRTC, and module-load machinery that memoryview-only consumers do not need.
+_LAZY_CACHE_ATTRS = frozenset(
+    {
+        "FileStreamProgramCache",
+        "ProgramCacheResource",
+        "SQLiteProgramCache",
+        "make_program_cache_key",
+    }
+)
+
+
+def __getattr__(name):
+    if name in _LAZY_CACHE_ATTRS:
+        from cuda.core.utils import _program_cache
+
+        value = getattr(_program_cache, name)
+        globals()[name] = value  # cache for subsequent accesses
+        return value
+    raise AttributeError(f"module 'cuda.core.utils' has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(__all__)