GR-Evolve: Design-Adaptive Global Routing via LLM-Driven Algorithm Evolution

Abstract: Modern ASIC design is becoming increasingly complex, driving up design costs while limiting productivity gains from existing EDA tools. Despite decades of progress, current tools rely on fixed heuristics and offer limited control via tool hyperparameters, requiring extensive manual tuning to achieve an acceptable quality of results (QoR). While prior work has explored learning-based optimization and design-specific hyperparameter tuning, these approaches operate within the constraints of static tool algorithm implementations and do not adapt the underlying algorithms to individual designs. To address this limitation, we introduce the concept of design-adaptive EDA tooling, in which the internal algorithms of EDA tools are automatically specialized to the characteristics of a given design. We instantiate this paradigm through GR-Evolve, a code evolution framework that leverages an agentic LLM to iteratively modify global routing source code using QoR-driven feedback. The framework equips the LLM with persistent contextual knowledge of open-source global routers along with an integrated toolchain for QoR evaluation within the OpenROAD infrastructure. We evaluate GR-Evolve across seven benchmark designs across three technology nodes and demonstrate up to 8.72% reduction in post-detailed-routing wirelength over existing baseline routers, highlighting the potential of LLM-driven EDA code evolution for design-adaptive global routing.

• The paper introduces an LLM-driven framework for dynamic source code evolution in global routing algorithms.
• It recasts global routing as a program optimization problem, achieving up to 8.72% DR wirelength reductions with Pareto frontier analysis across multiple benchmarks.
• The approach enables design–tool co-exploration by automating tuning with stateless sessions and detailed QoR feedback.

GR-Evolve: Design-Adaptive Global Routing via LLM-Driven Algorithm Evolution

Motivation and Problem Formulation

The paper "GR-Evolve: Design-Adaptive Global Routing via LLM-Driven Algorithm Evolution" (2604.22234) addresses the persistent issue of static heuristic-driven EDA tools that fail to adapt their internal algorithms to the characteristics of individual ASIC designs. While legacy optimization strategies and parameter tuning have been applied to global routing, they operate within the confines of locked tool implementations. The authors propose a paradigm shift: recasting global routing as a program optimization problem, aiming to specialize the source code of the global routing engine per design using autonomous LLM-driven modifications. This approach is rooted in the concept of design–tool co-exploration, enabling the joint evolution of both the design and the underlying router algorithm.

Figure 1: LLM-driven source code generation facilitates design-adaptive EDA tools, breaking away from static heuristic-based approaches.

GR-Evolve Framework: Closed-Loop Code Evolution

GR-Evolve is an agentic framework built on a persistent, stateless architecture, where an LLM agent iteratively proposes modifications to global router source code guided by multi-objective QoR feedback. The agent is provided with structured distillations of algorithmic strategies from major academic routers—FastRoute, CUGR, SPRoute—and operates within the OpenROAD infrastructure. The framework executes global and detailed routing flows for each code variant and uses downstream QoR metrics (wirelength, via count, runtime) to direct further evolutionary cycles.

Figure 2: GR-Evolve framework showing structured knowledge base, iterative code evolution, and QoR-driven validation in a closed feedback loop.

Key architectural features include:

• Knowledge base compression: The agent receives distilled summaries and source code for context efficiency.
• Stateless session execution: Each iteration reconstructs context from persistent externalized artifacts (QoR logs, version control), addressing LLM context length constraints.
• Version control and safety: The evolution process operates on a dedicated source code copy, logging all changes for reproducibility and isolating the agent from baseline router codebases.
• Multi-objective optimization: Prioritized objective hierarchy (detailed routing wirelength, via count, global routing runtime) with Pareto front selection.

  Figure 3: Structured knowledge base and context provided to the LLM agent for efficient code reasoning and adaptation.

Research Challenges and Methodological Advances

The formulation introduces three core challenges:

1. Expansive program search space vs limited LLM context: Full source codes and design states are too large for direct agentic reasoning, necessitating distilled, structured context.
2. Expensive delayed evaluation: Each variant's evaluation involves full EDA routing flows, requiring mechanisms for efficient bounded exploration and feedback capture.
3. Multi-objective trade-offs: Wirelength, via count, and runtime are often antagonistic; optimization requires explicit non-dominated solution tracking and Pareto frontier analysis.

GR-Evolve addresses these by:

• Utilizing context compression and version-controlled searchable history.
• Adopting a stateless artifact-driven session design.
• Recording all evaluated variants for post-hoc solution selection, decoupling exploration from exploitation.

Experimental Results: QoR and Pareto Frontier Analysis

The authors conduct extensive experiments across three technology nodes (SKY130HD, Nangate45, ASAP7) and multiple design benchmarks, evolving routers from three baseline implementations. They report robust DR wirelength reductions (up to 8.72%) over baselines across most design–router pairs, demonstrating effectiveness in program-level adaptation.

Figure 4: Pareto fronts and search space coverage for all router–design pairs in ASAP7, exhibiting non-dominated variants and baseline performance gaps.

Figure 5: Detailed Pareto frontier for 20 router–design pairs in Nangate45; demonstrates scalable search and diversity among code variants.

Figure 6: Pareto fronts for 8 router–design pairs in SKY130HD, showing DR wirelength improvements and variant density.

The tables provided highlight substantial improvements in DR wirelength with minimal or favorable trade-offs in via count and runtime, substantiating the framework's capacity to synthesize design-adaptive routing strategies. Notably, the scale of code modifications (#LoCM) varies widely, from minor heuristic tweaks to larger structural shifts, underscoring GR-Evolve’s flexibility.

The framework also demonstrates strong performance on standard ICCAD19 contest benchmarks, with the evolved CUGR_SWERV router outperforming baselines on wirelength and feasibility, supporting generalizability.

Algorithmic Insights from Code Evolution

Code diff analyses reveal that evolved routers integrate meaningful algorithmic improvements beyond hyperparameter tuning. For example, the evolved CUGR_AES implementation introduces per-net candidate grid evaluation, adaptive grid spacing based on net half-perimeter, and post-processing stages (global rebalance, wirelength pulse, compaction), supplanting fixed FLUTE-based Steiner constructions with a two-hub strategy and multistage re-routing.

These advanced techniques improve solution diversity and compactness, directly manifesting in reduced wirelength and improved routing feasibility. The LLM is shown to reason not only about parameter adjustments but about topological changes and smarter rerouting strategies.

Implications and Future Prospects

GR-Evolve’s agentic, design-adaptive methodology signifies a practical route toward next-generation EDA tooling, where the internal algorithms are not static but are dynamically code-evolved to the target design instance. This approach has practical implications:

• Tool customization: Enables per-design specialization, reducing need for manual parameter sweeps.
• QoR maximization: Uncovers previously unexplored regions of the algorithm space.
• Integration with learning-based flows: Provides a template for coupling LLM-driven code search with traditional learning-based optimization (e.g., RL or GNN-driven flows).
• Automation of EDA code evolution: Establishes a reproducible pipeline for continuous QoR improvement.

Theoretically, the paradigm advances the concept of agentic LLMs from script generation and flow parameterization toward active modification of performance-critical algorithmic modules. The evolution process could be further extended with multi-agent coordination, deeper context compression, and incorporation of domain-specific reward functions, potentially supporting cross-design generalization and continual learning.

Future work will likely address more scalable exploration methods, diverse objective formulations, integration of multi-agent LLMs, and adaptive context management to further push the boundaries of code-level EDA tool evolution.

Conclusion

GR-Evolve presents a viable framework for automatic code-level evolution of global routers, leveraging LLM-driven agentic systems to achieve design-adaptive routing that consistently outperforms static baselines. Through stateless, context-aware sessions, structured exploration, and explicit QoR-driven selection, the method demonstrates strong practical gains in physical design flows. This paradigm holds promise for broader adoption of program search and code evolution strategies in EDA, potentially reshaping the landscape of tool customization and design optimization.