Publish dataset (card cleaned, authored by Nathan Maine)

CORRECTION-NOTICE.md

@@ -0,0 +1,60 @@
+# Correction Notice — KV Cache Benchmark v3
+
+**Date:** 2026-04-01
+**Original publication:** 2026-03-31
+**Status:** Correcting methodology and findings
+
+---
+
+## What Changed
+
+### Finding 2 (Memory "Paradox") — RETRACTED
+
+**Original claim:** "q4_0 uses MORE memory than f16 on unified memory (+6%)"
+**Methodology used:** Process RSS via `ps`
+**Problem:** RSS measures CPU-side process memory, not GPU/unified memory allocations. On GB10 unified memory, KV cache allocations are not visible in RSS.
+
+**Corrected measurement (nvidia-smi + llama.cpp internals):**
+
+| Cache Type | KV Buffer (llama.cpp) | Total GPU (nvidia-smi) | vs f16 |
+|-----------|----------------------|----------------------|--------|
+| f16 | 768 MiB | 23,092 MiB | baseline |
+| q8_0 | 408 MiB | 22,732 MiB | **-360 MiB (saves 47%)** |
+| q4_0 | 216 MiB | 22,540 MiB | **-552 MiB (saves 72%)** |
+
+**Conclusion:** KV cache quantization DOES save memory on GB10, as expected. The "paradox" was a measurement error.
+
+### Finding 1 (Speed Cliff) — RETRACTED
+
+**Original claim:** "92.5% prompt throughput collapse at 64K with q4_0"
+**Corrected finding:** No prompt throughput cliff exists. q4_0 prompt processing is essentially identical to f16 at all context lengths including 110K tokens.
+
+**What actually happens:** Generation (decode) throughput degrades ~37% at 110K context with q4_0 vs f16. This is a real effect but it is generation speed, not prompt processing, and it is 37% not 92.5%.
+
+**Corrected throughput data (full range):**
+
+| Context | f16 prompt | q8_0 prompt | q4_0 prompt | f16 gen | q8_0 gen | q4_0 gen |
+|---------|-----------|-------------|-------------|---------|---------|---------|
+| ~1.5K | 923 | 925 | 926 | 45.2 | 45.3 | 45.6 |
+| ~6K | 1,211 | 1,207 | 1,206 | 44.7 | 44.9 | 45.0 |
+| ~12K | 1,188 | 1,184 | 1,191 | 44.9 | 42.9 | 42.7 |
+| ~24K | 1,153 | 1,149 | 1,152 | 44.6 | 39.7 | 39.3 |
+| **~110K** | **815** | **810** | **813** | **38.0** | **25.0** | **24.0** |
+
+The original 92.5% collapse was likely caused by failed completion requests returning error data, not actual throughput measurements.
+
+### Finding 3 (q8_0 Sweet Spot) — PARTIALLY VALID
+
+q8_0 does offer genuine KV buffer savings (47%) with minimal throughput impact at short-to-medium context. The generation speed degradation at 24K (~10%) needs further investigation at longer contexts.
+
+---
+
+## Root Cause of Original Errors
+
+1. **RSS is the wrong metric** for KV cache on unified memory. RSS reflects CPU-side process allocations, not GPU-side unified memory usage.
+2. **nvidia-smi + llama.cpp verbose output** provide the correct measurements.
+3. **The original benchmark did not verify that completions actually succeeded** — some data points may have been from failed requests.
+
+## Credit
+
+Community feedback from u/audioen on r/LocalLLaMA identified the RSS measurement flaw. Their critique was correct.

README.md

@@ -0,0 +1,148 @@
+---
+language:
+  - en
+license: apache-2.0
+tags:
+  - kv-cache
+  - quantization
+  - llama.cpp
+  - nvidia
+  - dgx-spark
+  - gb10
+  - benchmarking
+  - inference
+pretty_name: DGX Spark GB10 KV Cache Quantization Benchmark
+size_categories:
+  - n<1K
+task_categories:
+  - other
+---
+
+# KV Cache Quantization on NVIDIA DGX Spark GB10
+
+> **Corrected benchmarks** (v3, April 2026) — KV cache quantization behavior on the NVIDIA DGX Spark's GB10 Grace Blackwell unified memory architecture.
+
+**Author:** Nathan Maine
+**Date:** March 2026, corrected April 2026
+**Hardware:** NVIDIA DGX Spark (GB10, compute 12.1, 128GB unified memory)
+
+> **Correction Notice:** The original v1 benchmarks (March 31) contained methodology errors. Memory was measured via RSS (wrong on unified memory) and some throughput data came from failed requests. v3 uses nvidia-smi + llama.cpp internal reporting. See [CORRECTION-NOTICE.md](CORRECTION-NOTICE.md) for full details. Credit to u/audioen on r/LocalLLaMA for identifying the RSS measurement flaw.
+
+---
+
+## TL;DR
+
+KV cache quantization on DGX Spark GB10 works as expected:
+
+- **q4_0 saves 72% KV buffer memory** (216 MiB vs 768 MiB for f16)
+- **q8_0 saves 47% KV buffer memory** (408 MiB vs 768 MiB for f16)
+- **Prompt throughput is unaffected** by cache quantization at all context lengths
+- **Generation throughput degrades ~37%** at 110K context with q4_0 (24 tps vs 38 tps for f16)
+
+---
+
+## Memory (Corrected — nvidia-smi + llama.cpp internals)
+
+| Cache Type | KV Buffer (llama.cpp) | Total GPU (nvidia-smi) | Savings vs f16 |
+|-----------|----------------------|----------------------|---------------|
+| **f16** | 768 MiB | 23,092 MiB | baseline |
+| **q8_0** | 408 MiB | 22,732 MiB | **-360 MiB (-47% KV)** |
+| **q4_0** | 216 MiB | 22,540 MiB | **-552 MiB (-72% KV)** |
+
+At 110K context:
+
+| Cache Type | GPU Memory | vs f16 |
+|-----------|-----------|--------|
+| f16 | 23,116 MiB | baseline |
+| q8_0 | 22,856 MiB | -260 MiB |
+| q4_0 | 22,664 MiB | -452 MiB |
+
+---
+
+## Throughput
+
+### Prompt Processing (tokens/sec) — No degradation
+
+| Context | f16 | q8_0 | q4_0 |
+|---------|-----|------|------|
+| ~1.5K | 923 | 925 | 926 |
+| ~6K | 1,211 | 1,207 | 1,206 |
+| ~12K | 1,188 | 1,184 | 1,191 |
+| ~24K | 1,153 | 1,149 | 1,152 |
+| **~110K** | **815** | **810** | **813** |
+
+Prompt throughput is essentially identical across all cache types at all context lengths.
+
+### Generation (tokens/sec) — Degrades at long context
+
+| Context | f16 | q8_0 | q4_0 | q4_0 vs f16 |
+|---------|-----|------|------|------------|
+| ~1.5K | 45.2 | 45.3 | 45.6 | +0.9% |
+| ~6K | 44.7 | 44.9 | 45.0 | +0.7% |
+| ~12K | 44.9 | 42.9 | 42.7 | -4.9% |
+| ~24K | 44.6 | 39.7 | 39.3 | -11.9% |
+| **~110K** | **38.0** | **25.0** | **24.0** | **-36.8%** |
+
+Generation (decode) throughput degrades with quantized KV cache at long context. At 110K tokens, q4_0 is 37% slower than f16 for generation. q8_0 is similar at 34% slower.
+
+---
+
+## Test Setup
+
+```
+Model:     Nemotron-3-Nano-30B-A3B-UD-Q4_K_XL.gguf
+Hardware:  NVIDIA DGX Spark GB10 (compute 12.1, 124,610 MiB VRAM)
+OS:        DGX OS / Ubuntu aarch64
+llama.cpp: build 8399 (commit 892e3c333), aarch64 + CUDA
+CUDA:      13.0 | Driver: 580.126.09
+Flags:     --ctx-size 131072
+Protocol:  Server restarted between each configuration
+Memory:    nvidia-smi --query-compute-apps for GPU memory
+KV size:   llama.cpp verbose output (llama_kv_cache line)
+Throughput: llama.cpp response timings via /v1/chat/completions
+```
+
+---
+
+## What Was Wrong in v1
+
+The original paper (March 31) made two incorrect claims:
+
+1. **"92.5% prompt throughput collapse at 64K"** — Wrong. Prompt throughput is unaffected by cache quantization. The original data likely came from failed completion requests. The actual effect is a 37% generation speed reduction at 110K context.
+
+2. **"q4_0 uses MORE memory than f16"** — Wrong. This was measured via process RSS, which does not capture GPU/unified memory allocations on GB10. Actual measurement via nvidia-smi + llama.cpp shows q4_0 saves 552 MiB as expected.
+
+See [CORRECTION-NOTICE.md](CORRECTION-NOTICE.md) for full methodology comparison.
+
+---
+
+## Actual Finding: Generation Decode Overhead
+
+The real finding is more nuanced: **KV cache quantization saves memory as expected, but imposes a generation speed tax at long context.** At 110K tokens, q4_0 generation is 37% slower than f16 (24 vs 38 tps). This is likely due to dequantization overhead during the decode attention step, which processes the full KV cache for each generated token.
+
+Prompt processing is unaffected because it processes all tokens in parallel — the dequantization cost is amortized across the batch.
+
+This tradeoff may be acceptable depending on the use case:
+- **Long-context RAG** (mostly prompt, few generated tokens): use q4_0, save memory
+- **Long-form generation at long context**: use f16, preserve decode speed
+
+---
+
+## Raw Data
+
+- [`data/benchmark_results_v3_complete.csv`](data/benchmark_results_v3_complete.csv) — corrected v3 data
+- [`data/benchmark_results.csv`](data/benchmark_results.csv) — original v1 data (flawed, kept for reference)
+
+---
+
+## Citation
+
+```bibtex
+@techreport{maine2026kvcache,
+  title  = {KV Cache Quantization on NVIDIA DGX Spark GB10},
+  author = {Maine, Nathan},
+  year   = {2026},
+  note   = {Corrected April 2026},
+  url    = {https://huggingface.co/datasets/Nathan-Maine/dgx-spark-kv-cache-benchmark}
+}
+```

data/benchmark_results.csv

@@ -0,0 +1,14 @@
+context_tokens,cache_type,prompt_tps,gen_tps,rss_gb,notes
+3500,q8_0,30.5,14.2,,quick initial test
+8192,f16,371.3,14.7,1.25,
+8192,q8_0,,,1.34,speed not measured at this context
+8192,q4_0,363.4,14.2,1.34,
+16384,f16,360.7,13.9,1.40,
+16384,q8_0,,,1.49,speed not measured at this context
+16384,q4_0,346.2,12.7,1.49,
+32768,f16,328.3,13.5,1.59,
+32768,q8_0,,,1.69,speed not measured at this context
+32768,q4_0,316.9,11.0,1.69,
+65536,f16,282.7,13.3,1.94,
+65536,q4_0,21.3,8.6,2.06,CLIFF — 92.5% prompt tps collapse
+114688,q4_0,21.3,8.6,,f16 not testable at this context size

data/benchmark_results_v3_complete.csv

@@ -0,0 +1,19 @@
+context_tokens,cache_type,kv_buffer_mib,gpu_mem_mib,prompt_tps,gen_tps,notes
+0,f16,768,23092,,,"KV buffer from llama.cpp verbose, baseline GPU from nvidia-smi"
+1493,f16,768,23114,923.2,45.2,
+5916,f16,768,23116,1210.8,44.7,
+11814,f16,768,23116,1187.8,44.9,
+23610,f16,768,23116,1153.4,44.6,
+110019,f16,768,23116,815.0,38.0,64K+ context
+0,q8_0,408,22732,,,"47% smaller KV buffer vs f16"
+1493,q8_0,408,22754,925.1,45.3,
+5916,q8_0,408,22756,1206.7,44.9,
+11814,q8_0,408,22762,1183.9,42.9,
+23610,q8_0,408,22774,1149.1,39.7,
+110019,q8_0,408,22856,810.2,25.0,64K+ context — gen speed degraded 34%
+0,q4_0,216,22540,,,"72% smaller KV buffer vs f16"
+1493,q4_0,216,22562,925.7,45.6,
+5916,q4_0,216,22564,1205.8,45.0,
+11814,q4_0,216,22570,1191.2,42.7,
+23610,q4_0,216,22582,1151.9,39.3,
+110019,q4_0,216,22664,812.6,24.0,64K+ context — gen speed degraded 37%

results/cache_type_compatibility.md

@@ -0,0 +1,23 @@
+# Cache Type Compatibility on DGX Spark GB10
+
+## Supported Types (from --help, llama.cpp build 8399, aarch64+CUDA)
+
+```
+--cache-type-k: f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1
+--cache-type-v: f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1
+Default: f16 for both K and V
+```
+
+## Test Results
+
+| Format | Loads | Long-ctx safe | Memory benefit | Recommended |
+|--------|-------|--------------|----------------|-------------|
+| f16 | ✅ | ✅ | Baseline | ✅ Default |
+| q8_0 | ✅ | ✅ | None (paradox) | ✅ Long context |
+| q4_0 | ✅ | ❌ cliff at 64K | Negative (+6%) | ❌ Avoid |
+| q4_1 | untested | unknown | unknown | — |
+| iq4_nl | untested | unknown | unknown | — |
+| q5_0 | untested | unknown | unknown | — |
+| q5_1 | untested | unknown | unknown | — |
+| bf16 | untested | unknown | unknown | — |
+| f32 | untested | unknown | unknown | — |