File size: 5,764 Bytes
4bba228 8e571da 4bba228 8e571da 4bba228 | 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 | ---
license: apache-2.0
task_categories:
- other
tags:
- benchmark
- inference
- cold-start
- llm-serving
- mlops
- systems
size_categories:
- n<1K
configs:
- config_name: default
data_files: observations.csv
---
# LLM Container Cold-Start Benchmark
Measurements of how long it takes to bring a language model from cold storage to
a state where it can serve its first token, across **25 open-weight
models** spanning **17 architecture families** and
**100.9 GiB** of checkpoints, on a single NVIDIA T4.
Cold start is the latency a serverless or scale-to-zero inference platform pays
when it has no warm replica. It decomposes into weight transfer from storage,
deserialization into host memory, transfer to the accelerator, and engine
bring-up. This dataset measures each phase separately rather than reporting one
aggregate number, because the dominant term shifts with model size and setup --
and optimising the wrong term buys nothing.
## Headline finding: cold start is superlinear in checkpoint size
Fitting `load_ms = a x GiB^b` gives **b = 1.58 to 2.10** across conditions, where b = 1 would mean constant throughput. **Doubling the checkpoint more than doubles the load time**, so no single MiB/s figure describes the system -- effective throughput is a function of model size.
Concretely, throughput holds near **1535 MiB/s** below **5.18 GiB** and falls to **758 MiB/s** above it -- a **2.02x** collapse.
Throughput in the healthy regime: **1354 MiB/s (R2=0.868)**.
The most likely cause is **host memory, not the storage device**: the runtime
had roughly 12-13 GiB of usable system RAM, and the memory-mapped load path
depends on the OS page cache holding the checkpoint while tensors are
materialised. This is stated as a hypothesis with an obvious test attached
(re-run on a high-RAM instance and see whether the boundary moves), not as a
settled conclusion.
**Why it matters:** a cold-start budget extrapolated from small models will be
optimistic for large ones, and the gap widens with size. Below the boundary,
storage bandwidth is the lever; above it, more storage bandwidth does not help,
because the bottleneck has moved.
## Other results
- **safetensors vs legacy pickle:** median **1.71x** faster to
load over 20 models with identical weights. The format costs no
model quality and no hardware to change.
- **Storage tier:** a bandwidth-capped tier is roughly an order of magnitude
slower than local NVMe on the same checkpoints.
- **Engine bring-up** is a comparable cost to weight transfer at these sizes,
which is precisely the distinction that determines whether snapshot/restore
techniques would pay off for a given deployment.
## Files
| File | Contents |
|---|---|
| `observations.csv` | One row per (model, experiment, condition), joined to checkpoint size, parameter count, shard count and family. |
| `raw/runs.json` | The raw merged ledger, unmodified, so all statistics can be recomputed from source. |
| `cross_model_report.md` | The generated analysis: scaling fits, per-model tables, projections, noise profile, limitations. |
## Columns
`model_key`, `repo_id`, `family`, `tier`, `params_b`, `checkpoint_gib`,
`n_shards`, `bytes_per_param`, `experiment`, `condition`, `p50_ms`, `p95_ms`,
`stdev_ms`, `rsd`, `n_trials`, `throughput_mib_s`, `gpu`, `device_class`,
`reliable`.
`reliable` is `False` where relative standard deviation is 30% or more. Those
rows are published rather than dropped -- a reader may reasonably pick a
different threshold -- but no conclusion above rests on them.
## Method
- Each condition is repeated, warm-up runs are discarded, and **p50/p95** are
reported rather than a mean, because tail latency is what a scale-to-zero SLA
is written against.
- The OS page cache is evicted between trials (`posix_fadvise(DONTNEED)` on an
unprivileged runtime), so reads are genuinely cold rather than served from RAM.
- Runs were distributed across several Colab sessions coordinated through a
shared Postgres ledger with atomic claims and epoch fencing, so no task was
ever executed twice. Duplicate execution would not merely waste time -- two
workers would contend for the same disk and corrupt the I/O measurement.
- Registry metadata (checkpoint sizes, shard counts, gating) was read from the
Hugging Face API rather than estimated.
## Limitations
- **Free-tier hardware.** A single consumer GPU with shared, contended host I/O.
The *ratios* and the *scaling behaviour* transfer; the absolute milliseconds
are not production numbers.
- **Noise.** Median RSD is around 15%, with a long tail concentrated in engine
bring-up where JIT compilation varies run to run. Small effects here are not
findings.
- **Not measured:** driver-level checkpoint/restore (proprietary GPU memory
snapshotting), multi-GPU tensor-parallel loading, and real network-attached
storage -- the remote tier is a software bandwidth cap, which bounds the
penalty from below rather than reproducing it.
- **Coverage gaps** are listed at the top of the report.
## Reproducing
- **Code:** https://github.com/priyansh-saxena1/coldstart-lab
```bash
pip install -e ".[distributed,plots]"
coldstart-fleet init --tier small --device-class t4
coldstart-fleet work --device cuda --device-class t4
coldstart-fleet merge --out ./merged
```
## Citation
```bibtex
@misc{coldstart_bench_2026,
title = {LLM Container Cold-Start Benchmark},
year = {2026},
note = {Dataset: https://huggingface.co/datasets/ArchCoder/llm-cold-start-benchmark}
}
```
## License
Apache-2.0. Measurements only; no model weights are redistributed.
|