AI in EDA

A useful way to sort the field is by where the model sits relative to the checks that guard correctness. Verification (simulating the RTL and proving properties about it) guards what the chip does. Signoff (timing, power and manufacturing-rule checks on the finished layout) guards the physical result. A congestion predictor, a settings tuner or a learned macro placer only proposes something; the normal tools then build it and signoff checks it. A bad proposal costs runtime and quality of results (QoR: the speed, power and area achieved), but correctness is still guarded downstream. An LLM writing RTL sits before verification, so its mistakes are functional bugs, and they are caught only as well as the verification plan catches them.

The survey’s four categories (decision making inside tools, performance prediction, black-box optimization, automated design) are ordered by increasing automation.¹ Risk grows along the same axis, because each step hands the model more of the decisions a person used to review.

The evidence is uneven. Prediction and tuning papers are numerous but mostly trained and tested on small, often internal, datasets.² Learned macro placement is disputed in the open literature. LLM results come mostly from benchmarks of small modules whose problems may have leaked into training data. Commercial ML features exist in the major EDA tools, but this page covers only work whose method and results can be read in full.

Prediction: the label and the split

In supervised learning every training example needs a label, the right answer. Here the label is the outcome of a full tool run (the routed congestion map, the signoff slack), so each example costs hours of compute and datasets stay small. CircuitNet’s authors note that most earlier studies could only validate on small internal datasets.² CircuitNet itself is six RISC-V designs in one 28 nm technology, built with one commercial synthesis tool and one commercial place-and-route tool, each design run with 2,160 combinations of settings.²

That shapes what a result means. If the test set holds other runs of the same designs (a split by run), the model has already seen those circuits and only has to interpolate between settings. If it holds circuits never seen in training (a split by design), the test is closer to real use, where the next chip is always new. Check which split a paper used.

For timing, the model has to imitate STA. STA computes the arrival time at each pin in signal order: a gate’s output time is its latest input time plus its own delay, so each pin can be numbered by its depth in that order, its topological level. PreRoutGNN shows that in an earlier GNN the arrival-time error grew with level, because small errors at early pins were passed on and added up along long paths. Pre-training a graph autoencoder to summarize the whole circuit, and splitting large graphs in a way that keeps signal order, raised slack $R^2$ from 0.59 to 0.93.³ But $R^2$ averages over every timing endpoint, and the chip’s speed is set by the few worst paths, so also ask for the error on the most critical endpoints.

Flow tuning: sample budgets and noise

Each trial is a partial or full run of placement and routing, so a search gets tens to hundreds of samples, not millions. That is why sample-efficient methods dominate. Bayesian optimization is built for slow, noisy evaluations.⁶ The tree-structured Parzen estimator (TPE) sorts past samples into good and poor groups, models where each group falls, and proposes new points that look like the good ones.⁷

AutoTuner records PPA for every trial in a standard metrics format (METRICS2.1), has a sweep mode that tries every combination on a grid, and can tune any flow variable that can be set on the command line, plus values in the timing-constraint (SDC) file and global-routing layer adjustments.⁵ AutoDMP evaluates in two levels because, in its authors’ words, the estimated PPA after placement “might not correlate precisely” with PPA after routing. Only placements on the Pareto front of the cheap estimates go through the commercial router.⁷

Baselines matter as much as the method. DRiLLS’s headline 13% is relative to the starting design. In the same table, expert-written ABC scripts met the delay target on nine of ten designs while increasing average area by 26%, because they trade area for speed. That is the kind of detail a single average hides.⁸

Macro placement: what the dispute is about

The question sounds simple: does Google’s RL placer beat the alternatives? Answering it needs the code, test designs and an agreed final metric. Circuit Training was released as open source, which is what made independent assessment possible.¹² Cheng et al. reimplemented its undocumented pieces, released their test designs and evaluation scripts, and compared it on routed results against simulated annealing, RePlAce (an analytical placer), AutoDMP, a commercial macro placer and human experts. Among the good solutions, the agent’s training score, its “proxy cost,” had weak rank correlation with routed wire length, power and timing: sorting solutions by proxy cost did not sort them by routed quality.¹⁰

Markov concludes that the method lags humans, annealing and commercial software; his paper’s author note lists a role at Synopsys, an EDA vendor.¹¹ Goldie et al., the original authors, are at Google DeepMind, Google Research and Stanford. They argue that the reproductions removed pre-training, used 20× fewer RL experience collectors (the parallel workers that play out placements to learn from) and half the GPUs, and did not train to convergence.¹² The open question is narrow and technical: how much pre-training and compute the method needs to beat strong baselines on routed metrics, on designs anyone can rerun.

Lithography and test: a model as a starting point

GAN-OPC is pre-trained together with inverse lithography technology (ILT), a slow, accurate method that computes a mask by optimizing it against a model of the printing process. The trained network produces a near-optimal starting mask, and conventional OPC finishes the job.¹³

The test example works the same way. The GCN labels each node from four numbers: its logic level and the three SCOAP testability scores, which estimate how hard it is to force the node to 0 (C0), to force it to 1 (C1), and to see its value at an output (O). A loop inserts observation points where the model points, and the same commercial tool then reports fault coverage and pattern count.¹⁴ In both cases a physics- or fault-based engine checks the model’s output. That is why ML is easy to adopt here: a wrong guess costs extra iterations and gets caught before silicon.

Reading the RTL benchmarks

VerilogEval’s testbench feeds the model’s answer and the reference the same inputs, hand-picked cases plus random patterns lasting from a few hundred clock cycles for simple problems to several thousand for complex ones, and compares outputs on clock edges for sequential circuits and on every input change for combinational ones. The authors note that the simulator limits which Verilog syntax can be evaluated.¹⁵ They also found that during fine-tuning, pass@1 kept rising with more training passes while pass@5 and pass@10 fell: the model grew more confident and less varied. They recommend reporting both.¹⁵ RTLLM’s caution that passing every test does not prove correctness applies to all of these benchmarks: a pass means agreement on the stimulus the benchmark happened to apply.¹⁶

Contamination

VerilogEval’s problems come from a public website, so solutions to them may sit in any training set scraped from the web. The HumanEval authors hand-wrote their problems for exactly this reason, noting that public code repositories already held solutions to existing problem sets.²⁴ VeriContaminated applied two detection methods to VerilogEval and RTLLM across open and commercial models. CDD checks whether a model’s repeated samples for a problem are suspiciously alike, a sign of memorization. Min-K% Prob looks at the least likely 20% of tokens in a benchmark text: unseen text usually contains a few words the model finds very unlikely, so if even those score high, the model has probably seen the text. The paper concluded that data contamination is a critical concern, found the highest rates in commercial models such as GPT-3.5 and GPT-4o, and showed that mitigation costs some accuracy.¹⁷ Detection is statistical and imperfect, so these results are warning signs, not proof for any single model. The practical answer is evaluation on problems written after a model’s training cutoff, or on private sets.

Comparing agent and one-shot numbers

VerilogCoder’s 94.2% comes from a tool-using agent on small modules.¹⁹ CVDP’s 34% ceiling is first-try pass@1 on harder problems written by engineers, and the paper reports that agentic tasks involving reuse of existing RTL and verification were especially hard.¹⁸ Both groups are at NVIDIA and both numbers can be right. Together they show that small-module benchmarks leave little headroom, and that the hard part of RTL work sits in tasks those benchmarks don’t contain.

Cost and data in domain adaptation

ChipNeMo internal training corpus

23.1B tokens

DAPT, 70B model (A100 GPU-hours)

20,500

Pretraining the 70B base model (A100 GPU-hours)

1,720,320

Those figures come from ChipNeMo’s cost table; a GPU-hour is one A100 data-center GPU running for an hour, and all models trained on 128 of them. Its script benchmarks cover timing-analysis tasks in an in-house Python tool and a Tcl-based EDA tool, scored partly automatically and partly by engineers. The authors report more than 70% correctness on simple scripts, and 1,400 extra domain instructions improved script correctness by 18%.²⁰ Running domain pretraining directly on a chat-tuned model badly degraded its instruction following, so the instruction tuning had to come after domain training.²⁰

Agents and graded evaluations

ChatEDA first tests whether each generated script runs, then has human judges grade task decomposition and script quality blind, on 50 tasks split between simple flow calls, complex flow calls and calls that set parameters.²³ That is a reasonable design for a small benchmark, but a script that runs is not a design that meets its goals, and 50 tasks give wide error bars. For assertions, the Kande et al. spread from 26.54% average to 93.55% best shows how much prompt context matters. A generated assertion also has to be checked for vacuity (an assertion whose trigger never fires passes without testing anything) and for encoding the intended property.²¹ In LLM4DV’s results table, coverage on the Ibex CPU ranged from about 11% to 100% depending on the model, and a formal tool reached near-full coverage on seven of the eight designs.²²

What equivalence checking can and can’t guard

Equivalence checking proves that two designs match. It says nothing about whether the reference matches the spec. It suits LLM uses where the intent is to keep behavior the same: refactors, lint cleanup, area or power rewrites, translation between coding styles.

EQY lines up matching signals in the two designs and proves each partition separately. A change that re-encodes stored state, such as renumbering a state machine’s states, breaks that matching. The .eqy file then needs a “recode” section that maps old state codes to new ones, or the state registers are left unmatched and the state machine is proven as a whole with sequential-equivalence strategies.²⁷ The proof strategies use $k$-induction: show the two partitions agree for the first $k$ cycles, then show that $k$ cycles of agreement always imply agreement on the next. Some equivalent partitions can’t be proven this way at a given depth.²⁶ EQY reports every partition it fails to prove and writes a trace of the failing case, so a failure has to be read: it may be a real difference, as in the EQY quickstart’s example of a deliberately broken shifter, or a proof that needs a larger depth or another engine.²⁵

Proxy objectives

Learned placers and tuners optimize what is cheap to compute. Cheng et al. found weak rank correlation between Circuit Training’s proxy and routed results among good solutions, so a lower proxy did not reliably mean a better routed design.¹⁰ AutoDMP’s authors say the same of their post-placement estimates and check Pareto points in a commercial flow.⁷ Any claim that stops at proxy metrics is a claim about the proxy.

Baselines and compute parity

The macro-placement exchange shows both ways a comparison can go wrong. Critics argue the method loses to strong baselines such as simulated annealing and commercial placers; the original authors argue the reproductions under-trained their method.¹¹¹² A fair comparison gives every method a similar budget of wall-clock time and compute, tunes the baselines, and states both. DRiLLS’s table is a good model of disclosure: it lists a greedy search, expert scripts and the benchmark’s best published results alongside its own, with whether each met the delay constraint.⁸

Noise and selection

Placement and routing results move with the random seed and with small changes to settings. A best-of-N result against a single baseline run can report luck as gain. So can a tuner that searches over the seed itself: AutoTuner can tune the global router’s random seed, along with any command-line flow variable.⁵ Ask for the spread over reruns of the chosen settings.

A short checklist

• Baseline: named, tuned, and given comparable compute?
• Metric: measured after routing or at signoff, or a proxy? If a proxy, is its correlation shown?
• Split: unseen designs, or held-out runs of training designs?
• Data and code: released, so the result can be rerun?
• LLMs: $k$, number of samples, temperature, prompt, and benchmark age relative to the model’s training cutoff?
• Conflicts: who built the method, who built the baseline, and who funds each?

Public benchmarks are small, possibly contaminated, and unlike most production work, so teams that adopt these tools build internal evaluation sets from their own designs, past bugs and scripts, and rerun them whenever a model or prompt changes. CVDP’s mix of task types (debugging, assertion writing, checking code against a specification, agentic tasks) is a reasonable template for what such a set should cover.¹⁸

Learned prediction and tuning depend on data the team already generates. Logging per-run metrics in a consistent format, as AutoTuner does with METRICS2.1, is what makes later learning possible.⁵ Treat every model output as an untrusted input to the existing signoff and verification gates, and measure the total cost (compute, review time, re-verification) against the engineer time saved.

Graph neural networks on netlists

A netlist maps naturally to a directed graph: cells are nodes, wires are edges, the chip’s inputs are sources and its outputs are sinks. A GNN gives every node a vector of numbers (an embedding) and updates it layer by layer by combining the embeddings of its neighbors, so after L layers a node carries information from L hops away. In the testability GCN, each node starts with four features, its logic level and the SCOAP scores [LL, C0, C1, O]. Two aggregation layers produce the embeddings, and fully connected layers then classify each node as hard to observe or not. The authors stress speed, because commercial netlists have millions of gates.¹⁴

Timing models update nodes in signal order, as STA does. PreRoutGNN shows the weakness of that choice: in an earlier model, arrival-time error grew with topological level as errors piled up along the path. It adds a pre-trained graph autoencoder for whole-circuit context, models the delay between adjacent pins as a correction on top of the previous pin’s time, uses attention (a learned weighting) over each cell’s delay lookup tables, and splits the graph in a way that preserves signal order so large circuits fit in memory.³ Mirhoseini et al. used an edge-centric variant: each edge updates its embedding with a small fully connected network over its two endpoint nodes, and each node then takes the mean of its edges’ embeddings.⁹

RL formulation of placement

Reinforcement learning is framed as a Markov decision process: at each step the agent sees a state, picks an action, moves to a new state and receives a reward, and it learns a policy (a rule for picking actions) that maximizes total reward. Mirhoseini et al. pose macro placement this way:⁹

• State: a graph embedding of the netlist (placed and unplaced nodes), an embedding of the macro to place next, facts about the netlist and technology, and a mask of the grid cells where that macro may legally go.
• Action: the grid cell for the current macro. The chip area is divided into at most 128 × 128 cells, about 30 rows and columns on average. Cells that would push local density over the target are masked out, so density is a hard constraint.
• Order: macros sorted by size, largest first, with ties broken by signal order. The millions of standard cells are grouped into a few thousand clusters with hMETIS, a partitioner that cuts as few connections as possible, and placed by a force-directed method (wires act like springs pulling connected cells together) once all macros are down.
• Reward: zero at every step except the last, then the negative weighted sum of proxy wire length and congestion. Wire length is HPWL, half the perimeter of the smallest box around each net’s pins; congestion is the mean of the 10% most congested grid cells.
• Training: PPO (proximal policy optimization), a standard algorithm that nudges the policy toward actions that earned more reward while limiting how far each update can move it. Pre-trained across many blocks, the policy gives a zero-shot placement of a new block in under a second, and further training on that block improves it.

These design choices explain where the dispute bites. The reward is sparse and arrives only at the end, so learning needs many episodes, which is why compute and pre-training are at issue.¹² The reward is a proxy, so its agreement with routed results limits what the policy can achieve.¹⁰ DRiLLS shows a smaller formulation for comparison. Logic synthesis in ABC works on an and-inverter graph (AIG), a network made only of two-input AND gates and inverters. The state is a vector of statistics about that graph, the action is one of seven ABC transformations (resub, resub -z, rewrite, rewrite -z, refactor, refactor -z, balance), the reward favors area reduction under a delay constraint, and an advantage actor-critic (A2C) agent learns the policy.⁸

Surrogates and Bayesian optimization for flow tuning

Bayesian optimization treats the flow as an unknown function $f(x)$ of its settings $x$. It places a Gaussian process prior on $f$: a statistical model in which settings close together are expected to give similar results. After $n$ runs the model gives, at every untried $x$, a predicted mean $\mu_n(x)$ and an uncertainty $\sigma_n^2(x)$. An acquisition function turns those into a score for where to sample next. Expected improvement is the most common:

Here $f^*_n$ is the best value so far. It favors points that are either predicted to be good or highly uncertain. Entropy search and knowledge gradient are alternatives. The method suits fewer than about 20 continuous settings, evaluations that take minutes to hours, and noisy results, and has extensions for parallel batches, cheaper low-fidelity evaluations and constraints.⁶

TPE models the problem the other way round. It splits past samples into good and poor groups, fits a probability density to each, and proposes the candidate where the ratio of good to poor density is highest. AutoDMP’s multi-objective TPE decides which samples count as good by their position relative to the current Pareto front over wire length, density and congestion, and runs 16 DREAMPlace jobs in parallel on the GPUs.⁷ In place-and-route tuning the settings mix whole numbers and decimals, the goals conflict, and seed noise is large, so a multi-objective search followed by reruns of the chosen points is safer than a single weighted score.

pass@k and its pitfalls

pass@k is the probability that at least one of $k$ samples passes. Drawing exactly $k$ samples per problem gives a noisy estimate, so Chen et al. draw $n \ge k$ (they used $n = 200$, $k \le 100$), count the $c$ samples that pass, and compute, averaged over problems:

The ratio $\binom{n-c}{k} \big/ \binom{n}{k}$ is the chance that $k$ samples picked from the $n$ all come from the failing ones. The tempting shortcut $1 - (1 - \hat{p})^k$, from the measured pass@1 $\hat{p}$, consistently underestimates the true value.²⁴

def pass_at_k(n, c, k):
    if n - c < k:
        return 1.0
    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))

• The oracle assumption. pass@k for $k > 1$ counts a problem solved if any sample passes, as if something could pick the right one. In real design work the only way to pick is to verify each candidate, which is the expensive step.
• Test strength. A pass means the sample agreed with the reference on the applied stimulus. Weak tests inflate every pass@k.¹⁶
• Sampling settings. Temperature, prompt and in-context examples shift results; a number without them can’t be compared.
• pass@1 vs. pass@10. Fine-tuning can raise pass@1 while lowering pass@10, so report both.¹⁵
• Contamination. A public benchmark may be in the training data, and detection is statistical.¹⁷