Upload folder using huggingface_hub

README.md

@@ -0,0 +1,37 @@
+---
+license: cc-by-4.0
+language:
+- en
+pretty_name: LLM Inference Engineering Notes
+tags:
+- text
+- llm-inference
+- vllm
+- sglang
+- kv-cache
+- quantization
+task_categories:
+- text-generation
+size_categories:
+- n<1K
+---
+
+# LLM Inference Engineering Notes
+
+A small collection of technical notes (Markdown text) on serving large language models: KV-cache math, prefill vs decode, continuous batching, quantization, speculative decoding, GPU memory sizing, latency metrics, engine comparisons and interview prep. Includes a dependency-free KV-cache / GPU-memory calculator script. This is a notes collection, not a training dataset.
+
+## Table of contents
+
+- [Continuous batching explained with numbers](articles/continuous-batching-explained.md)
+- [How much GPU memory do you need to serve a 70B model?](articles/gpu-memory-for-70b.md)
+- [Inference engineer roadmap: skills, tools, and a 12-week plan](articles/inference-engineer-roadmap.md)
+- [KV cache math](articles/kv-cache-math.md)
+- [LLM inference interview questions with worked answers](articles/llm-inference-interview-questions.md)
+- [Prefill vs decode](articles/prefill-vs-decode.md)
+- [Quantization for serving: FP8, INT8, INT4 tradeoffs](articles/quantization-for-serving.md)
+- [Speculative decoding: when it helps and when it doesn't](articles/speculative-decoding.md)
+- [Time-to-first-token vs tokens-per-second: what to measure](articles/ttft-vs-tokens-per-second.md)
+- [vLLM vs SGLang vs TensorRT-LLM: when to pick which](articles/vllm-vs-sglang-vs-tensorrt-llm.md)
+- [KV cache calculator](calculator/kv_calc.py) ([README](calculator/README.md)) — interactive version: https://huggingface.co/spaces/inference-engineering-academy/llm-kv-cache-calculator
+
+Made by Inference Engineering Academy (https://www.inference-engineering.xyz/), which has a free Foundations course on LLM inference.

articles/continuous-batching-explained.md

@@ -0,0 +1,49 @@
+# Continuous batching explained with numbers
+
+Continuous batching is the single biggest reason modern LLM servers get high throughput. Here is why, with arithmetic you can check.
+
+## Why batch at all?
+During decode, each step generates one token per sequence and must read all model weights from GPU memory. Take Llama 3.1 8B in BF16: about 16 GB of weights. On an H100 SXM with about 3.35 TB/s of HBM bandwidth, one weight read takes at least
+
+16 GB / 3,350 GB/s = **~4.8 ms**.
+
+At batch size 1, that is at most ~210 tokens/s. With 32 sequences in the batch, the same weight read serves 32 tokens, so the ceiling becomes ~6,700 tokens/s, minus the extra cost of reading each sequence's KV cache. Batching amortizes the weight read.
+
+## The problem with static batching
+Static batching groups requests and runs them until **all** are finished. Suppose a batch of 4 has output lengths of 50, 100, 200 and 1,000 tokens.
+- The batch runs 1,000 steps.
+- Useful token-steps: 50 + 100 + 200 + 1,000 = 1,350.
+- Slots available: 4 x 1,000 = 4,000.
+- Utilization: 1,350 / 4,000 = **34%**.
+
+Worse, new requests wait in the queue for up to 1,000 steps (about 5 seconds at 4.8 ms/step), which wrecks time to first token.
+
+## Continuous (iteration-level) batching
+Introduced by Orca (OSDI 2022), continuous batching makes scheduling decisions at every decode step:
+1. Sequences that emit an end token leave immediately.
+2. Waiting requests are admitted into freed slots on the next step.
+3. Their prefill is run (often in chunks) alongside ongoing decodes.
+
+In the example above, as soon as the 50-token request finishes, a new request takes its slot. With a steady queue, slots stay close to 100% occupied, so throughput approaches the full batch ceiling, and queueing delay drops from "until the longest request ends" to "until any slot frees up".
+
+## What limits the batch size: KV cache
+Each running sequence holds a KV cache. For Llama 3.1 8B that is 128 KiB per token (2 x 32 layers x 8 KV heads x 128 dims x 2 bytes). On an 80 GB GPU at 90% utilization, after ~15 GiB of weights and ~2 GiB of overhead, about 50 GiB remains:
+
+50 GiB / 128 KiB = ~410,000 tokens.
+
+At an average of 2,000 tokens per sequence (prompt + output), that is ~200 concurrent sequences; at 8,192 tokens, ~50. This is why PagedAttention (allocating KV in small blocks on demand instead of reserving max length) matters: it lets the scheduler pack in sequences based on what they actually use.
+
+## Chunked prefill
+A new 8,000-token prompt can take tens of milliseconds to prefill. If it runs alone, every decoding sequence stalls for that time, which shows up as inter-token latency spikes. Chunked prefill splits the prompt into pieces (for example 512 or 2,048 tokens) and mixes each chunk with ongoing decode steps, smoothing latency.
+
+## Tuning knobs (vLLM names)
+- `--max-num-seqs`: upper limit on concurrent sequences.
+- `--max-num-batched-tokens`: tokens processed per step, which bounds prefill chunk size.
+- `--gpu-memory-utilization`: fraction of memory vLLM may use (KV cache gets what is left after weights).
+- `--max-model-len`: maximum sequence length; lowering it does not shrink per-token KV but prevents one request from needing more cache than you can fit.
+
+## Takeaway
+Batching works because weights are shared across sequences; continuous batching works because it keeps the batch full. The KV cache, not compute, usually decides how full it can get.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/gpu-memory-for-70b.md

@@ -0,0 +1,53 @@
+# How much GPU memory do you need to serve a 70B model?
+
+Short answer for Llama 3.1 70B: about **141 GB for BF16 weights alone**, so plan on 2 x 80 GB GPUs as the bare minimum and 4 x 80 GB for comfortable serving. With FP8 it squeezes onto one 80 GB GPU for light traffic; with 4-bit it fits on one 80 GB GPU (or two 48 GB GPUs) with useful KV space. Here is the full calculation so you can redo it for any model.
+
+## Step 1: weights
+Llama 3.1 70B has 70.6B parameters.
+- BF16: 70.6B x 2 bytes = **141.2 GB** (131.5 GiB)
+- FP8/INT8: 70.6B x 1 = **70.6 GB** (65.8 GiB)
+- INT4: 70.6B x 0.5 = **35.3 GB**, plus a few percent for quantization scales
+
+## Step 2: KV cache per token
+From the model's config: 80 layers, 8 KV heads (grouped-query attention), head_dim 128.
+
+KV per token = 2 x 80 x 8 x 128 x 2 bytes = 327,680 bytes = **320 KiB** (BF16), or 160 KiB with an FP8 KV cache.
+
+Per sequence:
+- 4,096 tokens: 1.25 GiB
+- 8,192 tokens: 2.5 GiB
+- 32,768 tokens: 10 GiB
+- 128K tokens (the model's maximum, 131,072): 40 GiB
+
+## Step 3: overhead
+Engines reserve memory for activations, CUDA graphs, and the CUDA context. Budget roughly 1 to 3 GiB per GPU, and remember engines like vLLM only use a fraction you set (`--gpu-memory-utilization`, default 0.9).
+
+## Step 4: put it together
+Usable memory per 80 GB GPU at 0.9 utilization ~= 72 GB = 67 GiB, minus ~2 GiB overhead = ~65 GiB.
+
+| Setup | Usable | Weights | Left for KV | Tokens of KV (BF16) | 8K-token sequences |
+|---|---|---|---|---|---|
+| 1 x 80 GB, BF16 | 65 GiB | 131.5 GiB | does not fit | - | - |
+| 2 x 80 GB, BF16 | 130 GiB | 131.5 GiB | does not fit at 0.9 | - | - |
+| 2 x 80 GB, BF16, util 0.95 | ~138 GiB | 131.5 GiB | ~6 GiB | ~20K | ~2 |
+| 4 x 80 GB, BF16 | ~260 GiB | 131.5 GiB | ~129 GiB | ~420K | ~51 |
+| 1 x 80 GB, FP8 weights + FP8 KV | ~65 GiB | 65.8 GiB | does not fit at 0.9 | - | - |
+| 1 x 80 GB, INT4 weights | ~65 GiB | ~34 GiB | ~31 GiB | ~100K | ~12 |
+
+(Numbers from the formulas above; "8K-token sequences" = KV left / 2.5 GiB.) The FP8 row shows why "70B in FP8 fits on one H100" is only just true: you need to raise utilization close to 1.0 and keep context short. A 141 GB H200 holds FP8 70B comfortably (~50 GiB left for KV at 0.9 utilization).
+
+## Step 5: choose by workload
+- **Few users, short prompts, budget-limited:** INT4 on one 80 GB GPU.
+- **Production chat at moderate scale:** BF16 or FP8 with tensor parallelism across 4 GPUs, or FP8 on 2 GPUs.
+- **Long context (32K+) for many users:** KV dominates; use FP8 KV cache, more GPUs, and prefix caching.
+
+## Do it for any model
+Read `config.json` and use:
+- weights = params x bytes per param
+- KV/token = 2 x num_hidden_layers x num_key_value_heads x (hidden_size / num_attention_heads) x bytes
+- concurrent tokens = (usable memory - weights) / KV per token
+
+Our zero-dependency calculator does this for you: [kv_calc.py](https://github.com/inference-engineering-academy/inference-engineering-notes).
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/inference-engineer-roadmap.md

@@ -0,0 +1,47 @@
+# Inference engineer roadmap: skills, tools, and a 12-week plan
+
+"Inference engineer" is the person who makes a trained model cheap, fast, and reliable to serve. Training teams care about loss curves; inference teams care about time-to-first-token (TTFT), inter-token latency, throughput per GPU, and cost per million tokens. This roadmap lists what to learn, in what order, and a concrete 12-week plan.
+
+## The core skills
+
+**1. The math of a forward pass.** You should be able to estimate, without running anything, how many bytes and FLOPs a token costs. For a dense model, a forward pass costs roughly 2 x parameters FLOPs per token, and decode must read every weight once per step. That one fact explains most of serving performance.
+
+**2. Memory: weights plus KV cache.** Weights are params x bytes (Llama 3.1 8B in FP16: 8.03B x 2 = ~16 GB). The KV cache is 2 x layers x kv_heads x head_dim x bytes per token (Llama 3.1 8B: 2 x 32 x 8 x 128 x 2 = 128 KiB per token). Sizing a deployment is mostly these two numbers.
+
+**3. Prefill vs decode.** Prefill processes the whole prompt in parallel and is compute-bound. Decode generates one token per step per sequence and is memory-bandwidth-bound at small batch sizes. Batching, chunked prefill, and disaggregated serving all exist because of this split.
+
+**4. Batching and scheduling.** Continuous (iteration-level) batching, introduced by Orca (OSDI 2022), lets new requests join a running batch every step. PagedAttention (vLLM, SOSP 2023) stores the KV cache in fixed-size blocks so memory is not wasted on padding.
+
+**5. Quantization.** FP8, INT8, and 4-bit weight formats (AWQ, GPTQ) trade a little accuracy for less memory and bandwidth. Know which part is quantized (weights, activations, KV cache) and how to measure quality loss.
+
+**6. Engines.** vLLM, SGLang, and TensorRT-LLM are the main open serving engines; NVIDIA Dynamo and similar systems orchestrate across many GPUs. Be able to deploy one, read its metrics, and tune it.
+
+**7. GPU basics.** HBM bandwidth (H100 SXM: about 3.35 TB/s), tensor-core FLOPs, NVLink vs PCIe, and what tensor and pipeline parallelism cost in communication.
+
+**8. Measurement.** Benchmarks that report TTFT, inter-token latency, and throughput at a fixed latency target, with realistic prompt/output length distributions.
+
+## A 12-week plan (about 8 to 10 hours a week)
+
+| Week | Focus | Deliverable |
+|---|---|---|
+| 1 | Transformer forward pass, FLOPs and bytes per token | A one-page estimate sheet for an 8B model |
+| 2 | KV cache math, GQA vs MHA | A script that computes KV per token for any config.json |
+| 3 | Prefill vs decode, roofline model | Plot measured decode tok/s vs batch size |
+| 4 | Run vLLM locally or on a rented GPU | OpenAI-compatible endpoint serving an 8B model |
+| 5 | Continuous batching and PagedAttention | Load test with 1, 8, 32, 64 concurrent users |
+| 6 | Metrics: TTFT, ITL, throughput, goodput | A benchmark report with p50/p99 |
+| 7 | Quantization: FP8, AWQ/GPTQ INT4 | Compare memory, speed, and an eval score |
+| 8 | Prefix caching and SGLang | Measure TTFT with a shared system prompt |
+| 9 | Speculative decoding | Measure acceptance rate and speedup on your workload |
+| 10 | Multi-GPU: tensor parallelism | Serve a 70B model across 2 to 4 GPUs |
+| 11 | TensorRT-LLM or Dynamo, disaggregated prefill/decode | Compare against your vLLM baseline |
+| 12 | Capstone | A write-up: cost per million tokens for a defined SLA |
+
+## Tips
+
+- Always write the estimate before running the benchmark. If they disagree by more than 2x, find out why; that is where learning happens.
+- Rent GPUs by the hour instead of buying; one week of experiments on a single 80 GB card is enough for weeks 4 to 9.
+- Publish your benchmark reports. They double as a portfolio for inference roles.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/kv-cache-math.md

@@ -0,0 +1,68 @@
+---
+title: "KV cache math: why Llama 3.1 8B needs ~128 KB per token"
+tags: llm, inference, gpu, machinelearning
+---
+
+If you serve LLMs, the KV cache, not the weights, usually decides how many users fit on one GPU. The good news is that its size is easy to calculate from `config.json`, and the calculation explains a lot of serving behaviour.
+
+## What the KV cache stores
+
+In every attention layer, each token produces a key vector and a value vector. During decoding, a new token's query has to attend over the keys and values of all earlier tokens. Because of the causal mask those earlier K/V vectors never change, so engines compute them once and keep them in GPU memory. That stored state is the KV cache. Without it, every decode step would recompute the whole prefix.
+
+## The formula
+
+```
+bytes per token = 2 × num_layers × num_kv_heads × head_dim × bytes_per_element
+```
+
+- **2**: one key plus one value
+- **num_layers**: `num_hidden_layers`
+- **num_kv_heads**: `num_key_value_heads`. This is the number of *KV* heads, not query heads.
+- **head_dim**: `head_dim`, or `hidden_size / num_attention_heads` if the field is missing
+- **bytes_per_element**: 2 for BF16/FP16, 1 for FP8
+
+## Llama 3.1 8B, worked out
+
+From its config: 32 layers, 32 query heads, 8 KV heads (grouped-query attention), hidden size 4096, so head_dim = 4096 / 32 = 128. At BF16:
+
+```
+2 × 32 × 8 × 128 × 2 = 131,072 bytes = 128 KiB per token
+```
+
+Now scale it:
+
+| Workload | KV cache |
+|---|---|
+| 1 request × 8,192 tokens | 1 GiB |
+| 1 request × 131,072 tokens (full context) | 16 GiB |
+| 32 requests × 8,192 tokens | 32 GiB |
+
+The BF16 weights of the 8B model take about 16 GB (~15 GiB). **A single full-context request needs more memory for cache than the model needs for weights.** A model that "fits" on a 24 GB card can still go out of memory as soon as real traffic arrives.
+
+## The most common mistake: using query heads
+
+If you plug in 32 attention heads instead of 8 KV heads, you get 512 KiB per token, which is 4× too high. Grouped-query attention lets 4 query heads share each KV head, and that sharing is exactly why Llama 3 can offer long contexts. For Llama 3.1 70B (80 layers, 8 KV heads, head_dim 128) the same formula gives 320 KiB per token, about 40 GiB at full 128K context.
+
+## What this means when you serve
+
+1. **Concurrency budget.** Free memory after weights ÷ (bytes per token × average sequence length) ≈ how many requests you can hold at once. On an 80 GB GPU running the 8B model with roughly 60 GB left for cache, that's about 480K tokens in total: ~60 requests at 8K, but only 3 at full context.
+2. **FP8 KV cache halves it.** At 1 byte per element you get 64 KiB per token. Engines like vLLM and SGLang support this; check quality on your own workload.
+3. **Paging matters.** Engines that preallocate the maximum length waste most of this memory. PagedAttention (vLLM) and radix-tree caches (SGLang) allocate in blocks, so memory follows actual length.
+4. **Decode speed falls with context.** Every decode step reads the whole cache for that sequence, so long contexts cost bandwidth as well as capacity.
+
+## A quick calculator
+
+```python
+def kv_bytes_per_token(layers, kv_heads, head_dim, dtype_bytes=2):
+    return 2 * layers * kv_heads * head_dim * dtype_bytes
+
+per_tok = kv_bytes_per_token(32, 8, 128)       # Llama 3.1 8B
+print(per_tok / 1024, "KiB/token")              # 128.0
+print(per_tok * 131072 / 2**30, "GiB @ 128K")   # 16.0
+```
+
+Run this for any model before you choose a context length, a GPU, or `--max-num-seqs`.
+
+---
+
+*If you want to go deeper, the free Inference Engineering Foundations course at inference-engineering.xyz works through these numbers for Llama 3.1 8B with runnable NumPy code.*

articles/llm-inference-interview-questions.md

@@ -0,0 +1,44 @@
+# LLM inference interview questions with worked answers
+
+These questions come up in interviews for inference, ML infrastructure, and LLM platform roles. Each answer shows the reasoning, because interviewers care about the estimate more than the final number.
+
+### 1. How big is the KV cache per token for Llama 3.1 8B?
+Config: 32 layers, 8 KV heads (grouped-query attention), head_dim 128, FP16 (2 bytes).
+KV per token = 2 (K and V) x 32 x 8 x 128 x 2 = 131,072 bytes = **128 KiB**.
+An 8,192-token sequence therefore needs 128 KiB x 8,192 = 1 GiB.
+
+### 2. Why is decode memory-bound?
+At batch size 1, every generated token requires reading all weights from HBM. Llama 3.1 8B in FP16 is about 16 GB. On an H100 SXM (about 3.35 TB/s), the floor is 16 / 3,350 s = ~4.8 ms per token, so at most ~210 tokens/s, regardless of FLOPs. The compute needed (about 2 x 8B = 16 GFLOPs per token) takes well under 0.1 ms at the GPU's FP16 tensor throughput. Bandwidth, not compute, is the limit.
+
+### 3. Then why does batching help?
+The weights are read once per step and shared by every sequence in the batch. With 32 sequences, the same ~4.8 ms weight read produces 32 tokens. Throughput rises almost linearly until the KV-cache reads or compute become the bottleneck.
+
+### 4. What is the difference between static and continuous batching?
+Static batching waits until every sequence in the batch finishes, so short requests sit idle behind long ones. Continuous batching (Orca, OSDI 2022) schedules at each iteration: finished sequences leave and new ones join every step. This raises GPU utilization and lowers queueing delay.
+
+### 5. What does PagedAttention solve?
+Allocating a contiguous KV buffer for the maximum length wastes memory on sequences that end early. PagedAttention (vLLM) splits the KV cache into fixed-size blocks, like OS virtual memory pages, allocating on demand. The vLLM paper reports large reductions in KV-cache waste, which allows bigger batches.
+
+### 6. Can a 70B model run on one 80 GB GPU?
+In FP16: 70.6B x 2 bytes = 141 GB. No. In FP8: ~71 GB of weights leaves about 9 GB; after ~2 GB of runtime overhead that is ~7 GB of KV cache, or about 21,000 tokens at 320 KiB per token (7e9 / 327,680). Workable for low concurrency, but tight. In 4-bit: ~35 GB (plus some for scales), which fits with room for KV cache. In practice, FP16/BF16 70B is usually served with tensor parallelism on 2 to 4 GPUs (2 is very tight, 4 is comfortable).
+
+### 7. What is TTFT and what drives it?
+Time to first token = queueing time + prefill time (+ network). Prefill cost grows with prompt length, so long prompts and busy queues dominate. Prefix caching and chunked prefill help.
+
+### 8. When does speculative decoding help?
+When decode is memory-bound and the draft model's tokens are often accepted. If acceptance rate is a and you propose k tokens, the expected tokens per target step is (1 - a^(k+1)) / (1 - a) (Leviathan et al., 2023). With a = 0.8, k = 4: (1 - 0.328) / 0.2 = 3.36 tokens per step. At large batch sizes the GPU is already busy, so the gain shrinks or disappears.
+
+### 9. How does tensor parallelism affect latency?
+It splits each layer's matrices across GPUs, so each GPU reads fewer weight bytes per step, lowering per-token latency. It costs two all-reduces per layer, which is cheap over NVLink and expensive over PCIe.
+
+### 10. What would you measure in a serving benchmark?
+TTFT (p50/p99), inter-token latency (p50/p99), output tokens per second per GPU, and goodput: requests per second that meet the latency SLA. Use realistic input/output length distributions, not a single fixed length.
+
+### 11. GQA vs MHA: why does it matter for serving?
+Grouped-query attention shares each K/V head across several query heads. Llama 3.1 8B has 32 query heads but 8 KV heads, so its KV cache is 4x smaller than full multi-head attention would need. That means 4x more concurrent tokens in the same memory.
+
+### 12. What does quantizing the KV cache to FP8 buy you?
+It halves KV memory (128 KiB to 64 KiB per token for Llama 3.1 8B), so you fit about twice as many tokens in cache, which means larger batches or longer contexts. Check accuracy on long-context tasks, where errors can accumulate.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/prefill-vs-decode.md

@@ -0,0 +1,55 @@
+---
+title: "Prefill vs decode: why LLM inference is memory-bandwidth bound"
+tags: llm, inference, gpu, performance
+---
+
+Ask why an LLM streams its answer at a steady ~100 tokens/s even on a GPU rated for nearly a petaFLOP, and you end up at one idea: generation has two phases with very different bottlenecks.
+
+## Two phases
+
+**Prefill** runs the whole prompt through the model in one forward pass. Every prompt token is processed in parallel, so each layer does matrix × matrix multiplications. Prefill fills the KV cache and produces the first output token, so it drives **time to first token (TTFT)**.
+
+**Decode** then generates one token per step. Each step pushes a single new token (per sequence) through every layer and attends over the cached K/V. Decode drives **time per output token (TPOT)**, also called inter-token latency.
+
+## Arithmetic intensity
+
+A GPU is limited either by how fast it can compute (FLOP/s) or by how fast it can read memory (bytes/s). The ratio that decides which one applies is **arithmetic intensity**: FLOPs done per byte moved.
+
+An H100 SXM offers roughly 989 TFLOP/s of dense BF16 and about 3.35 TB/s of HBM bandwidth. The break-even point (the "ridge" of the roofline) is about 989e12 / 3.35e12 ≈ **295 FLOPs per byte**. Below that, the work is memory-bound.
+
+For a matrix multiply against a weight matrix, each BF16 weight (2 bytes) gets used for 2 FLOPs (multiply + add) per token in the batch:
+
+- **Decode, batch 1:** ~2 FLOPs per 2 bytes ≈ **1 FLOP/byte**, far below 295. The GPU spends most of its time waiting for weights to arrive from HBM.
+- **Prefill, 2,000-token prompt:** each weight is reused for 2,000 tokens, so ≈ **2,000 FLOPs/byte**, well above the ridge. That's compute-bound.
+
+## Back-of-envelope decode speed
+
+Llama 3.1 8B in BF16 is about 16 GB of weights. Every decode step has to read all of them at least once:
+
+```
+16 GB / 3.35 TB/s ≈ 4.8 ms per step  →  ≈ 200 tokens/s upper bound (batch 1)
+```
+
+Real numbers come in lower because of KV-cache reads, kernel overheads and imperfect bandwidth use. Notice that FLOPs never showed up in that estimate. **For single-stream decode, memory bandwidth sets the speed.**
+
+## Why batching is the main lever
+
+If 32 sequences decode together, the weights are read once per step and used 32 times. Intensity rises about 32×, so throughput rises almost linearly while per-step latency barely moves. That's why serving engines use **continuous batching**: they admit new requests into the running batch at every step instead of waiting for a whole batch to finish.
+
+There's a catch. Weights are shared across the batch, but **KV cache is not**: each sequence reads its own cache on every step. As batch size and context grow, cache reads take over and decode stays memory-bound. This is why KV-cache size (128 KiB/token for Llama 3.1 8B in BF16) matters for speed as well as capacity.
+
+## What follows from this
+
+- **Quantizing weights speeds up decode** because there are fewer bytes to read. INT4/FP8 weights help decode more than they help prefill.
+- **Speculative decoding** uses spare compute: a small draft model proposes several tokens and the big model checks them in one pass, which is more work per byte read.
+- **Chunked prefill** splits long prompts into pieces so a big prefill doesn't stall everyone else's decode steps.
+- **Prefill/decode disaggregation** (as in NVIDIA Dynamo, and supported by vLLM and SGLang) runs the two phases on separate GPU pools, because they want different hardware and different batch sizes.
+- **Measure TTFT and TPOT separately.** A change that helps one often hurts the other.
+
+## Summary
+
+Prefill is a big parallel matrix multiply and is compute-bound. Decode reads every weight and the whole KV cache to produce one token, so it is memory-bandwidth-bound. Almost every serving optimization (batching, quantization, paging, speculation, disaggregation) is a way of getting more useful tokens out of each byte read from memory.
+
+---
+
+*If you'd like to work through these numbers yourself, the free Inference Engineering Foundations course at inference-engineering.xyz covers prefill, decode and the KV cache with runnable code.*

articles/quantization-for-serving.md

@@ -0,0 +1,49 @@
+# Quantization for serving: FP8, INT8, INT4 tradeoffs
+
+Quantization stores numbers in fewer bits. For serving, it does two things: it shrinks memory (more room for KV cache, fewer GPUs) and it cuts the bytes read per decode step (faster tokens when memory-bound). The question is always what you are quantizing and what it costs in quality.
+
+## Three things you can quantize
+1. **Weights only** (W4A16, W8A16): weights stored in 4 or 8 bits, dequantized to 16-bit for the matmul. Saves memory and bandwidth; compute stays 16-bit. Examples: AWQ, GPTQ.
+2. **Weights and activations** (W8A8 in FP8 or INT8): matmuls run in 8-bit on tensor cores. Saves memory, bandwidth, and compute. Needs hardware support (FP8 tensor cores arrived with Hopper/Ada).
+3. **KV cache** (FP8 KV): halves KV memory, so more concurrent tokens fit.
+
+## The memory math (Llama 3.1 70B, 70.6B params)
+| Format | Bytes/param | Weights |
+|---|---|---|
+| BF16 | 2 | 141 GB |
+| FP8 / INT8 | 1 | 71 GB |
+| INT4 | 0.5 (+ scales) | ~35 GB + a few % for scales |
+
+So BF16 needs at least two 80 GB GPUs (and really four for useful KV space), FP8 just fits on one with little KV room, and INT4 fits on one with plenty of room.
+
+## Speed: what to expect
+At small batch sizes decode is bandwidth-bound, so halving weight bytes can approach ~2x faster decode in the ideal case, and 4-bit can approach ~4x vs 16-bit. Real gains are lower because of dequantization overhead, KV-cache reads, and kernels that are not perfectly efficient.
+
+At large batch sizes decode becomes more compute-bound. Weight-only INT4 then helps less, and can even be slower than FP8 because the dequantize step adds work. W8A8 FP8 keeps helping because the matmuls themselves get faster on FP8 tensor cores.
+
+Rule of thumb:
+- **Low concurrency, latency-sensitive, or memory-starved:** weight-only INT4 (AWQ/GPTQ).
+- **High throughput on Hopper or newer:** FP8 W8A8.
+- **Older GPUs without FP8 (A100):** INT8 W8A8 (SmoothQuant-style) or INT4 weight-only.
+
+## FP8 vs INT8
+Both use 8 bits. INT8 is a uniform grid; FP8 (E4M3 for inference) has an exponent, giving more resolution near zero and a wider dynamic range. LLM activations have outliers, so FP8 usually needs less calibration effort than INT8 for the same quality. Many teams report near-baseline quality for FP8 on large models, but always verify on your own evals.
+
+## Quality: how to check
+- Run task evals you care about (your own test set first, then standard benchmarks such as MMLU or GSM8K).
+- Check long-context and reasoning tasks separately; errors from quantized KV cache can accumulate over long sequences.
+- Compare outputs on real prompts side by side; perplexity alone can hide regressions.
+- Smaller models usually lose more quality from 4-bit than large ones.
+
+## KV-cache quantization
+For Llama 3.1 70B, KV per token is 2 x 80 layers x 8 KV heads x 128 x 2 bytes = 320 KiB in FP16, and 160 KiB in FP8. On a deployment with 40 GiB free for KV, that is about 131,000 tokens in FP16 vs about 262,000 in FP8, which roughly doubles how many long conversations you can serve at once.
+
+## Practical checklist
+1. Prefer a published, pre-quantized checkpoint from the model vendor or a trusted source.
+2. Confirm your engine and GPU support the format with fast kernels (otherwise it may be slower than BF16).
+3. Benchmark at your real concurrency, not just batch 1.
+4. Run evals before and after; set a quality budget in advance.
+5. Quantize the KV cache separately and test long contexts.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/speculative-decoding.md

@@ -0,0 +1,52 @@
+# Speculative decoding: when it helps and when it doesn't
+
+Speculative decoding speeds up generation without changing the output distribution. It works by guessing several tokens cheaply and verifying them all with one pass of the big model. It is not a free lunch, and knowing when it backfires matters as much as knowing how it works.
+
+## How it works
+1. A cheap **draft** proposes k tokens (a small model, extra heads like Medusa/EAGLE, or n-gram lookup from the prompt).
+2. The **target** model processes all k proposals in one forward pass, the same cost profile as a short prefill.
+3. Proposals are accepted left to right using a rejection-sampling rule (Leviathan et al., 2023; Chen et al., 2023) that guarantees the output follows the target model's distribution. At the first rejection, the target supplies a corrected token.
+
+So each target pass yields between 1 and k + 1 tokens.
+
+## Why it can be faster
+At small batch sizes, a decode step is memory-bandwidth-bound: the GPU spends its time reading weights, not computing. Verifying 5 tokens costs nearly the same as generating 1, because the weights are read once either way. If several are accepted, you get several tokens for about the price of one.
+
+## The expected speedup
+If each draft token is accepted with probability a (assumed independent), the expected tokens per target pass with k drafts is
+
+E = (1 - a^(k+1)) / (1 - a)
+
+| a | k = 2 | k = 4 | k = 8 |
+|---|---|---|---|
+| 0.5 | 1.75 | 1.94 | 2.00 |
+| 0.7 | 2.19 | 2.77 | 3.20 |
+| 0.8 | 2.44 | 3.36 | 4.33 |
+| 0.9 | 2.71 | 4.10 | 6.13 |
+
+Example: a = 0.8, k = 4 gives (1 - 0.8^5) / 0.2 = (1 - 0.328) / 0.2 = 3.36.
+
+Wall-clock speedup is lower than E, because each step also pays for the draft and for a verification pass that is slightly more expensive than a normal decode. If drafting costs c (relative to one target step) per draft token, a rough estimate is speedup = E / (1 + k x c + verification overhead).
+
+## When it helps
+- **Low concurrency, latency-sensitive traffic** (chat with few simultaneous users, coding assistants).
+- **Predictable text:** code, structured output, summaries and edits that copy from the prompt. N-gram/prompt-lookup drafting is very effective when outputs repeat input text.
+- **A well-matched draft:** same tokenizer, trained on similar data, or heads trained on the target (EAGLE-style), which raise a.
+
+## When it doesn't
+- **High batch sizes.** When the batch already fills the GPU, decode is closer to compute-bound and extra verification tokens are no longer nearly free. Many engines see speedups shrink toward zero, or become slowdowns, as concurrency rises.
+- **Low acceptance:** creative writing at high temperature, or a draft that disagrees often. With a = 0.5, you never exceed 2 tokens per pass regardless of k.
+- **Too large k:** gains saturate (see the table) while draft and verify costs keep growing.
+- **Memory-tight deployments:** a draft model needs its own weights and KV cache, taking room from the batch.
+
+## How to evaluate it
+1. Measure acceptance rate on real prompts, not benchmarks.
+2. Sweep k (2 to 6 is typical) and concurrency (1, 8, 32, 64).
+3. Report inter-token latency and throughput at each point. Expect a crossover concurrency where speculation stops paying off.
+4. Enable it only below that crossover, or use an engine that adapts automatically.
+
+## Takeaway
+Speculative decoding trades spare compute for fewer sequential steps. It shines when compute is idle (small batches) and drafts are accurate; it fades when the GPU is already busy.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/ttft-vs-tokens-per-second.md

@@ -0,0 +1,47 @@
+# Time-to-first-token vs tokens-per-second: what to measure
+
+"How fast is it?" has at least four different answers for an LLM server. Picking the wrong one leads to optimizing the wrong thing. Here are the metrics, what drives each, and how to measure them honestly.
+
+## The metrics
+**Time to first token (TTFT).** From request sent to first output token received. Equals network + queueing + prefill. This is what a chat user feels as "responsiveness".
+
+**Inter-token latency (ITL), also called time per output token (TPOT).** Average gap between output tokens after the first. This is the perceived streaming speed. 1 / ITL is the per-user tokens per second.
+
+**End-to-end latency.** TTFT + (output tokens - 1) x ITL. For a 500-token answer with TTFT 300 ms and ITL 25 ms: 0.3 + 499 x 0.025 = **12.8 s**.
+
+**Throughput.** Total output tokens per second across all users, usually per GPU. This is what drives cost.
+
+**Goodput.** Requests per second that meet your latency targets (for example TTFT p99 < 1 s and ITL p99 < 50 ms). The most useful single number for capacity planning, because throughput at unacceptable latency is worthless.
+
+## What drives each
+| Metric | Main drivers | Typical fixes |
+|---|---|---|
+| TTFT | prompt length, queue depth, prefill compute | prefix caching, chunked prefill, more replicas, disaggregated prefill |
+| ITL | weight bytes per step, batch size, KV reads | quantization, tensor parallelism, speculative decoding (small batches) |
+| Throughput | batch size, KV-cache capacity | continuous batching, FP8 KV cache, more memory |
+
+## The core tradeoff
+Bigger batches raise throughput but also raise ITL, because each step does more work. For a memory-bound decode on Llama 3.1 8B (BF16, ~16 GB of weights) on an H100 SXM (~3.35 TB/s), the weight read alone is ~4.8 ms per step. At batch 1 that is ~210 tok/s for one user. At batch 64 each step also reads 64 sequences' KV caches and does 64x the compute, so ITL might rise to, say, 15 to 25 ms (40 to 65 tok/s per user) while total throughput rises to thousands of tokens/s. The exact numbers depend on engine and context length; measure them.
+
+Similarly, admitting a long prompt helps throughput but its prefill can stall decodes, spiking ITL for everyone else. Chunked prefill exists to manage this.
+
+## Which metric for which product
+- **Chat UI:** TTFT p99 under ~1 s and ITL fast enough to exceed reading speed. Reading runs at a few tokens per second, so ~20+ tok/s per user (ITL under ~50 ms) usually feels fast.
+- **Agents and tool calls:** end-to-end latency, because nobody reads the stream; each step blocks the next.
+- **Batch/offline jobs (evals, synthetic data):** throughput and cost per million tokens only.
+- **Voice:** TTFT is critical; aim for a few hundred milliseconds.
+
+## How to measure honestly
+1. **Use realistic lengths.** Sample input/output lengths from production logs. A benchmark with 128-token prompts says little about a RAG app with 6,000-token prompts.
+2. **Measure at the client,** with streaming on, so you include tokenization, queueing, and network.
+3. **Report percentiles,** at least p50 and p99. Averages hide tail stalls.
+4. **Sweep load.** Plot ITL p99 and TTFT p99 against request rate; find the knee where they blow up. Your capacity is just below it.
+5. **Use an open-loop load generator** (requests arrive at a set rate, e.g. Poisson) rather than a fixed number of users who wait for replies, which hides queueing.
+6. **Fix the output length** with `ignore_eos` or `max_tokens` when comparing engines, so one model does not "win" by writing shorter answers.
+7. **Write down versions and flags.** Engines change fast.
+
+## Cost from throughput
+Cost per million output tokens = (GPU $/hour) / (tokens per second x 3,600) x 1,000,000. At $2.50/hour and 2,500 tok/s: 2.50 / 9,000,000 x 1,000,000 = **$0.28 per million tokens**, but only at the latency that throughput was measured at. Always state both.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

articles/vllm-vs-sglang-vs-tensorrt-llm.md

@@ -0,0 +1,59 @@
+# vLLM vs SGLang vs TensorRT-LLM: when to pick which
+
+All three are open-source LLM serving engines with continuous batching, tensor parallelism, quantization support, and OpenAI-compatible APIs. Their strengths differ, and all three ship new releases often, so treat this as a decision framework and benchmark on your own workload before committing.
+
+## vLLM
+**Origin:** UC Berkeley, now a large community project (Apache 2.0).
+**Signature idea:** PagedAttention, which stores the KV cache in fixed-size blocks to avoid fragmentation and enable large batches.
+**Strengths:**
+- Broadest model coverage; new open models usually get vLLM support quickly.
+- Runs on NVIDIA, AMD, and other accelerators.
+- Simple to start: `vllm serve <model>` gives an OpenAI-compatible server.
+- Prefix caching, chunked prefill, speculative decoding, LoRA serving, many quantization formats.
+
+**Pick it when:** you want the safest default, need to serve many different models, or need non-NVIDIA hardware.
+
+## SGLang
+**Origin:** LMSYS / UC Berkeley researchers (Apache 2.0).
+**Signature idea:** RadixAttention, which keeps KV cache for shared prefixes in a radix tree and reuses it automatically across requests. It also has a frontend language for structured, multi-call LLM programs.
+**Strengths:**
+- Excellent when many requests share prefixes: long system prompts, few-shot examples, multi-turn chat, agents, and tree-of-thought style branching.
+- Fast constrained decoding (JSON schemas, regex).
+- Strong performance on large mixture-of-experts models such as DeepSeek.
+
+**Pick it when:** your traffic has heavy prefix reuse (agents, RAG with fixed templates, chat), or you rely on structured output.
+
+## TensorRT-LLM
+**Origin:** NVIDIA (Apache 2.0).
+**Signature idea:** models built into optimized engines using NVIDIA's kernels, with in-flight batching, FP8 and FP4 paths on recent GPUs.
+**Strengths:**
+- Often the highest raw performance on NVIDIA hardware, especially with FP8 on Hopper and FP4 on Blackwell.
+- Tight integration with Triton Inference Server and NVIDIA Dynamo.
+
+**Costs:** NVIDIA-only; historically more setup (engine builds, version pinning), although newer releases have a PyTorch-based workflow that reduces this.
+
+**Pick it when:** you are all-in on NVIDIA, serving a small number of models at high volume, and the last 10 to 30% of efficiency is worth engineering time.
+
+## Decision table
+
+| Situation | First choice |
+|---|---|
+| Prototype, many models, mixed hardware | vLLM |
+| Agents, multi-turn chat, shared system prompts | SGLang |
+| One model, huge volume, NVIDIA only | TensorRT-LLM |
+| Structured JSON output at scale | SGLang (vLLM also supports it) |
+| AMD GPUs | vLLM or SGLang |
+
+## How to benchmark fairly
+1. Use the same model weights and precision in each engine (for example BF16, or the same FP8 checkpoint).
+2. Replay a realistic distribution of input and output lengths, ideally sampled from your logs.
+3. Sweep concurrency (1, 8, 32, 128) and report TTFT p50/p99, inter-token latency p50/p99, and output tokens/s.
+4. Compare at a fixed latency SLA ("max throughput with p99 ITL under 50 ms"), not at peak throughput alone.
+5. Enable each engine's equivalent features (prefix caching, CUDA graphs) or disable them all.
+6. Record versions. Results from six months ago are often out of date.
+
+## A common pattern
+Many teams start on vLLM, move prefix-heavy workloads to SGLang, and adopt TensorRT-LLM for their highest-volume model once the traffic shape is stable. Because all three expose an OpenAI-compatible API, switching is mostly an operations change, not an application rewrite.
+
+---
+*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*

calculator/README.md

@@ -0,0 +1,44 @@
+# kv_calc.py: KV-cache and GPU memory calculator
+
+A single-file Python script (no dependencies) that answers: *will this model fit, and how many concurrent requests can I serve?*
+
+## Formula
+```
+KV bytes per token = 2 (K and V) x layers x kv_heads x head_dim x bytes_per_element
+weights bytes      = params x bits / 8
+```
+Example, Llama 3.1 8B in FP16: 2 x 32 x 8 x 128 x 2 = 131,072 bytes = **128 KiB per token**, so an 8,192-token sequence holds 1 GiB of KV cache.
+
+## Built-in models (from each model's public `config.json`)
+| model | params | layers | kv_heads | head_dim | KV/token (FP16) |
+|---|---|---|---|---|---|
+| llama-3.1-8b | 8.03B | 32 | 8 | 128 | 128 KiB |
+| llama-3.1-70b | 70.6B | 80 | 8 | 128 | 320 KiB |
+| llama-3.1-405b | 405.9B | 126 | 8 | 128 | 504 KiB |
+| mistral-7b-v0.1 | 7.24B | 32 | 8 | 128 | 128 KiB |
+| qwen2.5-7b | 7.62B | 28 | 4 | 128 | 56 KiB |
+| qwen2.5-72b | 72.7B | 80 | 8 | 128 | 320 KiB |
+
+Any other model: pass `--params-b --layers --kv-heads --head-dim`.
+
+## Usage
+```
+python3 kv_calc.py --list
+python3 kv_calc.py --model llama-3.1-8b --ctx 8192 --batch 16 --gpu-gb 80
+python3 kv_calc.py --model llama-3.1-70b --tp 4 --ctx 8192 --batch 32
+python3 kv_calc.py --model llama-3.1-70b --wbits 4 --kvbits 8 --gpu-gb 80
+```
+Sample output (Llama 3.1 8B, one 80 GB GPU, 0.9 utilization):
+```
+KV cache per token : 128.0 KiB
+Weights            : 15.0 GiB (16-bit)
+Left for KV        : 50.1 GiB -> 410,404 tokens total
+Max concurrent seqs at 8192 ctx: 50
+```
+
+## Caveats
+- `--overhead-gib` (default 2 GiB per GPU) is a rough allowance for activations, CUDA graphs and context; real numbers depend on engine and settings.
+- GPU sizes are vendor GB (1e9 bytes); outputs are GiB (2^30).
+- Ignores sliding-window attention, MLA (DeepSeek) and prefix-cache sharing, which all reduce KV use.
+
+Learn the reasoning behind these numbers in the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/).

calculator/kv_calc.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""KV-cache and GPU memory calculator for LLM serving. No dependencies.
+Configs are taken from each model's public config.json on Hugging Face
+(num_hidden_layers, num_key_value_heads, head_dim = hidden_size / num_attention_heads).
+Usage:
+  python3 kv_calc.py --model llama-3.1-8b --ctx 8192 --batch 16 --wbits 16 --kvbits 16 --gpu-gb 80
+  python3 kv_calc.py --list
+"""
+import argparse
+
+# name: (params_billion, layers, kv_heads, head_dim)
+MODELS = {
+    "llama-3.1-8b":   (8.03, 32, 8, 128),
+    "llama-3.1-70b":  (70.6, 80, 8, 128),
+    "llama-3.1-405b": (405.9, 126, 8, 128),
+    "mistral-7b-v0.1": (7.24, 32, 8, 128),
+    "qwen2.5-7b":     (7.62, 28, 4, 128),
+    "qwen2.5-72b":    (72.7, 80, 8, 128),
+}
+GiB = 1024 ** 3
+
+def kv_bytes_per_token(layers, kv_heads, head_dim, kvbits):
+    # 2 tensors (K and V) per layer
+    return 2 * layers * kv_heads * head_dim * kvbits / 8
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--model", default="llama-3.1-8b")
+    p.add_argument("--layers", type=int); p.add_argument("--kv-heads", type=int)
+    p.add_argument("--head-dim", type=int); p.add_argument("--params-b", type=float)
+    p.add_argument("--ctx", type=int, default=8192, help="tokens per sequence (prompt+output)")
+    p.add_argument("--batch", type=int, default=1, help="concurrent sequences")
+    p.add_argument("--wbits", type=int, default=16, help="weight bits: 16, 8, 4")
+    p.add_argument("--kvbits", type=int, default=16, help="KV cache bits: 16 or 8")
+    p.add_argument("--gpu-gb", type=float, default=80, help="memory per GPU in GB (vendor GB = 1e9)")
+    p.add_argument("--tp", type=int, default=1, help="tensor-parallel GPUs")
+    p.add_argument("--util", type=float, default=0.9, help="fraction of memory usable (vLLM gpu_memory_utilization)")
+    p.add_argument("--overhead-gib", type=float, default=2.0, help="per-GPU activations/CUDA context guess")
+    p.add_argument("--list", action="store_true")
+    a = p.parse_args()
+    if a.list:
+        for k, v in MODELS.items():
+            print(f"{k:16s} params={v[0]}B layers={v[1]} kv_heads={v[2]} head_dim={v[3]}")
+        return
+    params, layers, kvh, hd = MODELS.get(a.model, (None,)*4)
+    params = a.params_b or params; layers = a.layers or layers
+    kvh = a.kv_heads or kvh; hd = a.head_dim or hd
+    if None in (params, layers, kvh, hd):
+        p.error("unknown model: pass --params-b --layers --kv-heads --head-dim")
+    per_tok = kv_bytes_per_token(layers, kvh, hd, a.kvbits)
+    weights = params * 1e9 * a.wbits / 8
+    kv_total = per_tok * a.ctx * a.batch
+    usable = a.gpu_gb * 1e9 * a.util * a.tp - a.overhead_gib * GiB * a.tp
+    free_for_kv = usable - weights
+    print(f"KV cache per token : {per_tok/1024:.1f} KiB")
+    print(f"KV per sequence    : {per_tok*a.ctx/GiB:.2f} GiB at {a.ctx} tokens")
+    print(f"KV for batch {a.batch:<5} : {kv_total/GiB:.2f} GiB")
+    print(f"Weights            : {weights/GiB:.1f} GiB ({a.wbits}-bit)")
+    print(f"Usable memory      : {usable/GiB:.1f} GiB across {a.tp} GPU(s)")
+    if free_for_kv <= 0:
+        print("Weights do not fit. Use more GPUs (--tp) or lower --wbits."); return
+    print(f"Left for KV        : {free_for_kv/GiB:.1f} GiB -> {int(free_for_kv/per_tok):,} tokens total")
+    print(f"Max concurrent seqs at {a.ctx} ctx: {int(free_for_kv/(per_tok*a.ctx))}")
+    print("FITS" if kv_total <= free_for_kv else "DOES NOT FIT at this batch/ctx")
+
+if __name__ == "__main__":
+    main()