betaFeedback

WorksComputer Science

A Surrogate Model for Variation-Aware Clock-Mesh Analysis and Design-Space Exploration using Graph Neural Networks

Abstract

Clock meshes are widely used in high-performance VLSI systems to minimize skew and tolerate On-Chip Variation (OCV) in nanometer technologies. However, analyzing meshes is difficult because reconvergent paths and multi-source drivers prevent static timing analysis (STA) tools from handling mesh loops, making SPICE the industrial standard. SPICE simulations are accurate but slow, so clock-mesh synthesis relies on approximate models that overlook critical effects such as non-linear buffer driving caused by input slew and input skew. We propose a Graph Neural Network (GNN) based surrogate model of the clock mesh with a new graph representation and a new architecture that predicts power while also improving the delay and slew predictions at the sinks and capturing the skew histogram under OCV. Trained on SPICE data and tested on unseen real designs, our model achieves average errors of 3.403.40~ps in delay, 4.144.14~ps in slew and 4.464.46~ps in skew, compared with 6.286.28~ps, 12.3512.35~ps, and 11.6211.62~ps for our prior model, and 74.3774.37~ps delay and 27.5127.51~ps skew for the approximate method used in current state-of-the-art works. Our model predicts power within 3.4%3.4\% of SPICE on average, while delivering 18×18\times-1706×1706\times speed-ups over the approximate method under OCV modeling, enabling faster and more accurate clock-mesh design-space exploration. A case study on a real design further shows that our surrogate model finds buffering candidates that, at a balanced tradeoff, improves 99th99^{\text{th}}-percentile skew by 49.1%49.1\%, reduces power by 25.7%25.7\%, and reduces area by 37.3%37.3\% at the cost of a 6.8%6.8\% increase in 99th99^{\text{th}}-percentile maximum slew as compared to the state-of-the-art work.

Introduction

Clock Distribution Networks (CDNs) are fundamental to high-performance VLSI designs, ensuring precise synchronization across millions of sequential elements. Among various architectures, clock meshes stand out for their superior robustness to On-Chip Variation (OCV), offering low clock skew and improved tolerance to uncertainties in modern fabrication processes [10, 24, 28, 30, 31]. By leveraging multiple redundant paths, as shown in Figure 1, clock meshes robustly distribute the clock signal across the entire chip. However, these advantages come with significant challenges.

Figure 1. A clock tree driving the root clock to the mesh buffers through clock tree buffers. The redundant paths improve the tolerance to variations.

The difficulty in analyzing clock meshes arises from the simultaneous multi-source driving of the network. These sources originate from an underlying clock tree, where variations in delay among different branches introduce varying input arrival times to the mesh. Such input skew, combined with the inherently reconvergent paths within the mesh, means no independent driver-to-sink timing arcs exist, so traditional static timing analysis (STA) cannot derive mesh sink timing. SPICE-based simulation remains the industrial fallback, but is computationally prohibitive at scale and for repetitive calling inside mesh synthesis or design-space exploration.

The primary objective decides the requirements of a clock mesh analysis tool. For timing sign-off, accuracy is the only requirement, and for that SPICE remains unmatched. For clock mesh synthesis and design-space exploration, SPICE is infeasible since the evaluator must be called thousands of times on different candidates. So, four requirements follow. Req. 1: *the evaluator must model simultaneous multi-source driving with reconvergent paths natively, since the

Authors’ Contact Information: Muhammad Hadir Khan, [email protected], University of California, Santa Cruz, Santa Cruz, USA; Wajid Ali, [email protected], University of California, Santa Cruz, Santa Cruz, USA; Arya Thottiparambil Manikandan, University of California, Santa Cruz, Santa Cruz, USA; Matthew Guthaus, University of California, Santa Cruz, Santa Cruz, USA. mesh reconvergent structure provides its robustness to OCV and loop breaking is not trivial. Req. 2: the evaluator must be reusable across topology changes, so that any per-mesh setup cost is not repaid at every candidate evaluation. Req. 3: it must be able to represent the input skew and slew perturbations, since the OCV on the top-level tree that drives the mesh buffers is a dominant source of mesh skew. Req. 4: it must annotate delay, slew and power, since skew (derived from delays) and power are optimization objectives and slew is a constraint.

Prior methods satisfy partial requirements. The dedicated clock mesh analyzers [5, 14, 37] model multi-source driving correctly and are considerably more accurate than closed-form approximations satisfying Req. 1, but each amortizes a large per-mesh setup that buffering changes invalidate, therefore not meeting Req. 2. The learning-based interconnect timing models [6, 13, 15, 38] are fast and reusable but assume a net driven by a single cell and a directed acyclic structure, thus not meeting Req. 1. The mesh loops where handled, are broken by node splitting [6], discarding the reconvergence that gives a mesh its variation tolerance. Consequently, current clock mesh synthesis frameworks [18, 21, 27] annotate delays with the first-moment (FM) of the impulse response and estimate power with switched capacitance model CV2fCV^2f. FM satisfies Req. 1 and Req. 2 by representing the entire mesh structure and requiring only a single sparse matrix solve. However, it does not meet Req. 3 and Req. 4 by implicitly assuming all buffers switch simultaneously, so OCV-induced input skew cannot be represented and the method yields no transition time (slew) at sinks. Thus, prior works either offer accuracy without design-space exploration usability, or usability without variation awareness and power modeling.

Our prior work [19] proposed the first GNN based model for clock mesh timing analysis that annotates delay and slew at sinks in a fast manner. It satisfies Req. 1, Req. 2, and Req. 3 but not Req. 4 since it does not perform power analysis. Furthermore, OCV analysis is limited with only 500 MC simulations on two designs and missing the skew histogram tail metrics and plots. Moving forward we refer to our prior work as FASM [19] and propose an extension to this work by creating a new graph representation and model architecture to support power prediction and significantly improved delay/slew accuracy, followed by a methodology to capture the tail-ends of the skew histogram under OCVs, and a synthetic benchmark generation process that improves model generalization in order to be used inside the design-space exploration. Our contributions are to:

  • Propose a new graph representation that better encapsulates the clock mesh structure and improves performance.

  • Propose a new model architecture for better delay, slew, skew, and power predictions under OCVs.

  • Create a new synthetic benchmark generation strategy that improves model generalization for design-space exploration.

  • Propose the Active Learning (AL) strategy along with a tail-weighted loss function that helps capture the tail-ends of the skew histogram under OCV.

  • Provide a case study of our proposed model used inside an optimization loop to provide tradeoffs for performance, power, and area metrics.

The rest of the article is organized as follows: § 2 provides background and brief overview of the related work. § 3 explains our surrogate model for clock mesh analysis along with its training framework. § 4 discusses the methodology for capturing the tail-ends of the skew histogram under OCVs followed by § 5 and § 6 that explains our baseline comparison setup and results respectively. § 7 shows a case study using our surrogate model for buffering optimization and finally § 8 presents the conclusion.

Background and Related Work

Clock Meshes

Clock meshes are defined as a grid of m×nm \times n wires where mm represents the rows and nn represents the columns. At each of the m⋅nm \cdot n points where the horizontal and vertical wires intersect is a mesh node. The destinations of the clock signal are the sinks which are the flip-flop clock pins. The sinks attach to the mesh wires through small wires called stubs. Each mesh node may be driven by a buffer or not which depends on the sink density near the mesh nodes. We call these buffers the mesh buffers. The clock skew of the mesh is defined as the difference between the maximum and minimum sink arrival times, skew=max⁡idi−min⁡idi\mathrm{skew} = \max_i d_i - \min_i d_i, where did_i is the delay at sink ii. The sinks at the extremes of this delay distribution i.e, the fastest and slowest sinks within a mesh, are referred to as the tail sinks, since they reside in the tails of the per-mesh delay distribution.

STA Limitations and the Cost of SPICE

In traditional STA tools like Synopsys PrimeTime, a given netlist is converted to a timing graph which is a directed-acyclic-graph (DAG). The delays are propagated based on precharacterized lookup-tables for each library gate assuming a single driver charging an effective capacitive load. Clock meshes do not follow this assumption where each capacitive load is driven by many drivers simultaneously. Thereby, no independent driver-to-sink timing arcs exists and STA cannot derive the clock mesh sink timing. Hence, it relies on per-sink delay and slew annotations obtained from full SPICE simulation which is accurate but inefficient due to runtime. Also, its cost compounds under variation. To verify clock mesh timing, thousands of Monte-Carlo (MC) simulations are run by varying die-to-die and within-die parameters to check whether the mesh satisfies skew constraints under OCV [25]. If the mesh does not, multiple iterations of optimization follow, each requiring the same verification, thereby consuming huge design turnaround time.

We now assess prior work against the requirements established in § 1.

Dedicated Clock Mesh Analyzers

The methods described here are built specifically to analyze clock meshes and so they satisfy Req. 1 by construction. Chen et al. [5] slide a window across the mesh and run SPICE on the netlist captured in each window, reporting agreement within 1% of full mesh SPICE on clock latency. Ye et al. [37] apply harmonic-weighted model order reduction with port sliding, motivated by the steady-state operation of the clock networks. Standard reduction fails here because the mesh drivers introduce a larger number of ports, and those ports are the driver output themselves. Hao and Shi [14] apply Kron’s branch tearing recursively, encoding every resistive link and every non-root source resistor as a level of a link-BDD evaluated against a tree-BDD, at O(N(L+S)2)O(N(L+S)^2) cost in nodes NN, links LL, and sources SS.

None of the three methods meet Req. 2. Chen et al. regenerate SPICE per analysis, reporting hours for a single 65×6565 \times65 mesh. Ye et al. [37] take the driver outputs as the ports of their reduced model, so any inserted, removed, or relocated buffer forces reconstruction. Hao and Shi [14] make the source count a structural parameter of the decomposition, and their BDD construction dominates runtime, growing 639× from a 5×55 \times5 mesh to a 15×1515 \times15 mesh.

Learning-Based Interconnect and Clock Timing

This line of work applies learning to timing estimation and satisfies Req. 2 naturally, since inference carries no per-instance setup. SyncTREE [15] predicts clock-tree timing accurately using GNNs through two-step message passing from sinks to drivers and back. Guo et al. [13] build a GNN around a clock-tree timing engine. Both the works show good accuracy but assume a directed acyclic graph with a single path from driver to sink since their motivation is clock-tree timing analysis. Therefore, they do not meet Req. 1.

Cheng et al. [6] and Ye et al. [38] target non-tree RC nets and are therefore closer to our setting, but both assume a net driven by one driver. Cheng et al. break the loops by splitting nodes in breadth-first search order from a single source such that the Elmore delay is preserved at the split points. Ye et al. avoid loop breaking but define each wire path as the shortest route from source to sink, with node features including Elmore downstream capacitance and stage delay computed along that path. Their aggregation of path RC into compact features is somewhat similar to our edge attributes (discussed in § 3.1), and is motivated by the same concern with GNN depth and oversmoothing. The major difference is that a single source makes the path unique, so downstream capacitance and stage delay are well defined. Whereas, in a mesh every sink has a path from every buffer, and our edge attributes carry raw accumulated RC from each candidate driver rather than an Elmore quantity presupposing a direction of propagation. Additionally, both of these works obtain the driving cell’s delay from library lookup tables.

Neither assumption transfers to a clock mesh, where every sink is driven simultaneously by many buffers, so downstream capacitance is undefined and the buffer delay itself is a difficult quantity to measure rather than a simple table lookup, thus not satisfying Req. 1. Tearing the loops also destroys redundancy that gives mesh its variation tolerance. On that note, Ye et al. [38] report that loop breaking proposed by Cheng et al. [6] degraded non-tree accuracy from an R2R^2 of 0.99 to 0.67. Since these models admit a single source arrival time, they are unable to represent input skew across multiple drivers and hence they do not satisfy Req. 3 either.

Approximations used in Mesh Synthesis

Since no accurate clock mesh evaluators satisfy Req. 2, current mesh synthesis and optimization frameworks [18, 21, 27] annotate delays using the first-moment (FM) of the impulse response and estimate power with a switched capacitance CV2fCV^2f model. FM satisfies Req. 1 and Req. 2 where it models the mesh as a whole, and each evaluation is a single sparse matrix solve, making it the fastest method in the literature. However, it has some limitations:

Delay annotations through FM method

The FM method computes delay from the first moment of the impulse response, which is obtained by forming a DC equivalent circuit of the mesh. This form excites all buffers from a common source implicitly assuming simultaneous switching. However, OCV induces different arrival times per buffer, thereby limiting its representational capability. Also, it cannot compute the output transition time and hence sink slews are unavailable. We cover the details of the FM method in § 5 and show its performance in § 6.

Power optimization through dynamic power estimate. Dynamic power alone misses a key additional power component which is the short-circuit power. As noted by Wilke et al. [36] it has a significant portion of the total power consumption in clock meshes. This is caused by the multi-source structure of the mesh and happens due to OCV induced input skew at the mesh buffers, different output slews because of buffer size or load mismatch, or due to different drive strengths contending on the same mesh segment. A short-circuit current can flow directly between the buffers through the mesh wires in a brief window during which one driver might be pulling logical high while the other is still pulling logical low. To motivate the power analysis, Figure 2 shows the contribution of short-circuit power in clock meshes of real designs from the HighTide benchmarks [12] operating on 1 GHz frequency and 0.7 nominal VDD. The total power is computed through SPICE by taking the integral of current over a full clock period. Short-circuit power is obtained as the difference between total measured power and the dynamic power estimate. It constitutes a significant portion of the total power so a CV2fCV^{2}f estimate underestimates the total power.

Figure 2. Breakdown of total power consumption in clock meshes. The short-circuit power contributes significantly to the total power which is obtained by running SPICE.

State-of-the-art works annotate delays with FM even though more accurate evaluators exist, precisely because those evaluators cannot be invoked for per-candidate evaluation during the search phase. It is also the only method that represents simultaneous multi-driving structure of the mesh while retaining fast evaluation. This is the reason why we adopt FM as our primary baseline in this work.

The above discussion shows that no prior work satisfies all four requirements. This gap motivates our work to propose a surrogate that inherently captures the clock mesh structure, supports the OCV induced input skew and slew perturbations, and still provide accurate delay, slew, and power annotations in a faster way to be invoked inside STA timing closure and inside an optimization loop for design-space exploration.

Graph Neural Networks

GNNs have seen tremendous adaptability in EDA where learning on an unstructured netlist is essential. In general, GNNs follow a message passing framework where each node u∈Vu \in V, where VV is a set of nodes, aggregates information from its neighborhood N(u)N(u):

hu(k+1)=U(k)(hu(k),AGG(k)({hv(k),∀v∈N(u)}))(1)h_u^{(k+1)} = U^{(k)}\left(h_u^{(k)}, AGG^{(k)}\left(\{h_v^{(k)}, \forall v \in N(u)\}\right)\right) \tag*{(1)}

where AGG(⋅)AGG(\cdot) generates a message from the aggregated neighborhood of uu and U(⋅)U(\cdot) combines it with the current embedding hu(k)h_u^{(k)}. Each such iteration kk is a layer of the GNN, with the initial embeddings at k=0k = 0 set to the input node features.

Our work uses the Graph Attention Network (GAT) [33], which instantiates AGG(⋅)AGG(\cdot) as an attention-weighted sum of the neighbors, huk+1=σ(∑v∈N(u)αu,vWhv)h_u^{k+1} = \sigma(\sum_{v \in N(u)} \alpha_{u,v}Wh_v), with attention weights

αu,v=exp⁡(σ(aT[Whu⊕Whv]))∑v′∈N(u)exp⁡(σ(aT[Whu⊕Whv′]))(2)\alpha_{u,v} = \frac{\exp\left(\sigma\left(a^{T}\left[Wh_u \oplus Wh_v\right]\right)\right)}{\sum_{v' \in N(u)} \exp\left(\sigma\left(a^{T}\left[Wh_u \oplus Wh_{v'}\right]\right)\right)} \tag*{(2)}

where σ\sigma is a non-linear activation, aa is a trainable attention vector, WW is a trainable weight matrix, and ⊕\oplus denotes concatenation. This assigns each neighbor an importance in [0,1][0, 1]. As in the transformer architecture [32], GAT uses HH independently parameterized attention heads whose outputs are averaged. For graph-level regression, the node embeddings must additionally be summarized into a single vector through pooling, either global [39] or hierarchical [3], before a Multi-Layer Perceptron (MLP) produces the prediction.

Surrogate Model for Clock Mesh Analysis

Graph Representation

In this work, we represent the clock mesh as a bidirected homogeneous graph G=(V,E)G = (V, E) with edge attributes as shown in Figure 3. The mesh wires are represented as a standard π\pi-model with lumped capacitance and resistance which are used as edge features in the graph. The sinks are modeled as load capacitance to ground. The mesh nodes can either be buffered or not. In the case of Figure 3, mesh nodes M0 and M1 are buffered whereas M2 and M3 are not. As compared to FASM this representation helps us in the following way:

Figure 3. Left: A trivial clock-mesh grid example with buffering and sinks. Middle: Equivalent RC mesh network. Right: Our graph model representation.

Wire RC as edge features eliminates the wire nodes: FASM’s representation relies on node features alone where every mesh wire segment becomes a wire node carrying its resistance and capacitance. Encoding that RC as an edge attribute instead removes those nodes entirely, thereby shrinking our graphs.

Aggregating the mesh-to-sink path RC into one edge eliminates auxiliary connections: Even with RC on edges, a sink separated from its potential driver by several wire segments still requires several rounds of message passing, requiring deep GNNs that degrade performance due to oversmoothing [29]. Previous works have shown GNNs in EDA have seldom stacked beyond 4 layers without oversmoothing and overfitting [13]. FASM worked around this by adding auxiliary nodes to provide direct mesh-to-sink path. We instead accumulate the total path RC from a mesh node to each sink it may drive as an edge attribute, so a sink is one hop away from its potential driver and the auxiliary connections are unnecessary.

Using this representation removes the wire nodes and the auxiliary nodes thereby significantly reducing the total number of nodes in the graph, improving timing metric predictions, and providing faster inference time later discussed in § 6.

GNN Features and Labels

Each node in our graph has an associated feature vector as shown in Table 1. The features is_mesh_node and is_sink are one-hot encoded features that help the GNN to identify mesh nodes (M) and sinks (S). Also, each mesh node can be buffered or not, represented by the is_buffered feature. Note that in homogeneous GNNs all nodes are treated similarly, but we refer to nodes as M or S just for the reader’s convenience. All nodes have a feature vector with fixed dimension x⃗∈Rd\vec{x} \in\mathbb{R}^{d}. Any feature that does not apply to a relevant node has default value of 0. The input_delay and input_slew capture the delay and slew of the top-level tree arriving at the mesh buffers (see Figure 1). The buf_cap and buf_res capture the driving strength of the buffer and help learn its internal delay given the input_slew and the load it is driving through the sink_cap and the wire_res, wire_cap features. We create edges between each sink and its two nearest mesh nodes. This edge has a feature of the path RC from the sink to this mesh node and vice-versa as shown in Figure 4. For path S0 to M1 we add R2+R3+R5, stub resistances of other sinks (R4) are excluded because they are not on the path and are usually

TypeName (units)Description
Node featuresinput_delay (ps)Buffer input delay from tree
input_slew (ps)Buffer input slew from tree
buf_cap (fF)Buffer effective capacitance
buf_res (ohms)Buffer effective resistance
buf_len (nm)Buffer channel length
buf_vdd (V)Buffer VDD supply
buf_vth (V)Buffer threshold voltage
sink_cap (fF)sink load capacitance
x (nm)normalized x-coordinate
y (nm)normalized y-coordinate
is_sinkis this a sink node
is_mesh_nodeis this a grid mesh node
is_bufferedis this mesh node buffered
Edge featureswire_reswire resistance
wire_capwire capacitance
Global featurestotal_mesh_capsum of wires, sink, buffer capacitance
sink_densityratio of sinks to chip area
buffer_densityratio of buffers to total mesh nodes
max_stub_lengththe max stub wire length in the grid
min_stub_lengththe min stub wire length in the grid
Node labelsdelay_out (ps)delay value at each sink
slew_out (ps)slew value at each sink
Graph labelpower (mW)total power of mesh

Table 1. Node/Edge features and labels.

Figure 4. Calculation of the RC edge features between sink (S0) and its two nearby mesh nodes (M0, M1) and between two adjacent mesh nodes. (S1) follows similar pattern.

minimal. In a similar manner, we also accumulate the path capacitances from each mesh node to sink and vice-versa (not shown in Figure 4 for clarity). This helps the sink to identify whether it is driven significantly by a nearby mesh node and the driving strength of the buffer. It also provides information to the mesh node of how many sinks it must drive and their load capacitance. We also create edges between the adjacent mesh nodes as shown in Figure 4 where M0 and M1 are connected. This edge provides insight for the GNN model of an unloaded mesh wire without any sinks and only includes the mesh wire RC. In addition to the node and edge features we also utilize global features in order to encode global representations of the mesh. These features help our downstream model network to learn important global characteristics that impact the clock skew and power of a given mesh.

Model Architecture

We adopt a multitask learning framework [4] which consists of delay and slew prediction tasks at each sink as well as global tasks like delay distribution quantiles and power prediction. The backbone GNN is shared and we have task specific MLP heads as shown in Figure 5. For global tasks we concatenate the shared encoder embeddings from each layer of the GNN (XHX^H) and pass it through the pooling and readout layer to get XRX^R. To provide additional global context we append the global features by projecting it through an MLP. This is so that the global embeddings are in a higher dimension and preserve the global context when appended with embeddings already in a higher dimension. These embeddings are then passed to the separate task specific heads (quantile and power). The quantile head predicts the quantiles of the sink delay distribution. This is useful as it helps the model to learn global embeddings that shape the delay distributions of the clock mesh sinks as well as the skew of the clock mesh. We specifically predict the 0%, 1%, 5%, 10%, 25%, 50%, 75%, 90%, 95%, 99%, and 100% quantiles. Although skew depends only on the 0{sup}th and 100{sup}th quantiles, supervising the intermediate quantiles regularizes shared readout where along with the extremes it should also learn to predict the bulk of the distribution. The power head predicts the power of the clock mesh by utilizing the same shared embeddings. The usefulness of this multitask learning architecture is that the shared GNN encoder learns node embeddings in a global context by utilizing the mesh topology and spatial patterns whereas task specific heads focus on objective specific learning. Since the delay, slew and power are all physically related by the RC network and its transient response, this acts as an inductive bias and regularizes all tasks thereby improving generalization of our model.

Figure 5. Our model architecture uses K=4K = 4 GAT layers to perform message passing followed by normalization and ELU activation. Final node embeddings XKX^K are used by separate MLP heads for delay and slew prediction and pooled to perform global tasks such as delay quantile predictions and power prediction.

We utilize GAT convolutional layers [33] for our GNN implementation. However, the vanilla GAT convolution layers do not support edge features and rely on node features. For this, we modified (2) and compute attention scores by involving edge features as:

αu,v=exp⁡(σ(aT[Whu⊕Whv⊕Weeu,v]))∑v′∈N(u)exp⁡(σ(aT[Whu⊕Whv′⊕Weeuv′]))(3)\alpha_{u,v} = \frac{\exp\left(\sigma\left(\mathbf{a}^{T}\left[\mathbf{W}h_u \oplus\mathbf{W}h_v \oplus\mathbf{W}_e e_{u,v}\right]\right)\right)}{\sum_{v' \in N(u)} \exp\left(\sigma\left(\mathbf{a}^{T}\left[\mathbf{W}h_u \oplus\mathbf{W}h_{v'} \oplus\mathbf{W}_e e_{u v'}\right]\right)\right)} \tag*{(3)}

This allows each node to give importance to its neighbors based on both their node and edge features. Each GAT message passing layer is followed by Layer Normalization [2] which helps stabilize training by normalizing hidden node embeddings. For non-linear activations we use ELU [8]. A masking layer is used to omit nodes that are not sinks to calculate loss contributed by only the sink nodes.

Model Parameters

The model architecture parameters are shown in Table 2. Based on empirical evaluations, we did not find an improvement in performance with more than 4 GAT layers and 8 attention heads. The delay, slew, quantile and power heads all use similar MLP parameters. The global projection MLP uses 2 layers to project the global features to a higher dimensional hidden representation. All these parameters are based on the best performance of the model.

ParameterLayersChannelsAttn. Heads
GAT41288
Delay/Slew/Quantile/Power MLP364N/A
Global Proj. MLP264N/A

Table 2. Model Parameters

Model Loss Functions

Our loss function has a total of four components: losses from delay head, slew head, quantile head, and power head. We now discuss these losses.

Let a mini-batch contain GG mesh graphs, and let SgS_g denote the set of clock sinks of graph gg, so that ∣Sg∣\lvert S_g\rvert is its sink count. For sink ii, let did_i be the SPICE-measured delay and d^i\hat{d}_i the delay head prediction. The delay loss is the mean over graphs of the per-graph mean squared error,

Ldelay=1G∑g=1G1∣Sg∣∑i∈Sg(d^i−di)2(4)\mathcal{L}_{\mathrm{delay}} = \frac{1}{G} \sum_{g=1}^{G} \frac{1}{\lvert S_g\rvert} \sum_{i \in S_g} \left(\hat{d}_i-d_i\right)^2 \tag*{(4)}

The slew loss is also computed as a standard per-graph MSE.

Lslew=1G∑g=1G1∣Sg∣∑i∈Sg(s^i−si)2(5)\mathcal{L}_{\mathrm{slew}} = \frac{1}{G} \sum_{g=1}^{G} \frac{1}{\lvert S_g\rvert} \sum_{i \in S_g} \left(\hat{s}_i-s_i\right)^2 \tag*{(5)}

where sis_i denotes the true SPICE-measured transition time at sink ii and s^i\hat{s}_i for the slew head prediction.

Our model also has a global regression quantile head which predicts, for each design gg, the delay distribution at a fixed set of D=11D=11 probability levels τ=(0,0.01,0.05,0.1,0.25,0.5,0.75,0.9,0.95,0.99,1)\tau=(0, 0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 1), chosen to sample the tails densely. We also train this head using the MSE loss, where Qg(τd)Q_g(\tau_d) denotes the empirical τd\tau_d-quantile of the true sink delays and q^g,d\hat{q}_{g,d} for the prediction.

Lquant=1GD∑g=1G∑d=1D(q^g,d−Qg(τd))2(6)\mathcal{L}_{\mathrm{quant}} = \frac{1}{GD} \sum_{g=1}^{G} \sum_{d=1}^{D} \left(\hat{q}_{g,d}-Q_g(\tau_d)\right)^2 \tag*{(6)}

Because τ1=0\tau_1=0 and τD=1\tau_D=1 are the per-graph minimum and maximum sink delay, the predicted clock skew is read directly off the quantile head as:

skew^g=q^g,D−q^g,1.(7)\widehat{\mathrm{skew}}_g = \hat{q}_{g,D}-\hat{q}_{g,1}. \tag*{(7)}

The power head predicts total active power P^g\hat{P}_g per design and is likewise trained by mean squared error against the SPICE-measured active power of graph PgP_g,

Lpower=1G∑g=1G(P^g−Pg)2(8)\mathcal{L}_{\mathrm{power}} = \frac{1}{G} \sum_{g=1}^{G} \left(\hat{P}_g-P_g\right)^2 \tag*{(8)}

The total training loss combines all the terms:

L=λdelay⋅Ldelay+λslew⋅Lslew+λquant⋅Lquant+λpower⋅Lpower(9)\mathcal{L} = \lambda_{\mathrm{delay}} \cdot\mathcal{L}_{\mathrm{delay}} + \lambda_{\mathrm{slew}} \cdot\mathcal{L}_{\mathrm{slew}} + \lambda_{\mathrm{quant}} \cdot\mathcal{L}_{\mathrm{quant}} + \lambda_{\mathrm{power}} \cdot\mathcal{L}_{\mathrm{power}} \tag*{(9)}

Where, λdelay,λslew,λquant\lambda_{\mathrm{delay}}, \lambda_{\mathrm{slew}}, \lambda_{\mathrm{quant}}, and λpower\lambda_{\mathrm{power}} are the weights of each loss. With experiments we found out the best weights for each loss to be λdelay=1.0\lambda_{\mathrm{delay}}=1.0, λslew=0.1\lambda_{\mathrm{slew}}=0.1, λquant=0.1\lambda_{\mathrm{quant}}=0.1, and λpower=1.0\lambda_{\mathrm{power}}=1.0.

Synthetic Data Generation

The synthetic benchmarks in FASM [19] are all buffered using set-covering heuristics from prior works [27, 34]. This trains the model on a narrow buffering distribution which is not ideal for design-space exploration where extremely under-buffered or over-buffered meshes can be explored during the search phase. Therefore, in this work we generate synthetic benchmarks by sampling buffering density from uniform distribution range [0.1,1.0][0.1, 1.0] and picking buffer sizes with uniform sampling from the given buffer library. This allows a model to learn from a wider distribution of buffering and its effects on the clock mesh.

In order to create synthetic benchmarks with realistic characteristics, we implemented open-source designs in the HighTide benchmarks [12] using the OpenROAD [17] flow and extracted representative statistics of the clock meshes which are shown in Table 3. These four statistics jointly help describing the electrical behavior of the clock mesh. The number of sinks and the sink density describes the die area and how large the clock mesh would be created to drive the sinks. The spatial uniformity ratio characterizes how these sinks are distributed. It measures how the sinks are distributed across the die by comparing how far apart neighboring sinks are in real design to how far apart they would be under a random placement of the same sink count and die area. For each sink we take the distance to its nearest neighboring sink and average this over all sinks. We then divide by the mean nearest-neighbor distance expected if the same number of sinks were scattered uniformly at random over the die. This gives us a dimensionless value where if it is <1< 1 we have clustered sinks, with ≈1\approx1 we have a random arrangement, and with >1> 1 we have regular spaced sinks. Lastly, the blockage ratio defines blockages where the clock mesh cannot be routed. Some of the generated synthetic benchmarks are shown in Figure 6.

StatisticRangesDescription
sink count[500, 15000]Sets the size of the clock mesh.
sink density (sinks/μm2\mu\mathrm{m}^{2})[0.037, 0.86]Sinks per unit area, jointly with sink count it sets the die dimensions.
spatial uniformity ratio[0.4, 1.2]Sink placement pattern, clustered (<1< 1) random (≈1\approx1), or regular (>1> 1).
blockage ratio[0.0, 0.65]Fraction of the die area obstructed by blockages.

Table 3. Statistics for synthetic benchmark generation

Figure 6. Synthetic Clock Meshes. Row 1: Shows different designs with varying statistics from Table 3. Row 2: Shows a single design with varying buffer densities. The green rectangles are the blockages and red triangles are buffers.

Algorithm 1 Synthetic Benchmark Generation

Require: Real designs R\mathcal{R}; #synthetic designs NN; #bufferings per design PP; #MC samples per buffering MM; sigma multiplier nσn_{\sigma}; buffer library BLBL

Ensure: Labeled clock-mesh dataset D\mathcal{D}

nsinkn_{\mathrm{sink}}: number of clock sinks

ρ\rho: sink density, sinks per unit area

γ\gamma: spatial uniformity ratio, γ<1\gamma< 1 clustered, γ>1\gamma> 1 regular

β\beta: fraction of die area covered by blockages

  1. for each axis s∈{nsink,ρ,γ,β}s \in\{n_{\mathrm{sink}}, \rho, \gamma, \beta\} do

  2. [smin⁡,smax⁡]←[s_{\min},s_{\max}] \leftarrow observed range of ss over R\mathcal{R} &emsp; ▷ sampling ranges derived from real designs (Table 3)

  3. end for

  4. Θ←LatinHypercube⁡(N,{[smin⁡,smax⁡]}s)\Theta\leftarrow\operatorname{LatinHypercube}(N,\{[s_{\min},s_{\max}]\}_{s}) &emsp; ▷ uniform per-axis coverage

  5. B←∅\mathcal{B} \leftarrow\varnothing

  6. for each (nsink,ρ,γ,β)∈Θ(n_{\mathrm{sink}},\rho,\gamma,\beta) \in\Theta do

  7. A←nsink/ρA \leftarrow n_{\mathrm{sink}}/\rho; ℓ←A\ell\leftarrow\sqrt{A} &emsp; ▷ die area and side length

  8. K←PlaceBlockages⁡(β,ℓ)K \leftarrow\operatorname{PlaceBlockages}(\beta,\ell) &emsp; ▷ non-overlapping rects covering fraction β\beta

  9. S←PlaceSinks⁡(nsink,γ,ℓ,K)S \leftarrow\operatorname{PlaceSinks}(n_{\mathrm{sink}},\gamma,\ell,K) &emsp; ▷ match index γ\gamma, avoid KK

  10. B←B∪{(ℓ,S,K)}\mathcal{B} \leftarrow\mathcal{B} \cup\{(\ell,S,K)\}

  11. end for

  12. D←∅\mathcal{D} \leftarrow\varnothing

  13. for each benchmark B∈BB \in\mathcal{B} do

  14. {p1,…,pP}∼U(0.1,1.0)\{p_1,\ldots,p_P\} \sim\mathcal{U}(0.1,1.0) &emsp; ▷ buffer densities drawn uniformly per design

  15. for j←1j \leftarrow1 to PP do

  16. G←SynthesizeMesh⁡(B,pj,BL)G \leftarrow\operatorname{SynthesizeMesh}(B,p_j,BL) &emsp; ▷ mesh with buffering probability pjp_j, sizes from BLBL

  17. Z←SampleVariation⁡(G,M,nσ)Z \leftarrow\operatorname{SampleVariation}(G,M,n_{\sigma})

  18. for all z∈Zz \in Z do in parallel

  19. y←RunSpice⁡(G,z)y \leftarrow\operatorname{RunSpice}(G,z) &emsp; ▷ per-sink delay and slew, grid power

  20. D←D∪{(G,y)}\mathcal{D} \leftarrow\mathcal{D} \cup\{(G,y)\}

  21. end for

  22. end for

  23. end for

  24. return D\mathcal{D}

Since each of the statistic can vary independently, this leads to an exponential number of synthetic designs needed to capture the entire space which quickly becomes infeasible due to the cost of clock-mesh synthesis and label generation

by running SPICE simulations. Therefore, we use Latin Hypercube Sampling (LHS) [16] to generate our synthetic dataset. It treats the four statistics as independent axes bounded by the ranges observed in the real designs (shown in Table 3) and partitions each axis into equally probable intervals. Samples are drawn such that every interval on every axis is populated exactly once. This guarantees uniform coverage of each statistic individually while filling the joint space far more evenly than independent random sampling.

Each synthetic benchmark is then synthesized into a clock mesh with a random buffering sweep to expose the model to the full range of buffering configurations.

Finally, we run MM Monte-Carlo simulations by varying the parameters within their bounds listed in Table 4 for each design to have variation induced labels with SPICE. This process is briefly described in the Algorithm 1 where we set N=50N=50, P=20P=20, M=5M=5 and nσ=3n_{\sigma}=3 to apply 3σ3\sigma variations. So in total we have 50×20×5=500050 \times20 \times5=5000 synthetic designs in the dataset. With M=5M=5 we have only 5 MC samples for each design to train the model on. Increasing MM significantly increases the training dataset whereas the effective modeling of 3σ3\sigma tail-end skew histogram requires a large number of MC samples. We discuss this limitation and propose a solution in § 4.

Parameter (Affects)Gaussian(σ/μ\sigma/\mu)From
LeffL_{eff} (buf_len)0.84/21 (nm)[23]
WeffW_{eff} (buf_cap/res,sink_cap)0.26/6.5 (nm)[23]
VthV_{th} (buf_vth)0.021/0.3 (V)[35]
VddV_{dd} (buf_vdd)0.023/0.7 (V)[7]
Wire resistance (wire_res)0.003/0.02 (Ω\Omega/nm)[26]
Wire capacitance (wire_cap)5.4e−65.4e^{-6}/ 1.8e−41.8e^{-4} (fF/nm)[26]
Parameter (Affects)UniformFrom
Clock tree Delay (input_delay)±50\pm50 (ps)[27]
Clock tree Slew (input_slew)±10\pm10 (ps)[27]

Table 4. Variation Parameters for OCV. The (Affects) shows which variation parameter changes which graph node/edge feature.

Training Methodology

To train the model, we do a train/validate/test split of 80/10/10 from our synthetic dataset generated by the process outlined in § 3.6. All the labels are generated using Synopsys HSPICE. For optimizing the model parameters, ADAM [20] was used with a learning rate of 7.5e−47.5e^{-4} and weight decay of 5e−45e^{-4} for L2-regularization. Training was done with batch size of 1 and for a maximum of 5000 epochs. Early-stopping was implemented to exit if the validation results did not improve for more than 10 epochs. The training of our model completed in ≈9.4\approx9.4 hours and took 56 epochs before exiting early.

Methodology for Tail-End OCV Improvement

The 3σ3\sigma tail-end skews are important to analyze the robustness of clock mesh to OCVs. The mesh architecture, due to its reconverging and multiple buffer paths to each sink, intentionally smooths out most of the variation causing the tail-ends to occur in extremely rare variation patterns. In order to verify this, we ran 5000 MC simulations and calculated the expected number of samples needed to get at least one sample that produces skew beyond mean+3σ3\sigma as shown in Table 5. For example, if we want 99% confidence of seeing at least one such sample then we need the number of samples listed under "99% conf." column in Table 5. Thus, generating these tail events requires an extensive number of MC simulations and an exorbitant amount of time for SPICE label generation. Our model trained from synthetic data generation also misses this critical region due to being trained on only 5 MC samples. We therefore further improve upon this model by proposing a new tail-aware loss function and an efficient Active Learning (AL) approach for targeted tail-end skew training.

designskew mean (ps)skew (mean + 3σ3\sigma) (ps)# Samples ≥3σ\ge3\sigmaffSPICE samples NN expectedSPICE samples NN 99% conf.
ibex29.849.1410.82%122559
floonoc33.346.7340.68%147676
jpeg33.549.8310.62%161740
riscv32i31.054.9280.56%179820
mock-alu20.435.6280.56%179820
cva642.963.7220.44%2271044
coralnpu57.976.1200.40%2501149

Table 5. Rarity of tail-producing skews under uniform Monte Carlo sampling. For each design, 5000 variations were drawn and SPICE-simulated. Where ff denotes the measured fraction of corners whose skew reaches the mean+3σ3\sigma threshold. Since draws are independent, P(at least one in N)=1−(1−f)NP(\text{at least one in }N)=1-(1-f)^N, giving N=1/fN=1/f on average and N=ln⁡(0.01)/ln⁡(1−f)≈4.6/fN=\ln(0.01)/\ln(1-f)\approx4.6/f for 99% confidence.

Tail-Aware Loss Function

For OCV-aware timing analysis, delays at the tail sinks are important for accurate skew prediction. We therefore propose a rank-weighted absolute error loss that assigns higher importance to sinks at both extremes of the ground-truth delay distribution as shown in Figure 7. For a graph gg with sink count ∣Sg∣|S_g| and ground-truth delays {di}i=1∣Sg∣\{d_i\}_{i=1}^{|S_g|} and predicted delays {d^i}i=1∣Sg∣\{\hat{d}_i\}_{i=1}^{|S_g|}, the normalized rank of each sink is:

Figure 7. Proposed Tail-Aware Loss function. Each sink node is assigned a normalized rank ri∈[0,1]r_i \in[0,1] based on its ground-truth delay. The function assigns higher weight to the fastest and slowest sinks (shaded tail regions) compared to median sinks. Orange dots represent example sink nodes in a mesh, where the majority cluster near the median with few sinks at the tails.

ri=rank⁡(di)∣Sg∣−1,ri∈[0,1](10)r_i = \frac{\operatorname{rank}(d_i)}{|S_g|-1}, \qquad r_i \in[0,1] \tag*{(10)}

where rank⁡(di)∈{0,1,…,∣Sg∣−1}\operatorname{rank}(d_i) \in\{0,1,\ldots,|S_g|-1\} is the ordinal position of sink ii when sinks are sorted by increasing ground-truth delay. We then define a U-shaped weighting function:

w(ri)=1+α⋅4(ri−0.5)2(11)w(r_i) = 1 + \alpha\cdot4(r_i - 0.5)^2 \tag*{(11)}

where α\alpha is a hyperparameter that controls the tail emphasis. This quadratic function is minimized at the median (ri=0.5r_i = 0.5, where w=1w = 1) and maximized at both extremes (ri∈{0,1}r_i \in\{0,1\}, where w=1+αw = 1 + \alpha). In our experiments, choosing α=5\alpha= 5 gave us the best results, by which sinks at the tails receive 6×6\times the weight of median sinks, creating a smooth gradient of emphasis from center to extremes. The delay loss is then the weighted Mean Absolute Error (MAE):

Ldelay=1∣Sg∣∑i=1∣Sg∣w(ri)∣d^i−di∣(12)\mathcal{L}_{\mathrm{delay}} = \frac{1}{|S_g|}\sum_{i=1}^{|S_g|} w(r_i)\left|\hat{d}_i-d_i\right| \tag*{(12)}

We use ℓ1\ell_1 (absolute error) as the error metric because it is more robust to occasional large outliers in SPICE-simulated labels, preventing a single anomalous sink from dominating the gradient.

All other losses remain the same as in § 3.5. We do not apply rank-based weighted loss for slew since it does not depend on the max and min values at sinks like clock skew.

Active Learning for Tail-End Skew Refinement

As discussed in § 3.6, we have N=50N = 50 synthetic designs each having P=20P = 20 buffering densities. So, running thousands of MC simulations for each of the N×PN \times P designs to include 3σ3\sigma tail-end skews would require an exorbitant amount of time for SPICE label generation in addition to training. Therefore, we propose a surrogate-guided active learning approach where we utilize our baseline model trained in § 3.7 to search in a loop (Algorithm 2) that iteratively identifies, labels, and learns from the Top-KK variation patterns that produce maximum skews in a given mesh. Since the model already predicts the average case and we want to improve its performance on tail-end predictions, we use a parameter efficient finetuning approach where we keep the backbone GNN encoder frozen and add additional adapter layers similar to AdapterGNN [22] as shown in Figure 8. This framework allows the model to fit to the new data without forgetting the already learned average case representations.

Figure 8. Finetuning of the base model in the Active Learning loop. The GNN message passing layers are frozen and two additional Pre-Message and Post-Message MLPs are added to finetune to the data. The final embeddings are passed to the downstream MLPs in a similar manner as in Figure 5.

The procedure shown in Algorithm 2 takes as input the following: a pool of LL mesh designs stratified over buffering density from our synthetic dataset, a pretrained surrogate fθf_\theta from § 3.7 with the global GNN encoder frozen and adapter layers left trainable, and three budgets: MM variation samples per design, Top-KK configurations labeled per design, and RR refinement rounds.

Each round begins by acquiring candidate configurations. For every design, line 4 draws MM variation samples in a single step. Line 5 then evaluates the surrogate on the MM variation samples and reads their predicted skew from the quantile head as s^=q^D−q^1\hat{s} = \hat{q}_D - \hat{q}_1, which is the predicted spread between the earliest and latest sink. Because all MM samples share a single topology and differ only in their node and edge feature values, the edge index that defines the graph connectivity is constructed once per design and reused, and the samples are evaluated in batches of BB rather than one at a time. Line 7 ranks the variations by predicted skew and retains the KK largest.

The retained variation configurations are then labeled and the model is updated. Lines 8-11 invoke SPICE on each of the KK selected variation configurations, obtaining per-sink delays, slews and power, and append the resulting feature-label pairs to Daug\mathcal{D}_{\mathrm{aug}}. After the design loop closes (line 12), the round has contributed L×KL \times K labeled samples, and line 13 refits the adapter on the entire accumulated set rather than on the current round’s additions alone, so that earlier acquisitions are not forgotten and the next round’s ranking is produced by a strictly better informed model. The

Algorithm 2 Active Learning for Worst-Case Skew Refinement

Require: Clock mesh graphs {G1,…,GL}\{G_1,\ldots,G_L\} stratified over buffering density; pretrained surrogate fθf_\theta (frozen backbone, trainable adapter); sample budget MM; inference batch-size BB, label budget KK; rounds RR; sigma multiplier nσn_\sigma

Ensure: Refined surrogate fθf_\theta

  1. Daug←∅\mathcal{D}_{\mathrm{aug}} \leftarrow\varnothing

  2. for round r=1,…,Rr = 1,\ldots,R do

  3. &nbsp;&nbsp;&nbsp;&nbsp;for each graph GiG_i do

  4. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Zi←SampleVariation⁡(Gi,M,nσ)Z_i \leftarrow\operatorname{SampleVariation}(G_i, M, n_\sigma)

  5. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q^←fθ(Gi,Zi,B)\hat{q} \leftarrow f_\theta(G_i, Z_i, B) ▹M/B\triangleright M/B batched forward pass; DD delay quantiles per corner

  6. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;s^←q^D−q^1\hat{s} \leftarrow\hat{q}_D - \hat{q}_1 ▹\triangleright predicted skew per corner

  7. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Zi∗←Top-⁡K(Zi,s^)Z_i^* \leftarrow\operatorname{Top-}K(Z_i,\hat{s}) ▹\triangleright corners the surrogate deems worst

  8. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for all z∗∈Zi∗z^* \in Z_i^* do in parallel

  9. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y∗←RunSpice⁡(Gi,z∗)y^* \leftarrow\operatorname{RunSpice}(G_i,z^*)

  10. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Daug←Daug∪{(Gi,y∗)}\mathcal{D}_{\mathrm{aug}} \leftarrow\mathcal{D}_{\mathrm{aug}} \cup\{(G_i,y^*)\}

  11. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end for

  12. &nbsp;&nbsp;&nbsp;&nbsp;end for

  13. &nbsp;&nbsp;&nbsp;&nbsp;fθ←Train⁡(fθ,Daug)f_\theta\leftarrow\operatorname{Train}(f_\theta,\mathcal{D}_{\mathrm{aug}}) ▹\triangleright adapter only; backbone frozen, train with Tail-Aware Loss

  14. end for

  15. return fθf_\theta

Train then uses the Tail-Aware loss function we discussed in § 4.1 to train the delay head. All other heads are trained in a similar manner as described in § 3.5.

We set R=4R = 4, L=25L = 25, M=5000M = 5000, B=32B = 32, and K=5K = 5. Using the fast surrogate model allows us to apply M=5000M = 5000 variations for faster batched evaluation and pick the Top-KK skews. Although noisy, the surrogate refines in each round and we use the latest trained model before the start of the next round. The AL training loop performs additional 25⋅4⋅5=50025 \cdot4 \cdot5 = 500 SPICE simulations for label generation. The whole AL methodology takes 10.03 h total where 9.12 h are spent on labeling the Top-KK configurations and 0.91 h for training.

Experimental Setup

We implemented our surrogate model in Pytorch [1] with the Pytorch Geometric library [11]. The Synopsys HSPICE and FM method as well as the benchmark generation were run on an AMD EPYC 7542 32-Core Processor (64 threads) machine with 512Gb of memory. Training and testing of our model was done on an NVIDIA GeForce RTX 4090 24GiB card. In order to ensure no data leakage from training dataset to test set we regenerate the synthetic benchmarks in Table 6 using the process outlined in Algorithm 1. The real benchmarks are taken from OpenROAD [17] and HighTide benchmarks [12]. Clock meshes are implemented on the designs using ASAP7 7nm technology. The synthetic meshes are buffered randomly with uniform sampling from the PDK provided buffer library along with uniform buffering density sampling in range [0.1,1.0][0.1, 1.0]. Real design meshes are generated with bufferings from set-cover heuristics [34]. All the meshes are constructed with minimum total wire length [27] and operate on a 1 GHz frequency with 0.7 V nominal supply voltage. For all experiments we apply OCVs respecting the realistic bounds in Table 4.

Synthetic BenchmarksArea (μm2\mu\mathrm{m}^2)SinksGrid SizeBlockages
synth_006294.0502419x1915
synth_016197.0108210x106
synth_022846.9166112x125
synth_033795.6185812x120
synth_0431063.41366033x333
synth_0512770.6752226x2617
Real BenchmarksArea (μm2\mu\mathrm{m}^2)SinksGrid SizeBlockages
riscv32i5569.9105610x105
mock-alu2892.71141312x120
ibex5658.32193212x120
jpeg20585.92438320x200
cva623960.2486220x2012
coralnpu112525.3826926x264
floonoc60421.61374834x340

Table 6. Statistics of the test dataset that we evaluate our model on

Baseline Choices

As discussed in § 2.5 our primary baseline to compare against is the FM method due to it being the only method that represents a clock mesh structure inherently and supports fast evaluations.

The FM method is implemented following MeshWorks [27] by forming a DC equivalent circuit and constructing a graph Laplacian G where diagonal entries are sum of connected conductances and off-diagonal entries are negative of the branch conductance. The nodal analysis equation is then given by Gv=IGv = I where vv is the resulting nodal voltages and II is the vector of current sources. Since G is symmetric positive definite, we can solve this efficiently using Cholesky factorization. The resulting vector vv provides the first-order delay annotations, but does not provide slew.

A notable weakness of FM is that it assumes every mesh buffer switches ideally at time zero, the nominal condition under which state-of-the-art works employ it. Under OCV each buffer actually switches at a different time and with a finite slew, and FM sees none of this. Since every sink is driven jointly by many buffers through the low-resistance grid, the timing that FM misses shifts all sinks of a given corner by nearly the same amount, so its delay error is dominated by a single constant per corner rather than by per-sink mistakes. To avoid understating the baseline, we also report FM+cal, an idealized variant that is calibrated by removing the corner’s mean sink error computed from its own SPICE labels. This is the best any constant correction can achieve. The large delay MAE reduction of FM+cal is therefore expected by construction, and its residual isolates FM’s true per-sink accuracy. Skew, being the difference between the maximum and minimum sink delays, cancels any constant shift and is identical under both variants. We nevertheless report raw FM alongside FM+cal because the offset is not an artifact but a genuine consequence of FM’s inability to represent differing input arrival times, and calibrating it away requires per-corner SPICE labels that no design-space exploration flow has. The two columns thus separate what FM gets wrong in principle from what remains after the most favorable correction.

We also compare against our prior work FASM which is the only GNN based method that represents the mesh structure inherently.

Experimental Results

The need for new Synthetic Benchmark Generation

The goal of a surrogate model for design-space exploration is to remain fairly constant in performance to different mesh buffering configurations in order to rank solutions. In this experiment we show why training on prior benchmarks is not a good idea anymore. In order to rank them, we train the model proposed in FASM on old synthetic benchmarks and call it FASM-old and train the same model on the new synthetic benchmarks and call it FASM-new. On a real design ibex, we sweep the buffering density in range [0.1, 0.9] and for each, apply 20 random bufferings. The generated clock mesh variants are labeled by running SPICE and evaluated with FASM-old, FASM-new, and our proposed model in this work. The results are shown in Figure 9. Both the FASM-old and FASM-new converge in prior work training range, whereas FASM-old is inaccurate at other densities which any search algorithm might explore to find better solutions. The FASM-new model performs considerably better however, our proposed model beats both the prior variants while maintaining fairly constant performance in all buffering densities. Moving forward, we use FASM-new in all subsequent experiments for a fair comparison.

Figure 9. Comparison of different model inference capabilities on a buffering density search space. For each buffering density, we do 20 random bufferings of ibex and run SPICE to compare the model’s inference with actual labels. Both the FASM models converge inside shaded prior work [19] training range however, FASM-old is much more inaccurate for out-of-distribution bufferings as compared to FASM-new. Whereas, our proposed model in this work produces the least error in all the buffering density ranges.

Graph Representation and Model Architecture Ablation

An ablation study is performed to highlight the individual enhancements of the proposed graph representation in § 3.1 and model architecture in § 3.3 against the old graph representation and model architecture in FASM. For this ablation we pick the real designs in Table 6 and apply 100 random variations. The results are shown in Figure 10. The new graph representation itself provides significant improvements over the prior one in all test cases. The proposed model architecture further improves the performance on all but two test cases for skew error showing that combining both the graph representation and model architecture provides the best performance.

Figure 10. Ablation study showing individual improvements of the proposed graph representation and model architecture on the real designs. Each bar represents the mean error over 100 Monte-Carlo corners per design.

Furthermore, in Table 7 we show the scalability aspect of our graph representation. The total graph nodes and edges in FASM and the proposed graph representation are shown. On average we reduce the total nodes by 5.12×5.12\times and total edges by 3.87×3.87\times. We show the peak memory allocation of the GPU when loading the graph and doing a single inference pass. Our proposed representation on average reduces the memory usage by 5.10×5.10\times thereby allowing more graphs to be loaded onto the GPU for batched inference.

DesignGraph Nodes FASMGraph Nodes This WorkGraph Nodes Red.Graph Edges FASMGraph Edges This WorkGraph Edges Red.Peak GPU mem. (MB) FASMPeak GPU mem. (MB) This WorkPeak GPU mem. (MB) Red.
riscv32i5,7241,1285.07×18,3844,7203.89×280555.09×
mock-alu8,0011,5575.14×25,7766,7083.84×395775.13×
ibex10,5962,0765.10×34,0808,7843.88×5211025.11×
jpeg24,5954,7835.14×79,24820,5723.85×1,2062375.09×
cva626,2375,1575.09×84,32021,6243.90×1,2842515.11×
coralnpu44,5778,7535.09×143,29636,7403.90×2,1844285.10×
floonoc76,62814,9045.14×246,89663,9683.86×3,7587385.09×
total / mean196,35838,3585.12×632,000163,1163.87×9,6281,8885.10×

Table 7. Graph representation scalability comparison with FASM. In the last row the node and edge entries are totals and their reduction is the combined ratio. Peak GPU memory is calculated over a single inference pass, measured with matched models so the difference is only due to the graph representation.

Model Performance on Synthetic Benchmarks

Model Performance on Synthetic Benchmarks

For synthetic designs we apply a single random variation sample per design at a fixed 0.75 buffering density. The results are shown in Table 8. Our model outperforms all baselines on every metric. FM has significant accuracy loss where its raw delay MAE of 74.5 ps is dominated by the constant per-corner offset discussed in § 5.1, due to its inability to represent the input arrivals and slews that OCV on the top-level tree imposes on the mesh buffers. The FM+cal column isolates what remains after that offset is removed. Even with the idealized per-corner calibration, FM+cal trails our model on delay (7.60 vs. 4.20 ps). Skew is a relative difference between the maximum and minimum delay at the sinks so calibration does not affect it. FM under-predicts the skew of every design, with a mean error of 28.6 ps against 6.5 ps for our model. We further examine this at scale, when evaluating over thousands of MC corners on real designs in § 6.5.

DesignsDelay MAE (ps) This WorkDelay MAE (ps) FASM-newDelay MAE (ps) FMDelay MAE (ps) FM+calSlew MAE (ps) This WorkSlew MAE (ps) FASM-newSkew error (ps) This WorkSkew error (ps) FASM-newSkew error (ps) FMSkew error (ps) FM+cal
synth_005.116.4874.079.525.4010.170.9120.5121.3221.32
synth_016.5914.7663.969.4610.9325.127.418.5835.8635.86
synth_022.624.1375.134.014.4612.747.399.1316.1116.11
synth_033.914.3981.715.624.239.7511.1114.5635.2835.28
synth_043.265.1275.795.984.208.182.329.4641.2541.25
synth_053.736.4176.1611.007.659.8410.1213.9321.6421.64
Average Error (ps)4.206.8874.477.606.1412.636.5412.6928.5728.57

Table 8. Clock mesh timing metric prediction with this work, FASM-new [19], first-moment (FM) [18, 21, 27], and its idealized calibrated variant FM+cal (§ 5.1) on the synthetic test set with one MC sample and HSPICE labels as golden reference. Skew is a sink-pair difference and is identical under FM and FM+cal. Also, FM provides no slew estimate so omitted from table.

The power analysis results are shown in Table 9. The dynamic power estimate has on average 41.0% error whereas, our model captures the actual SPICE computed power with significant accuracy with average error of 3.06%. This shows that the global features we used along with our architecture helps the model learn the power consumption patterns in a clock mesh.

Synthetic designsPower (mW)Error (%)
This WorkSPICEDynamic PowerThis WorkDynamic Power
synth_008.738.355.184.5%37.9%
synth_012.312.271.471.9%35.3%
synth_024.434.532.652.2%41.5%
synth_034.664.822.663.3%44.6%
synth_0437.6736.9820.021.8%45.9%
synth_0513.8713.257.844.7%40.8%
Average Error (%)3.06%41.0%

Table 9. Clock mesh power comparison of this work, Dynamic Power (CV2fCV^{2}f) and actual power from running HSPICE on the synthetic benchmarks.

Model Performance on Real Benchmarks

For extensive performance analysis on real benchmarks, we evaluate every model on 5000 SPICE-simulated MC corners per design. To attribute our contributions individually, Table 10 reports three variants of our model: trained on the base synthetic dataset without AL (w/o AL, § 3.7), with AL under the default MSE loss (AL w/o Tail-Loss) and with AL under proposed Tail-Loss (AL w/ Tail-Loss). The w/o AL variant already matches the others on mean metrics but degrades at the tail. With only M=5M = 5 MC samples per training mesh, tail-producing variation patterns are rare in the base training data (§ 3.6), and its P99.9 skew error reflects that. AL improves P99.9 on 7/7 designs, and Tail-Loss improves it further on 6/7 at a slight cost in average delay MAE (3.19 ps to 3.40 ps). The full model (AL w/ Tail-Loss) outperforms FASM-new on every design and every metric.

DesignsMetric (ps)This WorkFASM-newFMFM+cal
w/o ALAL w/o Tail-LossAL w/ Tail-Loss
riscv32iDelay MAE3.583.403.696.4074.445.30
Slew MAE4.534.464.2710.98––
Skew Error (avg.)2.070.321.815.5725.5325.53
Skew P99.9 Error10.943.510.823.9554.7854.78
mock-aluDelay MAE3.413.363.595.1875.633.63
Slew MAE4.024.083.928.48––
Skew Error (avg.)4.344.153.538.9817.9017.90
Skew P99.9 Error6.200.240.086.7037.4637.46
ibexDelay MAE3.313.173.535.9974.715.07
Slew MAE4.184.013.9110.24––
Skew Error (avg.)0.561.392.8510.9326.0426.04
Skew P99.9 Error10.225.571.185.5649.8349.83
jpegDelay MAE3.072.983.005.3874.995.11
Slew MAE3.854.053.8310.09––
Skew Error (avg.)3.965.495.329.3027.0727.07
Skew P99.9 Error6.620.290.877.4346.7746.77
cva6Delay MAE3.233.193.477.0573.906.20
Slew MAE4.494.434.2913.48––
Skew Error (avg.)1.052.580.4214.4032.8132.81
Skew P99.9 Error9.888.857.799.5057.2357.23
coralnpuDelay MAE3.533.473.519.8571.297.54
Slew MAE5.265.675.3025.99––
Skew Error (avg.)9.7913.439.6923.5334.9134.91
Skew P99.9 Error5.283.652.7417.4256.5856.58
floonocDelay MAE2.922.793.074.1075.614.45
Slew MAE3.543.793.497.20––
Skew Error (avg.)6.529.727.618.6028.3128.31
Skew P99.9 Error6.483.421.166.5045.2945.29
Average Delay MAE3.293.193.406.2874.375.33
Average Slew MAE4.274.364.1412.35––
Average Skew Error4.045.304.4611.6227.5127.51
Average Skew P99.9 Error7.953.652.098.1549.7049.70

Table 10. OCV model accuracy on the real designs, evaluated on 5000 SPICE-simulated MC corners per design. We report per-sink Mean Absolute Error (MAE) for delay and slew, and two distribution-level skew metrics: the average skew error, ∣mean⁡(skewpred)−mean⁡(skewSPICE)∣|\operatorname{mean}(\mathrm{skew}_{\mathrm{pred}})-\operatorname{mean}(\mathrm{skew}_{\mathrm{SPICE}})|, and the tail skew error, ∣P99.9pred−P99.9SPICE∣|P99.9_{\mathrm{pred}}-P99.9_{\mathrm{SPICE}}|, computed over each design’s skew distribution. Our model is shown in three variants: trained without active learning (w/o AL), with AL under the default MSE loss (AL w/o Tail-Loss), and with AL under the proposed Tail-Loss (AL w/ Tail-Loss). FM+cal is the idealized per-corner calibrated FM of § 5.1. Skew is a sink-pair difference and is therefore identical under FM and FM+cal, and FM provides no slew estimate (–).

The FM columns depict the analytical baseline’s structural limits. The FM without calibration carries a large, nearly constant per-corner delay offset (§ 5.1). Once the idealized calibration removes this offset, FM+cal surpasses FASM-new on delay MAE (5.33 ps vs. 6.28 ps on average), but it still remains 1.6x above our full model (5.33 ps vs. 3.40 ps). Skew is not affected by the delay offset since it is a local relative change between the maximum and minimum delays at sinks. FM under-predicts the skew across all seven designs, with an average error of 27.51 ps and a P99.9 error of 49.70 ps. In contrast, our full model reduces the average P99.9 skew error by 24× relative to FM (49.70 ps vs. 2.09 ps)

and by 3.9× relative to FASM-new (8.15 ps vs. 2.09 ps). Figure 11 visualizes this behavior by plotting each model’s skew histogram against SPICE, showing where the mean and the tail of the distribution are captured or lost.

Figure 11. Skew histogram plots of the two benchmarks (ibex, riscv32i). Left: plots shows the overall skew histogram produced by SPICE, and our three model variants. Right: plots shows the zoomed in tail-end of the skew histogram and how each model captures it.

We also present our model’s performance on power prediction in Table 11. Our model generalizes to the real benchmarks as well and shows good accuracy in power prediction.

Real DesignsPower (mW)Error (%)
This WorkSPICEDynamic PowerThis WorkDynamic Power
riscv32i2.382.451.443.8%41.2%
mock-alu3.473.361.883.7%44.1%
ibex4.694.662.692.0%42.3%
jpeg10.3610.005.893.8%41.1%
cva69.549.215.753.7%37.6%
coralnpu16.3515.7110.844.1%31.0%
floonoc29.8129.1316.842.4%42.2%
Average Error (%)3.4%39.9%

Table 11. Clock mesh power comparison of this work, the dynamic power estimate (CV2fCV^{2}f), and actual HSPICE power on real designs, averaged over 5000 MC corners per design. Error is the mean per-corner absolute percentage error against SPICE.

Runtime Evaluation

The key reason to use FM method in state-of-the-art works is the speedup gain. However, the trade-off is the accuracy loss as we saw in Table 10. In order to measure our runtime gains with the FM method and with our prior work FASM, we compare them over a single pass and over 5000 MC sample evaluations as shown in Table 12. In one-pass speedup comparison we have better performance on all designs as compared to FM except the smallest design (riscv32i, 0.8×) where graph construction dominates. However, we are faster in all the designs from our prior work FASM which is mainly due to our new graph representation of the clock mesh. The major advantage we get over FM is in multiple calls during OCV evaluations, where we remain in the graph domain and update the features of the graph to represent OCV thereby requiring only the inference for each evaluation. On the contrary, FM method needs to compute the delays again.

DesignHSPICEFMThis WorkThis WorkFASMFASMover FMover FMover FASMover FASM
graph conv.infer.graph conv.infer.1 pass5000 MC1 pass5000 MC
riscv32i1.860.150.17810.00820.19990.00950.8×18×1.12×1.16×
mock-alu4.920.370.25640.00380.29030.00881.4×96×1.15×2.30×
ibex8.670.510.35500.00520.40320.01161.4×97×1.15×2.22×
jpeg28.033.560.88720.00691.32500.02694.0×503×1.51×3.84×
cva630.322.801.34900.01201.44350.02752.1×228×1.08×2.26×
coralnpu72.427.412.34160.01422.80200.04053.1×505×1.21×2.80×
floonoc166.5337.204.49510.02095.30010.07928.2×1706×1.19×3.68×

Table 12. Runtime for one mesh evaluation and for a 5000-sample Monte-Carlo sweep. We denote the SPICE netlist to graph conversion time as (graph conv.) and model inference time as (infer.). Under variation our model reuse a single converted graph and update only its features, so conversion is paid once. FM must be recomputed per corner.

Case Study: Variation-Aware Buffer Sizing

In this section, we present a study on using our proposed surrogate model inside an optimization loop. Here all the presented components of the model are utilized such as skew, slew, and power prediction under OCV. Using SPICE alone and not a surrogate model, this optimization would not be possible due to run-time. For this specific study, we use a multi-objective optimization method based on genetic algorithm called NSGA-II [9] where we optimize the skew, max slew and power under OCV. Our approach is not tied to NSGA-II since the surrogate serves only as a fast evaluator.

For this experiment, we select the ibex design with operating frequency of 1 GHz. We provide the NSGA-II algorithm with the clock mesh where each intersecting mesh point is the candidate for a buffer to be placed. In the case of ibex we have a grid size of 12 × 12 (see Table 6) meaning 12 · 12 = 144 potential buffering candidate locations. Each buffering candidate is represented as a vector b⃗\vec{b} of different buffer sizes. We use the ASAP7 PDK provided legal buffer sizes of {0, 2, 3, 4, 5, 6, 8, 10, 12, 16, 24} where size 0 just means no buffer at the location. The candidates vectors are reflected in the graph where the buffer related features are modified accordingly and then MM random variations are applied. Each candidate and their variations are independent and are evaluated in batched forward pass through the model. The candidate is scored on three objectives: the 99th^{th} percentile of predicted skew and max-slew, and the power consumption across the MM sampling variations. We used percentiles rather than the exact max value of the skew/slew across the MM variations due to randomness, where re-evaluating the same candidate with another MM random variations can produce a different max skew/slew value and also due to the surrogate model noise where it might over-predict or under-predict certain candidates at a single max value over all MM evaluations. Using percentiles gives the model more leverage to explore the candidates.

We initialize a population of Npop=100N_{pop} = 100 buffering candidates b⃗1\vec{b}_1, b⃗2\vec{b}_2, ..., b⃗100\vec{b}_{100} in two ways. First, we generate 50% of the informed candidates encoding a physical prior: for a fixed total drive strength the aggregate output conductance of the buffer set is unchanged, but distributing it over more sites shortens the mesh wire resistance in series with each driver and therefore lowers the effective driver resistance seen at every node, improving slew at identical buffer area. These candidates are drawn from a buffering density between [0.85, 1.00] and assign each active site a legal buffer size ss with probability proportional to 1/s21/s^{2}. This creates densely buffered meshes with many smaller buffers as opposed to sparse yet larger buffers yielding a mean buffer size of 3.5. Second, for the remaining candidates we do exploration by uniformly sampling the buffering density in range [0.10, 1.00] and uniformly sampling the buffer size from the library yielding a mean buffer size of 9.0. With this approach of initialization, we provide the algorithm with a balance of prior knowledge and exploration.

The parents are selected by binary tournament on front rank and crowding distance, recombined by uniform crossover with p=0.9p = 0.9 and mutated per site with p=0.03p = 0.03 by a move that steps a buffer to the adjacent larger or smaller legal size, randomizes it, or removes it. Offspring are merged with their parents and the whole pool is re-sorted each generation. We run a total of Ngen=20N_{gen} = 20 generations and use M=5000M = 5000 random variation samples.

The algorithm returns 66 Pareto front points that are evaluated with SPICE. The best candidates are chosen based on the minimum max-slew, minimum power, and one that balances all objectives.

Buffering Optimization Results

For comparison of our buffering solutions, we use the baseline buffered solution proposed by Venkataraman et al. [34] and with current state-of-the-art MeshWorks [27]. The results are shown in Table 13 and Table 14. The balanced design improves the 99th99^{\mathrm{th}}-percentile skew by 49.1%, power by 25.7% and buffer area by 37.3% over MeshWorks for a 6.8% slew increase. Moving along the front trades skew against the remaining budgets: the lowest power design gives up 4.6% of skew improvement to gain a further 2.7% of power and 3.5% of area, while the min-slew design reduces the slew penalty to 4.4% and still improves 99th99^{\mathrm{th}}-percentile skew by 40.5% at MeshWorks’ exact buffer count. The heuristic proposed in baseline [34] attains the best slew of any design considered (105.3 ps) but at the cost of 3.1× the area and 2.3× the power of our balanced design.

ibex design\multicolumn{3}{c}{skew (ps)}\multicolumn{3}{c}{max. slew (ps)}power (mW)area (μm2\mu\mathrm{m}^{2})# bufs
baseline [34]p50p_{50}p99p_{99}p99.9p_{99.9}p50p_{50}p99p_{99}p99.9p_{99.9}4.7154.37128
MeshWorks [27]21.137.343.098.4112.4117.62.7527.77139
Ours (min. slew)11.622.226.7106.5117.3120.22.1318.63139
Ours (balanced)10.219.022.8108.7120.0124.02.0417.41138
Ours (min. power)10.920.724.4111.2122.6127.21.9716.45129

Table 13. Buffering optimization on ibex, verified with 5000 HSPICE Monte Carlo corners per design at matched process seeds. Skew and maximum slew are reported as percentiles of the per-corner distribution, power is the mean.

Table 14. Relative change of the optimized buffering solutions with respect to each baseline, on the metrics of Table 13. Skew and maximum slew are reported at the median (p50p_{50}) and the 99th percentile (p99p_{99}) over 5000 matched Monte Carlo corners, power is the mean and area is total buffer cell area. Positive values denote improvement.

ibex designskewmax. slewpowerarea
p50p_{50}p99p_{99}p50p_{50}p99p_{99}
vs. MeshWorks [27]
Ours (min. slew)+45.0%+40.5%−8.2%−4.4%+22.3%+32.9%
Ours (balanced)+51.7%+49.1%−10.5%−6.8%+25.7%+37.3%
Ours (min. power)+48.3%+44.5%−13.0%−9.1%+28.4%+40.8%
vs. baseline [34]
Ours (min. slew)+60.1%+53.9%−12.7%−11.4%+54.7%+65.7%
Ours (balanced)+64.9%+60.6%−15.0%−14.0%+56.7%+68.0%
Ours (min. power)+62.5%+57.1%−17.6%−16.4%+58.3%+69.8%

Table 14. Relative change of the optimized buffering solutions with respect to each baseline, on the metrics of Table 13. Skew and maximum slew are reported at the median (p50p_{50}) and the 99th percentile (p99p_{99}) over 5000 matched Monte Carlo corners, power is the mean and area is total buffer cell area. Positive values denote improvement.

Buffering Optimization Runtime

Producing the Pareto front requires Ngen⋅Npop⋅M=20⋅100⋅5000N_{\mathrm{gen} } \cdot N_{\mathrm{pop}} \cdot M = 20 \cdot100 \cdot5000 resulting in 10710^{7} evaluations, which completes in 5.5 h on two NVIDIA RTX 4090s. SPICE is then run once per front point to validate the search, taking a further 9.5 min for a 66 point Pareto front. Selection of the candidates are done after running SPICE on the Pareto front points. Once the final candidates are selected, we run 5000 MC simulations on each to compare their robustness to OCV against the other baselines.

Table 12 reports single sequential runtimes, but both FM and HSPICE can be parallelized, so we compare against their best case on our machine. HSPICE corners are independent and scale across processes. On our 64-thread host, however, throughput saturates at 8 concurrent HSPICE instances because the runs are memory-bandwidth bound, and using more workers gains nothing, giving an effective 1.1 s per ibex corner. Even at that rate the 10710^{7} evaluations would take roughly four months, about 550× longer than the surrogate. This showcases why HSPICE is infeasible in search space exploration. However, it remains as the only exact evaluator, which is why we reserve it for validating the front rather than searching for it.

FM is a more interesting case because its solves are also independent, and at 0.51 s per ibex corner on 32 cores the 10710^{7} evaluations would finish in under two days if it scales perfectly. FM is therefore feasible but still falls short of the surrogate. However, it is not excluded on the runtime but rather due to its limitation and inaccuracies in computing metrics. It provides no slew for the feasibility constraint, the power estimate is inaccurate (42.3% error for ibex), and its computed skew worsens in the tail-ends under OCV (49.83 ps error for ibex).

Our surrogate does carry a one-time cost, namely synthetic data generation and training, but this cost is amortized: the model is inductive and is trained once for the technology, not per design or per search. Among the three evaluators, only the surrogate is simultaneously fast enough for the search and accurate enough for its objectives.

Conclusion

This work proposed the first full surrogate model of delay, slew, skew, power and variation for clock meshes and showed significant improvement in the timing metrics over its predecessor FASM. By modeling the clock mesh with an improved graph representation along with the new derived edge and global features, and a new model architecture the surrogate model effectively captures the complex interactions of the multiple drivers, reconverging paths, and OCV. Furthermore, with the new AL strategy along with our proposed Tail-Aware loss function we significantly improve capturing the skew histogram under OCV. Results show that the proposed model predicts all the metrics with marginal errors as compared to SPICE and significantly improves over the FM method used in current state-of-the-art works. We also motivate the use-case of a surrogate model to provide faster and accurate metrics at design-time for informed early decisions during clock mesh optimization and faster design-space exploration.

References

References

  1. [1]Jason Ansel et al. 2024. PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and Graph Compilation. In 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS ’24). ACM. doi:10.1145/3620665.3640366DOI
  2. [2]Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. 2016. Layer Normalization. arXiv:1607.06450 [stat.ML] https://arxiv.org/abs/1607.06450
  3. [3]Cătălina Cangea, Petar Veličković, Nikola Jovanović, Thomas Kipf, and Pietro Liò. 2018. Towards Sparse Hierarchical Graph Classifiers. arXiv:1811.01287 [stat.ML] https://arxiv.org/abs/1811.01287
  4. [4]Rich Caruana. 1997. Multitask Learning. Mach. Learn. 28, 1 (July 1997), 41–75. doi:10.1023/A:1007379606734DOI
  5. [5]H. Chen, C. Yeh, G. Wilke, S. Reddy, H. Nguyen, W. Walker, and R. Murgai. 2005. A sliding window scheme for accurate clock mesh analysis. In ICCAD-2005. IEEE/ACM International Conference on Computer-Aided Design, 2005. 939–946. doi:10.1109/ICCAD.2005.1560197DOI
  6. [6]Hsien-Han Cheng, Iris Hui-Ru Jiang, and Oscar Ou. 2020. Fast and Accurate Wire Timing Estimation on Tree and Non-Tree Net Structures. Design Automation Conference (DAC) (2020).DOI
  7. [7]Lawrence T. Clark, V. Vashishtha, Luciano Shifren, Aditya Gujja, Saurabh Sinha, Brian Cline, Chandrasekaran Ramamurthy, and Greg Yeric. 2016. ASAP7: A 7-nm finFET predictive process design kit. Microelectronics Journal 53 (2016), 105–115. doi:10.1016/j.mejo.2016.04.006DOI
  8. [8]Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. 2016. Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs). arXiv:1511.07289 [cs.LG] https://arxiv.org/abs/1511.07289
  9. [9]K. Deb, A. Pratap, S. Agarwal, and T. Meyarivan. 2002. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Transactions on Evolutionary Computation 6, 2 (2002), 182–197. doi:10.1109/4235.996017DOI
  10. [10]Madhav P. Desai, Radek Cuvakovic, and James Jensen. 1996. Sizing of clock distribution networks for high performance CPU chips. In Design Automation Conference (DAC). 389–394.DOI
  11. [11]Matthias Fey and Jan E. Lenssen. 2019. Fast Graph Representation Learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds.arxiv.org/abs/1903.02428
  12. [12]Benjamin Goldblatt, Paolo Pedroso, Farhad Modaressi, Ethan Sifferman, and Matthew R. Guthaus. 2026. HighTide: An Agent-Curated Open-Source VLSI Benchmark Suite. arXiv:2606.04126 [cs.AR] https://arxiv.org/abs/2606.04126
  13. [13]Zhizang Guo, Mingjie Liu, Jiaqi Gu, Shuhan Zhang, David Z. Pan, and Yibo Lin. 2022. A timing engine inspired graph neural network model for pre-routing slack prediction. In Proceedings of the 59th ACM/IEEE Design Automation Conference (San Francisco, California) (DAC ’22). Association for Computing Machinery, New York, NY, USA, 1207–1212. doi:10.1145/3489517.3530597DOI
  14. [14]Zhigang Hao and Guoyong Shi. 2010. A fast symbolic computation approach to statistical analysis of mesh networks with multiple sources. In 2010 15th Asia and South Pacific Design Automation Conference (ASP-DAC). 383–388. doi:10.1109/ASPDAC.2010.5419852DOI
  15. [15]Yuting Hu, Jiajie Li, Florian Klemme, Gi-Joon Nam, Tengfei Ma, Hussam Awad, and Jinjun Xiong. 2023. SyncTREF: Fast Timing Analysis for Integrated Circuit Design through a Physics-informed Tree-based Graph Neural Network. In Advances in Neural Information Processing Systems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36. Curran Associates, Inc., 21415–21428. https://proceedings.neurips.cc/paper_files/paper/2023/file/345e8fbbfc20d7d4f3a5cbe656a39a-Paper-Conference.pdfDOI
  16. [16]Ronald L. Iman. 2008. Latin Hypercube Sampling. John Wiley & Sons, Ltd. doi:10.1002/9780470061596.risk0299
  17. [17]Andrew B Kahng and Tom Spyrou. 2021. The OpenROAD project: Unleashing hardware innovation. In Proc. GOMAC.
  18. [18]Minseok Kang and Taewhan Kim. 2014. Integrated Resource Allocation and Binding in Clock Mesh Synthesis. ACM Trans. Des. Autom. Electron. Syst. 19, 3, Article 30 (June 2014), 28 pages. doi:10.1145/2611762DOI
  19. [19]Muhammad Hadir Khan and Matthew Guthaus. 2026. A Fast and Accurate Surrogate Model for Clock-Mesh Timing Analysis. Proceedings of the Great Lakes Symposium on VLSI 2026 (2026), 24–30. https://doi.org/10.1145/378709.3815287
  20. [20]Diederik P. Kingma and Jimmy Ba. 2017. Adam: A Method for Stochastic Optimization. arXiv:1412.6980 [cs.LG] https://arxiv.org/abs/1412.6980
  21. [21]Dejian Li, Jie Gan, Chongfei Shen, Qi Chen, Lixin Yang, Sihai Qiu, Xin Jin, Tiantian Wu, Zhijie Chen, and Meng Liu. 2025. Clock mesh synthesis through dynamic programming with physical parameters consideration. Integration 100 (2025), 102261. doi:10.1016/j.vlsi.2024.102261DOI
  22. [22]Shengrui Li, Xueting Han, and Jing Bai. 2024. AdapterGNN: parameter-efficient fine-tuning improves generalization in GNNs. In Proceedings of the Thirty-Eighth AAAI Conference on Artificial Intelligence and Thirty-Sixth Conference on Innovative Applications of Artificial Intelligence and Fourth Symposium on Educational Advances in Artificial Intelligence (AAAI’24/IAAI’24/EAAI’24). AAAI Press, Article 1516, 9 pages. doi:10.1609/aaai.v38i12.29264DOI
  23. [23]Masoumian, Georgios Selimis, Rui Wang, Geert-Jan Schrijen, Said Hamdioui, and Mottaqalliah Taouil. 2022. Reliability Analysis of FinFET-Based SRAM PUFs for 16nm, 14nm, and 7nm Technology Nodes. In 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE). 1189–1192. doi:10.23919/DATE54114.2022.9774735DOI
  24. [24]Hugh McIntyre, Srikant Arekapudi, Eric Busta, Timothy Fischer, Michael Golden, Aaron Horiuchi, Tom Meneghini, Samuel Naffziger, and James Vinh. 2012. Design of the Two-Core x86-64 AMD “Bulldozer” Module in 32 nm SOI CMOS. IEEE Journal of Solid-State Circuits 47, 1 (2012), 164–176. doi:10.1109/JSSC.2011.2167823DOI
  25. [25]Tusharkant Mishra, Pradeep Kothari, and Ayan Datta. 2025. Deterministic On Chip Variation Modeling of Clock Mesh. Presentation at Design Automation Conference. https://62dac.conference-program.com/presentation/?id=ENGPRES153&sess=sess225
  26. [26]Divya Prasad, Chenyun Pan, and Azad Naeemi. 2016. Impact of interconnect variability on circuit performance in advanced technology nodes. In 2016 17th International Symposium on Quality Electronic Design (ISQED). 398–404. doi:10.1109/ISQED.2016.7479234DOI
  27. [27]Anand Rajaram and David Z. Pan. 2010. Meshworks: a comprehensive framework for optimized clock mesh network synthesis. Trans. Comp.-Aided Des. Integ. Cir. Sys. 29, 12 (Dec. 2010), 1945–1958. doi:10.1109/TCAD.2010.2061130DOI
  28. [28]P. J. Restle, C.A. Carter, J.P. Eckhardt, B.L. Krauter, B.D. McCredie, K.A. Jenkins, A.J. Weger, and A.V. Mule. 2002. The clock distribution of the POWER4 microprocessor. In International Solid-State Circuits Conference (ISSCC). 144–145.
  29. [29]T. Konstantin Rusch, Michael M. Bronstein, and Siddhartha Mishra. 2023. A Survey on Oversmoothing in Graph Neural Networks. arXiv:2303.10993 (2023).arxiv.org/abs/2303.10993
  30. [30]Visvesh Sathe, Srikant Arekapudi, Charles Ouyang, Marios Papaefthymiou, Alexander Ishii, and Samuel Naffziger. 2012. Resonant clock design for a power-efficient high-volume x86-64 microprocessor. In 2012 IEEE International Solid-State Circuits Conference. 68–70. doi:10.1109/ISSCC.2012.6176933DOI
  31. [31]M. G.-R. Thomson, P. J. Restle, and N. K. James. 2006. A 5GHz Duty-Cycle Correcting Clock Distribution Network for the POWER6 Microprocessor. In International Solid-State Circuits Conference (ISSCC). 1522–1529.DOI
  32. [32]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Proceedings of the 31st International Conference on Neural Information Processing Systems (Long Beach, California, USA) (NIPS’17). Curran Associates Inc., Red Hook, NY, USA, 6000–6010.
  33. [33]Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua Bengio. 2018. Graph Attention Networks. arXiv:1710.10903 (2018).arxiv.org/abs/1710.10903
  34. [34]G. Venkataraman, F. Zhuo, J. Hu, and P. Li. 2006. Combinatorial Algorithms for Fast Clock Mesh Optimization. In International Conference on Computer-Aided Design (ICCAD). 563–567.
  35. [35]Xingsheng Wang, Andrew R. Brown, Binjie Cheng, and Asen Asenov. 2011. Statistical variability and reliability in nanoscale FinFETs. In 2011 International Electron Devices Meeting. 5.4.1–5.4.4. doi:10.1109/IEDM.2011.6131494DOI
  36. [36]Gustavo Wilke, Renan Fonseca, Cecilia Mezzomo, and Ricardo Reis. 2008. A novel scheme to reduce short-circuit power in mesh-based clock architectures. In Symposium on Integrated Circuits and System Design (SBCCI). 117–122.DOI
  37. [37]Xiaoji Ye, Peng Li, Min Zhao, Rajendran Panda, and Jiang Hu. 2010. Scalable Analysis of Mesh-Based Clock Distribution Networks Using Application-Specific Reduced Order Modeling. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 29, 9 (2010), 1342–1353. doi:10.1109/TCAD.2010.2059090
  38. [38]Yuyang Ye, Tinghuan Chen, Yifei Gao, Hao Yan, Bei Yu, and Longxing Shi. 2023. Fast and Accurate Wire Timing Estimation Based on Graph Learning. Design, Automation & Test in Europe Conference (DATE) (2023).DOI
  39. [39]Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. 2018. An end-to-end deep learning architecture for graph classification. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence and Thirtieth Innovative Applications of Artificial Intelligence Conference and Eighth AAAI Symposium on Educational Advances in Artificial Intelligence (New Orleans, Louisiana, USA) (AAAI’18/IAAI’18/EAAI’18). AAAI Press, Article 544, 8 pages.DOI

Paper details

vlnc:W_uyjshtxw
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents