Papers for

llm infrastructure engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Kvstream boosts large-scale llm cache retrieval with parallel storage

KVStream: Adaptive Parallel Storage Management for KV Caching in Large-Scale LLM Serving

Abstract: Long-context LLM serving for agentic, coding, and document workloads reuses prefixes whose key-value (KV) cache outgrows GPU and host memory, putting storage I/O on the critical path of the inference step for retrieving prefixes. A single node-local NVMe absorbs all retrievals, while the parallel file system or cloud file store that nodes already mount carries almost no inference traffic. We cast prefix retrieval as aggregate-bandwidth scheduling across these tiers and present KVStream, a KV cache engine that batches a step's reads, defers writes behind the forward pass, replicates each chunk on every tier, and lets each tier adaptively claim the next unread chunks once it is free. Our performance model shows this routing attains the aggregate-bandwidth bound without prediction or tuning, whereas any static split misses it by a margin that grows as per-tier bandwidths drift or fluctuate. It also predicts that the time-to-first-token (TTFT) gain grows with load, as faster retrieval drains the queue, and disappears when host memory or arrival order keeps reuse in cache. Plugged into LMCache and evaluated on four models, six datasets, and up to 128 GPUs, KVStream retrieves within 5% of the bound, delivers up to 1.49$\times$ higher offline throughput than LMCache, and lowers mean TTFT by up to 6.1$\times$ under bursty arrivals.

Thu 22 OctDistributed, Parallel, and Cluster Computing
The gist
When big AI models use long contexts, they reuse parts of previous data stored in a cache. But this cache gets too big for fast memory, so it has to rely on slower storage, causing delays. The authors designed KVStream, a system that smartly shares the work of fetching this cached data across different storage devices, speeding up access without needing complicated tuning. Tests showed KVStream can get data nearly as fast as theoretically possible, improving overall AI response speed, especially during heavy workloads.
Open → 2610.31827v1

E8 lattice vector quantization improves key compression for large language models

E8 Lattice Key Quantization for Low-Bit KV-Cache Compression

Abstract: Compressing the key-value (KV) cache is essential for serving long-context large language models (LLMs) under memory constraints. While current scalar quantization methods achieve significant compression, they typically face a quality-fidelity trade-off, either suffering from performance instability at 2-bit precision or necessitating 3-bit keys to maintain model quality. In this work, we demonstrate that a uniform low-bit k2v2 configuration (2-bit keys and 2-bit values) can preserve near-baseline quality by using vector quantization (VQ) based on the $E_8$ lattice for KV keys. We show that structured VQ exploits correlations across adjacent dimensions to achieve signal-to-quantization-noise ratios (SQNR) higher than those of independent scalar quantization at the same key payload rate. To ensure practical utility, we adapt a table-based asymmetric scoring algorithm that avoids explicit codebook dequantization during attention computation and preserves decode-throughput parity with scalar baselines. Across five LLM families, our $E_8$ k2v2 approach yields \textasciitilde$6\times$ KV compression, roughly 20\% smaller than scalar k3v2 (3-bit keys and 2-bit values), while retaining near-baseline long-context perplexity. In our full-suite perplexity evaluation, $E_8$ improves over scalar k3v2 in 80\% of model--dataset--context settings. These results indicate that $E_8$ lattice VQ improves quality per byte while keeping throughput at parity, suggesting that structured key quantization is a useful primitive for KV-compression stacks. Overall, our work provides a low-overhead primitive for expanding the quality-memory frontier in long-context LLM inference.

Sun 11 OctMachine LearningArtificial Intelligence
The gist
Large language models need to remember lots of information in memory, which can be expensive. Compressing this memory with fewer bits usually reduces quality or speed. The authors show that using a special math structure called the E8 lattice to group and compress memory keys in 2 bits keeps model quality high and runs just as fast. This method works better than older approaches that use 3 bits and results in roughly six times smaller memory for keys and values combined. Their approach works well across many language models and datasets without slowing down.
Open → 2610.15384v1