Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+datasets/all_samples.jsonl filter=lfs diff=lfs merge=lfs -text
+datasets/code_samples.jsonl filter=lfs diff=lfs merge=lfs -text
+datasets/general_qa_samples.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,132 @@
----
-license: apache-2.0
----
+# speed-bench — Long-Context Inference Benchmarking Toolkit
+
+A reproducible benchmark package for cold prefill and decode speed on the **llama.cpp `/v1/chat/completions`** endpoint. It includes the benchmark scripts, fixed prompt datasets, and measured results.
+
+## Contents
+
+```
+bench.py                     Benchmark runner (fixed-length sweep / dataset replay)
+report.py                    Combine results/*.json into a standard report (see below)
+prompts/prompt_<L>.txt       Fixed prompt datasets: 1024 / 4096 / 65536 / 131072 tokens
+datasets/                    Real-world benchmark dataset: 2 families x 3 tiers x 10 = 60 samples
+  all_samples.jsonl          All 60 samples
+  code_samples.jsonl         30 code samples
+  general_qa_samples.jsonl   30 general QA samples
+  1k_samples.jsonl           20 samples in the 1K tier
+results/bench_53_211.json    Raw measured results (complete per-request timings)
+config.json                  Full deployment details (quantization, n_ctx, sampling parameters, server fingerprint)
+```
+
+## Usage
+
+```bash
+python bench.py http://HOST:PORT MODEL results/out.json \
+       --lengths 1024,4096,65536,131072 --runs 2
+```
+
+The benchmark uses only the Python standard library (`transformers` is required for `--rebuild-prompts`). It processes lengths in the order given by `--lengths`, runs each tier `--runs` times, and writes the results to JSON after every run so an interruption does not lose completed data.
+
+## Metric definitions
+
+Use these settings when reproducing the measurements:
+
+| Item | Setting | Reason |
+|---|---|---|
+| Rate source | Server-reported `timings` (`prompt_per_second` / `predicted_per_second`) | Client timing includes network and queueing overhead |
+| `cache_prompt` | `false` | A cache hit makes prefill appear close to zero and produces misleading results |
+| `temperature` | `0` | Reduces decode-side variation |
+| `max_tokens` | `256` | Keeps the setting consistent across tiers for comparable decode rates |
+| Reasoning mode | `enable_thinking: false` + `reasoning_effort: low` | Otherwise reasoning can consume the output and make decode lengths incomparable |
+| Streaming | `stream: true` + `stream_options.include_usage` | Required to collect TTFT and usage |
+
+TTFT is measured by the client as the time until the first SSE event containing content. All other metrics are reported by the server.
+
+## Report format
+
+```bash
+python report.py results/bench_32_165_1k.json results/bench_32_165_4k.json ... --out report.md
+```
+
+The report contains one row for each (Dataset × Context) pair. Values are averaged across all samples in that tier. Failed requests are excluded from the averages and counted separately (`--out` writes the Markdown report to disk).
+
+| Dataset | Context | Input Tokens | Output Tokens | Prefill (tok/s) | TTFT (s) | Decode (tok/s) | E2E Latency (s) |
+|---|---|---|---|---|---|---|---|
+| code | 1k | 1039 | 246 | 431.6 | 2.65 | 16.5 | 17.35 |
+| code | 4k | 3847 | 243 | 460.4 | 9.06 | 15.0 | 24.94 |
+| general_qa | 1k | 1039 | 221 | 463.2 | 2.59 | 16.4 | 15.79 |
+| general_qa | 4k | 3978 | 243 | 496.4 | 8.31 | 15.0 | 24.22 |
+
+## Measured results (reference)
+
+Measured deployment: `http://10.77.53.211:8080`, GGUF **Q8_0**, `n_ctx=131072`, llama.cpp fingerprint `b11103-a78cbbf70` (see `config.json`).
+
+| Context | Prefill tok/s | Decode tok/s | TTFT | Total time per request |
+|---|---|---|---|---|
+| 1K | 509.5 | 17.9 | 2.3s | 16.3s |
+| 4K | 548.9 | 16.1 | 7.8s | 23.4s |
+| 64K | 300.5 | **5.9** | 218.6s | 261.2s |
+| 128K | — | — | — | **Server crashed during the request** (see below) |
+
+The difference between the two repeated runs at each tier was less than 0.3%, indicating good measurement repeatability for this endpoint.
+
+**Known issue:** After the 128K request (130,667 prompt tokens) was sent, the server died during prefill. The client waited 240 seconds before the connection was closed, after which the port returned `Connection refused`. The deployment's practical limit is below its declared `n_ctx`; confirm that the available GPU and system memory can hold the corresponding KV cache before running the full 128K tier.
+
+## Dataset mode: `datasets/`
+
+The benchmark uses real-world text as input, which better represents practical workloads than synthetic repeated text. The dataset contains **2 families × 3 tiers × 10 samples = 60 samples**:
+
+| File | Contents |
+|---|---|
+| `all_samples.jsonl` | All 60 samples, each with a `task_family` field |
+| `code_samples.jsonl` | 30 code samples (HumanEval tasks with CrossCodeEval code blocks as context) |
+| `general_qa_samples.jsonl` | 30 long-document QA and summarization samples from LongBench-Pro |
+
+| File | Family | 1k | 4k | 64k | 128k |
+|---|---|---|---|---|---|
+| `all_samples.jsonl` / family-specific files | code | — | 10 | 10 | 10 |
+| | general_qa | — | 10 | 10 | 10 |
+| `1k_samples.jsonl` | code | 10 | — | — | — |
+| | general_qa | 10 | — | — | — |
+
+**The 1K tier is an additional tier** derived in advance from the paired 4K tasks. Only the context between the anchor points is trimmed; the `<CURRENT_TASK>` block and the original question remain unchanged. As a result, the `tokenizer` field is `local-o200k (openai/gpt-oss-120b)`, while the original 60 samples use `server-tokenizer`. The `construction` field in both sets documents their origin.
+
+Fields in each record:
+
+- `messages` — **A chat payload that can be sent directly**; the benchmark uses it as-is rather than rebuilding it.
+- `expected_prompt_tokens` — The expected prompt token count calibrated with the tokenizer of the measured server (4k → 4096, 64k → 65536/65535, 128k → 114687/114688). `prompt_tokens_delta` in the results is the measured value minus this expectation and checks that the requested tier was sent correctly.
+- `template_overhead` — 52 tokens for the chat template, already included above.
+- `target_tokens` / `scale` / `task_family` / `source_dataset` / `source_id`
+- `canonical_solution` (code) / `answer` (QA) — Reference answers for spot checks only; they do not affect benchmarking.
+
+The target for the 128K tier is **114,688 tokens** (112 × 1024), not the commonly cited 131072. Do not mix the two values.
+
+```bash
+# Run the full 4K tier with four concurrent requests
+python bench.py http://HOST:PORT default results/out.json \
+  --dataset datasets/all_samples.jsonl --scale 4k --concurrency 4
+
+# Run only the code family, limited to five samples
+python bench.py http://HOST:PORT default results/out.json \
+  --dataset datasets/code_samples.jsonl --limit 5
+```
+
+Each result JSON record includes `id / task_family / scale / target_tokens / expected_prompt_tokens`. After the run, the benchmark prints an aggregate table by tier with mean prefill tok/s, decode tok/s, TTFT, total time, and error count.
+
+## Prompt datasets
+
+Each `prompts/prompt_<L>.txt` file repeats the `FILLER` paragraphs until the target token count and then appends the same question. The files are calibrated with the **o200k-harmony vocabulary** used by the measured llama.cpp service for the gpt-oss model family:
+
+| File | Target | Actual tokens | Characters |
+|---|---|---|---|
+| prompt_1024.txt | 1024 | 977 | 5,087 |
+| prompt_4096.txt | 4096 | 4,057 | 21,159 |
+| prompt_65536.txt | 65536 | 65,437 | 341,451 |
+| prompt_131072.txt | 130,816 (leaving room for 256 output tokens) | 130,667 | 681,833 |
+
+The token counts in the table are for the plain text under the o200k vocabulary. The server-reported `prompt_tokens` also includes chat-template overhead (about 60–70 tokens for the Harmony template), so values such as 1044 and 4100 in the results are expected.
+
+**Why use fixed files:** If every user builds the prompt locally with a different tokenizer, “64K” does not represent the same input across services and the measured rates are not comparable. Sending the fixed files ensures that everyone sends identical text.
+
+**Using a different vocabulary family:** The actual token count may shift by a few percent (for example, another vocabulary may count the same 64K prompt as 68K). If needed, run `python bench.py --rebuild-prompts <hf-tokenizer-id-or-local-path>` to regenerate the files and state the tokenizer used in the report.
+
+**Relation to `results/`:** `results/bench_53_211.json` was measured with prompts calibrated using the **server tokenizer**. Compared with the files shipped in this package, its token counts differ by about 0.1% (for example, 65,504 vs. 65,437). To align them exactly, rerun the benchmark after the server is available and overwrite the corresponding files in `results/`.

bench.py

@@ -0,0 +1,265 @@
+#!/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())

config.json

@@ -0,0 +1,22 @@
+{
+  "measured_endpoint": "http://10.77.53.211:8080",
+  "server": "llama.cpp",
+  "server_fingerprint": "b11103-a78cbbf70",
+  "model_file": "../model/model.q8_0.gguf",
+  "quantization": "Q8_0",
+  "gguf_size_bytes": 615329280,
+  "reported_params": 579133440,
+  "n_ctx": 131072,
+  "n_ctx_train": 131072,
+  "n_vocab": 201088,
+  "n_embd": 2880,
+  "request": {
+    "temperature": 0,
+    "max_tokens": 256,
+    "stream": true,
+    "cache_prompt": false,
+    "chat_template_kwargs": {"enable_thinking": false},
+    "reasoning_effort": "low"
+  },
+  "measured_at": "2026-09-30 local time"
+}

datasets/all_samples.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf6672be381c55f19bc8cb3dfbcd8d9acdca0ae294d64cef28d3279bb2970ba5
+size 29474501

datasets/code_samples.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba2d6defcb3feb70bc678e821c60c8d267755020970b0d3bdccd2b2a1fe2c923
+size 13911741

datasets/general_qa_samples.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:507c61b5dec65881ddf1dd16651e65a6b57f388a7a10bd6733bbef55caa5edad
+size 15562760

prompts/prompt_1024.txt

@@ -0,0 +1,3 @@
+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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 
+
+Based 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.

prompts/prompt_4096.txt

@@ -0,0 +1,3 @@
+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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 
+
+Based 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.

report.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Turn bench.py result files into the standard speed report table.
+
+    Dataset | Context | Input Tokens | Output Tokens | Prefill (tok/s) | TTFT (s) | Decode (tok/s) | E2E Latency (s)
+
+One row per (dataset, context tier); every value is the mean over that tier's samples.
+Failed requests (error != null) are excluded from the means and counted in a trailing note.
+
+Usage:
+  python report.py results/bench_32_165_*.json [--out report.md]
+  python report.py                 # default: every results/*.json
+"""
+import argparse
+import glob
+import json
+import os
+import statistics as st
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+TIER_ORDER = {'1k': 0, '4k': 1, '64k': 2, '128k': 3}
+COLUMNS = ('Dataset', 'Context', 'Input Tokens', 'Output Tokens', 'Prefill (tok/s)',
+           'TTFT (s)', 'Decode (tok/s)', 'E2E Latency (s)')
+
+
+def load_rows(paths: list) -> list:
+    rows = []
+    for path in paths:
+        with open(path) as fh:
+            payload = json.load(fh)
+        for r in payload.get('results', []):
+            r.setdefault('tier', r.get('scale') or f"{r.get('length', 0) // 1024}k")
+            r.setdefault('task_family', payload.get('dataset') or 'all')
+            rows.append(r)
+    return rows
+
+
+def mean(values: list) -> float:
+    values = [v for v in values if v is not None]
+    return st.mean(values) if values else float('nan')
+
+
+def build_table(rows: list) -> list:
+    groups: dict = {}
+    errors: dict = {}
+    for r in rows:
+        key = (r.get('task_family') or 'all', r.get('tier') or '?')
+        (groups if not r.get('error') else errors).setdefault(key, []).append(r)
+    table = []
+    for key in sorted(groups, key=lambda k: (k[0], TIER_ORDER.get(k[1], 9), k[1])):
+        g = groups[key]
+        table.append({
+            'Dataset': key[0],
+            'Context': key[1],
+            'Input Tokens': round(mean([r.get('prompt_tokens') for r in g])),
+            'Output Tokens': round(mean([r.get('completion_tokens') for r in g])),
+            'Prefill (tok/s)': round(mean([r.get('prefill_tok_s') for r in g]), 1),
+            'TTFT (s)': round(mean([r.get('ttft_s') for r in g]), 2),
+            'Decode (tok/s)': round(mean([r.get('decode_tok_s') for r in g]), 1),
+            'E2E Latency (s)': round(mean([r.get('wall_s') for r in g]), 2),
+            'n': len(g),
+            'errors': len(errors.get(key, [])),
+        })
+    return table
+
+
+def render(table: list) -> str:
+    lines = ['| ' + ' | '.join(COLUMNS) + ' |', '|' + '|'.join(['---'] * len(COLUMNS)) + '|']
+    for row in table:
+        lines.append('| ' + ' | '.join(str(row[c]) for c in COLUMNS) + ' |')
+    return '\n'.join(lines)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument('results', nargs='*')
+    ap.add_argument('--out')
+    a = ap.parse_args()
+
+    paths = a.results or sorted(glob.glob(os.path.join(HERE, 'results', '*.json')))
+    paths = [p for p in paths if os.path.basename(p) not in ('config.json',)]
+    if not paths:
+        raise SystemExit('no result files found')
+
+    table = build_table(load_rows(paths))
+    text = render(table)
+    print(text)
+    bad = sum(row['errors'] for row in table)
+    if bad:
+        print(f'\n注：{bad} 条请求失败，未计入均值。')
+    if a.out:
+        with open(a.out, 'w') as fh:
+            fh.write(text + '\n')
+        print(f'\n-> {a.out}')
+
+
+if __name__ == '__main__':
+    main()