vmm_fast route: native shard transport wrapper (compressed DMA + in-place GPU decode + Event fence)
c1dc9b2 verified | """SplitZip support for the ``vmm_fast`` route (native DLL allocator). | |
| Target: ``dynamic_offload.py::_prepare_vmm_fast_runtime`` where | |
| ``attach_model_linear_modules(...)`` (ddo-vmm-allocator, ``model_arena_adapter.py``) | |
| returns a ``ModelArenaWeightStore`` whose native shard transport reads EXACTLY | |
| ``binding.nbytes`` raw bytes from the safetensors shard straight into the VMM | |
| arena. Python never stages per-weight bytes on that path, so the staging-pool | |
| interception (``splitzip_staging.py``) never sees it. | |
| The seams that make a Python-only integration possible (verified against | |
| ddo-vmm-allocator @ 70802e1, ``model_arena_adapter.py``): | |
| 1. All uploads are enqueued on a Python-owned stream: | |
| ``self._upload_stream = torch.cuda.Stream(device=device_ordinal)``. | |
| 2. ``native.copy_from_host_async(arena_offset, source, stream=...)`` is the | |
| Python-visible DMA used for CPU-source uploads — it copies exactly | |
| ``source.nbytes``, so a compressed payload can be DMA'd if it arrives as a | |
| pinned tensor of that size. | |
| 3. ``wait_for_compute(ready_event)`` accepts polymorphic tokens, including a | |
| plain ``torch.cuda.Event`` — a decode enqueued after the DMA on the upload | |
| stream is fenced correctly by returning an event recorded after it. | |
| Strategy: replace ``store._native_shard_transport`` with | |
| ``SplitZipNativeShardTransport`` AFTER ``attach_model_linear_modules`` returns. | |
| Per compressed binding we read the blob into a persistent pinned buffer, DMA it | |
| into the arena range, decode the full BF16 weight in place on the upload | |
| stream, and return a torch Event. Raw (uncached) bindings are delegated to the | |
| inner transport unchanged. The native DLL is NOT modified. | |
| Because native-shard bindings may carry no retained CPU tensor, cache entries | |
| are additionally aliased to their safetensor slice identity at attach time | |
| (``bind_slice_aliases``) and resolved at fault time via ``binding.file_slice``. | |
| Hardware-verification points are listed in docs/developer/splitzip.md. | |
| """ | |
| from __future__ import annotations | |
| from pathlib import Path | |
| from typing import Any, Callable | |
| import torch | |
| from .splitzip_codec import GpuSplitZipDecoder, PayloadMeta, triton_available | |
| from .splitzip_shard_cache import SplitZipShardCache | |
| # A resolved cache entry: (blob_path, meta, codebook) | |
| _CacheHit = tuple[Any, PayloadMeta, Any] | |
| def _resolve_arena_view(store: Any) -> Callable[[Any, int, int], torch.Tensor]: | |
| """Find a callable that yields a torch view over arena device memory. | |
| Tries the store, then the native handle. If your build names it | |
| differently, pass ``arena_view_fn`` to :func:`enable_splitzip_fast_transport`. | |
| """ | |
| candidates = [] | |
| for owner in (store, getattr(store, "native", None)): | |
| for name in ("arena_view", "arena_view_bytes", "view_arena", "arena_tensor_view"): | |
| fn = getattr(owner, name, None) | |
| if callable(fn): | |
| candidates.append(fn) | |
| if not candidates: | |
| raise RuntimeError( | |
| "SplitZip fast transport could not resolve an arena-view helper on the " | |
| "ModelArenaWeightStore or its native handle. Pass arena_view_fn=... to " | |
| "enable_splitzip_fast_transport (signature: (native, arena_offset, nbytes) " | |
| "-> contiguous torch.uint8 CUDA tensor)." | |
| ) | |
| first = candidates[0] | |
| def arena_view_fn(native: Any, arena_offset: int, nbytes: int) -> torch.Tensor: | |
| view = first(native, arena_offset, nbytes) | |
| if not (torch.is_tensor(view) and view.is_cuda and view.is_contiguous()): | |
| raise RuntimeError("arena_view helper returned a non-CUDA or non-contiguous tensor") | |
| return view.reshape(-1) if view.dtype is torch.uint8 else view.reshape(-1).view(torch.uint8) | |
| return arena_view_fn | |
| class SplitZipNativeShardTransport: | |
| """Wraps the store's ``_NativeShardTransport``; overrides ``upload_batch``. | |
| Contract with ``ModelArenaWeightStore.fault_and_copy_if_needed`` (the only | |
| consumer): called as ``upload_batch([binding], native, upload_stream)`` and | |
| its return value is handed to ``wait_for_compute``. We keep that contract — | |
| including the observed single-binding call pattern. For a mixed multi- | |
| binding batch we raise, because one return token cannot fence both the | |
| inner ring path and our decode; split the batch instead. | |
| """ | |
| def __init__( | |
| self, | |
| inner: Any, | |
| shard_cache: SplitZipShardCache, | |
| store: Any, | |
| *, | |
| arena_view_fn: Callable[[Any, int, int], torch.Tensor] | None = None, | |
| ) -> None: | |
| if not triton_available(): | |
| raise RuntimeError( | |
| "SplitZip fast transport requires the vendored Triton codec " | |
| "(_splitzip_vendor.codec_gpu); on Windows use the staging-pool route." | |
| ) | |
| self._inner = inner | |
| self._shard_cache = shard_cache | |
| self._store = store | |
| self._device_id = getattr(store, "_device_ordinal", 0) | |
| self._decoder = GpuSplitZipDecoder(device_id=self._device_id) | |
| self._arena_view_fn = arena_view_fn or _resolve_arena_view(store) | |
| self._pinned: torch.Tensor | None = None # persistent pinned staging, uint8 | |
| self._dec_lut: dict[int, torch.Tensor] = {} # id(codebook) -> GPU dec_lut | |
| self.stats = {"compressed_uploads": 0, "delegated_uploads": 0, "comp_bytes": 0, "raw_bytes": 0} | |
| # Everything except upload_batch delegates to the inner transport (ring | |
| # prefetch, slot management, ...). Prefetched raw reads for compressed | |
| # bindings are wasted work until the adapter learns to skip them; they are | |
| # harmless (the prefetch target is simply not consumed for those bindings). | |
| def __getattr__(self, name: str) -> Any: | |
| return getattr(self._inner, name) | |
| # -- cache lookup ------------------------------------------------------- | |
| def _hit_for(self, binding: Any) -> _CacheHit | None: | |
| source = getattr(binding, "source", None) | |
| if source is not None: | |
| hit = self._shard_cache.lookup(source) | |
| if hit is not None: | |
| return hit | |
| # Preferred on the native-shard path: bindings may carry no retained | |
| # CPU tensor, so resolve via the safetensor slice identity aliased at | |
| # attach time (aliasing uses DDO's own offset convention). | |
| file_slice = getattr(binding, "file_slice", None) | |
| if file_slice is not None: | |
| return self._shard_cache.lookup_by_slice( | |
| Path(file_slice.path).name, file_slice.offset_bytes, file_slice.size_bytes | |
| ) | |
| return None | |
| def _dec_lut_for(self, codebook: Any, device: torch.device) -> torch.Tensor: | |
| key = id(codebook) | |
| lut = self._dec_lut.get(key) | |
| if lut is None or lut.device != device: | |
| lut = codebook.dec_lut.to(device) | |
| self._dec_lut[key] = lut | |
| return lut | |
| def _pinned_for(self, nbytes: int) -> torch.Tensor: | |
| if self._pinned is None or self._pinned.numel() < nbytes: | |
| self._pinned = torch.empty(nbytes, dtype=torch.uint8, pin_memory=True) | |
| return self._pinned | |
| # -- the seam ----------------------------------------------------------- | |
| def upload_batch(self, bindings: list[Any], native: Any, stream: Any) -> Any: | |
| hits = [(b, self._hit_for(b)) for b in bindings] | |
| if not any(hit is not None for _b, hit in hits): | |
| self.stats["delegated_uploads"] += len(bindings) | |
| return self._inner.upload_batch(bindings, native, stream) | |
| if len(bindings) > 1: | |
| raise NotImplementedError( | |
| "SplitZipNativeShardTransport observed a multi-binding upload_batch with " | |
| "compressed content. The adapter's known call pattern is one binding per " | |
| "call; either split the batch or extend this wrapper." | |
| ) | |
| binding, hit = hits[0] | |
| return self._upload_compressed(binding, hit, native, stream) | |
| def _upload_compressed(self, binding: Any, hit: _CacheHit, native: Any, stream: Any) -> torch.cuda.Event: | |
| blob_path, meta, codebook = hit | |
| comp = meta.comp_bytes | |
| raw_bytes = meta.n * 2 | |
| if comp > raw_bytes: | |
| raise RuntimeError( | |
| f"SplitZip payload exceeds the binding's arena range " | |
| f"({comp} > {raw_bytes}); the coverage gate should have skipped this tensor" | |
| ) | |
| pinned = self._pinned_for(comp) | |
| with open(blob_path, "rb", buffering=0) as handle: | |
| read = handle.readinto(memoryview(pinned.numpy()).cast("B")[:comp]) | |
| if read != comp: | |
| raise OSError(f"Short SplitZip blob read from {blob_path}: expected {comp}, got {read}") | |
| arena_offset = binding.offset # verified: passed to native.copy_from_host_async | |
| with torch.cuda.stream(stream): | |
| # 1) DMA the compressed payload into the arena range (comp bytes). | |
| native.copy_from_host_async(arena_offset, pinned[:comp], stream=stream) | |
| # 2) Expand bitwise over the same range on the upload stream: the | |
| # decoder first stashes arena[offset:offset+comp] to GPU scratch, | |
| # then writes the full BF16 weight over the arena range. | |
| arena_u8 = self._arena_view_fn(native, arena_offset, raw_bytes) | |
| slot_bf16 = arena_u8.view(torch.bfloat16) | |
| self._decoder.decode_slot_into( | |
| slot_bf16, meta, self._dec_lut_for(codebook, arena_u8.device), stream=stream | |
| ) | |
| # 3) Fence: wait_for_compute accepts a plain torch event; it must be | |
| # recorded AFTER the decode so compute never sees compressed bytes. | |
| ready = torch.cuda.Event() | |
| ready.record(stream) | |
| self.stats["compressed_uploads"] += 1 | |
| self.stats["comp_bytes"] += comp | |
| self.stats["raw_bytes"] += raw_bytes | |
| return ready | |
| def bind_slice_aliases(root: Any, shard_cache: SplitZipShardCache) -> int: | |
| """Alias cached content keys to safetensor slice identities, attach time only. | |
| Walks ``root``'s parameters while the loader CPU tensors are alive, reads | |
| each one's ``SafetensorFileSlice`` from the registry DDO bound as | |
| ``module._ddo_safetensor_slices``, and records the | |
| (shard name, offset_bytes, size_bytes) triple next to the content key. | |
| After this, ``SplitZipNativeShardTransport`` can resolve compressed | |
| bindings that carry no retained CPU tensor. | |
| Call BEFORE loader tensors are released (i.e. during/just after attach); | |
| returns the number of aliases created. | |
| """ | |
| registry = getattr(root, "_ddo_safetensor_slices", None) | |
| if registry is None: | |
| return 0 | |
| lookup = getattr(registry, "lookup", None) | |
| if not callable(lookup): | |
| return 0 | |
| aliases = 0 | |
| for _name, parameter in root.named_parameters(remove_duplicate=False): | |
| tensor = parameter.data | |
| if tensor is None or tensor.device.type != "cpu": | |
| continue | |
| file_slice = lookup(tensor) | |
| if file_slice is None: | |
| continue | |
| if shard_cache.alias_slice( | |
| tensor, Path(file_slice.path).name, file_slice.offset_bytes, file_slice.size_bytes | |
| ): | |
| aliases += 1 | |
| return aliases | |
| def enable_splitzip_fast_transport( | |
| store: Any, | |
| shard_cache: SplitZipShardCache, | |
| *, | |
| arena_view_fn: Callable[[Any, int, int], torch.Tensor] | None = None, | |
| ) -> SplitZipNativeShardTransport: | |
| """Swap SplitZip into a ``ModelArenaWeightStore``'s native shard transport. | |
| Call right after ``report, store = attach_model_linear_modules(...)`` in | |
| ``_prepare_vmm_fast_runtime`` when ``native_transport_kwargs`` is non-empty | |
| (i.e. the native DLL transport is active), and after | |
| :func:`bind_slice_aliases` while the loader tensors are still alive. | |
| Requires the vendored Triton codec; raises otherwise (the CPU fallback | |
| cannot run on this path because Python never stages per-weight bytes here). | |
| The native DLL is unchanged; this only re-routes file reads for compressed | |
| bindings through the Python-visible DMA seam and adds an in-place GPU | |
| decode on the upload stream. | |
| """ | |
| inner = getattr(store, "_native_shard_transport", None) | |
| if inner is None: | |
| raise RuntimeError( | |
| "store has no _native_shard_transport: native transport is not active. " | |
| "Enable vmm_native_transport, or use the SplitZipStagingPool route instead." | |
| ) | |
| wrapper = SplitZipNativeShardTransport(inner, shard_cache, store, arena_view_fn=arena_view_fn) | |
| store._native_shard_transport = wrapper | |
| return wrapper | |