speed-bench — Long-Context Inference Benchmarking Toolkit

A reproducible benchmark package for cold prefill and decode speed on the llama.cpp /v1/chat/completions endpoint. It includes the benchmark scripts, fixed prompt datasets, and measured results.

Contents

bench.py                     Benchmark runner (fixed-length sweep / dataset replay)
report.py                    Combine results/*.json into a standard report (see below)
prompts/prompt_<L>.txt       Fixed prompt datasets: 1024 / 4096 / 65536 / 131072 tokens
datasets/                    Real-world benchmark dataset: 2 families x 3 tiers x 10 = 60 samples
  all_samples.jsonl          All 60 samples
  code_samples.jsonl         30 code samples
  general_qa_samples.jsonl   30 general QA samples
  1k_samples.jsonl           20 samples in the 1K tier
results/bench_53_211.json    Raw measured results (complete per-request timings)
config.json                  Full deployment details (quantization, n_ctx, sampling parameters, server fingerprint)

Usage

python bench.py http://HOST:PORT MODEL results/out.json \
       --lengths 1024,4096,65536,131072 --runs 2

The benchmark uses only the Python standard library (transformers is required for --rebuild-prompts). It processes lengths in the order given by --lengths, runs each tier --runs times, and writes the results to JSON after every run so an interruption does not lose completed data.

Metric definitions

Use these settings when reproducing the measurements:

Item	Setting	Reason
Rate source	Server-reported timings (prompt_per_second / predicted_per_second)	Client timing includes network and queueing overhead
cache_prompt	false	A cache hit makes prefill appear close to zero and produces misleading results
temperature	0	Reduces decode-side variation
max_tokens	256	Keeps the setting consistent across tiers for comparable decode rates
Reasoning mode	enable_thinking: false + reasoning_effort: low	Otherwise reasoning can consume the output and make decode lengths incomparable
Streaming	stream: true + stream_options.include_usage	Required to collect TTFT and usage

TTFT is measured by the client as the time until the first SSE event containing content. All other metrics are reported by the server.

Report format

python report.py results/bench_32_165_1k.json results/bench_32_165_4k.json ... --out report.md

The report contains one row for each (Dataset × Context) pair. Values are averaged across all samples in that tier. Failed requests are excluded from the averages and counted separately (--out writes the Markdown report to disk).

Dataset	Context	Input Tokens	Output Tokens	Prefill (tok/s)	TTFT (s)	Decode (tok/s)	E2E Latency (s)
code	1k	1039	246	431.6	2.65	16.5	17.35
code	4k	3847	243	460.4	9.06	15.0	24.94
general_qa	1k	1039	221	463.2	2.59	16.4	15.79
general_qa	4k	3978	243	496.4	8.31	15.0	24.22

Dataset mode: datasets/

The benchmark uses real-world text as input, which better represents practical workloads than synthetic repeated text. The dataset contains 2 families × 3 tiers × 10 samples = 60 samples:

File	Contents
all_samples.jsonl	All 60 samples, each with a task_family field
code_samples.jsonl	30 code samples (HumanEval tasks with CrossCodeEval code blocks as context)
general_qa_samples.jsonl	30 long-document QA and summarization samples from LongBench-Pro

File	Family	1k	4k	64k	128k
all_samples.jsonl / family-specific files	code	—	10	10	10
	general_qa	—	10	10	10
1k_samples.jsonl	code	10	—	—	—
	general_qa	10	—	—	—

The 1K tier is an additional tier derived in advance from the paired 4K tasks. Only the context between the anchor points is trimmed; the <CURRENT_TASK> block and the original question remain unchanged. As a result, the tokenizer field is local-o200k (openai/gpt-oss-120b), while the original 60 samples use server-tokenizer. The construction field in both sets documents their origin.

Fields in each record:

• messages — A chat payload that can be sent directly; the benchmark uses it as-is rather than rebuilding it.
• expected_prompt_tokens — The expected prompt token count calibrated with the tokenizer of the measured server (4k → 4096, 64k → 65536/65535, 128k → 114687/114688). prompt_tokens_delta in the results is the measured value minus this expectation and checks that the requested tier was sent correctly.
• template_overhead — 52 tokens for the chat template, already included above.
• target_tokens / scale / task_family / source_dataset / source_id
• canonical_solution (code) / answer (QA) — Reference answers for spot checks only; they do not affect benchmarking.

The target for the 128K tier is 114,688 tokens (112 × 1024), not the commonly cited 131072. Do not mix the two values.

# Run the full 4K tier with four concurrent requests
python bench.py http://HOST:PORT default results/out.json \
  --dataset datasets/all_samples.jsonl --scale 4k --concurrency 4

# Run only the code family, limited to five samples
python bench.py http://HOST:PORT default results/out.json \
  --dataset datasets/code_samples.jsonl --limit 5

Each result JSON record includes id / task_family / scale / target_tokens / expected_prompt_tokens. After the run, the benchmark prints an aggregate table by tier with mean prefill tok/s, decode tok/s, TTFT, total time, and error count.

Prompt datasets

Each prompts/prompt_<L>.txt file repeats the FILLER paragraphs until the target token count and then appends the same question. The files are calibrated with the o200k-harmony vocabulary used by the measured llama.cpp service for the gpt-oss model family:

File	Target	Actual tokens	Characters
prompt_1024.txt	1024	977	5,087
prompt_4096.txt	4096	4,057	21,159
prompt_65536.txt	65536	65,437	341,451
prompt_131072.txt	130,816 (leaving room for 256 output tokens)	130,667	681,833

The token counts in the table are for the plain text under the o200k vocabulary. The server-reported prompt_tokens also includes chat-template overhead (about 60–70 tokens for the Harmony template), so values such as 1044 and 4100 in the results are expected.

Why use fixed files: If every user builds the prompt locally with a different tokenizer, “64K” does not represent the same input across services and the measured rates are not comparable. Sending the fixed files ensures that everyone sends identical text.

Using a different vocabulary family: The actual token count may shift by a few percent (for example, another vocabulary may count the same 64K prompt as 68K). If needed, run python bench.py --rebuild-prompts <hf-tokenizer-id-or-local-path> to regenerate the files and state the tokenizer used in the report.

Relation to results/: results/bench_53_211.json was measured with prompts calibrated using the server tokenizer. Compared with the files shipped in this package, its token counts differ by about 0.1% (for example, 65,504 vs. 65,437). To align them exactly, rerun the benchmark after the server is available and overwrite the corresponding files in results/.