ArchCoder/llm-cold-start-benchmark

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

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

@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.