| |
| """Build the released CircuitQA corpus from the template questions and the repository-disjoint split. |
| |
| For every record the design's full source is recovered from its upstream repository (accepted |
| only if it matches the text the question was generated from), the record's backend is run on |
| that source with the question's own parameters (timing and power optimisation questions use the |
| delay and power targets), and the answer is computed from the backend output with the question |
| template. Records are kept only if the backend measures the design: records whose backend reports |
| an error, simulations whose generated testbench does not compile or run, cross-stage mappings |
| whose synthesis produced no netlist, and toggle-rate questions about a signal that is not in the |
| recorded waveform are not included. Simulation activity is measured from the VCD waveform. |
| |
| Steps: |
| python3 corpus_v2.py candidates -> splits/v2/candidates.jsonl (resolve with corpus_resolve.py) |
| python3 corpus_v2.py calls -> splits/v2/calls.jsonl (run with mt_ground.py) |
| python3 corpus_v2.py build -> splits/v2/{train,val,test}.jsonl |
| """ |
| import json, re, sys, os, hashlib, collections |
| REV = os.path.dirname(os.path.abspath(__file__)); os.chdir(REV) |
| os.makedirs("splits/v2", exist_ok=True) |
| SPLITS = ("train", "val", "test") |
| def did(r): return hashlib.sha256((r["source_file"] + "::" + r["module_name"]).encode()).hexdigest()[:12] |
| def target(r): |
| t = r["stage1_target"]; t = json.loads(t) if isinstance(t, str) else t |
| return t["tool"], t.get("parameters") or {} |
| def ckey(d, tool, p): return hashlib.sha256(json.dumps([d, {"tool": tool, "parameters": p}], sort_keys=True).encode()).hexdigest()[:16] |
| mode = sys.argv[1] |
| if mode == "candidates": |
| seen = {} |
| for s in SPLITS: |
| for l in open(f"splits/s3_repo_disjoint.{s}.jsonl"): |
| r = json.loads(l); k = did(r) |
| if k not in seen: seen[k] = {"design_id": k, "split": s, "source_file": r["source_file"], "module_name": r["module_name"], "stored": r["verilog_code"] or ""} |
| with open("splits/v2/candidates.jsonl", "w") as f: |
| for c in seen.values(): f.write(json.dumps(c) + "\n") |
| print("unique designs", len(seen)) |
| elif mode == "calls": |
| designs = {json.loads(l)["design_id"] for l in open("splits/v2/designs_full.jsonl")} |
| calls = {} |
| for s in SPLITS: |
| for l in open(f"splits/s3_repo_disjoint.{s}.jsonl"): |
| r = json.loads(l); d = did(r) |
| if d not in designs: continue |
| tool, p = target(r); k = ckey(d, tool, p) |
| calls[k] = {"key": k, "design_id": d, "tool": tool, "parameters": p} |
| with open("splits/v2/calls.jsonl", "w") as f: |
| for c in calls.values(): f.write(json.dumps(c) + "\n") |
| print("unique calls", len(calls), collections.Counter(c["tool"] for c in calls.values())) |
| elif mode == "build": |
| sys.path.insert(0, REV) |
| import generate_qa_v7_full_tools as G |
| import importlib.util |
| _spec = importlib.util.spec_from_file_location("eda_release", os.path.join(REV, "eda_tools.py")) |
| OPT = importlib.util.module_from_spec(_spec); _spec.loader.exec_module(OPT) |
| code = {json.loads(l)["design_id"]: json.loads(l)["verilog_code"] for l in open("splits/v2/designs_full.jsonl")} |
| res = {} |
| for l in open("splits/v2/results.jsonl"): |
| r = json.loads(l); res[r["key"]] = r["result"] |
| stats = {} |
| for s in SPLITS: |
| out, why = [], collections.Counter(); changed = 0 |
| for l in open(f"splits/s3_repo_disjoint.{s}.jsonl"): |
| r = json.loads(l); d = did(r) |
| if d not in code: why["source_not_recovered"] += 1; continue |
| tool, p = target(r); t = res.get(ckey(d, tool, p)) |
| if t is None: why["not_grounded"] += 1; continue |
| if r["subcategory"] in ("delay_opt", "power_opt"): |
| |
| p = {"target_metric": "delay" if r["subcategory"] == "delay_opt" else "power"} |
| t = OPT.optimization_advisor(code[d], p["target_metric"]) |
| r = dict(r, stage1_target=json.dumps({"tool": tool, "parameters": p})); why["opt_target_set"] += 1 |
| if t.get("status") == "error": why["backend_error"] += 1; continue |
| ms = t.get("mapping_statistics") or {} |
| if tool == "cross_stage_mapper" and not ms.get("netlist_wires") and not ms.get("netlist_cells"): |
| why["synthesis_no_netlist"] += 1; continue |
| if tool == "simulation_tool" and t.get("status") == "estimated": why["simulation_not_measurable"] += 1; continue |
| signal = None |
| m = re.match(r"What is the toggle rate of signal (\S+) in module", r["question"]) |
| if m: |
| signal = m.group(1) |
| if signal not in (t.get("toggle_rates") or {}): |
| why["toggle_signal_not_recorded"] += 1; continue |
| ans = G.V7Generator._generate_answer(None, r["category"], r["subcategory"], r["question"], t, r["module_name"], |
| signal, p.get("graph_type", "CDFG"), p.get("target_metric", "area")) |
| essential = {k: v for k, v in t.items() if k not in ["synthesis_log", "simulation_log", "nodes", "edges"]} |
| ctx = f"Question: {r['question']}\n\nTool: {tool}\nResult: {json.dumps(essential)}" |
| if len(ctx) > 1500: ctx = ctx[:1500] + "..." |
| changed += ans != r["answer"] |
| out.append(dict(r, answer=ans, verilog_code=code[d], tool_result=t, tool_parameters=p, stage2_context=ctx, |
| corpus_version="release")) |
| why["kept"] += 1 |
| with open(f"splits/v2/{s}.jsonl", "w") as f: |
| for o in out: f.write(json.dumps(o) + "\n") |
| n = sum(why.values()); stats[s] = {"v1": n, **why, "answer_changed": changed} |
| print(s, json.dumps(stats[s])) |
| json.dump(stats, open("splits/v2/stats.json", "w"), indent=1) |
|
|
