Scherm-AI/onprem-llm-benchmark

Scherm On-Premise LLM Inference Benchmark — v0.8

Throughput, latency and resource benchmarks for on-premise LLM inference across a wide range of GPUs — datacenter (B200, L40S), Blackwell workstation (RTX PRO 6000), consumer (RTX 4090/4070), unified-memory (DGX Spark / GB10) and legacy/AMD — covering the full stack of a production assistant: chat serving, embeddings, reranking, vision, OCR and speech-to-text.

Engine: vLLM (mostly the NGC 26.03 image, engine v0.17.1; Blackwell needs it for sm_120/121 kernels). Each measurement is taken on a fully dedicated GPU (--exclusive), inference only (server already warm — no model load/download counted).

→ See REPRODUCING.md to reproduce every experiment on your own hardware. Raw per-experiment CSVs live under raw/<machine>/; consolidated tables under data/.

🚀 Run it on your own Slurm cluster (NVIDIA or AMD)

Self-contained jobs in scripts/portable-slurm/ recreate everything from scratch — they download the runners straight from this repo, no setup of ours required. Four flavors (nvidia_container · nvidia_venv · amd_container · amd_venv); AMD/ROCm covers Frontier/ORNL.

# preview every job that would be submitted (nothing runs):
DRY_RUN=1 SBATCH_SCRIPT=amd_container.sbatch PARTITION=batch bash scripts/portable-slurm/run_all.sh
# then submit all benchmarks (all models × all tasks) with one chosen sbatch:
SBATCH_SCRIPT=amd_container.sbatch PARTITION=batch ACCOUNT=<projid> \
  SCRATCH=/lustre/orion/<projid>/scratch/$USER bash scripts/portable-slurm/run_all.sh

See scripts/portable-slurm/README.md for which flavor to pick and what to adapt to your cluster.

---

🏆 Ranking de GPU por modelo (pico de throughput, tok/s)

AWQ = 4-bit quantizado; BF16 = precisão cheia. A maioria das GPUs roda AWQ (cabe mais); a RTX PRO 6000 (96GB) roda ambos — a comparação AWQ×BF16 aparece onde há as duas.

output_len importa — e muito. O comprimento da saída muda o throughput em ~3-4×: o tempo do servidor é dominado pela fase de decode, então gerar 256 tokens/requisição rende muito mais tok/s agregado que gerar 128. Por isso só se compara tok/s entre o mesmo output_len. Detalhes na nota metodológica abaixo. Tudo agora vem de data/serving_ALL.csv, com a coluna output_len correta lida do env de cada shard (reconstrução v0.8).

Cada tabela abaixo é output_len=256 — o regime em que rodou a grande maioria das GPUs (B200, L40S, RTX 4090/4070, GB10). A RTX PRO 6000 tem os dois regimes; onde há a linha out-128 dela, ela vai numa tabela out-128 própria logo em seguida, nunca misturada com os números out-256. O #/@conc é a concorrência do pico. Números da B200 são multi-GPU (tensor-parallel); a coluna TP diz quantas GPUs — para comparação single-GPU justa com a RTX, veja a linha B200 TP1.

Qwen2.5-7B (chat) — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	17470	1024	4
—	NVIDIA B200 (single-GPU)	AWQ	7292	1024	1
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	6154	256	1
3	NVIDIA L40S	AWQ	3504	64	1
4	NVIDIA L40S (Grace ARM)	AWQ	3121	128	1
5	NVIDIA RTX 4090	AWQ	2710	128	1
6	NVIDIA GB10 (DGX Spark)	AWQ	1291	64	1
7	NVIDIA RTX 4070	AWQ	1085	64	1

Qwen2.5-14B (chat) — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	8758	512	4
—	NVIDIA B200 (single-GPU)	AWQ	3567	512	1
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	2830	256	1
3	NVIDIA L40S	AWQ	1660	64	1
4	NVIDIA L40S (Grace ARM)	AWQ	1469	128	1
5	NVIDIA RTX 4090	AWQ	984	32	1
6	NVIDIA GB10 (DGX Spark)	AWQ	422	32	1

Qwen2.5-32B (chat) — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	5089	512	4
—	NVIDIA B200 (single-GPU)	AWQ	1381	64	1
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	1301	256	1
3	NVIDIA L40S	AWQ	852	64	1
4	NVIDIA L40S (Grace ARM)	AWQ	516	32	1
5	NVIDIA RTX 4090	AWQ	392	16	1
6	NVIDIA GB10 (DGX Spark)	AWQ	297	64	1

Single-GPU justo (32B-AWQ, out-256): a RTX PRO 6000 (1301 @conc=256) fica praticamente empatada com uma B200 (TP1: 1381 @conc=64) — e a 1×B200 custa ~4,5× a RTX. O 5089 da B200 é com 4 GPUs (TP4). Num ponto de operação com concorrência casada (conc=128), a RTX ainda sobe a ~1262 tok/s contra ~1152 da B200 TP1 no mesmo conc — ou seja, no single-GPU a RTX chega a passar uma B200 na faixa de produção. A B200 só abre vantagem quando você paga por várias GPUs.

Qwen2.5-72B (≥80GB) — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	2672	512	4
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	609	128	1

Qwen2.5-Coder-7B — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	13832	256	4
—	NVIDIA B200 (single-GPU)	AWQ	5884	512	1
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	6177	256	1
3	NVIDIA L40S	AWQ	3491	64	1
4	NVIDIA L40S (Grace ARM)	AWQ	3172	128	1
5	NVIDIA RTX 4090	AWQ	2023	128	1
6	NVIDIA GB10 (DGX Spark)	AWQ	1172	64	1
7	NVIDIA RTX 4070	AWQ	857	64	1

Qwen2.5-Coder-14B — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	7040	512	4
—	NVIDIA B200 (single-GPU)	AWQ	2882	512	1
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	2833	256	1
3	NVIDIA L40S	AWQ	1646	64	1
4	NVIDIA L40S (Grace ARM)	AWQ	1502	128	1
5	NVIDIA RTX 4090	AWQ	990	64	1
6	NVIDIA GB10 (DGX Spark)	AWQ	554	64	1

Qwen2.5-Coder-32B — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	AWQ	4577	512	4
2	NVIDIA RTX PRO 6000 Blackwell	AWQ	1298	256	1
3	NVIDIA L40S	AWQ	867	64	1
4	NVIDIA RTX 4090	AWQ	379	16	1
5	NVIDIA GB10 (DGX Spark)	AWQ	299	64	1

RTX PRO 6000 — regime output_len=128 (⚠️ não comparar com as tabelas out-256 acima)

Estas linhas da RTX PRO 6000 rodaram com saída de 128 tokens (o lote antigo). Ficam isoladas porque um out-128 rende ~3-4× menos tok/s que out-256 e misturá-las falsearia o ranking.

modelo	quant	tok/s	@conc
Qwen2.5-Coder-7B	AWQ	5273	128
Qwen2.5-7B	AWQ	5251	128
Qwen2.5-Coder-7B	BF16	3708	128
Qwen2.5-7B	BF16	3674	128
Llama-Guard-3-8B	—	3165	128
Qwen2.5-Coder-14B	AWQ	1850	128
Qwen2.5-14B	AWQ	1845	128
Qwen2.5-14B	BF16	1746	128
Mixtral-8x7B	AWQ	1737	128
Qwen2.5-32B	BF16	812	128
Qwen2.5-Coder-32B	AWQ	811	128
Qwen2.5-32B	AWQ	809	128
Llama-3.3-70B	AWQ	391	128
Qwen2.5-72B	AWQ	378	128

Llama-Guard-3-8B (guardrail) — output_len=256

#	GPU	quant	tok/s	@conc	TP
1	NVIDIA B200	BF16	5010	32	1
2	NVIDIA L40S (Grace ARM)	BF16	2096	128	1

Llama-3.3-70B e Mixtral-8x7B só têm medição na RTX PRO 6000 (regime out-128) — ficam na tabela out-128 acima. A linha BF16 out-128 da Llama-Guard (5258) também.

---

🔬 Nota metodológica: output_len e comparação justa

Throughput de serving é medido pela mediana de output_tok_s (coluna output_tok_s_median em data/serving_ALL.csv), pegando o pico entre as concorrências varridas. Três pontos que mudam a leitura das tabelas:

1. output_len domina o número. O tempo de uma requisição é todo decode (gerar token a token). Dobrar a saída (128 → 256) não dobra o custo por token, mas enche muito melhor o batch contínuo do vLLM — o tok/s agregado sobe **3-4×**. Logo, tok/s de out-128 e out-256 não são a mesma métrica e nunca devem ir na mesma tabela/ranking.
2. O dataset tem os dois regimes. Na v0.8 o output_len de cada shard foi relido do env real do experimento (antes o workflow hardcodava 128 em linhas que eram 256 — erro corrigido). Resultado verificado:
   • B200 — todos os shards de serving: output_len=256.
   • GPPD (L40S, RTX 4090, RTX 4070, P100…) — todos: 256.
   • GB10 / DGX Spark — 256 (config legada confirmada).
   • RTX PRO 6000 — mista: 38 shards 128 (lote antigo) + 7 shards novos 256 (*_out256_*). É a única GPU com os dois — por isso aparece nas tabelas out-256 e numa tabela out-128 separada.
3. Comparações só entre o mesmo output_len. As tabelas de ranking acima são todas out-256, que é o regime da maioria das GPUs, dando a comparação justa B200 × RTX × L40S × 4090 × Spark. A comparação-chave RTX × B200 em 32B-AWQ é out-256 vs out-256 (RTX ~1301 / conc=256, ~1262 / conc=128, contra B200 TP1 ~1381 — single-GPU, casado). Os números out-128 da RTX (32B-AWQ ~809) ficam isolados e não entram em nenhuma comparação cross-GPU nem no custo-benefício. Um shard legado de config divergente (num-prompts C×3, que dava ~1735 no 32B-AWQ) foi descartado por não ser reprodutível com a metodologia padrão.

q3 vs mediana: as tabelas de serving, OCR, STT e vision usam mediana. Só embeddings e reranking (próxima seção) reportam o q3 (3º quartil) do pico — leia como teto sustentado sob carga favorável, não como mediana.

---

🧩 Stack do assistente além do chat

Embeddings e reranking reportam o q3 (3º quartil) da vazão de pico entre as amostras, não a mediana — leia como o teto sustentado sob carga favorável. As demais tabelas usam mediana.

Embeddings — BAAI/bge-m3 (embeddings/s, pico)

#	GPU	emb/s
1	NVIDIA RTX PRO 6000 Blackwell	1706
2	NVIDIA L40S (Grace ARM)	729
3	NVIDIA RTX 4090	727
4	NVIDIA L40S	685
5	NVIDIA RTX 4070	291
6	NVIDIA RTX 2080 Ti	61
7	NVIDIA GB10 (DGX Spark)	59
8	NVIDIA GTX 1080 Ti	27
9	AMD RX 7900 XT	11

Reranking — BAAI/bge-reranker-v2-m3 (pairs/s, pico)

#	GPU	pairs/s
1	NVIDIA RTX PRO 6000 Blackwell	6407
2	NVIDIA RTX 4090	4000
3	NVIDIA L40S (Grace ARM)	3681
4	NVIDIA RTX 4070	2132

Speech-to-text — whisper-large-v3 (faster-whisper, audio-seconds/s, pico)

#	GPU	audio_s/s
1	NVIDIA RTX PRO 6000 Blackwell	449
2	NVIDIA RTX 4090	343
3	NVIDIA RTX 4070	182

STT roda só em GPUs x86 — o L40S aqui é Grace (ARM/aarch64), onde CTranslate2/faster-whisper não compila. RTF medido < 0,02 (transcreve muito mais rápido que tempo real).

Vision — Qwen2.5-VL-7B-Instruct (tok/s, pico)

#	GPU	tok/s
1	NVIDIA RTX 4090	2264
2	NVIDIA L40S (Grace ARM)	2067
3	NVIDIA RTX PRO 6000 Blackwell	1404
4	NVIDIA L40S	1171

---

📄 OCR de documentos — latência por página (doc 1 página)

Extração de documentos com modelos de visão (vLLM). Página A4 jurídica típica.

Modelo	GPU	ms/página	tok/s	nota
DeepSeek-OCR (3B)	RTX PRO 6000	320	512	🥇 OCR-direto, ~11× mais rápido que NuMarkdown
DeepSeek-OCR-2 (3B)	RTX PRO 6000	394	413	quase igual
Qwen2.5-VL-7B	RTX 4090	1148	56	VLM genérico
NuMarkdown-8B-Thinking	RTX PRO 6000	3554	101	thinking model (gera raciocínio/página)
NuMarkdown-8B-Thinking	RTX 4090	5520	57	—

DeepSeek-OCR vs NuMarkdown: na RTX PRO 6000, o DeepSeek-OCR (3B) é ~11× mais rápido (320 vs 3554 ms/página). O NuMarkdown é um thinking model de 8B (Qwen2.5-VL por baixo) que gera centenas de tokens de raciocínio por página antes do markdown; o DeepSeek-OCR é 3B otimizado pra OCR direto. Para extração em volume, DeepSeek-OCR é o caminho. (Acurácia CER/WER pendente de ground-truth — o texto extraído de cada modelo está salvo para comparação.)

NuMarkdown-8B em todas as GPUs (baseline cross-GPU, doc 1 página)

Dados consolidados em data/ocr_pages_ALL.csv; brutos em raw/.

GPU	VRAM	ms/pág	tok/s	doc 50 págs (total)
B200	180GB	2133	152	167s (~3min) 🥇
RTX PRO 6000	96GB	3554	101	555s (~9min)
RTX 4090	24GB	5520	57	428s (~7min) 🥉 melhor custo
L40S	48GB	6424	49	518s (~9min)
DGX Spark (GB10)	128GB	25617	13	1981s (~33min) 🐌 memory-bound

Sizing pro OCR: banda de memória > VRAM total. B200 (HBM3e) faz OCR a 152 tok/s — 12× a Spark. A RTX 4090 (consumer) é ~4,5× mais rápida que a DGX Spark no decode do thinking-model. OCR pesado nunca deve rodar na Spark. GPUs Pascal/Turing e a RTX 4070 (12GB, OOM) não rodam OCR-8B.

---

💰 Custo-benefício — tok/s por US$1.000 (Qwen2.5-32B AWQ, output_len=256, single-GPU)

Todos os números aqui são mesma métrica agora: pico da mediana de tok/s em output_len=256, por GPU (a B200 usa a linha TP1, single-GPU, para custo-benefício justo — não os 5089 de 4 GPUs). Nada de valores da config legada C×3 descartada (o antigo 1735 da RTX não entra aqui).

GPU	preço aprox.	tok/s (out-256, 1 GPU)	tok/s por US$1k
RTX PRO 6000 Blackwell	$9.000	1301	145 🥇
RTX 4090	$3.549	392	110
L40S	$8.300	852	103
B200 (1 GPU)	~$40.000	1381	35
DGX Spark (GB10)	$4.699	297	63

Com a métrica agora comparável (mesmo output_len, mesmo nº de GPUs), o quadro muda em relação a versões anteriores: no single-GPU 32B-AWQ, a RTX PRO 6000 lidera o tok/s por dólar — entrega ~1301 tok/s (praticamente igual à 1381 de uma B200) por ~1/4,5 do preço. A RTX 4090 segue como a opção consumer de melhor razão em modelos que cabem em 24GB, mas não roda 32B-AWQ com o mesmo headroom. A B200 só faz sentido econômico quando você escala em várias GPUs (TP2/TP4): aí o throughput absoluto (5089 tok/s em 4 GPUs) e a densidade por rack compensam — é uma máquina de concorrência agregada, não de custo por token single-GPU. A RTX PRO 6000 continua sendo a única single-GPU que roda 32B-AWQ com folga em 96GB (contexto longo, concorrência alta) e a única que sobe até 72B.

---

🗺️ Matriz de cobertura — o que rodou em cada GPU

GPU	serving	embed	rerank	stt	vision	ocr
B200	✅	—	—	—	—	✅
RTX PRO 6000 Blackwell	✅	✅	✅	✅	✅	✅
L40S	✅	✅	✅	⛔ARM	✅	✅
RTX 4090	✅	✅	✅	✅	✅	✅
RTX 4070	✅	✅	✅	✅	⛔12GB	⛔12GB
GB10 (DGX Spark)	✅	✅	—	—	—	✅
RTX 2080 Ti / 1080 Ti / P100	ollama	✅	⛔	⛔	⛔	⛔
AMD RX 7900 XT	ollama	✅	⛔ROCm	⛔ROCm	⛔ROCm	⛔ROCm

Tetos físicos (não são lacunas, são limites de hardware):

• AMD RX 7900 XT — vLLM-ROCm só faz serving de texto; pooling (rerank), vision e CTranslate2-STT não têm caminho ROCm.
• L40S (Grace) — aarch64; faster-whisper/CTranslate2 não compila → sem STT.
• GPUs pré-2020 (P100, 1080Ti, 2080Ti) — sem vLLM moderno; só ollama (serving) + embeddings.
• RTX 4070 (12GB) — não cabe modelos de visão/OCR de 7-8B (OOM).

---

📁 Estrutura do repositório

data/        *_ALL.csv consolidados (schema único, 1 linha por ponto medido)
raw/         CSV bruto por experimento, por máquina (gppd/ b200/ spark/ rtx-6000/)
scripts/     runners + jobs por plataforma (runners/ gppd-slurm/ b200-apptainer/ rtx-docker/ spark-ollama/)
REPRODUCING.md  passo-a-passo para reproduzir em cada hardware

⚠️ Nota sobre engines

A maioria dos resultados usa a imagem NGC vLLM (26.03, engine v0.17.1) para uniformidade e suporte Blackwell. Alguns runs antigos usaram vLLM v0.11.0; DeepSeek-OCR usa a imagem oficial vllm/vllm-openai (a NGC não traz torchaudio, dependência da inspeção da arquitetura). Para comparação justa entre GPUs, prefira linhas com o mesmo engine — e, no serving, o mesmo output_len (ver nota metodológica).

O serving das GPUs pré-2020 (P100, 1080 Ti, 2080 Ti) e da AMD RX 7900 XT é via ollama (não vLLM), consolidado à parte em data/ollama_ALL.csv com schema próprio (tok/s agregado e por-stream). Não é comparável 1:1 com as tabelas vLLM acima — engine, batching e métrica diferem.

---

📜 Changelog

v0.8

• Reconstrução do serving_ALL.csv com output_len correto. O comprimento de saída de cada shard passou a ser lido do env real do experimento, corrigindo o bug em que o workflow anterior hardcodava output_len=128 em linhas que na verdade eram 256. Agora cada ponto carrega o regime certo na coluna output_len.
• Rankings de serving separados por output_len. Todas as tabelas de throughput passaram a ser output_len=256 (regime da maioria das GPUs); a RTX PRO 6000, que tem os dois regimes, ganhou uma tabela output_len=128 isolada. Fim da mistura que inflava/deflacionava comparações.
• RTX PRO 6000 output_len=256. Adicionados os 7 shards novos *_out256_*, habilitando a comparação justa B200 × RTX em out-256 (ex.: 32B-AWQ RTX ~1301 vs B200 TP1 ~1381, single-GPU).
• Custo-benefício recalculado com métrica comparável (mesmo output_len, single-GPU / B200 TP1). Descartado o shard legado de config divergente (num-prompts C×3, ~1735 no 32B-AWQ) por não reproduzir com a metodologia padrão.
• Saneamento do ollama. Serving das GPUs legadas/AMD isolado em ollama_ALL.csv, deixando claro que não é comparável com as tabelas vLLM.
• Correção de nomes de GPU duplicados/inconsistentes (variantes com underscore vs. espaço) unificadas na consolidação.
• Nova nota metodológica explicando o efeito ~3-4× do output_len e a regra de só comparar dentro do mesmo regime; declaração explícita de q3 vs mediana por tabela.

Dados brutos consolidados — um arquivo por workload

Consolidam 100% de raw/: os 282 JSON e também os 60 CSV que não têm JSON par (rodadas em que apenas o agregado foi gravado). Cobertura verificada: 342 de 342 arquivos.

Ficam em data/raw/, separados dos CSV agregados de análise que estão na raiz de data/:

Arquivo	Linhas	Colunas	Conteúdo
data/raw/full_raw_serving.csv	5.818	65	5.610 medições individuais (uma linha por repetição) + 208 agregadas
data/raw/raw_ocr.csv	316	70	latência por documento (304) e acurácia CER (12)
data/raw/raw_ollama.csv	440	72	serving via ollama, só agregados
data/raw/raw_stt.csv	128	63	transcrição de áudio, só agregados
data/raw/raw_embed.csv	88	61	embeddings, só agregados
data/raw/raw_vision.csv	64	59	multimodal, só agregados
data/raw/raw_rerank.csv	53	58	reranking, só agregados
data/raw/full_raw.csv	6.907	210	tudo numa tabela só — a soma exata dos acima

Cada arquivo traz o conjunto completo de metadados descrito abaixo; separar por workload apenas remove as colunas que aquele experimento não usa (o consolidado tem 210 colunas porque reúne schemas distintos; os individuais ficam entre 58 e 72). Todos têm 1 linha física = 1 registro, sem quebras de linha embutidas, então funcionam também com awk, split e afins.

A coluna metric_family identifica o tipo de experimento de cada linha (serving_per_rep, serving_aggregate, doc_latency, accuracy_cer, audio_latency, embedding, rerank, vision). Ela existe porque um mesmo workload pode reunir experimentos com métricas disjuntas: em raw_ocr.csv, por exemplo, as 12 linhas de accuracy_cer preenchem cer_* e deixam doc_pages vazio, e as 304 de doc_latency fazem o inverso. Coluna vazia ali significa "métrica não se aplica a esta linha", não dado faltante.

Metadados por linha. Além das métricas, cada linha carrega tudo que existe sobre a execução, vindo do env/meta do JSON ou recuperado do caminho e do nome do arquivo:

Campo	Preenchido	Observação
source_file, machine, workload, concurrency	100%	rastreia a linha até o arquivo de origem
gpu_name, gpu_vendor	100%	grafia normalizada (11 GPUs, NVIDIA e AMD); o valor original fica em gpu_name_raw
model	99,4%	as 42 linhas restantes vêm de 5 CSV de OCR que gravaram o placeholder ocrmodel e não trazem o modelo em nenhum campo nem no nome
engine	96,0%	vllm, ollama, surya, faster-whisper
timestamp_utc	93,4%
python	92,4%	versão do interpretador da coleta
nvidia_driver	89,7%
seed	89,5%
output_len	87,6%
served_model	83,9%	nome servido pelo endpoint
tensor_parallel	81,7%	ver nota abaixo
engine_version, platform, warmups, input_len, gpu_count, gpu_mem_total_mib	81,2–81,6%	só as coletas com vLLM gravaram
slurm_job_id	65,5%	extraído do nome do arquivo, nos jobs do GPPD/B200

tensor_parallel foi gravado explicitamente em poucas coletas; onde gpu_count == 1 ele vale 1 por definição e é preenchido, com tensor_parallel_source distinguindo recorded de inferred_single_gpu. Nenhum outro campo é inferido. Colunas que a coleta criou mas nunca preencheu (caso de model_revision) são descartadas, para não sugerir dado onde não há.

O que a linha representa — coluna is_aggregate:

is_aggregate	Linhas	O que é	Workloads
0	5.610	Uma repetição individual, sem nenhuma média aplicada. rep_index numera a repetição dentro do ponto.	serving
1	1.297	Estatística do ponto (median, q1, q3, min, max), porque a coleta desses workloads não guardou os valores individuais.	ollama, ocr, stt, embed, vision, rerank

Para análise estatística com dado bruto de verdade (intervalo de confiança, teste de hipótese, distribuição), use data/raw/full_raw_serving.csv com is_aggregate == 0: são 5.610 execuções individuais com output_throughput, request_throughput, mean_ttft_ms, median_ttft_ms, p99_ttft_ms, mean_tpot_ms, mean_itl_ms, mean_e2el_ms, total_input_tokens, total_output_tokens e vram_used_mib por repetição. Esse total confere exatamente com a soma de reps de todos os JSON de raw/, ou seja, nenhuma medição individual foi perdida na consolidação.

Limite conhecido: apenas o workload serving guardou repetições individuais. Os demais (ocr, ollama, stt, embed, vision, rerank) gravaram só mediana/quartis no momento da coleta — os valores por repetição foram descartados na origem e não são recuperáveis a partir de raw/.

Tudo é gerado por scripts/build_full_raw_csv.py a partir de raw/, e pode ser reconstruído a qualquer momento.