Spaces:
Running
Running
| """Per-material table opening; all table decoding/probing stays upstream. | |
| The router resolves through a source's _find(), not its _open_*() methods. | |
| Consequently per-material locking must live on the tablebase which actually | |
| owns the opened files. This module holds one small copy of upstream's | |
| double-checked open contract and the block-cache accessor shared by the | |
| router and the remote sources. | |
| """ | |
| from __future__ import annotations | |
| import threading | |
| from typing import Any | |
| import weakref | |
| class PerMaterialOpening: | |
| """Mixin for chesstb.Tablebase with independent first opens per material. | |
| Upstream probe() registers readers around the entire recursive walk; | |
| its close() drains them before closing the caches. No probing logic or | |
| lifecycle override is needed here. As upstream, direct calls to private | |
| _open_* methods must not race close(). | |
| """ | |
| def __init__(self, *args: Any, **kwargs: Any) -> None: | |
| self._material_locks: weakref.WeakValueDictionary = weakref.WeakValueDictionary() | |
| self._material_locks_meta_lock = threading.Lock() | |
| super().__init__(*args, **kwargs) | |
| def _material_lock(self, kind: str, cache_key: Any) -> Any: | |
| # A caller's context manager holds a strong reference while waiting | |
| # and while owning the lock. Unused lock objects can then disappear, | |
| # without deleting a lock another thread may still be waiting on. | |
| with self._material_locks_meta_lock: | |
| key = (kind, cache_key) | |
| lock = self._material_locks.get(key) | |
| if lock is None: | |
| lock = threading.Lock() | |
| self._material_locks[key] = lock | |
| return lock | |
| def _table_open_lock(self, kind: str, cache_key: Any) -> Any: | |
| return self._material_lock(kind, cache_key) | |
| def _open_any(self, kind: str, cache: dict, file_cls: Any, cfg: Any) -> Any: | |
| key = cfg.cache_key | |
| try: | |
| return cache[key] | |
| except KeyError: | |
| pass | |
| with self._table_open_lock(kind, key): | |
| try: | |
| return cache[key] | |
| except KeyError: | |
| pass | |
| path = self._find(kind, cfg.name(), file_cls.EXT) | |
| table = file_cls(cfg, path, self._block_cache) if path is not None else None | |
| # Cache genuine absence, but never cache a transport/parse error. | |
| cache[key] = table | |
| return table | |
| def _open_wdl(self, cfg: Any) -> Any: | |
| return self._open_any("wdl", self._wdl_cache, self.WDL_FILE, cfg) | |
| def _open_dtz(self, cfg: Any) -> Any: | |
| return self._open_any("dtz", self._dtz_cache, self.DTZ_FILE, cfg) | |
| def _open_dtc(self, cfg: Any) -> Any: | |
| return self._open_any("dtc", self._dtc_cache, self.DTC_FILE, cfg) | |
| def _open_dtm(self, cfg: Any) -> Any: | |
| return self._open_any("dtm", self._dtm_cache, self.DTM_FILE, cfg) | |
| def _open_dtm50(self, cfg: Any) -> Any: | |
| return self._open_any("dtm50", self._dtm50_cache, self.DTM50_FILE, cfg) | |
| def block_cache_usage(tb: Any) -> tuple[int, int]: | |
| """(decoded blocks, resident bytes) of an upstream tablebase's block cache. | |
| Reads upstream's private _block_cache, _lru, and cur_bytes. | |
| """ | |
| cache = tb._block_cache | |
| return len(cache._lru), cache.cur_bytes | |