# SplitZip in DDO — VMM routes (vmm_fast primary, vmm_runtime fallback)

Lossless, bitwise-exact compression of offloaded BF16 weights using
[SplitZip](https://arxiv.org/abs/2605.01708) (NeurIPS 2026, MIT code at
[Intelligent-Microsystems-Lab/SplitZip](https://github.com/Intelligent-Microsystems-Lab/SplitZip)).

## What it does

SplitZip splits each BF16 value into a sign+mantissa byte (stored verbatim)
and an exponent byte, codes the top-16 exponents with 4-bit codes (two per
byte), and routes rare exponents to a sparse escape stream (chunk-local
positions, chunk=1024). Expected payload ≈ **0.756× raw** (ratio ~1.32×).
The paper's throughput numbers (613 GB/s encode / 2182 GB/s decode on H200)
are for LLM KV activations; treat your own measurements as authoritative.

## Files added

| File | Role |
| --- | --- |
| `splitzip_codec.py` | Payload layout, calibration, pure-torch codec, upstream Triton encoder + `GpuSplitZipDecoder` |
| `splitzip_shard_cache.py` | One-time builder + runtime lookup (content keys AND slice keys, coverage-gated ≥0.99) |
| `splitzip_fast.py` | **vmm_fast route**: wraps the native shard transport — compressed DMA + in-place GPU decode + torch Event fence |
| `splitzip_staging.py` | **vmm_runtime fallback route**: `SplitZipStagingPool(PinnedStagingPool)` + `decode_group_slots` |

## One-time vendor step

Copy the upstream MIT codec into the package:

```
src/diffusers_dynamic_offloader/_splitzip_vendor/__init__.py
src/diffusers_dynamic_offloader/_splitzip_vendor/codec_gpu.py   # from SplitZip repo
src/diffusers_dynamic_offloader/_splitzip_vendor/LICENSE
```

Windows has no Triton: the fast route is unavailable there by construction
(Python never stages per-weight bytes on it); the staging-pool route falls
back to CPU decode. Add a `splitzip = ["triton>=3.0"]` optional dependency.

## Build the cache (once per model checkpoint)

```python
from pathlib import Path
from diffusers_dynamic_offloader.splitzip_shard_cache import SplitZipShardCacheBuilder

tensors = [(name, mod.weight.data)
           for name, mod in transformer.named_modules()
           if type(mod).__name__ == "Linear" and mod.weight.dtype is torch.bfloat16]
report = SplitZipShardCacheBuilder(Path(cache_root)).build(tensors)
print(report)  # {"encoded": N, "ratio": ~0.76, "skipped_coverage": ..., ...}
```

Calibration runs on the real weights (paper protocol: offline, per-tensor).
Tensors whose Top-16 exponent coverage falls below 0.99 are left uncompressed
by construction — worst case is parity. FP8-E4M3 must NOT be encoded (paper:
expansion); the code gates to `torch.bfloat16` only.

## Route A (primary): vmm_fast with the native DLL allocator

In `_prepare_vmm_fast_runtime`, right after
`report, store = attach_model_linear_modules(...)` and while the loader CPU
tensors are still alive:

```python
from diffusers_dynamic_offloader.splitzip_shard_cache import SplitZipShardCache
from diffusers_dynamic_offloader.splitzip_fast import bind_slice_aliases, enable_splitzip_fast_transport

shard_cache = SplitZipShardCache(Path(cache_root))
bind_slice_aliases(module, shard_cache)        # content key -> (shard, offset, size) aliases
enable_splitzip_fast_transport(store, shard_cache)  # replaces store._native_shard_transport
```

How a compressed fault is served (all on the store's upload stream, no DLL
changes): blob read (comp bytes) → `native.copy_from_host_async(binding.offset,
pinned[:comp], stream)` → `GpuSplitZipDecoder` stashes the payload to GPU
scratch and decodes the full BF16 weight over the arena range → `torch.Event`
recorded after the decode is returned to `wait_for_compute`. Raw (uncached)
bindings are delegated to the inner transport unchanged.

Hardware verification points specific to this route (see checklist below):
`binding.offset` / `binding.file_slice` attribute names, the arena-view helper
(pass `arena_view_fn=` if resolution fails), whether `copy_from_host_async`
requires the host buffer to be `cuMemHostRegister`ed, and whether the adapter
prefetches via the transport for compressed bindings (harmless wasted reads).

## Route B (fallback): vmm_runtime with the pinned staging pool

Replace the pool construction in `_prepare_vmm_runtime` (around L1436) with the
SplitZip subclass, and expand slots after upload:

```python
from diffusers_dynamic_offloader.splitzip_staging import SplitZipStagingPool, decode_group_slots

self._vmm_staging_pool = SplitZipStagingPool(
    pool_size_bytes, slots=2, shard_cache=shard_cache, registered_virtual_host=...,  # existing kwargs
)
# in _schedule_vmm_execution_group, after arena.acquire(...) and before mark_upload:
decode_group_slots(sources, slot_tensors, shard_cache, stream=self._vmm_upload_stream)
```

Invariants (do not break): staging entries always advance by the RAW byte
size; only the leading `comp_bytes` of an entry hold payload; GPU decode is
enqueued after the HtoD DMA and before `mark_upload(group, stream, pool)` on
the same stream.

## Invariants common to both routes

1. **Wire format is frozen**: `pk[n_pairs] u8, sm[n] u8, chunk_id[4·n_esc] i32
   LE, local_pos[2·n_esc] u16 LE, esc_val[n_esc] u8`, 4-byte-aligned offsets.
   The Triton kernels and both decoders compile views against exactly this.
2. **Statefulness**: the codebook lives in the cache manifest; a compressed
   blob is useless without its `dec_lut` — never delete the manifest alone.
3. **Coverage gate 0.99**: below it, the paper's size model degrades; broad-
   exponent distributions can EXPAND (measured 1.17× on adversarial data).
   The gate is the protection — do not lower it without a coverage report.
4. **Losslessness**: the builder asserts bitwise round-trip per tensor before
   writing a blob; keep that assertion.

## Validation checklist (before trusting it)

- [ ] CPU suite: `pytest tests/test_splitzip_codec.py` — green, no GPU needed.
- [ ] Vendored-codec sanity on GPU: encode/decode one real weight with
      upstream `codec_gpu.py`; assert bitwise equality.
- [ ] Cross-check: `GpuSplitZipEncoder` output must decode bit-exactly with
      the pure-torch decoder (proves GPU encoder ↔ wire layout agreement).
- [ ] Fast route single fault: materialize one compressed weight through
      `SplitZipNativeShardTransport`; compare the arena range bytes against a
      raw upload of the same weight.
- [ ] Microbench: `_dec_4bit_quad64` GB/s on your GPU vs PCIe HtoD bandwidth
      — decode must fit under it, else the CPU-decode route is faster.
- [ ] End-to-end: one denoise run with SplitZip on vs off; compare wall-clock,
      host RSS, rematerialization counts, and output pixels (must be identical).
- [ ] Windows: staging-pool CPU-decode path produces bitwise-equal staged views.