scripts/runners/run_serving.py

#!/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()