File size: 6,361 Bytes
0cb039c | 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 | #!/usr/bin/env python3
"""Classify completed C++ corpus probes into actionable DecBench tiers.
Tier A: linked project ELF + DWARF + saved preprocessed C++ (.ii).
Tier B: linked project ELF + DWARF, but .ii needs regeneration/replay.
Tier C: clone/configure/build reached the project but needs a small build adapter.
Tier D: unsuitable/failed before producing a usable debug binary.
The final shortlist prefers A, then B, and ranks by approximate DWARF function
coverage plus number of usable debug images. Tier C is reported but never used
to fill the final 50 because it has not actually produced a qualified binary.
"""
from __future__ import annotations
import argparse
import csv
import json
from pathlib import Path
from typing import Any
def artifact_score(row: dict[str, Any]) -> float:
a = row.get("artifacts") or {}
funcs = int(a.get("dwarf_subprogram_count_sample") or 0)
bins = int(a.get("dwarf_elf_count") or 0)
ii = int(a.get("ii_count") or 0)
return min(funcs, 5000) + min(bins, 30) * 30 + min(ii, 200) * 5
def classify(row: dict[str, Any]) -> tuple[str, str]:
a = row.get("artifacts") or {}
linked = int(a.get("linked_elf_count") or 0)
dwarf = int(a.get("dwarf_elf_count") or 0)
ii = int(a.get("ii_count") or 0)
if linked > 0 and dwarf > 0 and ii > 0:
return "A", "oracle-ready: ELF + DWARF + .ii"
if linked > 0 and dwarf > 0:
return "B", "build+DWARF ready; regenerate .ii from compile commands"
clone_ok = int((row.get("clone") or {}).get("returncode", 1)) == 0
stage = row.get("failure_stage")
if clone_ok and stage in {"build", "artifact_oracle"}:
return "C", f"adapter candidate ({stage})"
return "D", f"rejected ({stage or 'unknown'})"
def load_rows(root: Path) -> list[dict[str, Any]]:
rows: list[dict[str, Any]] = []
seen: set[str] = set()
for p in sorted(root.rglob("*.json")):
try:
row = json.loads(p.read_text())
except Exception:
continue
if not isinstance(row, dict) or "repo" not in row:
continue
repo = str(row["repo"])
if repo in seen:
continue
seen.add(repo)
tier, reason = classify(row)
row["tier"] = tier
row["tier_reason"] = reason
row["selection_score"] = artifact_score(row)
rows.append(row)
return rows
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--probes", required=True)
ap.add_argument("--out", required=True)
ap.add_argument("--limit", type=int, default=50)
args = ap.parse_args()
out = Path(args.out)
out.mkdir(parents=True, exist_ok=True)
rows = load_rows(Path(args.probes))
rows.sort(key=lambda r: (r["tier"], -r["selection_score"], r["repo"].lower()))
tier_a = [r for r in rows if r["tier"] == "A"]
tier_b = [r for r in rows if r["tier"] == "B"]
tier_c = [r for r in rows if r["tier"] == "C"]
tier_d = [r for r in rows if r["tier"] == "D"]
final = (tier_a + tier_b)[: args.limit]
(out / "all-probes-classified.json").write_text(json.dumps(rows, indent=2) + "\n")
(out / "tier-a-oracle-ready.json").write_text(json.dumps(tier_a, indent=2) + "\n")
(out / "tier-b-build-dwarf.json").write_text(json.dumps(tier_b, indent=2) + "\n")
(out / "tier-c-adapter.json").write_text(json.dumps(tier_c, indent=2) + "\n")
(out / "final-50.json").write_text(json.dumps(final, indent=2) + "\n")
fields = ["rank", "repo", "tier", "selection_score", "linked_elf", "dwarf_elf", "ii", "dwarf_subprogram_sample", "revision", "build_system", "reason"]
with (out / "final-50.csv").open("w", newline="") as f:
w = csv.DictWriter(f, fieldnames=fields)
w.writeheader()
for i, r in enumerate(final, 1):
a = r.get("artifacts") or {}
w.writerow({
"rank": i,
"repo": r["repo"],
"tier": r["tier"],
"selection_score": r["selection_score"],
"linked_elf": a.get("linked_elf_count", 0),
"dwarf_elf": a.get("dwarf_elf_count", 0),
"ii": a.get("ii_count", 0),
"dwarf_subprogram_sample": a.get("dwarf_subprogram_count_sample", 0),
"revision": r.get("revision"),
"build_system": r.get("build_system"),
"reason": r["tier_reason"],
})
summary = {
"attempted_available": len(rows),
"tier_a_oracle_ready": len(tier_a),
"tier_b_build_dwarf": len(tier_b),
"tier_c_adapter": len(tier_c),
"tier_d_rejected": len(tier_d),
"build_qualified_a_plus_b": len(tier_a) + len(tier_b),
"final_selected": len(final),
"final_repos": [r["repo"] for r in final],
}
(out / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")
lines = [
"# DecBench C++ corpus funnel — build qualification summary",
"",
f"- completed probe artifacts available: **{len(rows)}**",
f"- Tier A (ELF + DWARF + `.ii`): **{len(tier_a)}**",
f"- Tier B (ELF + DWARF; `.ii` replay needed): **{len(tier_b)}**",
f"- Tier C (small build adapter needed): **{len(tier_c)}**",
f"- Tier D (rejected): **{len(tier_d)}**",
f"- actual build-qualified (A+B): **{len(tier_a)+len(tier_b)}**",
f"- selected: **{len(final)}**",
"",
"## Selected build-qualified targets",
"",
"| # | repository | tier | DWARF ELF | `.ii` | sampled DWARF subprograms |",
"|---:|---|:---:|---:|---:|---:|",
]
for i, r in enumerate(final, 1):
a = r.get("artifacts") or {}
lines.append(
f"| {i} | `{r['repo']}` | {r['tier']} | {a.get('dwarf_elf_count',0)} | {a.get('ii_count',0)} | {a.get('dwarf_subprogram_count_sample',0)} |"
)
lines += ["", "## Tier C — adapter candidates", ""]
for r in tier_c[:30]:
lines.append(f"- `{r['repo']}` — {r['tier_reason']}")
(out / "summary.md").write_text("\n".join(lines) + "\n")
print(json.dumps(summary))
return 0
if __name__ == "__main__":
raise SystemExit(main())
|