#!/usr/bin/env python3 """Parse all benchmark result files and print both summary tables + write CSV.""" import json import os import re import csv RESULTS_DIR = os.path.dirname(os.path.abspath(__file__)) KEYS = [ ("llama-3.1-8b-instruct", "Llama-3.1-8B", "f16", "F16"), ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q8_0", "Q8_0"), ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q4_K_M", "Q4_K_M"), ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q2_K", "Q2_K"), ("qwen2.5-7b-instruct", "Qwen2.5-7B", "f16", "F16"), ("qwen2.5-7b-instruct", "Qwen2.5-7B", "Q8_0", "Q8_0"), ("qwen2.5-7b-instruct", "Qwen2.5-7B", "Q4_K_M", "Q4_K_M"), ("qwen2.5-7b-instruct", "Qwen2.5-7B", "Q2_K", "Q2_K"), ("gemma-2-9b-it", "Gemma-2-9B", "f16", "F16"), ("gemma-2-9b-it", "Gemma-2-9B", "Q8_0", "Q8_0"), ("gemma-2-9b-it", "Gemma-2-9B", "Q4_K_M", "Q4_K_M"), ("gemma-2-9b-it", "Gemma-2-9B", "Q2_K", "Q2_K"), ] def path(prefix, suffix): return os.path.join(RESULTS_DIR, f"{prefix}_{suffix}") def parse_bench(prefix): """Return (prefill_ts, prefill_std, decode_ts, decode_std, weight_gib) or Nones.""" p = path(prefix, "bench.json") if not os.path.exists(p): return None, None, None, None, None try: data = json.load(open(p)) prefill_ts = prefill_std = decode_ts = decode_std = weight_gib = None for r in data: if r.get("n_prompt", 0) > 0 and r.get("n_gen", 0) == 0: prefill_ts = round(r["avg_ts"], 1) prefill_std = round(r.get("stddev_ts", 0), 1) weight_gib = round(r["model_size"] / (1024**3), 2) elif r.get("n_gen", 0) > 0 and r.get("n_prompt", 0) == 0: decode_ts = round(r["avg_ts"], 1) decode_std = round(r.get("stddev_ts", 0), 1) return prefill_ts, prefill_std, decode_ts, decode_std, weight_gib except Exception as e: print(f" WARN bench parse error for {prefix}: {e}") return None, None, None, None, None def parse_vram(prefix): """Return peak VRAM (GiB) from nvidia-smi dmon log. When monitoring a single GPU (-i N), this is simply the max fb value seen. When monitoring all GPUs (older logs), we fall back to sum of (peak − min) per GPU as an estimate of our job's incremental VRAM. """ p = path(prefix, "vram.log") if not os.path.exists(p): return None try: from collections import defaultdict gpu_min = defaultdict(lambda: float("inf")) gpu_max = defaultdict(lambda: 0) with open(p) as f: has_timestamp = False for header_line in f: if header_line.strip().startswith("#") and "Time" in header_line: has_timestamp = True if not header_line.strip().startswith("#"): break f.seek(0) for line in f: line = line.strip() if not line or line.startswith("#"): continue parts = line.split() if len(parts) < 3: continue try: if has_timestamp: # cols: HH:MM:SS gpu_idx fb_mb bar1_mb ... gpu = int(parts[1]) fb = int(parts[2]) else: # cols: gpu_idx fb_mb bar1_mb ccpm_mb gpu = int(parts[0]) fb = int(parts[1]) if fb < gpu_min[gpu]: gpu_min[gpu] = fb if fb > gpu_max[gpu]: gpu_max[gpu] = fb except (ValueError, IndexError): continue if not gpu_max: return None n_gpus = len(gpu_max) if n_gpus == 1: # Single-GPU log: peak fb is exactly our job's peak VRAM peak_mib = max(gpu_max.values()) else: # Multi-GPU log: use delta (peak - min) per GPU to strip baseline peak_mib = sum(gpu_max[g] - gpu_min[g] for g in gpu_max) return round(peak_mib / 1024, 2) except Exception as e: print(f" WARN vram parse error for {prefix}: {e}") return None def parse_ttft(prefix): """Return (ttft_ms, tpot_ms, latency_ms) or (None, None, None).""" p = path(prefix, "ttft.json") if not os.path.exists(p): return None, None, None try: d = json.load(open(p)) return d.get("ttft_ms"), d.get("tpot_ms"), d.get("latency_ms") except Exception as e: print(f" WARN ttft parse error for {prefix}: {e}") return None, None, None def parse_ppl(prefix): """Return (perplexity, ppl_std) or (None, None).""" p = path(prefix, "ppl.txt") if not os.path.exists(p): return None, None try: text = open(p).read() m = re.search(r"PPL\s*=\s*([\d.]+)\s*\+/-\s*([\d.]+)", text) if m: return float(m.group(1)), float(m.group(2)) m = re.search(r"PPL\s*=\s*([\d.]+)", text) return (float(m.group(1)), None) if m else (None, None) except Exception as e: print(f" WARN ppl parse error for {prefix}: {e}") return None, None def parse_hellaswag(prefix): """Return accuracy % float or None.""" p = path(prefix, "hellaswag.txt") if not os.path.exists(p): return None try: text = open(p).read().strip() # format: "400\t78.50000000%\t[74.2%, 82.2%]" m = re.search(r"([\d.]+)%", text) return round(float(m.group(1)), 2) if m else None except Exception as e: print(f" WARN hellaswag parse error for {prefix}: {e}") return None def parse_winogrande(prefix): """Return accuracy % float or None.""" p = path(prefix, "winogrande.txt") if not os.path.exists(p): return None try: text = open(p).read().strip() # format: "1267\t73.4807\t..." — second col is % correct parts = text.split() return round(float(parts[1]), 2) if len(parts) >= 2 else None except Exception as e: print(f" WARN winogrande parse error for {prefix}: {e}") return None def fmt(val, fmt_str, missing="—"): return format(val, fmt_str) if val is not None else missing def main(): rows = [] for (file_prefix_base, model_label, quant_file, quant_label) in KEYS: prefix = f"{file_prefix_base}-{quant_file}" prefill, prefill_std, decode, decode_std, weight = parse_bench(prefix) peak_vram = parse_vram(prefix) ttft, tpot, latency = parse_ttft(prefix) ppl, ppl_std = parse_ppl(prefix) hellaswag = parse_hellaswag(prefix) winogrande = parse_winogrande(prefix) rows.append({ "model": model_label, "quant": quant_label, "prefill_ts": prefill, "prefill_std": prefill_std, "decode_ts": decode, "decode_std": decode_std, "weight_gib": weight, "peak_vram": peak_vram, "ttft_ms": ttft, "tpot_ms": tpot, "latency_ms": latency, "ppl": ppl, "ppl_std": ppl_std, "hellaswag": hellaswag, "winogrande": winogrande, }) # ── Write CSV ───────────────────────────────────────────────────────────── csv_path = os.path.join(RESULTS_DIR, "benchmark_results.csv") fieldnames = ["model", "quant", "prefill_ts", "prefill_std", "decode_ts", "decode_std", "ttft_ms", "tpot_ms", "latency_ms", "weight_gib", "peak_vram", "ppl", "ppl_std", "hellaswag", "winogrande"] with open(csv_path, "w", newline="") as f: w = csv.DictWriter(f, fieldnames=fieldnames) w.writeheader() w.writerows(rows) print(f"CSV written → {csv_path}\n") # ── Table 1: Speed & Memory ─────────────────────────────────────────────── print("TABLE 1 — Speed & Memory") print("─" * 120) hdr = (f"{'Model':<22} {'Quant':<8} {'Prefill (t/s)':>18} {'Decode (t/s)':>18}" f" {'TTFT':>8} {'TPOT':>8} {'Latency':>9} {'Wt(GiB)':>8} {'PkVRAM':>8}") print(hdr) print(f"{'':22} {'':8} {'mean ± std':>18} {'mean ± std':>18}" f" {'(ms)':>8} {'(ms)':>8} {'(ms)':>9} {'':>8} {'(GiB)':>8}") print("─" * 120) prev_model = None for r in rows: if r["model"] != prev_model and prev_model is not None: print() prev_model = r["model"] idx = rows.index(r) is_first = idx == 0 or rows[idx-1]["model"] != r["model"] if r["prefill_ts"] is not None and r["prefill_std"] is not None: prefill_col = f"{r['prefill_ts']:.1f}±{r['prefill_std']:.1f}" else: prefill_col = "—" if r["decode_ts"] is not None and r["decode_std"] is not None: decode_col = f"{r['decode_ts']:.1f}±{r['decode_std']:.1f}" else: decode_col = "—" print( f"{r['model'] if is_first else '':22}" f" {r['quant']:<8}" f" {prefill_col:>18}" f" {decode_col:>18}" f" {fmt(r['ttft_ms'], '8.1f')}" f" {fmt(r['tpot_ms'], '8.1f')}" f" {fmt(r['latency_ms'], '9.1f')}" f" {fmt(r['weight_gib'], '8.2f')}" f" {fmt(r['peak_vram'], '8.2f')}" ) print("─" * 120) # ── Table 2: Quality ────────────────────────────────────────────────────── print("\nTABLE 2 — Quality") print("─" * 70) print(f"{'Model':<22} {'Quant':<8} {'PPL↓':>8} {'HellaSwag↑':>12} {'Winogrande↑':>13}") print(f"{'':22} {'':8} {'':>8} {'(%)':>12} {'(%)':>13}") print("─" * 70) prev_model = None for r in rows: if r["model"] != prev_model and prev_model is not None: print() prev_model = r["model"] idx = rows.index(r) is_first = idx == 0 or rows[idx-1]["model"] != r["model"] print( f"{r['model'] if is_first else '':22}" f" {r['quant']:<8}" f" {fmt(r['ppl'], '8.2f')}" f" {fmt(r['hellaswag'], '12.2f')}" f" {fmt(r['winogrande'], '13.2f')}" ) print("─" * 70) # ── LaTeX: Quality table ───────────────────────────────────────────────── print() print(r"""\begin{table}[t] \centering \caption{% Model quality metrics at multiple quantization levels. \textbf{PPL} = perplexity on the Wikitext-2 test set (lower is better). \textbf{HellaSwag} = accuracy on 400 commonsense-NLI tasks from the HellaSwag validation set (higher is better). \textbf{Winogrande} = accuracy on 1{,}267 debiased pronoun-resolution tasks (higher is better). Both accuracy benchmarks are evaluated via log-likelihood ranking.% } \label{tab:llamacpp_quality} \begin{tabular}{@{} l l r rr @{}} \toprule \textbf{Model} & \textbf{Quant} & \textbf{PPL\,$\downarrow$} & \textbf{HellaSwag (\%)\,$\uparrow$} & \textbf{Winogrande (\%)\,$\uparrow$} \\""") prev_model = None for r in rows: idx = rows.index(r) is_first = idx == 0 or rows[idx-1]["model"] != r["model"] if is_first: print(r" \midrule") quant = r["quant"].replace("_", r"\_") name_col = r["model"] if is_first else " " * len(r["model"]) if r["ppl"] is not None and r["ppl_std"] is not None: ppl_str = f"${r['ppl']:.2f}\\pm{r['ppl_std']:.2f}$" elif r["ppl"] is not None: ppl_str = f"{r['ppl']:.2f}" else: ppl_str = "---" hs = f"{r['hellaswag']:.2f}" if r["hellaswag"] is not None else "---" wg = f"{r['winogrande']:.2f}" if r["winogrande"] is not None else "---" print(f" {name_col} & {quant} & {ppl_str} & {hs} & {wg} \\\\") print(r""" \bottomrule \end{tabular} \end{table}""") # ── LaTeX: Speed & Memory table ────────────────────────────────────────── print() print(r"""\begin{table*}[t] \centering \caption{% Inference speed and memory usage for three open-weight LLMs at multiple quantization levels, measured on NVIDIA~L40S GPU using llama.cpp. \textbf{Prefill} = prompt-processing throughput at 512 input tokens (PP512, tokens/s); \textbf{Decode} = text-generation throughput at 128 output tokens (TG128, tokens/s); \textbf{TTFT} = time-to-first-token; \textbf{TPOT} = time-per-output-token; \textbf{Latency} = TTFT\,+\,TPOT (mean of 3 streaming runs, 512-token prompt, 128 output tokens, temperature~0); \textbf{Weight} = model-weight VRAM footprint; \textbf{Peak} = maximum VRAM during benchmark.% } \label{tab:llamacpp_speed_memory} \resizebox{\linewidth}{!}{% \begin{tabular}{@{} l l rr rrr rr @{}} \toprule \multirow{2}{*}{\textbf{Model}} & \multirow{2}{*}{\textbf{Quant}} & \multicolumn{2}{c}{\textbf{Throughput (t/s)}} & \multicolumn{3}{c}{\textbf{Latency (ms)}} & \multicolumn{2}{c}{\textbf{VRAM (GiB)}} \\ \cmidrule(lr){3-4}\cmidrule(lr){5-7}\cmidrule(lr){8-9} & & \textbf{Prefill} & \textbf{Decode} & \textbf{TTFT} & \textbf{TPOT} & \textbf{Total} & \textbf{Weight} & \textbf{Peak} \\""") prev_model = None for r in rows: idx = rows.index(r) is_first = idx == 0 or rows[idx-1]["model"] != r["model"] if is_first: print(r" \midrule") quant = r["quant"].replace("_", r"\_") name_col = r["model"] if is_first else " " * len(r["model"]) if r["prefill_ts"] is not None and r["prefill_std"] is not None: prefill_str = f"${r['prefill_ts']:.0f}\\pm{r['prefill_std']:.0f}$" elif r["prefill_ts"] is not None: prefill_str = f"{r['prefill_ts']:.0f}" else: prefill_str = "---" if r["decode_ts"] is not None and r["decode_std"] is not None: decode_str = f"${r['decode_ts']:.1f}\\pm{r['decode_std']:.1f}$" elif r["decode_ts"] is not None: decode_str = f"{r['decode_ts']:.1f}" else: decode_str = "---" ttft = f"{r['ttft_ms']:.1f}" if r["ttft_ms"] is not None else "---" tpot = f"{r['tpot_ms']:.2f}" if r["tpot_ms"] is not None else "---" lat = f"{r['latency_ms']:.1f}" if r["latency_ms"] is not None else "---" wt = f"{r['weight_gib']:.2f}" if r["weight_gib"] is not None else "---" pk = f"{r['peak_vram']:.2f}" if r["peak_vram"] is not None else "---" print( f" {name_col} & {quant} & " f"{prefill_str} & {decode_str} & " f"{ttft} & {tpot} & {lat} & " f"{wt} & {pk} \\\\" ) print(r""" \bottomrule \end{tabular}% } \end{table*}""") if __name__ == "__main__": main()