fixup! feat(core.utils): retry read on Windows sharing PermissionError; ensure threads exit before cache close

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -1100,6 +1100,34 @@ def _replace_with_sharing_retry(tmp_path: Path, target: Path) -> bool:
     return False
 
 
+def _stat_and_read_with_sharing_retry(path: Path) -> tuple[os.stat_result, bytes]:
+    """Snapshot stat and read bytes, retrying briefly on Windows transient
+    sharing-violation ``PermissionError``.
+
+    Reads race the rewriter's ``os.replace``: on Windows, the destination
+    can be momentarily inaccessible (winerror 5/32/33) while the rename
+    completes. Mirroring ``_replace_with_sharing_retry``'s budget keeps
+    transient contention from being mistaken for a real read failure.
+
+    Raises ``FileNotFoundError`` on miss or after exhausting the Windows
+    sharing-retry budget. Other ``PermissionError`` (real ACL/permission
+    issues) and any non-Windows ``PermissionError`` propagate.
+    """
+    last_exc: BaseException | None = None
+    for delay in _REPLACE_RETRY_DELAYS:
+        if delay:
+            time.sleep(delay)
+        try:
+            return path.stat(), path.read_bytes()
+        except FileNotFoundError:
+            raise
+        except PermissionError as exc:
+            if not _IS_WINDOWS or getattr(exc, "winerror", None) not in _SHARING_VIOLATION_WINERRORS:
+                raise
+            last_exc = exc
+    raise FileNotFoundError(path) from last_exc
+
+
 def _prune_if_stat_unchanged(path: Path, st_before: os.stat_result) -> None:
     """Unlink ``path`` iff its stat still matches ``st_before``.
 
@@ -1236,8 +1264,10 @@ def __getitem__(self, key: object) -> ObjectCode:
             # Snapshot stat *before* read so we can detect a concurrent
             # os.replace during the read/parse window; a stale stat means
             # another writer wrote a fresh file that must not be pruned.
-            st_before = path.stat()
-            data = path.read_bytes()
+            # The helper retries on Windows transient sharing-violation
+            # PermissionErrors so a racing rewriter does not turn a hit
+            # into a spurious propagated error.
+            st_before, data = _stat_and_read_with_sharing_retry(path)
         except FileNotFoundError:
             raise KeyError(key) from None
         k = _as_key_bytes(key)
@@ -1309,8 +1339,7 @@ def __len__(self) -> int:
         count = 0
         for path in list(self._iter_entry_paths()):
             try:
-                st_before = path.stat()
-                data = path.read_bytes()
+                st_before, data = _stat_and_read_with_sharing_retry(path)
             except FileNotFoundError:
                 continue
             try:

cuda_core/tests/test_program_cache.py

@@ -1310,6 +1310,14 @@ def reader(thread_id: int):
         threads += [threading.Thread(target=reader, args=(i,)) for i in range(4)]
         for t in threads:
             t.start()
+        for t in threads:
+            t.join(timeout=30)
+        # On slow runners (Windows CI in particular) the loop above can return
+        # before every worker has finished its 200 iterations. Signal stop and
+        # join again so the ``with`` block does NOT tear down the cache while
+        # workers are still mid-operation -- that would surface as spurious
+        # "SQLiteProgramCache is closed" errors that mask the real assertion.
+        stop.set()
         for t in threads:
             t.join(timeout=30)
         assert not any(t.is_alive() for t in threads)