fix(core): two robustness fixes from roborev review

Roborev jobs #1770 and #1771:

* MEDIUM @ _program_cache.py:1235 -- ``__setitem__`` calls
  ``tempfile.mkstemp(dir=self._tmp)`` without ensuring ``tmp/`` still
  exists. If something deletes it after ``__init__`` (operators
  clearing by hand, another process's wipe), every subsequent write
  crashes with FileNotFoundError even though we could trivially
  recreate it. Fixed: ``self._tmp.mkdir(parents=True, exist_ok=True)``
  before mkstemp -- same defensive recreation we already do for
  ``entries/<2-char>/`` shard subdirs.

* LOW @ _program.pyx:177 -- the uncached NVRTC path warns when the
  active driver can't load freshly-generated PTX. Cache hits skipped
  this warning, so ``Program.compile("ptx", cache=cache)`` could
  silently hand back PTX that won't actually load on the active
  driver. Loadability is a property of the driver, not of how the
  bytes were produced -- mirror the warning before returning a
  cached hit so cached and uncached calls behave the same on
  loadability-vs-driver mismatches.

Tests added:

* ``test_filestream_cache_recreates_tmp_dir_if_missing`` --
  ``shutil.rmtree(root/"tmp")`` between two writes; the second write
  must still succeed and recreate the dir.
* ``test_cache_hit_emits_ptx_loadability_warning_when_driver_too_old``
  -- monkeypatch ``_can_load_generated_ptx`` to False on a preseeded
  cache; cache hit must emit the RuntimeWarning.
* ``test_cache_hit_no_ptx_warning_when_driver_supports_it`` --
  inverse: warning must NOT fire when the driver can load it.

Roborev #1770 also raised a MEDIUM about ``extra_sources`` being hashed
in caller-provided order. NVVM module linking is order-dependent in the
general case (overlapping symbols, weak definitions, etc.), so
canonicalizing the order would be unsound without proving the input
subset NVVM actually treats as order-insensitive. Keeping the
order-sensitive hash is the safer default; documented as part of
``_NvvmBackend.hash_extra_payload``'s comment in the strategy class.

Author: cpcloud

cuda_core/cuda/core/_program.pyx

@@ -175,6 +175,23 @@ cdef class Program:
         )
         hit_bytes = cache.get(key)
         if hit_bytes is not None:
+            # The uncached NVRTC path warns when the active driver can't
+            # load freshly-generated PTX; that loadability is a property
+            # of the driver, not of how the bytes were produced, so the
+            # warning applies equally to cached PTX. Mirror it here so a
+            # cache hit doesn't silently hide an incompatibility that the
+            # uncached call would have surfaced.
+            if (
+                self._backend == "NVRTC"
+                and target_type == "ptx"
+                and not _can_load_generated_ptx()
+            ):
+                warn(
+                    "The CUDA driver version is older than the backend version. "
+                    "The generated ptx will not be loadable by the current driver.",
+                    stacklevel=2,
+                    category=RuntimeWarning,
+                )
             return ObjectCode._init(hit_bytes, target_type, name=self._options.name)
         compiled = _program_compile_uncached(self, target_type, name_expressions, logs)
         cache[key] = compiled

cuda_core/cuda/core/utils/_program_cache.py

@@ -1513,6 +1513,12 @@ def __setitem__(self, key: object, value: bytes | bytearray | memoryview | Objec
         data = _extract_bytes(value)
         target = self._path_for_key(key)
         target.parent.mkdir(parents=True, exist_ok=True)
+        # Re-create ``tmp/`` if something deleted it after ``__init__``
+        # (operators clearing the cache by hand, ``rm -rf cache_dir/tmp``,
+        # another process's overzealous wipe). Cheap and idempotent;
+        # without it, every subsequent write would crash with
+        # FileNotFoundError even though we could trivially recover.
+        self._tmp.mkdir(parents=True, exist_ok=True)
 
         fd, tmp_name = tempfile.mkstemp(prefix="entry-", dir=self._tmp)
         tmp_path = Path(tmp_name)

cuda_core/tests/test_program_cache.py

@@ -1576,6 +1576,27 @@ def test_filestream_cache_uses_default_dir_when_path_omitted(tmp_path, monkeypat
     assert (tmp_path / "default-fc" / "entries").is_dir()
 
 
+def test_filestream_cache_recreates_tmp_dir_if_missing(tmp_path):
+    """If ``tmp/`` is deleted out from under a live cache (operator clearing
+    by hand, another process's wipe, etc.), the next write must recreate
+    it rather than crash with ``FileNotFoundError``. The cache already
+    recreates the per-shard ``entries/<2-char>/`` directory; ``tmp/``
+    deserves the same treatment since ``mkstemp`` writes there."""
+    import shutil
+
+    from cuda.core.utils import FileStreamProgramCache
+
+    root = tmp_path / "fc"
+    with FileStreamProgramCache(root) as cache:
+        cache[b"k"] = b"first"
+        # Nuke tmp/ between writes; the second write must still succeed.
+        shutil.rmtree(root / "tmp")
+        cache[b"k2"] = b"second"
+        assert cache[b"k"] == b"first"
+        assert cache[b"k2"] == b"second"
+        assert (root / "tmp").is_dir()
+
+
 def test_filestream_cache_sweeps_stale_tmp_files_on_open(tmp_path):
     """A crashed writer can leave files in ``tmp/``; the next ``open`` must
     sweep ones older than the staleness threshold so disk usage doesn't

cuda_core/tests/test_program_compile_cache.py

@@ -116,6 +116,53 @@ def _explode(_program, *_args, **_kwargs):
     assert cache.set_calls == []
 
 
+def test_cache_hit_emits_ptx_loadability_warning_when_driver_too_old(monkeypatch):
+    """The uncached NVRTC path warns when the active driver can't load
+    freshly-generated PTX. That loadability is a property of the driver,
+    not of how the bytes were produced, so a cache hit on the same
+    (NVRTC + ptx target_type) compile must emit the same warning. Without
+    this mirror, ``compile("ptx", cache=cache)`` would silently hand back
+    PTX that won't actually load on the active driver."""
+    options = ProgramOptions(arch="sm_80", name="warn_program")
+    program = Program(_KERNEL, "c++", options)
+    key = make_program_cache_key(code=_KERNEL, code_type="c++", options=options, target_type="ptx")
+
+    monkeypatch.setattr(_program_module, "_can_load_generated_ptx", lambda: False)
+
+    def _explode(_program, *_args, **_kwargs):
+        raise AssertionError("_program_compile_uncached must not be called on cache hit")
+
+    monkeypatch.setattr(_program_module, "_program_compile_uncached", _explode)
+    cache = _RecordingCache(preseed={key: _SENTINEL_BYTES})
+
+    with pytest.warns(RuntimeWarning, match="driver"):
+        result = program.compile("ptx", cache=cache)
+
+    assert bytes(result.code) == _SENTINEL_BYTES
+
+
+def test_cache_hit_no_ptx_warning_when_driver_supports_it(monkeypatch):
+    """Inverse of the warning test: when the driver can load the PTX, no
+    warning is emitted on cache hit (the wrapper must not be over-eager)."""
+    import warnings
+
+    options = ProgramOptions(arch="sm_80", name="quiet_program")
+    program = Program(_KERNEL, "c++", options)
+    key = make_program_cache_key(code=_KERNEL, code_type="c++", options=options, target_type="ptx")
+
+    monkeypatch.setattr(_program_module, "_can_load_generated_ptx", lambda: True)
+
+    def _explode(_program, *_args, **_kwargs):
+        raise AssertionError("_program_compile_uncached must not be called on cache hit")
+
+    monkeypatch.setattr(_program_module, "_program_compile_uncached", _explode)
+    cache = _RecordingCache(preseed={key: _SENTINEL_BYTES})
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")  # any warning becomes an exception
+        program.compile("ptx", cache=cache)
+
+
 def test_cache_rejects_name_expressions():
     """``name_expressions`` is incompatible with ``cache=``: the cache stores
     raw binary bytes, but ``ObjectCode.symbol_mapping`` (populated by