Baseline: tree as shared

This commit is contained in:
alexm committed 2026-10-05 03:03:38 +00:00
commit 31f2fb8a5a
1679 files changed
+1024562

No files matched your search

+125
View File
@@ -0,0 +1,125 @@
"""Compiler Explorer, the oracle every corpus item is checked against.
Requests follow Mojo Quest's (src/lib/compile.ts), which its CI runs against
the same compiler id, so a result here means what it means there:
run compile and execute in one request (an "executor request"); the
answer has buildResult.code, didExecute, code, stdout, stderr, timedOut
asm compile only and return the Intel-syntax listing with source lines
both compile with the listing AND execute; whether one request returns
both is itself a probe (probes/godbolt-asm-and-run.mojo)
Every answer is normalised to one shape, `Result`, and kept beside the raw
JSON (minus a listing duplicated in `asm`) so a later reading can change.
"""
from __future__ import annotations
import json
import time
import urllib.error
import urllib.request
from typing import Any
from .common import PipelineError
USER_AGENT = "programming-plus-mojo-corpus/0.1 (+https://pplus.scient.ing; corpus verification, low rate)"
ASM_FILTERS = {"binary": False, "execute": False, "intel": True, "demangle": True, "labels": True,
"libraryCode": False, "directives": True, "commentOnly": True, "trim": True}
def request_body(source: str, mode: str = "run", stdin: str = "", args: str = "") -> dict[str, Any]:
if mode == "run":
options = {"userArguments": args, "executeParameters": {"args": [], "stdin": stdin},
"compilerOptions": {"executorRequest": True, "skipAsm": True},
"filters": {"execute": True}, "tools": [], "libraries": []}
elif mode == "asm":
options = {"userArguments": args, "compilerOptions": {"executorRequest": False, "skipAsm": False},
"filters": dict(ASM_FILTERS), "tools": [], "libraries": []}
elif mode == "both":
options = {"userArguments": args, "executeParameters": {"args": [], "stdin": stdin},
"compilerOptions": {"executorRequest": False, "skipAsm": False},
"filters": {**ASM_FILTERS, "execute": True}, "tools": [], "libraries": []}
else:
raise PipelineError(f"unknown godbolt mode {mode!r}")
return {"source": source, "options": options, "lang": "mojo", "allowStoreCodeDebug": False}
def _lines(arr: Any) -> str:
return "\n".join((x.get("text", "") if isinstance(x, dict) else str(x)) for x in arr) if isinstance(arr, list) else ""
def normalise(mode: str, data: dict[str, Any]) -> dict[str, Any]:
"""One shape for every mode: compiled, buildStderr, executed, exitCode, stdout, stderr, timedOut, asm."""
if mode == "run":
build = data.get("buildResult") or {}
return {
"compiled": build.get("code") == 0,
"buildStderr": _lines(build.get("stderr")),
"executed": bool(data.get("didExecute")),
"exitCode": data.get("code") if isinstance(data.get("code"), int) else None,
"stdout": _lines(data.get("stdout")),
"stderr": _lines(data.get("stderr")),
"timedOut": bool(data.get("timedOut")),
"asm": None,
}
exe = data.get("execResult") or {}
asm = [asm_line(a) for a in data.get("asm") or [] if isinstance(a, dict)]
return {
"compiled": data.get("code") == 0,
"buildStderr": _lines(data.get("stderr")),
"executed": bool(exe.get("didExecute")) if exe else False,
"exitCode": exe.get("code") if isinstance(exe.get("code"), int) else None,
"stdout": _lines(exe.get("stdout")),
"stderr": _lines(exe.get("stderr")),
"timedOut": bool(exe.get("timedOut")),
"asm": asm,
"returnedAsm": bool(asm),
"returnedExec": bool(exe),
}
def asm_line(a: dict[str, Any]) -> dict[str, Any]:
"""One listing line, with where it came from. `file` and `main` keep godbolt's marking of the source
file as given (`source.file`, `source.mainsource`), so the instructions inlined from the standard
library, whose lines are lines of the library's files, can be told from the program's own."""
src = a.get("source") or {}
out: dict[str, Any] = {"text": a.get("text", ""), "line": src.get("line")}
if src:
out["file"] = src.get("file")
if "mainsource" in src:
out["main"] = src.get("mainsource")
return out
def slim_raw(data: dict[str, Any]) -> dict[str, Any]:
return {k: v for k, v in data.items() if k not in ("asm", "popularArguments")}
def post(base: str, compiler: str, body: dict[str, Any], timeout: int = 90, retries: int = 5,
attempts: list[int] | None = None) -> dict[str, Any]:
"""POST and return the answer. `attempts`, if given, receives how many tries it took, so a slow
answer can be told apart from a slow compile (godbolt reports its own compile time separately)."""
url = f"{base}/api/compiler/{urllib.request.quote(compiler, safe='')}/compile"
data = json.dumps(body).encode()
delay = 2.0
for attempt in range(retries + 1):
req = urllib.request.Request(url, data=data, method="POST", headers={
"Content-Type": "application/json", "Accept": "application/json", "User-Agent": USER_AGENT})
if attempts is not None:
attempts[:] = [attempt + 1]
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read().decode("utf-8"))
except urllib.error.HTTPError as e:
if e.code in (429, 500, 502, 503, 504) and attempt < retries:
wait = float(e.headers.get("Retry-After") or delay)
time.sleep(min(wait, 120)); delay *= 2
continue
raise PipelineError(f"godbolt answered HTTP {e.code} for {compiler}") from e
except (urllib.error.URLError, TimeoutError) as e:
if attempt < retries:
time.sleep(delay); delay *= 2
continue
raise PipelineError(f"godbolt unreachable: {e}") from e
raise AssertionError("unreachable")