bench.py

#!/usr/bin/env python3
"""Speed bench for a llama.cpp /v1/chat/completions server.

Two modes:

1. Length sweep - fixed prompts shipped in prompts/prompt_<L>.txt, one request per length.
   Prompts ship as files so every replica sends byte-identical input; sizing them at run
   time against a local tokenizer is what makes "64K" mean different things on different
   servers. They were calibrated for the o200k-harmony vocabulary (gpt-oss family, what the
   measured llama.cpp servers serve). Rebuild with --rebuild-prompts if your tokenizer differs.

2. Dataset - replay a jsonl of ready-made chat samples (datasets):
   2 families x 3 tiers x 10 samples = 60, each carrying its own `messages` payload and the
   `expected_prompt_tokens` it was calibrated to against the server tokenizer.

Rates come from the server's own `timings` block (prompt_per_second / predicted_per_second);
a client-side estimate is used only when the server omits it.

Usage:
  python bench.py http://HOST:PORT MODEL results/out.json --lengths 1024,4096 --runs 2
  python bench.py http://HOST:PORT MODEL results/out.json \
      --dataset datasets/all_samples.jsonl --scale 4k --concurrency 4
  python bench.py --rebuild-prompts openai/gpt-oss-120b
"""
import argparse
import concurrent.futures
import json
import os
import sys
import time
import urllib.request

HERE = os.path.dirname(os.path.abspath(__file__))
PROMPT_DIR = os.path.join(HERE, 'prompts')
DEFAULT_LENGTHS = (1024, 4096, 65536, 131072)
N_CTX = 131072  # context window of the measured deployment
FILLER = (
    'The quarterly report shows that revenue grew across all regions, with the strongest performance in Asia-Pacific. '
    'Engineering shipped the new storage layer, cut p99 latency by 30%, and closed 214 tickets. '
    'Risks include supplier delays, currency exposure, and hiring in the Berlin office. '
)
QUESTION = (
    '\n\nBased on the document above, write a very detailed and comprehensive analysis report of at least 3000 words '
    'covering every point, with sections, risks, recommendations and an action plan. Do not stop early.'
)


def post(url: str, body: dict, timeout: int = 3600):
    req = urllib.request.Request(url, data=json.dumps(body).encode(), headers={'Content-Type': 'application/json'})
    return urllib.request.urlopen(req, timeout=timeout)


def one_run(url: str, model: str, messages: list, max_tokens: int) -> dict:
    """One cold request; returns the measured rates."""
    body = {
        'model': model,
        'messages': messages,
        'max_tokens': max_tokens,
        'temperature': 0,
        'stream': True,
        'cache_prompt': False,  # true cold prefill - cached prompts would fake the prefill rate
        'stream_options': {'include_usage': True},
        'timings_per_token': True,
        'chat_template_kwargs': {'enable_thinking': False},
        'reasoning_effort': 'low',
    }
    t0 = time.time()
    ttft = None
    n_out = 0
    timings = None
    usage = None
    err = None
    try:
        with post(url + '/v1/chat/completions', body) as r:
            for line in r:
                line = line.decode().strip()
                if not line.startswith('data:') or line == 'data: [DONE]':
                    continue
                d = json.loads(line[5:])
                if d.get('error'):
                    err = 'stream: ' + json.dumps(d['error'])[:300]
                    break
                if d.get('timings'):
                    timings = d['timings']
                if d.get('usage'):
                    usage = d['usage']
                for c in d.get('choices', []):
                    delta = c.get('delta', {})
                    if delta.get('content') or delta.get('reasoning_content'):
                        if ttft is None:
                            ttft = time.time() - t0
                        n_out += 1
    except Exception as e:  # noqa: BLE001 - the point is to record the failure, not to crash the sweep
        err = str(e)[:300]
        try:
            err += ' | ' + e.read().decode()[:300]
        except Exception:
            pass
    total = time.time() - t0
    res = {
        'error': err,
        'wall_s': round(total, 2),
        'ttft_s': round(ttft, 2) if ttft else None,
        'prompt_tokens': (usage or {}).get('prompt_tokens'),
        'completion_tokens': (usage or {}).get('completion_tokens'),
    }
    if timings:  # server-side numbers are authoritative
        res.update(
            prefill_tok_s=round(timings.get('prompt_per_second', 0), 1),
            decode_tok_s=round(timings.get('predicted_per_second', 0), 1),
            prefill_ms=round(timings.get('prompt_ms', 0)),
            decode_ms=round(timings.get('predicted_ms', 0)),
            prompt_n=timings.get('prompt_n'),
            predicted_n=timings.get('predicted_n'),
        )
    elif ttft and usage:
        res.update(
            prefill_tok_s=round(usage['prompt_tokens'] / ttft, 1),
            decode_tok_s=round(usage['completion_tokens'] / max(total - ttft, 1e-3), 1),
        )
    return res


def build_prompt(tokenizer, target: int) -> str:
    """Repeat FILLER until the prompt hits `target` tokens, then append the question."""
    per_block = len(tokenizer.encode(FILLER * 20, add_special_tokens=False)) / 20
    n = max(1, int((target - 40) / per_block))
    prompt = FILLER * n + QUESTION
    while len(tokenizer.encode(prompt, add_special_tokens=False)) > target and n > 1:
        n -= 1
        prompt = FILLER * n + QUESTION
    return prompt


def rebuild_prompts(tokenizer_path: str) -> None:
    from transformers import AutoTokenizer

    tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
    os.makedirs(PROMPT_DIR, exist_ok=True)
    for length in DEFAULT_LENGTHS:
        target = min(length, N_CTX - 256)  # leave exactly max_tokens room for the answer
        prompt = build_prompt(tokenizer, target)
        path = os.path.join(PROMPT_DIR, f'prompt_{length}.txt')
        with open(path, 'w') as fh:
            fh.write(prompt)
        print(f'{path}: {len(tokenizer.encode(prompt, add_special_tokens=False))} tokens, {len(prompt)} chars')


def summarise(results: list) -> None:
    """Print mean rates per tier - the number a speed report actually quotes."""
    groups: dict = {}
    for r in results:
        groups.setdefault(r.get('tier', '(all)'), []).append(r)
    print(f"\n{'tier':<10}{'n':>4}{'prefill tok/s':>15}{'decode tok/s':>14}{'TTFT s':>9}{'wall s':>9}{'errors':>8}")
    for tier, rows in sorted(groups.items()):
        ok = [r for r in rows if not r.get('error')]
        if not ok:
            print(f'{tier:<10}{len(rows):>4}{"-":>15}{"-":>14}{"-":>9}{"-":>9}{len(rows):>8}')
            continue
        mean = lambda key: sum(r[key] for r in ok if r.get(key) is not None) / max(  # noqa: E731
            sum(1 for r in ok if r.get(key) is not None), 1)
        print(f'{tier:<10}{len(rows):>4}{mean("prefill_tok_s"):>15.1f}{mean("decode_tok_s"):>14.1f}'
              f'{mean("ttft_s"):>9.1f}{mean("wall_s"):>9.1f}{len(rows) - len(ok):>8}')


def run_length_sweep(a) -> None:
    out = {'mode': 'length_sweep', 'url': a.url, 'model': a.model, 'max_tokens': a.max_tokens,
           'runs': a.runs, 'started': time.strftime('%F %T'), 'results': []}
    for length in (int(x) for x in a.lengths.split(',')):
        path = os.path.join(PROMPT_DIR, f'prompt_{length}.txt')
        with open(path) as fh:
            prompt = fh.read()
        print(f"[{time.strftime('%T')}] len={length} prompt={path} chars={len(prompt)}", flush=True)
        for i in range(a.runs):
            res = one_run(a.url, a.model, [{'role': 'user', 'content': prompt}], a.max_tokens)
            res.update(length=length, tier=f'{length // 1024}k', run=i + 1)
            out['results'].append(res)
            print(f'  run{i + 1}: {json.dumps(res)}', flush=True)
            with open(a.out, 'w') as fh:
                json.dump(out, fh, indent=1)
    finish(out, a)


def run_dataset(a) -> None:
    records = []
    with open(a.dataset) as fh:
        for line in fh:
            r = json.loads(line)
            if a.scale and r.get('scale') != a.scale:
                continue
            if a.family and r.get('task_family') != a.family:
                continue
            records.append(r)
    if a.limit:
        records = records[:a.limit]
    if not records:
        raise SystemExit(f'no records in {a.dataset} matched --scale {a.scale} --family {a.family}')

    out = {'mode': 'dataset', 'url': a.url, 'model': a.model, 'max_tokens': a.max_tokens,
           'dataset': os.path.relpath(a.dataset, HERE), 'concurrency': a.concurrency,
           'started': time.strftime('%F %T'), 'results': []}
    print(f"[{time.strftime('%T')}] {len(records)} samples, concurrency={a.concurrency}, "
          f"max_tokens={a.max_tokens}", flush=True)

    def run_one(rec):
        res = one_run(a.url, a.model, rec['messages'], a.max_tokens)
        res.update(id=rec.get('id'), task_family=rec.get('task_family'), scale=rec.get('scale'),
                   tier=rec.get('scale'), target_tokens=rec.get('target_tokens'),
                   expected_prompt_tokens=rec.get('expected_prompt_tokens'))
        if res.get('prompt_tokens') and rec.get('expected_prompt_tokens'):
            res['prompt_tokens_delta'] = res['prompt_tokens'] - rec['expected_prompt_tokens']
        return res

    with concurrent.futures.ThreadPoolExecutor(max_workers=a.concurrency) as pool:
        futures = {pool.submit(run_one, r): r for r in records}
        for done in concurrent.futures.as_completed(futures):
            res = done.result()
            out['results'].append(res)
            print(f"  {res['id']:<22} in={res.get('prompt_tokens')} out={res.get('completion_tokens')} "
                  f"prefill={res.get('prefill_tok_s')} tok/s decode={res.get('decode_tok_s')} tok/s "
                  f"wall={res.get('wall_s')}s err={res.get('error')}", flush=True)
            with open(a.out, 'w') as fh:
                json.dump(out, fh, indent=1)
    finish(out, a)


def finish(out: dict, a) -> None:
    out['finished'] = time.strftime('%F %T')
    out['results'].sort(key=lambda r: (r.get('tier') or '', r.get('id') or ''))
    with open(a.out, 'w') as fh:
        json.dump(out, fh, indent=1)
    summarise(out['results'])
    print(f'\nDONE -> {a.out}', flush=True)


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument('url', nargs='?')
    ap.add_argument('model', nargs='?')
    ap.add_argument('out', nargs='?')
    ap.add_argument('--lengths', default=','.join(str(x) for x in DEFAULT_LENGTHS))
    ap.add_argument('--runs', type=int, default=2)
    ap.add_argument('--max-tokens', type=int, default=256)
    ap.add_argument('--dataset', help='jsonl of ready-made samples (see datasets/)')
    ap.add_argument('--scale', help='dataset mode: only this tier, e.g. 4k')
    ap.add_argument('--family', help='dataset mode: only this family, e.g. code')
    ap.add_argument('--limit', type=int, help='dataset mode: cap the number of samples')
    ap.add_argument('--concurrency', type=int, default=1, help='dataset mode: parallel in-flight requests')
    ap.add_argument('--rebuild-prompts', metavar='TOKENIZER')
    a = ap.parse_args()

    if a.rebuild_prompts:
        rebuild_prompts(a.rebuild_prompts)
        return
    if not (a.url and a.model and a.out):
        ap.error('url, model and out are required (or use --rebuild-prompts)')

    if a.dataset:
        run_dataset(a)
    else:
        run_length_sweep(a)


if __name__ == '__main__':
    sys.exit(main())