Building a chip runs code through a slow chain of tools. Synthesis turns the hardware description into gates, and placement and routing turn the gates into a physical layout. Only at the end do designers learn the chip's power, timing and area. Machine-learning predictors try to skip this chain. The strongest recent ones are multimodal: they combine the source code with graphs extracted from it, and sometimes with gate netlists or layout images. But those extra inputs are exactly the artifacts that take hours or days to produce. Early in a project they are often missing, and the graph sometimes cannot be built at all because a draft fails to compile. This note proposes treating each downstream artifact as a missing modality, meaning an input stream that may be absent at test time. It also observes that in chip design the missing modality is unusual in two ways. You can pay to get it by running the tool. And the training data contains several real outcomes for each source design, so the uncertainty the model should express can be measured directly.
The core idea fits in two sentences. Train one predictor over any subset of {Verilog code, dataflow graph, gate netlist, layout}. It outputs a calibrated distribution over final timing and power, and it learns that distribution's width from the observed spread of outcomes across repeated implementation runs of the same design. Then use the gap between "code-only" and "code+netlist" predictions to decide which candidate designs are worth sending through the next expensive tool stage.
Core Claim
Existing cross-stage hardware predictors are deterministic, and none of them tolerates missing inputs. RTLDistil has a student graph network, which sees only 16 abstract features from the register-transfer description, copy the internal features of a teacher that sees 96 post-layout physical features. CircuitFusion pulls code embeddings toward synthesized-netlist embeddings. UniRTL and TopoRTL require both code and graph. UniRTL's authors concede that its graph extraction fails outright on code that cannot be synthesized. In vision and affect research, Probabilistic Conformal Distillation (PCD) argues that matching a full-information teacher point-for-point across an "irreparable information asymmetry" makes the student hallucinate. PCD responds by mapping missing-modality inputs to Gaussian densities. PCD, however, never observes the true spread of the missing information. It regularizes toward a density whose width it cannot check.
Our claim is that chip design gives that check for free. CircuitNet 3.0 runs industrial synthesis and place-and-route through 10 to 50 optimization iterations per design. One register-transfer design therefore maps to a population of physical outcomes. We propose to supervise the predictor's distribution for each availability pattern against that empirical population, rather than against a single teacher vector. We then calibrate the resulting intervals with split conformal prediction, separately for each pattern. A predictor that is honestly uncertain where the physics is genuinely undetermined should do two things. Its point accuracy should match deterministic distillation. Its intervals should also be good enough to steer how tool time is spent. That second capability is new, and neither field has tested it.
Research Program
The model has one lightweight encoder per modality. It uses a frozen code encoder for Verilog, a graph transformer for the operator-level dataflow graph, a graph network for the gate netlist, and a convolutional encoder for the layout bitmap. A shared fusion network combines whichever encoders are present, without zero placeholders. We follow the product-of-experts style of Neural Multisensory Scene Inference, in which each present modality contributes a Gaussian "expert" and absent ones contribute nothing. This keeps a single network valid for all fifteen non-empty subsets. During training, whole modalities are dropped at random as in ModDrop. Dropping is biased toward the patterns that occur in practice and that follow the order of the design flow: code-only, code plus graph, code plus netlist, and so on.
The training objective has three parts. The first is a proper scoring rule, the continuous ranked probability score, computed between the predicted distribution and the empirical set of outcomes across implementation runs for that design. The second is a distillation term in PCD's spirit: the full-modality latent should lie inside the high-density region of the partial-modality distribution, rather than equal its mean. The third is the usual point-regression term. The essential ingredient is the first part, because it ties uncertainty to observed variability rather than to model capacity. The tool can also turn out to be nearly deterministic, so that its runs barely differ. In that case the empirical spread is small, and the method reduces to robust point prediction. Reporting that would itself be a useful negative result about where the "one-to-many" story in Gap 2 holds.
After training, we hold out a calibration split. For each availability pattern $S$, we compute a conformal quantile $q_S$ of normalized residuals $|y - \mu_S(x)|/\sigma_S(x)$, where $\mu_S$ and $\sigma_S$ are the predicted mean and spread given modalities $S$. The interval $\mu_S \pm q_S \sigma_S$ then has finite-sample coverage under exchangeability. For design-space exploration, a candidate $x$ sits at availability pattern $S$, and $c$ is the hours needed to reach the next pattern $S'$. We send $x$ forward when
$$ \Pr_S\!\left[x \text{ is Pareto-optimal}\right]\cdot\left(1-\Pr_S\!\left[x \text{ is Pareto-optimal}\right]\right) \;>\; \lambda\, c , $$
where $\lambda$ trades tool hours against decision uncertainty. The left side is largest when the code-only prediction is genuinely undecided about whether the design is worth keeping. In words: run the next tool stage only on designs whose fate the cheap prediction cannot settle.
Baselines
The naive reference is a CircuitNet-style late-fusion model trained on complete data and evaluated with absent modalities filled by zeros or a learned mask token. ModDrop's gesture results suggest it will collapse: the Jaccard index fell from 0.881 to 0.466 without dropout training when hand video was lost. We expect something similar here. We also report each single-modality model as a floor.
The strongest existing competitor on the code-to-layout timing question is RTLDistil. It is the only method in the file that bridges register-transfer and layout features, and it reports an arrival-time Pearson correlation of 0.9227 with mean absolute percentage error of 16.87% on its 2,004-design suite. CircuitNet 3.0 reports RTLDistil at a correlation of 0.887 on CircuitNet 3.0. We will retrain RTLDistil on our exact CircuitNet 3.0 splits, with the same feature extraction, a matched parameter count and the same hyperparameter-search budget. Beating it means matching or exceeding its arrival-time correlation in the code-plus-graph setting while also delivering intervals at or above nominal coverage, which RTLDistil cannot produce. Exceeding its correlation is a bonus, not the claim.
For the code-plus-graph setting we will also run UniRTL. It reports delay mean absolute error of 0.3384 on StructRTL, against 0.5414 for the StructRTL baseline. We will evaluate it on its native benchmark and on a code-only variant, since it has no code-only path.
The strongest simple baseline is a ModDrop-trained fusion model with a heteroscedastic Gaussian output head, plus a five-member deep ensemble of it. We will give it the identical data, dropout schedule, compute and conformal calibration step. For this baseline we found no reported result on Lacuna in hardware settings.
Two ablations isolate the key ingredient. One replaces the multi-run distributional target with a single-run label, keeping everything else fixed. The other removes the PCD-style latent term. If the first ablation costs nothing, the empirical-spread supervision is not doing the work.
Why not just…?
Why not just zero-fill or use a mask token for the missing graph or layout? Fusion layers trained on complete inputs misread an all-zero stream as a real signal. ModDrop's drop from 0.881 to 0.466 is the clearest evidence of this in the file. UniRTL's ablation also shows that removing the graph badly hurts delay prediction. Our naive baseline measures this directly on hardware data, so the claim does not rest on transfer from gesture recognition.
Why not just train a separate model for every design stage? With four modalities that means fifteen models, each trained on less signal. Unimodal predictors also trail fused ones: CircuitNet 3.0 reports a 36.0% timing-error reduction from fusion, and RTLDistil's comparison shows the single-graph MasterRTL at an arrival-time correlation of 0.3498. Still, per-subset specialists are a fair upper bound for each pattern. We will train the code-only and code-plus-graph specialists and report the gap.
Why not just add an uncertainty head and modality dropout, and skip distillation entirely? This is the real threat. A heteroscedastic head trained on single-run labels learns noise only from variation between designs. It cannot tell "this design's timing is undetermined until placement" apart from "similar-looking designs differ." With multi-run targets, the two can be separated. The decisive check is the correlation between predicted spread and the observed spread across runs for the same design, compared between our model and the ensembled heteroscedastic baseline. If they tie, we will say so. The contribution then shrinks to a calibrated, stage-aware benchmark plus the acquisition rule, and the extra distillation machinery should be dropped.
Why not just always run Yosys so the graph is never missing? Yosys aborts on drafts with elaboration errors, a failure UniRTL itself reports. Even when it succeeds, it produces no placement or routing information. We will report the fraction of real and corrupted drafts that Yosys rejects, and accuracy on exactly those drafts.
Why not just fine-tune a large code language model? TopoRTL shows that text models cannot tell apart designs with similar text but different structure, and its 29.13M-parameter model beats 7B-parameter language models. We include a fine-tuned code encoder as one of our modality encoders. If code-only prediction from it alone equals the fused model, that is a finding we will report.
Proposed Experiments
The main testbed is CircuitNet 3.0, with its 15,863 instances spanning code, netlist graphs and layout bitmaps, and worst negative slack from −6 to 0 ns. We will first verify that per-iteration implementation outcomes are recoverable from the release. If they are not, we will rerun the implementation flow with varied seeds and constraints on a subset of designs to obtain several outcomes per design. As secondary testbeds we use the CircuitFusion and TopoRTL suites for power and area, and StructRTL for the code-plus-graph comparison with UniRTL. To create non-synthesizable inputs realistically, we reuse CircuitNet 3.0's AST mutation to inject elaboration-breaking edits, and we keep the original labels for the code-only path.
Metrics are as follows. For point accuracy we use Pearson correlation and mean absolute percentage error on arrival time, worst negative slack and total power. For calibration we use empirical coverage at 90% and mean interval width for each availability pattern. For honesty about uncertainty we use the ranked probability score and the correlation between predicted and observed spread. For downstream value we use Pareto hypervolume reached per tool-hour in a simulated design-space sweep, comparing three policies: our acquisition rule, "implement everything", and "implement the top-k by point prediction."
Three outcomes would settle the proposal. First, code-only coverage stays near nominal while the zero-fill baseline's falls well below it. Second, predicted spread tracks the observed spread across runs better than the ensembled heteroscedastic head. Third, the acquisition rule reaches the hypervolume of exhaustive implementation using a clearly smaller share of tool hours than top-k selection. If the second outcome fails, the distributional-distillation claim fails. If the third fails, the claim that the missing modality is worth pricing fails.
References
- Bridging Layout and RTL: Knowledge Distillation based Timing Prediction
- CircuitFusion: Multimodal Circuit Representation Learning for Agile Chip Design
- UniRTL: Unifying Code and Graph for Robust RTL Representation Learning
- Topology Matters in RTL Circuit Representation Learning
- Probabilistic Conformal Distillation for Enhancing Missing Modality Robustness
- CircuitNet 3.0: A Multi-Modal Dataset with Task-Oriented Augmentation for AI-Driven Circuit Design
- Neural Multisensory Scene Inference
- ModDrop: adaptive multi-modal gesture recognition