File size: 8,832 Bytes
77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f 77299d7 4095c9f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 | """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()
# -- lookup -------------------------------------------------------------
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
# -- aliasing -----------------------------------------------------------
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
# -- blob access ----------------------------------------------------------
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)
|