| """Benchmark gains documented in PR descriptions: fetch bodies (gh) and extract measurements (LLM, HF Inference).""" |
|
|
| import json |
| import re |
| import statistics |
| import subprocess |
| import sys |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| from huggingface_hub import InferenceClient |
|
|
| CACHE = Path(__file__).parent / ".context/prs" |
| MODEL = "Qwen/Qwen3-235B-A22B-Instruct-2507" |
| FALLBACK = "openai/gpt-oss-120b:cerebras" |
| MAX_BODY = 24_000 |
| MAX_SOURCE, CHUNK = 80_000, 4_000 |
| |
| HAS_NUMBERS = re.compile(r"\d+(?:\.\d+)?\s?(?:[x×](?![\w\d])|%|us\b|µs|ms\b|tflops|gb/s|tok/s|tokens/s)", re.I) |
|
|
| PROMPT = """Extract the performance measurements from this GitHub pull request description of a GPU kernel change. |
| |
| Only extract before-vs-after comparisons where the baseline is the code/config BEFORE this PR (main, default config, \ |
| previous kernel, "before") and the optimized side is THIS PR ("after", "tuned", "PR"). Skip comparisons against other \ |
| libraries or alternatives, accuracy/eval scores, and anything not explicitly in the text. Never invent or compute numbers. |
| |
| Return JSON: {{"measurements": [{{ |
| "scope": "kernel" | "e2e", // kernel micro-benchmark vs end-to-end serving/model benchmark |
| "hardware": str | null, // e.g. "H100", "B200", "MI300X" |
| "model": str | null, // e.g. "DeepSeek-V3" |
| "shape": str | null, // other shape params, e.g. "N=7168,K=2048" or "hidden=4096" |
| "batch_size": int | null, // batch size / num tokens / M, if the row has one |
| "metric": str, // e.g. "latency", "throughput", "TFLOPS" |
| "unit": str | null, // e.g. "us", "tok/s" |
| "higher_is_better": bool, // false for latency/time, true for throughput/TFLOPS/bandwidth |
| "baseline": number | null, |
| "optimized": number | null, |
| "stated_speedup": number | null // ONLY if the text states a speedup ratio without raw values (e.g. "1.3x" -> 1.3, "+20%" -> 1.2) |
| }}]}} |
| Return {{"measurements": []}} if there are none. One entry per table row / reported number. |
| |
| PR title: {title} |
| |
| PR description: |
| {body}""" |
|
|
|
|
| def _key(repo: str, n: int) -> str: |
| return f"{repo.replace('/', '__')}-{n}" |
|
|
|
|
| def pr_body(repo: str, n: int) -> str | None: |
| """PR description, or None if the fetch failed (so callers don't cache a fake empty body).""" |
| f = CACHE / f"{_key(repo, n)}.md" |
| if not f.exists(): |
| r = subprocess.run(["gh", "api", f"repos/{repo}/pulls/{n}", "--jq", '.body // ""'], capture_output=True, text=True) |
| if r.returncode and "404" not in r.stderr: |
| print(f" gh {repo}#{n}: {r.stderr.strip()[:100]}", file=sys.stderr) |
| return None |
| f.write_text(r.stdout if not r.returncode else "") |
| return f.read_text() |
|
|
|
|
| def speedup(m: dict) -> float | None: |
| """Normalized so > 1 means this PR is better.""" |
| b, o = m.get("baseline"), m.get("optimized") |
| if isinstance(b, (int, float)) and isinstance(o, (int, float)) and b > 0 and o > 0: |
| return round(o / b if m.get("higher_is_better") else b / o, 4) |
| s = m.get("stated_speedup") |
| return float(s) if isinstance(s, (int, float)) and s > 0 else None |
|
|
|
|
| def chunks(body: str) -> list[str]: |
| """Split on blank lines into <= CHUNK pieces: one call per long benchmark table section stays under the |
| gateway timeout. An oversized paragraph (a giant table) is split by lines, repeating its 2 header lines.""" |
| out = [""] |
| for para in body[:MAX_SOURCE].split("\n\n"): |
| lines = para.splitlines() |
| pieces = [para] if len(para) <= CHUNK else [ |
| "\n".join(lines[:2] + lines[i : i + 60]) for i in range(2, len(lines), 60)] |
| for p in pieces: |
| if out[-1] and len(out[-1]) + len(p) > CHUNK: |
| out.append("") |
| out[-1] += p + "\n\n" |
| return out |
|
|
|
|
| def _llm(client: InferenceClient, content: str) -> list[dict]: |
| for attempt, model in enumerate([MODEL, FALLBACK, FALLBACK]): |
| try: |
| r = client.chat_completion(model=model, max_tokens=16000, temperature=0, response_format={"type": "json_object"}, |
| messages=[{"role": "user", "content": content}]) |
| return json.loads(r.choices[0].message.content)["measurements"] |
| except Exception: |
| if attempt == 2: |
| raise |
|
|
|
|
| def extract(repo: str, n: int, title: str, client: InferenceClient) -> list[dict]: |
| f = CACHE / f"{_key(repo, n)}.gains.json" |
| if f.exists(): |
| return json.loads(f.read_text()) |
| body = pr_body(repo, n) |
| if body is None: |
| return [] |
| ms = [] |
| if HAS_NUMBERS.search(body): |
| parts = chunks(body) |
| try: |
| for i, part in enumerate(parts): |
| ctx = "" if i == 0 else f"(Part {i + 1}/{len(parts)}. For context only, the description starts: " \ |
| f"{body[:1200]!r}. Extract ONLY from the part below.)\n\n" |
| ms += _llm(client, PROMPT.format(title=title, body=ctx + part)) |
| except Exception as e: |
| print(f" llm {repo}#{n}: {type(e).__name__} {str(e)[:100]}", file=sys.stderr) |
| return [] |
| ms = [m | {"speedup": speedup(m)} for m in ms if isinstance(m, dict)] |
| ms = [m for m in ms if m["speedup"] and 0.01 < m["speedup"] < 1000] |
| f.write_text(json.dumps(ms)) |
| return ms |
|
|
|
|
| def fetch_all(prs: dict[tuple[str, int], str], workers: int = 24) -> dict[tuple[str, int], tuple[str, list[dict]]]: |
| """{(gh_repo, pr): title} -> {(gh_repo, pr): (body, measurements)}""" |
| CACHE.mkdir(parents=True, exist_ok=True) |
| client = InferenceClient() |
| keys = sorted(prs) |
| with ThreadPoolExecutor(workers) as ex: |
| bodies = list(ex.map(lambda k: pr_body(*k), keys)) |
| gains = list(ex.map(lambda k: extract(*k, prs[k], client), keys)) |
| print(f" PRs: {len(keys)}, with gains: {sum(bool(g) for g in gains)}", file=sys.stderr) |
| return {k: (b or "", g) for k, b, g in zip(keys, bodies, gains)} |
|
|
|
|
| def summarize(ms: list[dict], scope: str) -> float | None: |
| s = [m["speedup"] for m in ms if m.get("scope") == scope] |
| return round(statistics.median(s), 4) if s else None |
|
|
