| """SplitZip compressed shard cache for the DDO VMM routes. |
| |
| One-time build: calibrate a per-tensor Top-16 exponent codebook on the real |
| weight tensors (paper protocol: offline calibration, per-tensor granularity, |
| coverage-gated at >=0.99), encode each BF16 weight to the aligned SplitZip |
| payload, and write one blob per tensor plus a manifest. |
| |
| Runtime: two lookup modes. |
| - Content key (SHA-1 of the weight bytes): used wherever the live CPU tensor |
| is available (staging-pool route, builder verification). |
| - Slice key (shard file name, offset_bytes, size_bytes): used by the vmm_fast |
| native-shard route, where bindings carry no retained CPU tensor. Slice keys |
| are aliased at attach time via ``alias_slice`` while the loader tensors are |
| still alive, and persisted in the manifest. |
| |
| Cache dir layout: |
| <root>/manifest.json |
| <root>/blobs/<tensor_key>.bin |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import tempfile |
| import threading |
| from pathlib import Path |
|
|
| import torch |
|
|
| from .splitzip_codec import ( |
| GpuSplitZipEncoder, |
| PayloadMeta, |
| SplitZipCodebook, |
| calibrate_codebook, |
| encode_torch, |
| triton_available, |
| ) |
|
|
| COVERAGE_MIN = 0.99 |
| CHUNK_SIZE = 1024 |
|
|
|
|
| def _tensor_key(tensor: torch.Tensor) -> str: |
| digest = hashlib.sha1() |
| digest.update(str(tuple(tensor.shape)).encode()) |
| digest.update(str(tensor.dtype).encode()) |
| digest.update(str(tensor.numel() * tensor.element_size()).encode()) |
| data = tensor.contiguous().view(torch.uint8).reshape(-1) |
| digest.update(data.numpy().tobytes()) |
| return digest.hexdigest() |
|
|
|
|
| class SplitZipShardCacheBuilder: |
| """Builds the compressed shard cache from the model's CPU weight tensors.""" |
|
|
| def __init__(self, root: Path, *, coverage_min: float = COVERAGE_MIN) -> None: |
| self.root = Path(root) |
| self.coverage_min = float(coverage_min) |
|
|
| def build(self, tensors: list[tuple[str, torch.Tensor]]) -> dict: |
| """Encode every BF16 tensor; skip tensors that fail the coverage gate. |
| |
| ``tensors`` are (module_qualname, cpu_weight) pairs, e.g. from a |
| named_modules() walk over the transformer. Returns a report; entries |
| not in the manifest are served uncompressed by the transport. |
| """ |
| blobs = self.root / "blobs" |
| blobs.mkdir(parents=True, exist_ok=True) |
| encoder = GpuSplitZipEncoder() if triton_available() else None |
| manifest: dict = {"format": 1, "chunk_size": CHUNK_SIZE, "coverage_min": self.coverage_min, "entries": {}} |
| report = {"encoded": 0, "skipped_coverage": 0, "skipped_dtype": 0, "comp_bytes": 0, "raw_bytes": 0} |
| for qualname, tensor in tensors: |
| if tensor.dtype is not torch.bfloat16: |
| report["skipped_dtype"] += 1 |
| continue |
| if not tensor.is_contiguous(): |
| raise ValueError(f"{qualname}: SplitZip build requires contiguous weights") |
| codebook, coverage = calibrate_codebook(tensor) |
| if coverage < self.coverage_min: |
| report["skipped_coverage"] += 1 |
| continue |
| if encoder is not None: |
| payload, meta = encoder.encode(tensor, codebook) |
| else: |
| payload, meta = encode_torch(tensor, codebook, CHUNK_SIZE) |
| key = _tensor_key(tensor) |
| blob_path = blobs / f"{key}.bin" |
| fd, tmp = tempfile.mkstemp(dir=blobs) |
| try: |
| with os.fdopen(fd, "wb") as handle: |
| handle.write(payload) |
| os.replace(tmp, blob_path) |
| except BaseException: |
| with contextlib_suppress(): |
| os.unlink(tmp) |
| raise |
| manifest["entries"][key] = { |
| "qualname": qualname, |
| "blob": f"blobs/{key}.bin", |
| "codebook": codebook.to_json(), |
| "meta": meta.to_json(), |
| "raw_bytes": tensor.numel() * tensor.element_size(), |
| "slice_keys": [], |
| } |
| report["encoded"] += 1 |
| report["comp_bytes"] += meta.comp_bytes |
| report["raw_bytes"] += tensor.numel() * tensor.element_size() |
| report["ratio"] = (report["comp_bytes"] / report["raw_bytes"]) if report["raw_bytes"] else None |
| _write_manifest(self.root, manifest) |
| return report |
|
|
|
|
| def contextlib_suppress(): |
| import contextlib |
|
|
| return contextlib.suppress(OSError) |
|
|
|
|
| def _write_manifest(root: Path, manifest: dict) -> None: |
| fd, tmp = tempfile.mkstemp(dir=root) |
| try: |
| with os.fdopen(fd, "w") as handle: |
| json.dump(manifest, handle) |
| os.replace(tmp, root / "manifest.json") |
| except BaseException: |
| with contextlib_suppress(): |
| os.unlink(tmp) |
| raise |
|
|
|
|
| class SplitZipShardCache: |
| """Runtime lookup over a built cache; safe to share across staging calls. |
| |
| ``alias_slice`` is the only mutation and is persisting to the manifest, so |
| concurrent readers either see an entry or not — never a partial one. |
| """ |
|
|
| def __init__(self, root: Path) -> None: |
| self.root = Path(root) |
| manifest_path = self.root / "manifest.json" |
| if not manifest_path.is_file(): |
| raise FileNotFoundError(f"SplitZip shard cache missing {manifest_path}") |
| with open(manifest_path) as handle: |
| self._manifest = json.load(handle) |
| self.chunk_size = int(self._manifest.get("chunk_size", CHUNK_SIZE)) |
| self._entries: dict[str, dict] = self._manifest["entries"] |
| self._slice_index: dict[tuple[str, int, int], str] = {} |
| for key, entry in self._entries.items(): |
| for slice_key in entry.get("slice_keys", []): |
| self._slice_index[(slice_key[0], int(slice_key[1]), int(slice_key[2]))] = key |
| self._lock = threading.RLock() |
|
|
| |
|
|
| def _hit(self, key: str) -> tuple[Path, PayloadMeta, SplitZipCodebook] | None: |
| entry = self._entries.get(key) |
| if entry is None: |
| return None |
| meta = PayloadMeta.from_json(entry["meta"]) |
| codebook = SplitZipCodebook.from_json(entry["codebook"]) |
| return self.root / entry["blob"], meta, codebook |
|
|
| def lookup(self, tensor: torch.Tensor) -> tuple[Path, PayloadMeta, SplitZipCodebook] | None: |
| if tensor.dtype is not torch.bfloat16: |
| return None |
| with self._lock: |
| return self._hit(_tensor_key(tensor)) |
|
|
| def lookup_by_slice(self, shard_name: str, offset_bytes: int, size_bytes: int) -> tuple[Path, PayloadMeta, SplitZipCodebook] | None: |
| """Slice-key lookup for the vmm_fast native-shard route (no CPU tensor).""" |
| with self._lock: |
| key = self._slice_index.get((shard_name, int(offset_bytes), int(size_bytes))) |
| return self._hit(key) if key is not None else None |
|
|
| |
|
|
| def alias_slice( |
| self, |
| tensor: torch.Tensor | str, |
| shard_name: str, |
| offset_bytes: int, |
| size_bytes: int, |
| ) -> bool: |
| """Bind a shard slice identity to a cached entry; returns False if absent. |
| |
| Call while the loader CPU tensors are alive (attach time), passing the |
| weight tensor (or its content key). ``offset_bytes``/``size_bytes`` |
| must come from DDO's own ``SafetensorFileSlice`` so the convention |
| matches whatever the adapter stores — never computed independently. |
| """ |
| key = tensor if isinstance(tensor, str) else _tensor_key(tensor) |
| slice_key = (shard_name, int(offset_bytes), int(size_bytes)) |
| with self._lock: |
| entry = self._entries.get(key) |
| if entry is None: |
| return False |
| existing = entry.setdefault("slice_keys", []) |
| if list(slice_key) not in existing: |
| existing.append(list(slice_key)) |
| self._slice_index[slice_key] = key |
| _write_manifest(self.root, self._manifest) |
| return True |
|
|
| |
|
|
| def read_blob(self, tensor: torch.Tensor, size_bytes: int) -> bytes | None: |
| """Read one compressed payload, or None when the tensor is not cached.""" |
| hit = self.lookup(tensor) |
| if hit is None: |
| return None |
| blob_path, meta, _codebook = hit |
| if size_bytes < meta.comp_bytes: |
| raise RuntimeError( |
| f"staging slot too small for SplitZip payload: need {meta.comp_bytes}, have {size_bytes}" |
| ) |
| with self._lock: |
| with open(blob_path, "rb") as handle: |
| return handle.read(meta.comp_bytes) |
|
|
