krisdcosta/edge-llm-bench

Edge LLM Bench — GGUF Quantization Benchmarks on Edge Devices

Controlled inference benchmark dataset for 7 GGUF K-quant quantization variants (Q2_K through Q8_0) of Llama 3.2 3B Instruct and Qwen 2.5 1.5B Instruct across three hardware platforms:

Device	SoC / CPU	RAM	Backend
Google Pixel 6a	Google Tensor G1 (ARM Cortex-X1)	6 GB LPDDR5	llama.cpp CPU
Apple M4 Mac	Apple M4 (ARM, 10-core)	16 GB unified	llama.cpp Metal
HP Pavilion x86	Intel Core i5-1235U (12th gen)	16 GB DDR4	llama.cpp CPU

4,407 total records across 5 splits. All inference records are non-warmup, success-status runs collected under controlled thermal conditions. Contaminated and failed records are archived separately and not included here.

---

Key Findings (from the accompanying paper)

• Non-monotonic throughput on ARM: Q2_K is ~99% faster than Q6_K on Pixel 6a (ctx=256 cliff_sweep filled-context, n=10) despite having less than half the bits per weight — contradicting GPU-derived assumptions. Q4_K_M and Q5_K_M cliff-sweep ctx=256 baselines are affected by a thermal warmup burst; use standard_sweep values for those two variants.
• KV-cache collapse threshold: Q2_K suffers a −48% throughput cliff beyond ~512 tokens on Pixel 6a (ARM); Q3_K_M is cliff-attenuated (≤11%, not fully immune); x86 cliff predicted at ctx≈1,280 tokens via L2-cache formula, observed at 1,300–1,400 (within 8%)
• Non-monotonic quality: Q4_K_S outperforms Q8_0 on BoolQ (74% vs 68%) despite fewer bits — superblock K-quant structure allocates precision more effectively than naive int8; Q6_K is Pareto-dominated (slower AND less accurate than Q4_K_M)
• imatrix calibration hurts low-bitwidth models: imatrix degrades Q2_K by −4pp and Q3_K_M by −7pp on BoolQ; modest improvement for Q6_K (+4pp). Do not use imatrix for variants below Q4_K_S
• Cross-device consistency: Non-monotonic CPU throughput ordering (Q2_K fastest, Q6_K slowest) confirmed on both ARM NEON and x86 AVX2; ordering reverses on Metal GPU where Q4_K_S/Q4_K_M are fastest and Q8_0 is slowest

---

Splits

pixel_inference — 2,875 rows

Pixel 6a (ARM, CPU backend) inference runs.

Column	Type	Description
device	string	"Pixel6a"
backend	string	"CPU"
model	string	Model name
variant	string	GGUF quantization variant (Q2_K … Q8_0)
context_len	int	Prompt context window in tokens
trial	int	Trial index within the experiment
threads	int	CPU thread count (null = default 4)
decode_tps	float	Decode throughput (tokens/second)
prefill_tps	float	Prefill throughput (tokens/second)
ttft_s	float	Time to first token (seconds) — populated for standard_sweep only
e2e_s	float	End-to-end latency (seconds) — populated for standard_sweep only
n_output_tokens	int	Number of generated tokens
experiment_type	string	cliff_sweep | standard_sweep | thread_sweep | kv_cache_quant
kv_quant	string	KV cache quantization type (null = default, "q8_0" = quantized)
ngl	int	GPU layers (null for CPU runs)
ts	string	ISO-8601 timestamp
source_file	string	Originating filename

experiment_type values:

• cliff_sweep — context length varied to characterise KV-cache collapse (canonical n=10)
• standard_sweep — fixed 4 context windows (256/512/1024/2048), 13 trials, 2 warmup
• thread_sweep — Q4_K_M at threads=1/2/4/8, ctx=256, 15 trials
• kv_cache_quant — KV cache set to q8_0 to test collapse mitigation

---

m4_inference — 1,021 rows

Apple M4 Mac inference runs. Contains two backend configurations:

• Metal GPU (931 rows) — backend = "Metal", ngl = 99. Includes Llama 3.2 3B and Qwen 2.5 1.5B. Cliff sweep covers ctx=1024–2048 (13 points, n=5 trials). Results: flat profile on Metal (all variants within ±9%), confirming no KV-cache cliff on GPU-accelerated inference.
• CPU (90 rows) — backend = "CPU", ngl = 0, threads = 4. Llama 3.2 3B only.
  • Cliff sweep (88 rows): ctx=256–2048 (13 points, pre-aggregated n_trials=5 per ctx). Collected 2026-04-09. 3 outlier points excluded (Q5_K_M ctx=2048 OOM, Q6_K ctx=1536 CV=81%, Q8_0 ctx=2048 CV=99%). Results: significant context-dependent degradation on M4 CPU (Q2_K −13%, Q3_K_M −54%, Q4_K_S −53%, Q6_K −60% from ctx=256→2048). Note: ctx=256 cliff baseline may be inflated by CPU boost state at start of each variant's sweep.
  • TPS sweep (7 rows, experiment_type = "standard_sweep", context_len = 0): pure decode reference (n_prompt=0, n_gen=128, n=10 trials, 2026-04-06). Thermally settled baseline. Throughput ordering: Q4_K_S (13.16) > Q8_0 (12.60) > Q4_K_M (12.51) > Q2_K (12.31)

    Q3_K_M (11.48) > Q5_K_M (10.59) > Q6_K (9.29) tok/s. Non-monotonic: Metal reversal (Q4_K_S fastest) confirmed on M4 CPU as well; Q6_K remains slowest.

Same columns as pixel_inference.

---

x86_inference — 399 rows

Intel Core i5-1235U (x86, AVX2, CPU backend), Windows 11. Contains three experiment types:

• standard_sweep — Llama 3.2 3B (7 rows) — one reference run per variant at ctx=256, 6 threads
• standard_sweep — Qwen 2.5 1.5B (7 rows) — one reference run per variant at ctx=256, 6 threads; cross-model validation that non-monotonic CPU throughput ordering (Q2_K fastest, Q6_K slowest) holds on x86
• cliff_sweep (385 rows) — n=5 trials per variant across 11 context lengths (256–2,048) using filled-context methodology (Llama 3.2 3B only); collected 2026-04-08 to characterise the x86 KV-cache cliff

The cliff sweep enables x86 KV-cache collapse characterisation. Predicted cliff at ctx≈1,280 tokens (from L2-cache formula); observed at 1,300–1,400 tokens (within 8%).

Same columns as pixel_inference. backend = "CPU", threads = 6.

Note: x86 cliff sweep and quality evaluation cover Llama 3.2 3B only. Qwen 2.5 1.5B on x86 is limited to standard_sweep (ctx=256 decode reference). No Qwen cliff or quality data for x86.

---

quality_benchmarks — 105 rows

Accuracy scores on 6 NLP benchmarks for 7 quantization variants on Pixel 6a.

Column	Type	Description
benchmark	string	arc_challenge | arc_easy | boolq | hellaswag | mmlu | truthfulqa | custom_qa
variant	string	GGUF quantization variant
device	string	"Pixel6a"
model	string	Model name
calibration	string	"standard" or "imatrix" (importance-weighted)
accuracy_pct	float	Accuracy percentage (0–100)
correct	int	Correct answers
total	int	Total questions evaluated
status	string	"success" for all included rows

Benchmark sample sizes: 100 questions each (random sample from official test sets). BoolQ imatrix calibration covers all 7 variants. TruthfulQA imatrix data collected for Q2_K and Q3_K_M only.

---

perplexity — 7 rows

WikiText-2 perplexity scores for Llama 3.2 3B Instruct on Pixel 6a.

Column	Type	Description
variant	string	GGUF quantization variant
model	string	Model name
device	string	"Pixel6a"
perplexity	float	WikiText-2 perplexity (lower = better); null if not evaluated
perplexity_status	string	"success" or "not_evaluated"
corpus	string	"wikitext2_full" (285K tokens) or "wikitext2_sample" (12K tokens)
tokens_approx	int	Approximate token count used
note	string	Reason if not_evaluated

Important: Q2_K and Q3_K_M were evaluated on the full WikiText-2 corpus; Q4_K_M, Q6_K, Q8_0 on a 12K-token sample. Do not directly compare perplexity values across these two groups without accounting for corpus size effects. Q4_K_S and Q5_K_M were added after the initial sweep and are marked not_evaluated.

---

How to Load

from datasets import load_dataset

# Pixel 6a inference runs
pixel = load_dataset("KrisDcosta/edge-llm-bench", "pixel_inference", split="train")

# M4 Mac inference runs
m4 = load_dataset("KrisDcosta/edge-llm-bench", "m4_inference", split="train")

# Quality benchmarks
quality = load_dataset("KrisDcosta/edge-llm-bench", "quality_benchmarks", split="train")

# Perplexity scores
ppl = load_dataset("KrisDcosta/edge-llm-bench", "perplexity", split="train")

Quick analysis examples

import pandas as pd
from datasets import load_dataset

# Load as pandas
df = load_dataset("KrisDcosta/edge-llm-bench", "pixel_inference", split="train").to_pandas()

# Mean decode TPS per variant on Pixel 6a (cliff sweep only)
cliff = df[df["experiment_type"] == "cliff_sweep"]
print(cliff.groupby("variant")["decode_tps"].mean().sort_values(ascending=False))

# KV-cache collapse: TPS at ctx=512 vs ctx=2048
stable = cliff[cliff["context_len"].isin([512, 2048])]
print(stable.groupby(["variant", "context_len"])["decode_tps"].mean().unstack())

# Thread count impact on Q4_K_M
threads = df[df["experiment_type"] == "thread_sweep"]
print(threads.groupby("threads")["decode_tps"].agg(["mean", "std"]))

---

Methodology

Hardware setup:

• Pixel 6a benchmarks run via ADB with llama.cpp NDK cross-compiled for arm64-v8a
• Device placed on flat surface, screen off, no active charging during runs
• Each experiment preceded by 2 warmup trials (excluded from dataset)
• 1-minute cooldown between variant changes; 30s between context window changes

Thermal controls:

• Benchmarks aborted if device temperature > 42°C (re-run after cooldown)
• Temperature logged per trial where accessible via /sys/class/thermal/
• Measurement noise reduced from ±8% to ±2% through thermal discipline

Prompts:

• Context windows filled with repeating document content to target token count
• Output capped at 64 tokens (cliff sweep) or 128 tokens (standard sweep)
• 3 fixed prompts rotated across trials (standard sweep)

M4 Mac:

• llama.cpp Metal backend, ngl=99 (all layers on GPU)
• Run via llama-bench CLI wrapper with same context/output targets

x86:

• llama.cpp CPU, AVX2 enabled, 6 threads, Windows 11
• Reference run: 1 trial per variant at ctx=256 (collected March 2026)
• Cliff sweep: n=5 trials per variant × 11 context sizes (256–2,048), filled-context methodology, 140s inter-trial cooldown (collected April 2026)

Quality evaluation:

• 100-question samples from official benchmark test sets
• Exact-match scoring with normalised output parsing
• imatrix calibration data generated from 512-token WikiText-2 passages

---

Known Limitations

1. Pixel 6a primary focus — x86 and M4 coverage is less comprehensive than Pixel; x86 has n=5 trials for cliff sweep but no thread sweep, no kv_cache_quant experiments
2. x86 Qwen limited to standard_sweep — Qwen 2.5 1.5B on x86 provides decode TPS reference at ctx=256 only; no cliff sweep, thread sweep, or quality data for Qwen on x86
3. Perplexity corpus inconsistency — see note in perplexity split above
4. No power/energy data — /proc interfaces on Pixel 6a are unreliable without root; battery drain proxy metrics were collected but not included in this release
5. Single model family for quality benchmarks — quality data (BoolQ, HellaSwag, etc.) collected on Pixel 6a only; no cross-device quality comparison
6. llama.cpp version — builds used llama.cpp circa February–April 2026; results may differ with significantly newer versions

---

Variants Reference

Variant	Bits/Weight	File Size	Notes
Q2_K	2.6	~1.3 GB	Fastest on ARM; lowest quality
Q3_K_M	3.3	~1.6 GB	Cliff-immune on ARM; stable across all tested contexts
Q4_K_S	4.1	~1.8 GB	Good compression; imatrix gains significant
Q4_K_M	4.5	~1.9 GB	Pareto-optimal on ARM (speed × quality)
Q5_K_M	5.5	~2.2 GB	Best imatrix gains
Q6_K	6.6	~2.5 GB	Slowest on ARM; susceptible to collapse
Q8_0	8.0	~3.2 GB	Near-FP16 quality; stable at long context

Model: meta-llama/Llama-3.2-3B-Instruct quantized with llama.cpp llama-quantize. imatrix calibration data generated from WikiText-2 using llama-imatrix.

---

Citation

If you use this dataset, please cite the accompanying paper:

@misc{dcosta2026gguf,
  title   = {Non-Monotonic Quantization on Mobile ARM: KV-Cache Collapse and
             Superblock Dynamics in GGUF Inference},
  author  = {Dcosta, Kris},
  year    = {2026},
  note    = {Preprint. Dataset: https://huggingface.co/datasets/KrisDcosta/edge-llm-bench}
}

---

License

Dataset: CC BY 4.0 Benchmark code: Apache 2.0

Benchmark datasets used for quality evaluation (ARC, BoolQ, HellaSwag, MMLU, TruthfulQA) are subject to their respective licenses. This dataset contains only model accuracy scores, not the benchmark questions themselves.