acceptodds
Withdrawn from ICLR 2027

Paretorouter: VLSI Global Routing With Multi-Objective Optimization

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Global routing (GR) has been a central task in modern chip design. Many efforts, either ML-based or heuristic, have been proposed that seek to optimize specific business goals, such as overflow (OF) and wirelength (WL) of generated routes. Notably, recent end-to-end neural routers have demonstrated significant speed advantages in optimizing wirelength, yet they struggle to achieve efficiency in reducing overflow. In fact, a good trade-off between the above two metrics has not been achieved, especially when overall efficiency is pursued, as existing ML-based methods often optimize only a single metric. To bridge this gap for more practical industry applications, we propose a flow-matching-based router for GR, called ParetoRouter, which achieves trade-offs between WL and OF, generating highly connected routes at high speed and quality. In the training phase, two differential metric-oriented routing results are utilized to build the training datasets. Beyond their average—a base 'Average Flow' between pins and routes—we introduce a disambiguation objective that mitigates discrete topological artifacts. A Pareto sampling method, based on the Das-Dennis method, is also devised to achieve trade-offs between OF and WL in the inference phase. Extensive experimental results show that it achieves the lowest (or tied-lowest) **overflow** on all evaluated benchmarks and, compared with the end-to-end DSBRouter, produces **fewer superfluous routes** on ISPD07 with **over 70x** less generation time.

Primary area:
optimization
Keywords:
Global Routing, Multi-Objective Optimization.

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_SmbLOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduces ParetoRouter, an ML-based, multi-objective global router for VLSI design using flow matching. It explicitly balances wirelength (WL) and overflow (OF) using a "Average Flow" objective and a Das-Dennis-based Pareto sampling method to generate preference-compliant routing solutions.

Critical strengths

Novel Multi-Objective Approach: Applying flow matching and Pareto sampling to explicitly balance WL and OF trade-offs is an innovative step that addresses a major gap in existing single-metric ML routers.

Generation Efficiency: The method significantly reduces generation time compared to existing end-to-end ML-based solvers (like DSBRouter) while maintaining highly competitive overflow metrics.

Critical weaknesses
  1. The absence of open-source code limits the ability to verify and independently reproduce the claimed experimental results.

  2. Missing Ablation Studies: The hyperparameters introduced by the loss function and the classifier function lack clear explanations and ablation studies, making it difficult to assess model sensitivity.

  3. Ambiguous Preference Selection: The paper does not adequately elaborate on the methodology or practical criteria for choosing between OF-preferred and WL-preferred configurations. It just enumerates a series of weights.

  4. Classifier Complexity vs. Benefit: Introducing a classifier function increases the overall model complexity, but it appears to provide only marginal benefits to the final routing performance. The necessity and trade-offs of this added complexity are not well justified.

Questions for authors

See the weaknesses above.

Reviewer_dLeNOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes a flow-based global router trained from two classical routing teachers using average-flow, confidence-weighted, and adversarial losses. Objective-weighted guidance supports alternative overflow/wirelength trade-offs during one-step neural generation. The experimental section demonstrates connected routes and strong overflow improvements over some neural baselines, with substantial speedups relative to DSBRouter. The system includes a guidance computation that constructs a complete route.

Critical strengths
  1. The paper addresses a meaningful trade-off rather than a single score.
  2. The reported neural-baseline improvements and component ablation studies are promising.
Critical weaknesses

Please refer to the questions section.

Questions for authors
  1. Given Eq.7's weighted-mean minimizer, what mechanism selects a valid topology when the teachers disagree? This may be a shared question for multi-objective loss function design; a simple weighted summation may result in undesired performance.
  2. The authors may want to discuss more about the reason for choosing routing as the application for the proposed method. It seems that the method can be viewed as a relatively general MO generative framework. What specific adaptation did the method make to fit the routing problem? Or is this work indeed proposing a general MO generative framework? In this case, what is the difference between this work and existing literature considering MO generation and generation with guidance?
3 comments
AuthorsOpenReview ↗

Response to Reviewer dLeN (1/3)

We sincerely thank the reviewer for the two precise and insightful questions. Both concern the division of roles between training and sampling: ParetoRouter learns a preference-agnostic prior during training, while topology selection and the multi-objective trade-off are determined at sampling time using the current routing state. We explain this design principle below and list the corresponding revisions.

Q1. Eq. 7's weighted-mean minimizer and topology selection.

We thank the reviewer for this sharp observation, and we agree with it. We will revise Sec. 4.1 to make the role of the loss explicit.

What Eq. 7 does. π\pi is computed per training net from the two teachers' OF and WL and is held constant (no gradient), so Eqs. 6–7 are regression losses whose sum has a pixel-wise weighted-mean minimizer. Ldis\mathcal{L}_{\mathrm{dis}} therefore only shapes a learned prior, while the discrete topology choice is made at sampling time, as described below. We will make the phrase "follow the better route" in Sec. 4.1 more precise accordingly. Over all 221,919 training nets, the teachers disagree on 61.0%. Among these, π\pi equals exactly 1/21/2 on 64.0% (identical OF and WL, e.g., the two equal-length L-shapes of a two-pin net), where Eq. 7 reduces to Eq. 6. Our implementation also includes a small entropy term 0.01 p(1−p)0.01\,p(1-p), which we will add to Sec. 4.1.

What selects the topology. The discrete choice is made at sampling time by the route construction inside the guidance (Alg. 3, line 4). It builds a connected reference route r′r' on the current capacity under the ω\omega-weighted cost, with the network's high-confidence pixels as candidates, and the guidance gradient (Eq. 13) moves the prediction toward r′r'. To verify this division of roles, we ran this sampling step with the paper model on all 221,919 training inputs at ω=(0.5,0.5)\omega=(0.5,0.5):

Agreed pixelsDisputed pixelsOff-route pixels
Mean prediction (scale [−1,1][-1,1])0.23−0.37−0.99
Share reaching the candidate threshold (0.8)20.3%4.3%0.02%

The prediction is thus highest where the teachers agree, lower where they disagree, and close to −1-1 off-route: agreed pixels become candidates about 5× more often than disputed ones and about 1,000× more often than off-route pixels, and the construction completes the rest. The resulting r′r' connects all pins on 100% of the nets. On the disputed segments of the 135k disagreeing nets, r′r' follows one teacher in 61.5% of cases (covering at least half of that teacher's disputed pixels and less than half of the other's), takes a route different from both in 35.3%, and keeps both teachers' segments in only 3.3%. The superposition implied by the weighted-mean minimizer is thus resolved by the construction into a single connected route under the requested preference. The learned candidates also matter: compared with constructing from the pins alone ("w/o NN"), they reduce WL by 2.2% on ibm01 (64,648 vs. 66,119).

Why the choice is deferred to sampling. For the 64.0% exact ties, the teachers' OF and WL provide no basis for preferring either topology. Congestion, which could distinguish them, emerges as nets are routed sequentially on a shared capacity map; this information is available at sampling time, through the remaining capacity and the preference ω\omega. During training, the adversarial term complements Eqs. 6–7: unlike them, it is not minimized by the pixel-wise mean, because the discriminator's real samples are individual routes rather than their averages.

On weighted summation in multi-objective loss design. A weighted sum of regression losses toward conflicting targets is minimized by a compromise. When the feasible set is non-convex, that compromise need not be a valid solution. The set of routes is non-convex: the average of the two L-shapes of a two-pin net is a half-intensity rectangle. ParetoRouter therefore uses the weighted loss only to learn a prior, and the topology is selected at sampling time by the construction under the preference ω\omega. The scalarization in Eq. 11 is linear, as in ParetoFlow, and thus targets supported Pareto points; a Tchebycheff scalarization could replace it without changing the rest of the pipeline, which we will discuss as a limitation.

AuthorsOpenReview ↗

Response to Reviewer dLeN (2/3)

Q2. Why routing, and how does ParetoRouter differ from MO generation and guided generation?

We thank the reviewer for this question, which helps us position the work more clearly. ParetoRouter is an application-driven method for global routing rather than a general multi-objective generative framework. Its contribution lies in adapting preference-guided flow generation to routing's feasibility constraints and evolving capacity state. The guided vector field (Eq. 9), the weighted score distribution (Eqs. 11–12) and the Das–Dennis weights follow ParetoFlow (Yuan et al., 2025), which we will acknowledge explicitly in Sec. 4.2. The routing-specific adaptations are:

(i) Hard feasibility: every net must be connected. A route that leaves any pin unconnected is invalid, and pixel-wise generative objectives do not encode this constraint. ParetoRouter therefore enforces feasibility at sampling time, by defining the guidance target as a feasible route: for each net, the classifier (Alg. 3, line 4) builds a connected rectilinear route on the current capacity, with all pins forced in as terminals and the network's high-confidence pixels as Steiner candidates, and scores the prediction by its pixel-wise agreement with this route. The guidance gradient thus points toward a valid route under the requested preference, rather than toward a pixel-wise compromise between alternative topologies (Q1: on all 221,919 training inputs, these reference routes connect all pins).

(ii) State-dependent objectives under sequential generation. OF depends on the capacity left by all previously routed nets, so a design is generated net by net: each net is conditioned on its pins and the current residual capacities, and capacity is decremented after each net, so congestion builds up across nets. ParetoFlow and other offline MOO methods instead score independent samples with predictors learned from offline data. In routing, OF and WL are known in closed form but are defined only on a connected route and the current capacity. We therefore extend the route-based guidance of DSBRouter (Shi et al., 2025), which targets OF only, to a multi-objective classifier that needs no trained predictor: its route cost is J=γOF∗ωOF∗C+γWL∗ωWL∗LJ=\gamma_{\mathrm{OF}}*\omega_{\mathrm{OF}}*C+\gamma_{\mathrm{WL}}*\omega_{\mathrm{WL}}*L on the live capacity, with a continuous overflow cost CC, so that the classifier has a signal before overflow actually occurs, and scale factors γ\gamma that compensate for the sparsity of OF relative to WL.

(iii) Multiple valid targets per input. Each input has two teacher routes from conventional routers with different trade-offs (NTHU-Route, NCTU-GR), which often differ in topology at equal cost (Q1). We weight them with routing metrics computed on the same capacity map (Eq. 7), use an adversarial term whose real samples are single-topology routes, and resolve the remaining ambiguity by the construction at sampling time.

(iv) Scale. A design contains 10410^4–10610^6 nets. We train the backbone to predict the full displacement and apply the guidance in a single step at t=0t=0, replacing the coefficient (1−t)/t(1-t)/t, which diverges at t=0t=0, with a constant ρ\rho (Eq. 10, App. A.3), and generate nets in GPU batches. This contributes to the >70× generation-time reduction relative to DSBRouter.

Why routing. The WL–OF trade-off is intrinsic to global routing: relieving congestion requires detours that lengthen wires, and the preferred balance differs across designs and design stages. Conventional routers fix this balance in their cost functions, and existing learning-based routers optimize a single metric (Table 1), so exploring the trade-off requires re-tuning and re-running. ParetoRouter trains one preference-agnostic model and injects ω\omega only at sampling time.

AuthorsOpenReview ↗

Response to Reviewer dLeN (3/3)

Relation to MO generation and guided generation.

  • ParetoFlow. ParetoRouter generates sequentially conditioned solutions instead of independent samples, replaces learned predictors with a construction-based classifier on the current routing state, and replaces multi-step sampling with one-step guided sampling.
  • Pareto-guided diffusion (PROUD, Yao et al., 2024). PROUD adjusts denoising gradients so that independently generated samples approach the Pareto front of fixed property functions. ParetoRouter's objectives instead depend on a routing state shared by sequentially generated nets.
  • DSBRouter's guidance. ParetoRouter uses a flow instead of a Schrödinger bridge, and a weighted multi-objective classifier instead of an OF-only one (App. A.2.2).
  • Preference-conditioned methods (e.g., PMOCO, Lin et al., 2022; MOGFN, Jain et al., 2023). These condition training on the preference. ParetoRouter does not: ω\omega enters only at sampling time.
  • One-step generative combinatorial solvers with gradient search (e.g., Fast T2T, Li et al., 2024). ParetoRouter handles two conflicting objectives under capacity constraints that evolve during routing.

Transfer of the construction-based classifier to other combinatorial generation tasks with fast heuristic solvers is a direction for future work.

Held-out check for Q1. To verify that the division of roles in Q1 is not specific to the training inputs, we ran both teachers (NTHU-Route and NCTU-GR) on seven designs never used for training (ibm01–06 from ISPD98 and adaptec1 from ISPD07) and built 83,018 paired inputs with the same preprocessing as the training data. The teachers disagree on 43.2% of them, and on these nets a pixel-wise superposition of the two routes is not a valid route: their intersection connects all pins on only 1.4%. The paper model's prediction again peaks where the teachers agree (mean 0.25), is lower where they disagree (−0.38) and is close to −1 off-route (−1.00), matching the training statistics. The construction yields an r′r' that connects all pins on 100% of the nets; on the disagreeing nets it follows one teacher on 66.1%, takes a route different from both on 29.0%, and keeps both teachers' disputed segments on only 4.9%.

Revisions. (1) Clarify in Sec. 4.1 that Ldis\mathcal{L}_{\mathrm{dis}} shapes the prior while the topology is selected at sampling time; add the entropy term; state the training/sampling division of roles with the statistics above, including the held-out check. (2) Add a positioning paragraph to Sec. 1 and a summary of the classifier, including the continuous overflow cost and the role of γ\gamma, to Sec. 4.2; cite PROUD, PMOCO, MOGFN and Fast T2T in App. A.1. (3) Discuss linear scalarization (Eq. 11) as a limitation.

These revisions will make the training/sampling division of roles and the routing-specific contributions explicit. We thank the reviewer again for these questions and would be glad to provide any further clarification.

Reviewer_N6kTOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents ParetoRouter, a flow-matching model for global routing with adjustable trade-offs between wirelength and overflow. It combines supervision from NCTU-GR and NTHURouter through an average-flow objective and a disambiguation loss, then uses preference-weighted gradient guidance during one-step sampling. Experiments on ISPD98 and ISPD07 compare routing quality, connectivity, and runtime against classical and learning-based methods. The reported results show improvements over DSBRouter in overflow and runtime, while ablations and weight sweeps examine the contributions of individual components and the resulting trade-offs.

Critical strengths
  • A single trained model supports different wirelength–overflow trade-offs without retraining, offering useful control over routing priorities.
  • Zero overflow on all five adaptec benchmarks in Table 4 provides evidence of effectiveness on complete circuits.
Critical weaknesses
  • The route construction procedure in Algorithm 3, line 4 is insufficiently specified. Despite the “w/o NN” ablation, its contribution to routing quality and runtime remains unclear.
  • The evaluation provides limited evidence of practical applicability. It uses older 2D benchmarks with up to 0.87M nets, without demonstrating scalability to larger designs or benefits after detailed routing. The lack of competing Pareto fronts under matched budgets also leaves its advantage over existing routers unclear.
Questions for authors
  • How is the complete routing map constructed in Algorithm 3, line 4? Does “w/o NN” run this procedure alone, and how much runtime does it account for?
  • How do ParetoRouter’s WL–OF trade-offs compare with a tuned conventional router under the same total runtime budget, including all guidance and connection steps?
  • Are results available on larger designs or after downstream detailed routing? These would help assess practical applicability beyond the current 2D benchmarks.
3 comments
AuthorsOpenReview ↗

Response to Reviewer N6kT (1/3)

We sincerely thank the reviewer for the careful reading and the three concrete questions, which helped us clarify several aspects of our method. We address them with new experiments: a runtime breakdown on 20 benchmarks, an end-to-end detailed-routing study on public ISPD18/ISPD19 designs, and a scalability study on 20 benchmarks and on MemPool-Group from the ISPD'24 contest (up to 3.25M nets). All new timings exclude model loading. Below, we describe the construction procedure and present the results and their scope.

Q1. Route construction (Alg. 3, line 4), "w/o NN", and runtime share.

(a) How the complete routing map is constructed. We will expand line 4 into explicit pseudocode. Line 4 calls a non-neural, congestion-aware rectilinear routing heuristic. Its inputs are the predicted routing map, the net's pins, and the current horizontal and vertical residual capacities.

  1. Candidates. Grid cells whose predicted value is at least 0.8 become candidate points. All pins are always included.
  2. Initial segments. Consecutive candidates in the same row or column are joined by straight segments. Each segment ee has the cost J(e)=γOF∗ωOF∗C(e)+γWL∗ωWL∗L(e)J(e)=\gamma_{\mathrm{OF}}*\omega_{\mathrm{OF}}*C(e)+\gamma_{\mathrm{WL}}*\omega_{\mathrm{WL}}*L(e), where L(e)L(e) is its length and C(e)C(e) is a congestion surrogate computed from the residual capacities along ee.
  3. Component connection. Disconnected components are joined greedily by the cheapest L-shaped connection, which adds its bend point.
  4. Extraction. A Kruskal-style pass accepts segments in increasing cost until all pins are connected. The selected segments are then rasterised.

(b) What "w/o NN" means. Yes. "w/o NN" runs this procedure with an all-zero prediction, so the candidates are the pins only. The cost function, capacity updates and sequential protocol are unchanged, isolating the contribution of the construction procedure.

(c) Runtime share. On ibm01 (five seeds), the full method takes 26.3 s:

ComponentTimeShare
neural inference5.7 s22%
gradient guidance8.7 s33%
route construction (all invocations)10.3 s39%
other1.5 s6%

"w/o NN" takes 5.2 s. On average, construction costs 0.90 ms per net (10.3 s over the 11,507 nets of ibm01), and the cost grows with the number of pins. These timings use a different machine from the paper's and a single solver process, so they are lower than the 47.3 s in Table 3; WL remains consistent (64,648 ± 102 here vs. 64,790 in the paper).

This result is not specific to ibm01: we also measured the breakdown on 20 benchmarks with 11.5k to 895k nets (ISPD98: ibm01–06; ISPD07: adaptec1–5, newblue1–3; ISPD18: test2, test5, test8; ISPD19: test7, test8, test9, the last two suites in GR format), where route construction takes 26–59% of routing time. Construction is a substantial computational component, and the revision will report its runtime share explicitly.

(d) Contribution to quality. Compared with "w/o NN", using the network's candidates reduces 2D wirelength by 2.2% on ibm01 (64,648 ± 102 vs. 66,119). After detailed routing (Q3), routed wirelength is 0.34% (ispd18_test2) and 0.51% (ispd19_test3) shorter, while the official ISPD score (excluding DRC) differs by at most 0.3% in either direction.

AuthorsOpenReview ↗

Response to Reviewer N6kT (2/3)

Q2. Comparison under a matched runtime budget.

We thank the reviewer for this important question. We agree that it differs from the one our weight sweep answers, which evaluates preference control within one trained model, and that the current experiments do not establish an advantage under a matched budget.

To address it transparently, our new measurements make the runtime gap explicit. On the six ISPD18/19 designs where we ran OpenROAD, its FastRoute completes global routing 14–28× faster than ParetoRouter, and CUGR is faster still (see the table in Q3). Under the same total budget, a tuned conventional router can therefore evaluate many parameter settings.

ParetoRouter's contribution is inference-time preference control in a single trained learning-based router. Existing learning-based routers optimize a single metric (Table 1); ParetoRouter takes the overflow–wirelength preference ω\omega as an inference-time input, with ω\omega entering both the guidance and the construction cost. Changing the preference requires neither retraining nor re-tuning a cost function. Among learning-based routers, the paper also reports more than 70× shorter generation time than DSBRouter on ISPD07. The implementation offers opportunities for optimization: neural inference and guidance take about 1.3 ms per net on ibm01, while construction, which accounts for 26–59% of routing time (Q1(c)), is currently implemented in unoptimized pure Python. The revision will distinguish these contributions from matched-budget competitiveness with tuned conventional routers and report runtimes that include all steps.

Q3. Larger designs and detailed routing.

(a) Detailed routing. We evaluated downstream detailed routing using an end-to-end OpenROAD flow on the public ISPD18/ISPD19 detailed-routing benchmarks (LEF/DEF).

  • Global routers: ParetoRouter (paper model, without retraining on these designs, ω=(0.5,0.5)\omega=(0.5,0.5)), FastRoute and CUGR.
  • Every router's 2D routes use the same layer assignment and TritonRoute settings. FastRoute through our layer assignment and through its own guides differ by less than 0.2% in routed wirelength.
  • Legality: TritonRoute's DRC count plus an independent geometric connectivity check. Guide and track metrics: the official ISPD18/19 evaluators, whose DRC component requires Cadence Innovus, which we did not use.
Design (#nets)Global routerGR timeDRVs / opensRouted WL (µm)#ViasOfficial score (excl. DRC; lower is better)
ispd18_test1 (3.2k)ParetoRouter (ours)8.2 s0 / 091,22036,696348,112
FastRoute0.6 s0 / 086,92835,935327,605
CUGR0.4 s0 / 086,26236,385323,275
ispd18_test2 (36.8k)ParetoRouter (ours)121 s0 / 01,647,531394,0665,711,948
FastRoute6.1 s0 / 01,588,361385,3675,501,218
CUGR1.4 s0 / 01,583,921389,7945,492,100
ispd19_test3 (9.0k)ParetoRouter (ours)19.5 s0 / 084,95764,153784,224
FastRoute0.7 s0 / 083,16563,296763,927
CUGR0.7 s0 / 082,60063,308755,665
ispd19_test5 (29.4k)ParetoRouter (ours)67.7 s≈6,270 after 15 iter.———
FastRoute4.1 s0 / 0950,206169,150—
CUGR1.5 s0 / 0991,128167,105—

On the first three designs, ParetoRouter's global routes are detail-routable with zero DRVs and no open nets, at a cost of +2.2–5.7% routed wirelength, +0.9–2.3% vias and +2.7–7.7% official score relative to FastRoute and CUGR. These designs are not congested at the global-routing level, and other values of ω\omega change routed wirelength by less than 0.1%.

The study also identifies a limitation on designs with large macro blockages. On ispd19_test5 (5 metal layers, two large macros), ParetoRouter's routes cross the macros. After 15 detailed-routing iterations, about 6,300 violations remain, almost all shorts, while FastRoute, CUGR and the official guides reach zero. The cause is structural: line-4 construction joins only straight and L-shaped segments between network candidates and pins and does not provide obstacle-aware detouring around blockages spanning hundreds of GCells; the training data also contain no such macros. Changing ω\omega or increasing the congestion weight did not resolve this failure. We will report this limitation and discuss a maze-routing fallback for blocked nets and training data that include macro blockages.

AuthorsOpenReview ↗

Response to Reviewer N6kT (3/3)

(b) Scalability. We measured runtime and memory on the same 20 benchmarks listed in Q1(c) (11.5k to 895k nets) and on MemPool-Group from the ISPD'24 contest (3.25M nets), none of which was used for training.

  • The network, guidance and construction path scales approximately linearly: the log-log slope of time against #nets is 1.04 (R2=0.98R^2=0.98), about 1.8–3.6 ms per net.
  • Total time grows slightly faster (slope 1.12).
  • Within these benchmark suites, the largest design, ispd19_test9 (895k nets), finishes in 1.8 h.
  • For reference, FastRoute takes 6.5 / 30 / 74 s on ispd18_test2 / test5 / test8, versus 130 / 546 / 1,252 s for ParetoRouter.
  • Across these benchmark suites, peak CPU memory is at most 5.1 GB and peak GPU memory at most 24 GB.
  • MemPool-Group is 3.7× larger than the paper's largest design (0.87M nets), with a GCell grid of 1782×2417. On this design, the network, guidance and construction path takes 2.0 h, about 2.6 ms per net, which is within the range above. Construction takes 49% of this time, and peak CPU / GPU memory is 4.6 / 24.8 GB. The resulting 2D wirelength is 25,691,199 GCell edges, 1.215× the HPWL lower bound of the same nets (21,147,258). Since ParetoRouter outputs 2D routes, this number is not directly comparable with the contest's 3D results, and we do not score it with the contest's 3D evaluator.

The largest design of each suite:

DesignSuite#netsTotal timeTime per netConstruction sharePeak GPU / CPU memory
ibm06ISPD9833,354136.65 s*4.1 ms49%12.3 / 2.0 GB
adaptec5ISPD07867,4411,500.11 s*1.7 ms49%16.7 / 3.9 GB
ispd18_test8ISPD18179,7031,252 s7.0 ms26%14.3 / 2.8 GB
ispd19_test9ISPD19895,0746,598 s7.4 ms30%17.3 / 5.1 GB
MemPool-GroupISPD243,252,5967,370 s†2.3 ms49%24.8 / 4.6 GB

*Generation time as reported in the paper (Tables 3 and 4). †Network, guidance and construction path only.

These results support ParetoRouter's practical applicability at industrial scale within the evaluated settings. Its learned path keeps a per-net cost of about 2–4 ms from 11.5k nets up to the 3.25M-net MemPool-Group design, with at most 5.1 GB of CPU memory. The same model, trained only on the eight bigblue/newblue designs, also produces detail-routable global routes with zero DRVs and no open nets on three unseen ISPD18/19 designs without retraining. The revision will state this scope explicitly and identify large macro blockages and runtime relative to conventional routers as the main directions for future work.

Revisions. (1) Explicit pseudocode for Alg. 3, line 4, and a precise definition of "w/o NN". (2) Runtime breakdown, with all solver time included. (3) Explicit scope for matched-budget performance and industrial applicability. (4) Detailed-routing and scalability results, including the ispd19_test5 failure case, in a new appendix.

The revision will incorporate these results and distinguish preference control, scalability, and downstream routing performance explicitly. We thank the reviewer again for these constructive questions and would be glad to provide any further clarification or experiments.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.