"""Build a kernel-optimization RL dataset from vLLM / SGLang / FlashInfer source and git history. Subsets: tuned_configs - (Triton kernel source, model shape, GPU, batch size) -> autotuned launch config. kernel_commits - before/after kernel code from performance commits, tagged with model + hardware. Usage: uv run build.py [--push REPO_ID] [--from-disk] """ import ast import difflib import functools import hashlib import json import re import statistics import subprocess import sys from pathlib import Path from datasets import Dataset, DatasetDict, load_from_disk from huggingface_hub import HfApi, hf_hub_download import gains ROOT = Path(__file__).parent REPOS = ROOT / ".context/repos" OUT = ROOT / ".context/out" GITHUB = {"vllm": "vllm-project/vllm", "sglang": "sgl-project/sglang", "flashinfer": "flashinfer-ai/flashinfer"} # --------------------------------------------------------------------------- git helpers def git(repo: str, *args: str) -> str: return subprocess.run(["git", "-C", str(REPOS / repo), *args], capture_output=True, check=True).stdout.decode( "utf-8", "replace" ) def ensure_clone(repo: str) -> None: # Blobless clone: full history (commits+trees) but file contents are fetched on demand. if not (REPOS / repo).exists(): REPOS.mkdir(parents=True, exist_ok=True) subprocess.run( ["git", "clone", "-q", "--filter=blob:none", "--no-checkout", f"https://github.com/{GITHUB[repo]}", str(REPOS / repo)], check=True, ) def fetch_blobs(repo: str, oids: list[str]) -> None: # One round trip per 2k blobs instead of git's lazy one-blob-per-request fetch. oids = sorted(set(oids)) for i in range(0, len(oids), 2000): git(repo, "-c", "fetch.negotiationAlgorithm=noop", "fetch", "-q", "--no-tags", "--no-write-fetch-head", "--filter=blob:none", "origin", *oids[i : i + 2000]) def blob(repo: str, oid: str) -> str: return git(repo, "cat-file", "-p", oid) def ls_tree(repo: str, prefix: str) -> list[tuple[str, str]]: """(oid, path) for every file under prefix at HEAD.""" rows = [line.split(None, 3) for line in git(repo, "ls-tree", "-r", "HEAD", "--", prefix).splitlines()] return [(r[2], r[3]) for r in rows if r[1] == "blob"] LICENSE_RE = re.compile(r"SPDX-License-Identifier:\s*([^\n*]+)|(proprietary rights|TensorRT Source Code License)" r"|(Apache License)|(Redistribution and use in source and binary forms)|(Permission is hereby granted)", re.I) def file_license(code: str) -> str: """License declared in the file header; header-less files inherit their repo's Apache-2.0.""" m = LICENSE_RE.search(code[:5000]) if not m: return "Apache-2.0" spdx, proprietary, apache, bsd, mit = m.groups() return spdx.strip() if spdx else "proprietary" if proprietary else "Apache-2.0" if apache else "BSD" if bsd else "MIT" def permissive(lic: str) -> bool: return lic.startswith(("Apache-2.0", "BSD", "MIT")) @functools.cache def head_license(repo: str, path: str) -> str: return file_license(git(repo, "show", f"HEAD:{path}")) def stage_licenses() -> Path: """Upstream LICENSE/NOTICE files: Apache-2.0 sec. 4 requires shipping them with redistributed code.""" for repo in GITHUB: files = [(o, p) for o, p in ls_tree(repo, ".") if re.match(r"(LICENSE|NOTICE|licenses/)", p)] fetch_blobs(repo, [o for o, _ in files]) for oid, p in files: dst = OUT / "licenses" / repo / p dst.parent.mkdir(parents=True, exist_ok=True) dst.write_text(blob(repo, oid)) return OUT / "licenses" # --------------------------------------------------------------------------- subset 1: tuned configs CONFIG_DIRS = [ ("vllm", "vllm/model_executor/layers/fused_moe/configs/"), ("vllm", "vllm/model_executor/layers/quantization/utils/configs/"), ("vllm", "vllm/model_executor/layers/mamba/ops/configs/selective_state_update/"), ("sglang", "python/sglang/srt/layers/moe/moe_runner/triton_utils/configs/"), ("sglang", "python/sglang/kernels/ops/gemm/configs/"), ] def pick_kernel(repo: str, cfg_dir: str, dtype: str, block_shape: str | None) -> tuple[str, str] | None: """Mirror each repo's runtime dispatch: (file, @triton.jit fn) that consumes this config, or None.""" if "moe" in cfg_dir: f = {"vllm": "vllm/model_executor/layers/fused_moe/fused_moe.py", "sglang": "python/sglang/kernels/ops/moe/fused_moe_triton_kernels.py"}[repo] return f, "fused_moe_kernel_gptq_awq" if dtype.startswith("int4_w4a16") else "fused_moe_kernel" if "mamba" in cfg_dir: return "vllm/model_executor/layers/mamba/ops/mamba_ssm.py", "_selective_scan_update_kernel" if not block_shape: # channelwise / bf16 GEMM configs feed other kernels return None if repo == "vllm": # vllm's int8 block configs are orphaned (kernel removed upstream) return ("vllm/model_executor/layers/quantization/utils/fp8_utils.py", "_w8a8_triton_block_scaled_mm") \ if dtype.startswith("fp8") else None if dtype.startswith("int8"): return "python/sglang/kernels/ops/gemm/int8_kernel.py", "_w8a8_block_int8_matmul" if dtype.startswith("fp8"): return "python/sglang/kernels/ops/gemm/fp8_kernel.py", "_w8a8_block_fp8_matmul" return None # ponytail: hand-picked MoE models for shape->model matching; add repo ids here to widen coverage. MOE_MODELS = [ "mistralai/Mixtral-8x7B-v0.1", "mistralai/Mixtral-8x22B-v0.1", "deepseek-ai/DeepSeek-V2-Lite", "deepseek-ai/DeepSeek-V2", "deepseek-ai/DeepSeek-V3", "moonshotai/Kimi-K2-Instruct", "Qwen/Qwen1.5-MoE-A2.7B", "Qwen/Qwen2-57B-A14B", "Qwen/Qwen3-30B-A3B", "Qwen/Qwen3-235B-A22B", "Qwen/Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-Next-80B-A3B-Instruct", "openai/gpt-oss-20b", "openai/gpt-oss-120b", "meta-llama/Llama-4-Scout-17B-16E-Instruct", "meta-llama/Llama-4-Maverick-17B-128E-Instruct", "databricks/dbrx-instruct", "allenai/OLMoE-1B-7B-0924", "ai21labs/AI21-Jamba-Mini-1.5", "zai-org/GLM-4.5", "zai-org/GLM-4.5-Air", "zai-org/GLM-4.6", "MiniMaxAI/MiniMax-M2", "microsoft/Phi-3.5-MoE-instruct", "baidu/ERNIE-4.5-21B-A3B-PT", "baidu/ERNIE-4.5-300B-A47B-PT", "tencent/Hunyuan-A13B-Instruct", "ibm-granite/granite-3.1-3b-a800m-instruct", "deepseek-ai/deepseek-moe-16b-base", "jetmoe/jetmoe-8b", "meituan-longcat/LongCat-Flash-Chat", "inclusionAI/Ling-lite-1.5", "XiaomiMiMo/MiMo-V2-Flash", ] EXPERT_KEYS = ["num_local_experts", "n_routed_experts", "num_experts", "moe_num_experts"] INTER_KEYS = ["moe_intermediate_size", "expert_ffn_hidden_size", "intermediate_size", "ffn_hidden_size"] def moe_shapes() -> dict[str, tuple[int, int]]: """model -> (num_experts, per-expert intermediate size), cached on disk.""" cache = OUT / "moe_models.json" if cache.exists(): return {k: tuple(v) for k, v in json.loads(cache.read_text()).items()} shapes = {} for rid in MOE_MODELS: try: cfg = json.loads(Path(hf_hub_download(rid, "config.json")).read_text()) except Exception as e: # gated / renamed repos are just skipped print(f" skip {rid}: {type(e).__name__}", file=sys.stderr) continue cfg = cfg.get("text_config") or cfg.get("ffn_config", {}) | cfg e = next((cfg[k] for k in EXPERT_KEYS if isinstance(cfg.get(k), int)), None) n = next((cfg[k] for k in INTER_KEYS if isinstance(cfg.get(k), int)), None) if e and n: shapes[rid.split("/")[1]] = (e, n) cache.write_text(json.dumps(shapes, indent=1)) return shapes def match_models(E: int, N: int, shapes: dict) -> list[str]: """Models whose MoE layer yields this (E, N) under tensor parallel (N=I/tp) or expert parallel (E=experts/ep).""" out = [] for name, (experts, inter) in shapes.items(): out += [f"{name} (TP{tp})" for tp in (1, 2, 4, 8, 16) if E == experts and N * tp == inter] out += [f"{name} (EP{ep})" for ep in (2, 4, 8, 16, 32) if N == inter and E * ep == experts] return out def parse_config_name(name: str) -> dict: """'E=8,N=14336,device_name=NVIDIA_H100,block_shape=[128, 128].json' -> dict.""" return {k: v for k, v in re.findall(r"(\w+)=(\[[^\]]*\]|[^,]+)", name.removesuffix(".json"))} @functools.cache def kernel_source(repo: str, path: str, fn: str) -> str | None: code = git(repo, "show", f"HEAD:{path}") for node in ast.walk(ast.parse(code)): if isinstance(node, ast.FunctionDef) and node.name == fn: start = min([d.lineno for d in node.decorator_list] + [node.lineno]) return "\n".join(code.splitlines()[start - 1 : node.end_lineno]) return None def config_prompt(r: dict) -> str: spec = "\n".join(f"- {k}: {v}" for k, v in r["shape"].items()) models = ", ".join(r["candidate_models"]) or "unknown" return ( f"You are tuning the Triton kernel `{r['kernel_name']}` (from {r['repo']}) for one deployment.\n\n" f"Hardware: {r['device_name']}\nQuant dtype: {r['dtype']}\nProblem shape:\n{spec}\n" f"Batch size (tokens, M): {r['M']}\nModels with this shape: {models}\n\n" f"Kernel source:\n```python\n{r['kernel_source']}\n```\n\n" f"Pick the fastest launch configuration. Answer with a JSON object with exactly these keys: " f"{', '.join(json.loads(r['best_config']))}." ) def config_prs(repo: str, prefix: str) -> dict[str, tuple[int | None, int]]: """config path -> (PR of the newest commit that added/changed it, #config files that commit touched).""" log = git(repo, "log", "--no-renames", "--diff-filter=AM", "--format=%x00%s", "--name-only", "--", prefix) out = {} for chunk in log.split("\x00")[1:]: subject, *paths = [l for l in chunk.splitlines() if l] pr = re.search(r"\(#(\d+)\)\s*$", subject) for p in paths: out.setdefault(p, (int(pr[1]) if pr else None, len(paths))) return out def same_gpu(hw: str | None, device: str) -> bool: """Token match: 'H100' ~ 'NVIDIA_H100_80GB_HBM3', but 'H20' never matches 'NVIDIA_H200'.""" toks = lambda s: set(re.split(r"[^A-Z0-9]+", s.upper())) - {"", "NVIDIA", "AMD", "INSTINCT"} return bool(hw) and toks(hw) <= toks(device) def shape_ok(shape: str | None, meta: dict) -> bool: """No key=value in the measurement's shape contradicts the config's own (E, N, K, headdim, ...).""" got = {k.lower(): v for k, v in re.findall(r"(\w+)\s*=\s*([^,;\s]+)", shape or "")} return all(got[k.lower()] == str(v) for k, v in meta.items() if k.lower() in got) def gain_at(ms: list[dict], M: int, device: str, meta: dict, n_files: int) -> float | None: """Documented kernel speedup of the tuned config over the default at batch size M, only when unambiguous.""" c = [m for m in ms if m.get("scope") == "kernel" and m.get("batch_size") == M and shape_ok(m.get("shape"), meta)] if n_files > 1: # PR tuned several files: only trust rows that name this GPU c = [m for m in c if same_gpu(m.get("hardware"), device)] s = [m["speedup"] for m in c] # rows that disagree (e.g. per-dtype tables the extractor didn't label) -> don't guess return round(statistics.median(s), 4) if s and max(s) / min(s) <= 1.05 else None def build_tuned_configs() -> list[dict]: shapes = moe_shapes() print(f" {len(shapes)} MoE model shapes", file=sys.stderr) rows = [] for repo, prefix in CONFIG_DIRS: files = [(o, p) for o, p in ls_tree(repo, prefix) if p.endswith(".json")] fetch_blobs(repo, [o for o, _ in files]) sha = git(repo, "rev-parse", "HEAD").strip() prs = config_prs(repo, prefix) for oid, path in files: pr, n_files = prs.get(path, (None, 0)) meta = parse_config_name(Path(path).name) dtype = meta.pop("dtype", "bf16/fp16") device = meta.pop("device_name", None) block_shape = meta.pop("block_shape", None) kernel = pick_kernel(repo, prefix, dtype, block_shape) src = kernel and kernel_source(repo, *kernel) if not device or not src: print(f" skip {path}: no device or kernel {kernel}", file=sys.stderr) continue kfile, kfn = kernel if not permissive(head_license(repo, kfile)): continue table = json.loads(blob(repo, oid)) triton_dir = re.search(r"triton_(\d+_\d+_\d+)", path) triton_ver = table.pop("triton_version", None) or (triton_dir and triton_dir[1].replace("_", ".")) E, N = meta.get("E"), meta.get("N") cands = match_models(int(E), int(N), shapes) if E and N and "fused_moe" in kfn else [] for M, cfg in table.items(): if not M.isdigit() or not isinstance(cfg, dict): continue r = dict( repo=repo, commit=sha, config_path=path, kernel_file=kfile, kernel_name=kfn, kernel_source=src, license=head_license(repo, kfile), device_name=device, dtype=dtype, block_shape=block_shape, triton_version=triton_ver, shape=meta, M=int(M), candidate_models=cands, best_config=json.dumps(cfg), config_pr=pr, config_pr_files=n_files, # group by basename so the same shape (any repo / triton version / M) never straddles splits split="test" if int(hashlib.md5(Path(path).name.encode()).hexdigest(), 16) % 10 == 0 else "train", ) r["prompt"] = config_prompt(r) r["shape"] = json.dumps(meta) rows.append(r) print(f" {repo}:{prefix} -> {len(rows)} rows so far", file=sys.stderr) docs = gains.fetch_all({(GITHUB[r["repo"]], r["config_pr"]): Path(r["config_path"]).name for r in rows if r["config_pr"]}) for r in rows: pr, n_files = r.pop("config_pr"), r.pop("config_pr_files") ms = docs[(GITHUB[r["repo"]], pr)][1] if pr else [] r["config_pr_url"] = f"https://github.com/{GITHUB[r['repo']]}/pull/{pr}" if pr else None r["config_pr_gains"] = json.dumps(ms) r["speedup_vs_default"] = gain_at(ms, r["M"], r["device_name"], json.loads(r["shape"]), n_files) return rows # --------------------------------------------------------------------------- subset 2: kernel commits KERNEL_PATHS = { "vllm": ["csrc", "vllm/model_executor/layers", "vllm/attention", "vllm/v1/attention", "vllm/kernels"], "sglang": ["sgl-kernel", "python/sglang/srt/layers", "python/sglang/kernels"], "flashinfer": ["include", "csrc", "flashinfer"], } PERF_GREP = r"\[perf\]|optimi|speed ?up|faster|perf|tune|tuning|accelerat|throughput|latency" PERF_TITLE = re.compile(PERF_GREP, re.I) # git --grep also hits PR bodies; require the signal in the title SKIP_TITLE = re.compile(r"^revert|\[(build|ci|ci/build|doc|docs|test|tests|misc)\]|compil|\bjit\b|wheel|\bci\b", re.I) SKIP_PATH = re.compile(r"(^|/)(tests?|benchmarks?|docs?|examples?|configs?)/") LANG = {".cu": "cuda", ".cuh": "cuda", ".cpp": "cpp", ".cc": "cpp", ".h": "cpp", ".hpp": "cpp", ".py": "python"} MAX_FILES_PER_COMMIT, MAX_BYTES, MAX_CHANGED = 10, 120_000, 800 FAMILIES = { "deepseek": r"deep ?seek|\bdsv\d|\bds-?v\d|\bds-?r1\b", "qwen": r"qwen", "llama": r"llama", "mixtral": r"mixtral", "mistral": r"mistral|ministral", "kimi": r"kimi|moonshot", "glm": r"\bglm", "gpt-oss": r"gpt-?oss", "gemma": r"gemma", "minimax": r"minimax", "mamba": r"mamba|nemotron-?h\b", "nemotron": r"nemotron", "phi": r"\bphi-?\d", "grok": r"grok", "ernie": r"ernie", "hunyuan": r"hunyuan", "jamba": r"jamba", "dbrx": r"dbrx", "olmo": r"olmo", "granite": r"granite", "llava/vlm": r"llava|\bvlm\b|\bvision\b", } HW_RE = re.compile( r"\b(H(?:20|100|200|800)|GB?[23]00|B[23]00|A100|A10G?|L40S?|L4|RTX ?\d{4}|MI3\d{2}X?|gfx\d{3,4}|sm_?\d{2,3}a?" r"|hopper|blackwell|ampere|ada|rocm|xpu|npu|cpu|tpu|gaudi)\b", re.I) SPEEDUP_RE = re.compile(r"\b\d+(?:\.\d+)?\s?[x×](?![\w\d])") def kernel_lang(path: str, code: str) -> str | None: lang = LANG.get(Path(path).suffix) if lang != "python": return lang if "@triton.jit" in code or "@triton.autotune" in code: return "triton" if "cutlass.cute" in code or "@cute.kernel" in code: return "cute_dsl" return None # plain Python glue isn't a kernel def tags(text: str) -> tuple[list[str], list[str], list[str]]: low = text.lower() models = [f for f, rx in FAMILIES.items() if re.search(rx, low)] hw = sorted({re.sub(r"^(SM\d+)A$", r"\1", re.sub(r"[ _]", "", h.upper())) for h in HW_RE.findall(text)}) return models, hw, SPEEDUP_RE.findall(text)[:10] def perf_commits(repo: str) -> list[dict]: log = git(repo, "log", "--no-merges", "--no-renames", "-i", "-E", f"--grep={PERF_GREP}", "--format=%x00%H%x1f%aI%x1f%B%x1e", "--raw", "--no-abbrev", "--", *KERNEL_PATHS[repo]) commits = [] for chunk in log.split("\x00")[1:]: head, raw = chunk.split("\x1e", 1) sha, date, msg = head.split("\x1f", 2) title = msg.strip().splitlines()[0] if not PERF_TITLE.search(title) or SKIP_TITLE.search(title): continue files = [] for line in raw.strip().splitlines(): meta, path = line.split("\t", 1) _, _, old, new, status = meta.split() if status == "M" and Path(path).suffix in LANG and not SKIP_PATH.search(path): files.append((path, old, new)) if 0 < len(files) <= MAX_FILES_PER_COMMIT: commits.append(dict(sha=sha, date=date, msg=msg.strip(), files=files)) return commits EDIT_FORMAT = """Respond with one or more edits to the file, each in exactly this format: <<<<<<< SEARCH (exact, contiguous lines copied from the current file) ======= (the replacement lines) >>>>>>> REPLACE""" FENCE = {"cuda": "cuda", "cpp": "cpp", "triton": "python", "cute_dsl": "python"} def commit_prompt(r: dict) -> str: # the PR title is the task statement (like the issue in SWE-RL); the PR body is withheld since it describes the fix goal = re.sub(r"\s*\(#\d+\)\s*$", "", r["title"]) return ( f"Optimize this {r['language']} kernel file from {r['repo']} ({r['path']}).\n\n" f"Goal: {goal}\nTarget hardware: {', '.join(r['hardware_mentioned']) or 'unspecified'}\n" f"Target models: {', '.join(r['models_mentioned']) or 'unspecified'}\n\n" f"Current file:\n```{FENCE[r['language']]}\n{r['before_code']}\n```\n\n{EDIT_FORMAT}" ) def build_kernel_commits() -> list[dict]: rows = [] for repo in KERNEL_PATHS: commits = perf_commits(repo) fetch_blobs(repo, [o for c in commits for _, a, b in c["files"] for o in (a, b)]) for c in commits: title = c["msg"].splitlines()[0] pr = re.search(r"\(#(\d+)\)", title) for path, old, new in c["files"]: before, after = blob(repo, old), blob(repo, new) lang = kernel_lang(path, after) lic = file_license(after) if not lang or max(len(before), len(after)) > MAX_BYTES or not (permissive(lic) and permissive(file_license(before))): continue diff = list(difflib.unified_diff(before.splitlines(), after.splitlines(), path, path, lineterm="")) added = sum(1 for l in diff if l.startswith("+") and not l.startswith("+++")) removed = sum(1 for l in diff if l.startswith("-") and not l.startswith("---")) if not 0 < added + removed <= MAX_CHANGED: continue models, hw, speedups = tags(c["msg"] + "\n" + path) rows.append(dict( repo=repo, commit=c["sha"], date=c["date"], pr_number=int(pr[1]) if pr else None, pr_url=f"https://github.com/{GITHUB[repo]}/pull/{pr[1]}" if pr else None, title=title, message=c["msg"][:8000], path=path, language=lang, license=lic, before_code=before, after_code=after, diff="\n".join(diff), lines_added=added, lines_removed=removed, files_in_commit=len(c["files"]), models_mentioned=models, hardware_mentioned=hw, speedup_claims=speedups, )) rows[-1]["prompt"] = commit_prompt(rows[-1]) print(f" {repo}: {len(commits)} commits -> {len(rows)} rows so far", file=sys.stderr) docs = gains.fetch_all({(GITHUB[r["repo"]], r["pr_number"]): r["title"] for r in rows if r["pr_number"]}) for r in rows: body, ms = docs[(GITHUB[r["repo"]], r["pr_number"])] if r["pr_number"] else ("", []) r |= dict(pr_body=body[:gains.MAX_BODY], gains=json.dumps(ms), kernel_speedup=gains.summarize(ms, "kernel"), e2e_speedup=gains.summarize(ms, "e2e")) # temporal split: newest ~10% of commits is test (closest to post-training-cutoff code) cutoff = sorted(r["date"] for r in rows)[int(len(rows) * 0.9)] for r in rows: r["split"] = "test" if r["date"] >= cutoff else "train" return rows # --------------------------------------------------------------------------- main def to_dd(rows: list[dict]) -> DatasetDict: return DatasetDict({s: Dataset.from_list([{k: v for k, v in r.items() if k != "split"} for r in rows if r["split"] == s]) for s in ("train", "test")}) if __name__ == "__main__": OUT.mkdir(parents=True, exist_ok=True) for repo in GITHUB: ensure_clone(repo) if "--from-disk" in sys.argv: # push the last build (e.g. after editing only the card) subsets = {name: load_from_disk(OUT / name) for name in ("tuned_configs", "kernel_commits")} else: subsets = {"tuned_configs": to_dd(build_tuned_configs()), "kernel_commits": to_dd(build_kernel_commits())} for name, dd in subsets.items(): print(name, dd, file=sys.stderr) dd.save_to_disk(OUT / name) if "--push" in sys.argv: repo_id = sys.argv[sys.argv.index("--push") + 1] for name, dd in subsets.items(): dd.push_to_hub(repo_id, config_name=name) HfApi().upload_folder(folder_path=stage_licenses(), path_in_repo="licenses", repo_id=repo_id, repo_type="dataset") HfApi().upload_folder(folder_path=ROOT, path_in_repo="code", repo_id=repo_id, repo_type="dataset", allow_patterns=["build.py", "gains.py", "reward.py", "test_build.py", "pyproject.toml", "uv.lock"]) # our card carries the `configs:` YAML, so it replaces the auto-generated one HfApi().upload_file(path_or_fileobj=ROOT / "README.md", path_in_repo="README.md", repo_id=repo_id, repo_type="dataset")