#!/usr/bin/env python3 """ Scherm On-Premise LLM Inference Benchmark — serving runner (ACM-grade). Roda dentro do container vLLM. Para cada (modelo já servido) varre níveis de concorrência, repete N vezes, e agrega com mediana + IQR + p50/p95/p99 + IC95%. Saída: JSON (bruto + agregado) e CSV. Loga ambiente para reprodutibilidade. Determinismo: seed fixa; servidor deve subir com enforce_eager e VLLM_ENABLE_V1_MULTIPROCESSING=0. Warmup descartado. Uso: python run_serving.py --served-model REPO --base-url http://localhost:8000 \ --concurrencies 1 4 8 16 32 64 128 256 --reps 10 --warmups 1 \ --input-len 512 --output-len 256 --out /path/results --tag GPUNAME """ import argparse, json, os, subprocess, statistics, sys, time, platform from datetime import datetime, timezone def sh(cmd): return subprocess.run(cmd, shell=True, capture_output=True, text=True) def gpu_info(): r = sh("nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader") line = (r.stdout.strip().splitlines() or [""])[0] parts = [p.strip() for p in line.split(",")] return {"name": parts[0] if parts else "unknown", "memory_total_mib": parts[1].split()[0] if len(parts) > 1 else "", "driver": parts[2] if len(parts) > 2 else ""} def gpu_count(): r = sh("nvidia-smi -L"); return len([l for l in r.stdout.splitlines() if l.startswith("GPU")]) def vram_used_mib(): r = sh("nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits") vals = [int(x) for x in r.stdout.split() if x.strip().isdigit()] return max(vals) if vals else None def vllm_version(container_internal=True): r = sh("vllm --version 2>/dev/null"); return r.stdout.strip() or r.stderr.strip() def quantiles(xs): xs = sorted(x for x in xs if x is not None) if not xs: return {} n = len(xs) def pct(p): if n == 1: return xs[0] k = (n - 1) * p; f = int(k); c = min(f + 1, n - 1) return xs[f] + (xs[c] - xs[f]) * (k - f) mean = statistics.fmean(xs) std = statistics.pstdev(xs) if n > 1 else 0.0 # IC95% (t aproximado por normal para n>=10; senão só média) ci = 1.96 * (std / (n ** 0.5)) if n > 1 else 0.0 return {"n": n, "mean": round(mean, 3), "std": round(std, 3), "median": round(pct(0.5), 3), "q1": round(pct(0.25), 3), "q3": round(pct(0.75), 3), "p5": round(pct(0.05), 3), "p95": round(pct(0.95), 3), "p99": round(pct(0.99), 3), "min": round(xs[0], 3), "max": round(xs[-1], 3), "ci95_halfwidth": round(ci, 3)} def run_bench_once(served, base_url, conc, n_prompts, in_len, out_len, seed, tmpjson): """Roda vllm bench serve uma vez, salvando JSON; retorna dict de métricas.""" if os.path.exists(tmpjson): os.remove(tmpjson) cmd = (f"vllm bench serve --model {served} --base-url {base_url} " f"--dataset-name random --random-input-len {in_len} --random-output-len {out_len} " f"--num-prompts {n_prompts} --max-concurrency {conc} --seed {seed} --temperature 0 " f"--percentile-metrics ttft,tpot,itl,e2el --metric-percentiles 50,95,99 " f"--save-result --result-filename {tmpjson} 2>&1") r = sh(cmd) if not os.path.exists(tmpjson): return {"error": "no_json", "stderr_tail": r.stdout[-800:]} with open(tmpjson) as f: d = json.load(f) # campos do vllm bench serve JSON return { "request_throughput": d.get("request_throughput"), "output_throughput": d.get("output_throughput"), "total_token_throughput": d.get("total_token_throughput"), "mean_ttft_ms": d.get("mean_ttft_ms"), "median_ttft_ms": d.get("median_ttft_ms"), "p99_ttft_ms": d.get("p99_ttft_ms"), "mean_tpot_ms": d.get("mean_tpot_ms"), "median_tpot_ms": d.get("median_tpot_ms"), "p99_tpot_ms": d.get("p99_tpot_ms"), "mean_itl_ms": d.get("mean_itl_ms"), "p99_itl_ms": d.get("p99_itl_ms"), "mean_e2el_ms": d.get("mean_e2el_ms"), "completed": d.get("completed"), "total_input_tokens": d.get("total_input_tokens"), "total_output_tokens": d.get("total_output_tokens"), } def main(): ap = argparse.ArgumentParser() ap.add_argument("--served-model", required=True) ap.add_argument("--base-url", default="http://localhost:8000") ap.add_argument("--concurrencies", nargs="+", type=int, default=[1,4,8,16,32,64,128,256]) ap.add_argument("--reps", type=int, default=10) ap.add_argument("--warmups", type=int, default=1) ap.add_argument("--input-len", type=int, default=512) ap.add_argument("--output-len", type=int, default=256) ap.add_argument("--seed", type=int, default=1234) ap.add_argument("--out", required=True) ap.add_argument("--tag", default="") ap.add_argument("--run-id", default="") # sufixo único p/ evitar colisão de CSV entre jobs paralelos ap.add_argument("--model-revision", default="") a = ap.parse_args() os.makedirs(a.out, exist_ok=True) g = gpu_info(); ngpu = gpu_count() env = { "timestamp_utc": datetime.now(timezone.utc).isoformat(), "gpu_name": g["name"], "gpu_count": ngpu, "gpu_mem_total_mib": g["memory_total_mib"], "nvidia_driver": g["driver"], "vllm_version": vllm_version(), "served_model": a.served_model, "model_revision": a.model_revision, "seed": a.seed, "reps": a.reps, "warmups": a.warmups, "input_len": a.input_len, "output_len": a.output_len, "python": platform.python_version(), "platform": platform.platform(), "vllm_v1_multiprocessing": os.environ.get("VLLM_ENABLE_V1_MULTIPROCESSING", "unset"), } safe = a.served_model.replace("/", "_") # ESCRITA INCREMENTAL: define CSV/header antes do loop p/ gravar a cada conc (não perder parcial se travar) _sfx = f"{a.tag}_{a.run_id}" if a.run_id else a.tag _csv = f"{a.out}/serving_{_sfx}_" + safe + ".csv" _header = ("gpu,vram_total_mib,gpu_count,model,concurrency,n_ok," "output_tok_s_median,output_tok_s_q1,output_tok_s_q3," "total_tok_s_median,ttft_ms_median,ttft_ms_p95,tpot_ms_median,vram_used_mib_median\n") if not os.path.exists(_csv): with open(_csv, "w") as _f: _f.write(_header) tmpjson = f"{a.out}/_bench_{safe}.json" # /tmp do container nao grava no Apptainer; usar --out (bind) rows = [] raw = {"env": env, "points": []} for conc in a.concurrencies: n_prompts = max(conc * 8, 16) # warmup (descartado) for _ in range(a.warmups): run_bench_once(a.served_model, a.base_url, conc, n_prompts, a.input_len, a.output_len, a.seed, tmpjson) reps = [] for i in range(a.reps): m = run_bench_once(a.served_model, a.base_url, conc, n_prompts, a.input_len, a.output_len, a.seed + i, tmpjson) m["vram_used_mib"] = vram_used_mib() reps.append(m) ok = [r for r in reps if "error" not in r] agg = {} for metric in ["output_throughput","total_token_throughput","request_throughput", "mean_ttft_ms","p99_ttft_ms","mean_tpot_ms","p99_tpot_ms","mean_itl_ms"]: agg[metric] = quantiles([r.get(metric) for r in ok]) vram = quantiles([r.get("vram_used_mib") for r in ok]) raw["points"].append({"concurrency": conc, "n_ok": len(ok), "reps": reps, "agg": agg, "vram": vram}) # linha CSV (mediana dos principais) def med(k): return agg.get(k, {}).get("median", "") rows.append([g["name"], g["memory_total_mib"], ngpu, a.served_model, conc, len(ok), med("output_throughput"), agg.get("output_throughput",{}).get("q1",""), agg.get("output_throughput",{}).get("q3",""), med("total_token_throughput"), med("mean_ttft_ms"), agg.get("mean_ttft_ms",{}).get("p95",""), med("mean_tpot_ms"), vram.get("median","")]) # grava incrementalmente a row recém-criada (sobrevive a travamento em conc seguinte) with open(_csv, "a") as _f: _f.write(",".join(str(x) for x in rows[-1]) + "\n") print(f" [{a.served_model}] conc={conc} n={len(ok)} " f"out_tok/s(med)={med('output_throughput')} ttft(med)={med('mean_ttft_ms')}ms " f"vram={vram.get('median','')}MiB", flush=True) # nome único por job (run_id) evita colisão de CSV entre modelos paralelos na mesma GPU sfx = f"{a.tag}_{a.run_id}" if a.run_id else a.tag with open(f"{a.out}/serving_{sfx}_{safe}.json", "w") as f: json.dump(raw, f, indent=2) csv = f"{a.out}/serving_{sfx}_{safe}.csv" header = ("gpu,vram_total_mib,gpu_count,model,concurrency,n_ok," "output_tok_s_median,output_tok_s_q1,output_tok_s_q3," "total_tok_s_median,ttft_ms_median,ttft_ms_p95,tpot_ms_median,vram_used_mib_median\n") # CSV já foi escrito incrementalmente dentro do loop (ver _csv). Nada a fazer aqui. print(f"[OK] {a.served_model}: JSON + CSV em {a.out} ({csv})", flush=True) if __name__ == "__main__": main()