File size: 8,213 Bytes
a64b4b7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
#!/usr/bin/env python3
"""Measurements beyond the official score, with the kit's own engine command line and client.

  batch  concurrent requests 1, 2, 4 on the official engine settings (which allow 4
         sequences), then 8 and 16 on an engine with room for 16: aggregate throughput,
         per-request TPOT and TTFT, acceptance length
  long   prompts of about 1K to 16K tokens (a document assembled from the kit's reference
         outputs, then an instruction), one request at a time: TTFT, TPOT, acceptance length
  k      draft lengths 8 and 12 instead of the competition's fixed 3 (information only)

Environment as for scripts/kit.py (EMC2_HOME, EMC_TARGET, EMC_SUB, EMC2_WORK, EMC_RESULTS);
--target-only measures the target without a draft. Writes $EMC_RESULTS/bench_<tag>.json.

    python scripts/bench.py --tag draft --what batch,long,k
"""
import argparse
import json
import os
import statistics
import sys
import time
import traceback
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

kit = Path(os.environ["EMC2_HOME"]).resolve()
work = Path(os.environ.get("EMC2_WORK", "emc2-work")).resolve()
cache = work / "cache"
os.environ.update({
    "EMC2_HOME": str(kit), "EMC2_WORK": str(work), "PYTHONDONTWRITEBYTECODE": "1",
    "HF_HUB_OFFLINE": "1", "TRANSFORMERS_OFFLINE": "1", "VLLM_NO_USAGE_STATS": "1", "DO_NOT_TRACK": "1",
    "XDG_CACHE_HOME": str(cache), "HF_HOME": str(cache / "hf"), "VLLM_CACHE_ROOT": str(cache / "vllm"),
    "TORCHINDUCTOR_CACHE_DIR": str(cache / "inductor"), "TRITON_CACHE_DIR": str(cache / "triton"),
    "PATH": str(Path(sys.executable).parent) + os.pathsep + os.environ.get("PATH", ""),
})
sys.path.insert(0, str(kit))
from emc2 import client, common, server  # noqa: E402
from emc2.common import load_json, load_jsonl  # noqa: E402

TARGET = Path(os.environ["EMC_TARGET"]).resolve()
for mod in (common, server):
    for name, value in (("TARGET_DIR", TARGET), ("WORK", work)):
        if hasattr(mod, name):
            setattr(mod, name, value)
DATA = kit / "data" / "dev"
CHAT_PREFIX = [248045, 846, 198]                                      # <|im_start|>user\n
CHAT_SUFFIX = [248046, 198, 248045, 74455, 198, 248068, 271, 248069, 271]   # ... assistant, no thinking
LENGTHS = (1000, 2000, 4000, 8000, 12000, 16000)


def log(msg):
    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)


def ms(xs, q=0.5):
    xs = sorted(x for x in xs if x is not None)
    return round(1000 * xs[min(len(xs) - 1, int(q * len(xs)))], 2) if xs else None


def subset(prompts, per_domain):
    seen, out = {}, []
    for p in prompts:
        if seen.get(p["domain"], 0) < per_domain:
            seen[p["domain"]] = seen.get(p["domain"], 0) + 1
            out.append(p)
    return out


class Bench:
    def __init__(self, sub, contract, target, stop):
        self.spec = {"method": "mtp", "model": str(sub)} if sub else None
        self.contract, self.target, self.stop = contract, target, stop
        self.timeout = contract["request_timeout_s"]

    def server(self, name, **override):
        return server.VllmServer(dict(self.contract, **override), self.target, spec=self.spec, name=name)

    def counters(self, srv):
        return client.spec_counters(srv.url) if self.spec else (0.0, 0.0)

    def warm(self, srv):
        for w in load_jsonl(DATA / "warmup.jsonl"):
            client.complete(srv.url, w["prompt_token_ids"], w["max_tokens"], self.stop, self.timeout)

    def run(self, srv, prompts, concurrency=1):
        """Send the prompts with `concurrency` requests in flight; one row of measurements."""
        a0, d0 = self.counters(srv)
        t0 = time.monotonic()
        call = lambda p: client.complete(srv.url, p["prompt_token_ids"], p["max_tokens"], self.stop, self.timeout)
        with ThreadPoolExecutor(concurrency) as ex:
            res = list(ex.map(call, prompts))
        wall = time.monotonic() - t0
        a1, d1 = self.counters(srv)
        toks = sum(len(r["token_ids"]) for r in res)
        return {"requests": len(res), "concurrency": concurrency, "output_tokens": toks,
                "wall_s": round(wall, 2), "throughput_tok_s": round(toks / wall, 1),
                "tpot_median_ms": ms([r["tpot_s"] for r in res]), "tpot_p90_ms": ms([r["tpot_s"] for r in res], 0.9),
                "ttft_median_ms": ms([r["ttft_s"] for r in res]), "ttft_max_ms": ms([r["ttft_s"] for r in res], 1.0),
                "acceptance_length": round(1 + (a1 - a0) / (d1 - d0), 4) if self.spec and d1 > d0 else None}


def long_prompts(per_length=2):
    from tokenizers import Tokenizer
    tok = Tokenizer.from_file(str(TARGET / "tokenizer.json"))
    sep = tok.encode("\n\n", add_special_tokens=False).ids
    instr = tok.encode("\n\nSummarize the text above in detail, section by section.", add_special_tokens=False).ids
    stream = []
    for r in load_jsonl(DATA / "reference.jsonl"):
        stream += [t for t in r["token_ids"] if t < 248044] + sep        # plain text only
    while len(stream) < 2 * LENGTHS[-1]:
        stream += stream
    out = []
    for L in LENGTHS:
        body = L - len(CHAT_PREFIX) - len(instr) - len(CHAT_SUFFIX)
        for j in range(per_length):
            off = (j * len(stream) // per_length) % (len(stream) - body)
            ids = CHAT_PREFIX + stream[off:off + body] + instr + CHAT_SUFFIX
            out.append({"length": len(ids), "prompt_token_ids": ids, "max_tokens": 256})
    return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--tag", required=True)
    ap.add_argument("--what", default="batch,long")
    ap.add_argument("--target-only", action="store_true")
    ap.add_argument("--per-domain", type=int, default=8)
    a = ap.parse_args()
    sub = None if a.target_only or not os.environ.get("EMC_SUB") else Path(os.environ["EMC_SUB"]).resolve()
    contract, target = load_json(kit / "contract.json"), load_json(kit / "target.json")
    b = Bench(sub, contract, target, load_json(DATA / "meta.json")["stop_token_ids"])
    prompts = subset(load_jsonl(DATA / "prompts.jsonl"), a.per_domain)
    out = {"tag": a.tag, "draft": str(sub) if sub else None, "prompts": len(prompts),
           "official_max_num_seqs": contract["max_num_seqs"], "batch": [], "long": [], "k": [], "errors": []}
    dest = Path(os.environ.get("EMC_RESULTS", work / "results")) / f"bench_{a.tag}.json"
    dest.parent.mkdir(parents=True, exist_ok=True)
    save = lambda: dest.write_text(json.dumps(out, indent=2))
    what = set(a.what.split(","))

    def section(name, fn):
        if name not in what:
            return
        try:
            fn()
        except Exception as e:  # noqa: BLE001 - keep the other measurements
            out["errors"].append(f"{name}: {type(e).__name__}: {e}")
            traceback.print_exc()
        save()

    def batch():
        for max_seqs, levels in ((contract["max_num_seqs"], (1, 2, 4)), (16, (8, 16))):
            with b.server(f"bench-batch{max_seqs}", max_num_seqs=max_seqs) as srv:
                b.warm(srv)
                for n in levels:
                    row = dict(b.run(srv, prompts, n), engine_max_num_seqs=max_seqs)
                    out["batch"].append(row)
                    log(f"batch {n}: {row}")
                    save()

    def long():
        rows = long_prompts()
        with b.server("bench-long") as srv:
            b.warm(srv)
            for L in LENGTHS:
                group = [r for r in rows if abs(r["length"] - L) < 64]
                row = dict(b.run(srv, group, 1), prompt_tokens=L)
                out["long"].append(row)
                log(f"context {L}: {row}")
                save()

    def k():
        if not sub:
            return
        for kk in (8, 12):
            with b.server(f"bench-k{kk}", num_speculative_tokens=kk) as srv:
                b.warm(srv)
                row = dict(b.run(srv, prompts, 1), num_speculative_tokens=kk)
                out["k"].append(row)
                log(f"K={kk}: {row}")
                save()

    section("batch", batch)
    section("long", long)
    section("k", k)
    log(f"wrote {dest}")
    return 0 if not out["errors"] else 1


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