Pith. sign in

REVIEW 4 major objections 7 minor 27 references

A four-agent LLM pipeline can automate CGRA hardware/software co-design, cutting power by 59% and producing a working 7nm layout.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 16:27 UTC pith:UZNBG3C2

load-bearing objection Real framework, one interesting mechanism, but the abstract and the body contradict each other on the headline results, and the body itself undercuts the 5x claim. the 4 major comments →

arxiv 2509.13557 v7 pith:UZNBG3C2 submitted 2025-09-16 cs.AR

MACO: A Multi-Agent LLM Framework for Automated CGRA Hardware/Software Co-Design

Zesong Jiang , Yuqi Sun , Qing Zhong , Mahathi Krishna , Deepak Patil , Cheng Tan , Jeff Zhang This is my paper
classification cs.AR
keywords CGRAhardware/software co-designmulti-agent LLMLLM self-learningEDA-guided designpower optimization7nm ASIC flowreconfigurable architecture
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper tries to establish that a structured multi-agent LLM framework can automate the co-design of CGRA hardware and the compiler parameters that drive it, replacing the usual manual, iterative tuning. It claims the framework—called MACO in the abstract and MALTA in the body—outperforms few-shot LLM prompting, domain-augmented prompting, and manual design on power, while also improving power efficiency by 36.8%, and that one generated CGRA survives a full 7nm ASIC flow at 30.49 mW and 435 MHz. The mechanism that makes this fast is an adaptive-confidence selector in which the LLM learns from EDA tool reports and, once its confidence exceeds a threshold, chooses designs without further tool calls. A sympathetic reader would care because CGRA design is currently slow and expert-bound; if the framework works as claimed, the bottleneck shifts from human iteration to LLM-plus-tool loops that are much cheaper to run.

Core claim

The paper's central claim is that a multi-agent LLM framework can automate CGRA hardware/software co-design and beat both manual design and simpler LLM prompting on power. The body reports average power reductions of 59.4% versus Qwen few-shot, 48.9% versus domain-augmented Qwen, and 27.1% versus manual design, plus a 36.8% power-efficiency gain; one generated 4x4 CGRA completed a 7nm ASIC flow at 2.99 mm², 30.49 mW, and 435 MHz. The abstract calls the system MACO and claims 25.9% power reduction, 20.0% performance improvement, and 5x search acceleration, while the body's Table II says early iterations take longer because tools are called multiple times. The key idea is that EDA feedback tea

What carries the argument

The central mechanism is Algorithm 1, an adaptive-confidence selector: it computes exp(-|l_score - t_score|/sigma) between the LLM's ranking and the EDA tool's ranking, updates a confidence estimate by exponential moving average, and once confidence exceeds a threshold it lets the LLM choose without tool evaluation, with periodic forced validation. The surrounding pipeline is organized as four collaborating agents: co-design, error correction, multi-judge selection, and evaluation/feedback. This confidence-switching procedure is what converts tool-verified iterations into fast LLM-only iterations.

Load-bearing premise

The framework's speedup rests on the assumption that the exponential similarity between LLM scores and EDA tool scores in Algorithm 1 is a dependable predictor of the LLM's selection accuracy once confidence passes the threshold; the paper specifies neither the score scales nor sigma, and after the switch the LLM chooses without tool verification.

What would settle it

Silently run the EDA tool for, say, 10 more iterations after the confidence threshold is crossed and compare the LLM's choices with the tool's choices on the same candidate sets; if agreement is not near-perfect, the self-learning selector is not yet trustworthy, and the reported 5x speedup should be re-benchmarked against always-tool selection including periodic validation calls.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • CGRA design for a target kernel can be carried out end-to-end by the four-agent loop, from candidate generation through RTL and physical design, without manual parameter tuning.
  • Replacing tool-based selection with LLM selection after confidence matures is what enables faster iteration; the paper reports 5x search acceleration.
  • Jointly optimizing hardware and software parameters yields better power efficiency than optimizing hardware alone, as shown by the ablation without software optimization.
  • The generated designs are not just functional; at least one MALTA-generated 4x4 CGRA completed a 7nm ASIC layout at 30.49 mW and 435 MHz.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The abstract's headline numbers (25.9% power, 20.0% performance, 5x search acceleration) do not match the body's reported averages (59.4%, 48.9%, 27.1% power reductions; 36.8% power-efficiency gain), and the body's Table II notes that runtime is longer in early iterations; the 5x acceleration claim needs a consistent accounting of when tool calls are counted.
  • The confidence-switching mechanism is where the speedup comes from; a straightforward test is to log the LLM's chosen design versus the tool's chosen design after confidence crosses the threshold. If the agreement rate stays near chance, the acceleration is buying speed at the cost of unvalidated selections.
  • Since sigma and the score scales in exp(-|l_score - t_score|/sigma) are not specified, the confidence values are not reproducible across models and tools; calibrating sigma per model would be a concrete extension.
  • The current evaluation is per-kernel optimization; a natural next test is multi-kernel or domain-level co-design where one CGRA must serve several kernels, which would stress the selection stage differently than single-kernel power minimization.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 7 minor

Summary. The paper proposes a multi-agent LLM framework for coarse-grained reconfigurable array (CGRA) hardware/software co-design. The body calls the framework MALTA, whereas the abstract refers to MACO. The framework decomposes the design loop into four stages: CGRA co-design, validation/correction, best-design selection, and evaluation/feedback. It integrates an OpenCGRA-based mapper (MapFixer), RTL generation, and Synopsys Design Compiler for power/area estimates, and introduces an adaptive-confidence mechanism in which an LLM gradually replaces EDA-tool-based selection after its choices become sufficiently consistent with tool reports. The evaluation covers 8 kernels across three domains, comparing against Qwen few-shot, Qwen domain-augmented, and manual design. The body reports power reductions of 59.4%, 48.9%, and 27.1% versus those baselines, a 36.8% power-efficiency improvement, and one 4x4 CGRA taken through an ASAP7 7nm ASIC flow (2.99 mm², 30.49 mW, 435 MHz). The abstract, however, claims different headline numbers: 25.9% power reduction, 20.0% performance improvement, 5x search acceleration, and validation through a complete 7nm flow.

Significance. Automating CGRA HW/SW co-design with LLM agents is a timely and useful goal, and the body demonstrates a working system that can generate and correct CGRA designs, integrate external EDA tools, and carry one design through physical implementation. The open-source claim, if backed by a released repository, would be a community asset. The reported per-kernel power/efficiency results in Table II and Figure 4 do support the weaker claim that MALTA often finds lower-power CGRAs than the tested baselines under a speedup constraint. However, the significance is substantially undermined by the abstract/body mismatch: the abstract's headline numbers are not present in the body, and the one claimed acceleration result (5x) is contradicted by the runtime data in Table II. The self-learning mechanism that would enable acceleration is never validated. Thus, the paper's central quantitative claims are not currently supported by the evidence.

major comments (4)
  1. [Abstract vs. §IV-B, Table II] The abstract's headline claims (25.9% power reduction, 20.0% performance improvement, 5x search acceleration) do not appear in the body. The body reports different numbers: power reductions of 59.4%, 48.9%, and 27.1% versus the three baselines, plus a 36.8% power-efficiency improvement. No 20% performance improvement appears anywhere, and 'performance' is never defined. More seriously, Table II's runtime column shows MALTA's runtime is larger than every baseline for every kernel (e.g., fir: 185.6 min vs 104.1–137.6; fft: 252.8 vs 110.2–132.8; spmv: 150.4 vs 89.8–117.9; gemm: 216.3 vs 100.7–144.8), and the table note states: 'Since our framework calls the tool multiple times in the early stages, it tends to consume a longer time.' This directly contradicts the abstract's 'accelerates the search process by 5x.' The central quantitative claims are therefore neither verifiable from the body
  2. [§III-C, Algorithm 1] The adaptive-confidence self-learning mechanism is the only proposed route to accelerating selection, but it is never tested. The similarity exp(−|l_score−t_score|/σ) uses an unspecified σ and undefined score scales. Conf_Threshold, Validation_Interval N, and EMA factor α are not given. No experiment reports the number of tool evaluations skipped, the confidence trajectory, or the accuracy of LLM-only selections after switching to LLM-only mode. Thus, the claim that this mechanism accelerates the design process is unsupported. A minimal validation would compare wall-clock time or tool-call counts with and without the self-learning switch, and plot selection accuracy against the confidence threshold.
  3. [§IV-A, §IV-B, Figure 4] The performance metric is not defined. The abstract claims a 20% 'performance improvement,' but the body only reports speedup relative to an in-order CPU and power efficiency, without defining whether performance means throughput, latency, cycles, or something else. Figure 4's axis is labeled 'Normalized Power Efficiency' but the normalization baseline and the definition of power efficiency are not stated. The absence of a defined metric makes the reported improvements non-reproducible. Additionally, the number of independent runs and run-to-run variance are not reported for the 10-iteration results.
  4. [§IV-B, Physical Implementation] The claim of validating physical design through a 'complete 7nm ASIC design flow' rests on a single 4x4 CGRA generated for the embedded domain, with area 2.99 mm², power 30.49 mW, and frequency 435 MHz. There is no comparison baseline, no timing/power analysis against an alternative design, and no evidence that this design is the result of MALTA's iterative optimization rather than a single generated candidate. This demonstrates that one MALTA-generated RTL can be passed through ASAP7; it does not validate the framework's design quality or physical-design awareness. The abstract's wording overstates this evidence.
minor comments (7)
  1. [Throughout] The framework is called MACO in the abstract and MALTA in the body, including the title of the full text. This naming inconsistency must be resolved.
  2. [Algorithm 1] Variables t_choice, t_score, l_choice, and l_score are used before being explicitly defined; clarify their roles and units.
  3. [Table III] The table is described as 'one-shot' while the framework is iterative; clarify how one-shot relates to the 10-iteration results in Table II.
  4. [Table IV] Table IV lists HW/SW parameters for one kernel (spmv) but provides no associated power/performance results; either add the measurements or point explicitly to Figure 4.
  5. [Figure 5] Convergence curves for fft, spmv, and gemm show no error bars or confidence intervals; specify whether these are best-of-10, median, or mean values.
  6. [Abstract / §IV] The abstract claims the framework is 'open-source,' but no repository link or artifact availability statement is provided in the manuscript.
  7. [General] There are multiple typos and stylistic issues, e.g., 'Framwork', 'effiencicy', and 'none HW/SW co-design approaches'; a careful proofread is needed.

Circularity Check

0 steps flagged

No significant circularity; the framework's claims rest on external tool evaluations and calibration against tool reports, not on self-defined or fitted targets.

full rationale

The paper's derivation chain is not circular. MALTA is an iterative search loop in which candidate CGRA designs are validated and scored by external tools: OpenCGRA [26] for mapping/speedup, Synopsys Design Compiler for power/area, and ASAP7 for physical design. The reported power reductions, speedups, and area values are direct measurements from these tools, not quantities derived from the framework's own definitions. The LLM self-learning mechanism in Algorithm 1 computes a confidence score as an exponential moving average of the similarity between LLM scores and tool scores; this is a calibration/surrogate-model approach, and the confidence threshold only decides when to skip tool evaluation. It does not redefine the evaluation metric nor fit the final power/performance numbers. The only provenance concern is that OpenCGRA [26] is authored by a co-author (Cheng Tan) and is used both as the design-validation backend and the speedup evaluation baseline. However, OpenCGRA is an open-source external tool, so this is a minor self-citation rather than load-bearing circularity; it does not make the central multi-agent co-design contribution reduce to its own input. The abstract contains numbers (25.9% power, 20% performance, 5x search acceleration) that do not appear in the body, and Table II's runtime column explicitly shows MALTA taking longer than baselines, contradicting the 5x acceleration claim. This is an internal-consistency/correctness problem, not a circular-derivation problem, so it is noted but does not raise the circularity score.

Axiom & Free-Parameter Ledger

5 free parameters · 5 axioms · 0 invented entities

No new physical entities, particles, forces, or conserved quantities are introduced; the framework's agents are software components, not claimed entities needing independent evidence. The main implicit commitments are the reliability of OpenCGRA as ground truth, the completeness of the error-repair stage, and the validity of the confidence-calibration mechanism.

free parameters (5)
  • sigma (similarity scale) = not specified
    Algorithm 1 line 8 uses exp(-|l_score - t_score|/sigma); sigma and the score scales are undefined, yet they drive when the LLM is trusted over EDA tools.
  • Conf_Threshold = not specified
    Algorithm 1 line 4; the confidence threshold for switching from tool-based to LLM-based selection is not given.
  • Validation_Interval (N) = not specified
    Algorithm 1 line 4 and Section III-C; the mandatory tool-validation interval is never set.
  • alpha (EMA factor) = not specified
    Algorithm 1 line 9; the exponential moving average factor is not given.
  • Number of candidate designs K = not specified
    Stage 3 uses top K designs; K is not stated.
axioms (5)
  • domain assumption MapFixer and rule-based error correction can repair all structural and compilation errors in LLM-generated CGRA designs
    Stage 2 assumes repairs are complete enough that only validated designs reach selection; no estimate of residual invalid designs is reported for the full MACO loop.
  • domain assumption OpenCGRA toolflow [26] faithfully models speedup and power of generated CGRAs
    All performance and power claims rest on OpenCGRA cycle estimates and DC Compiler synthesis; no silicon measurement of the generated CGRA is reported beyond a single layout with power estimate.
  • domain assumption EMA confidence from LLM/tool score agreement generalizes to future iterations
    Algorithm 1's switching rule assumes past agreement predicts future LLM reliability; this is exactly the unablated assumption in Section III-C.
  • domain assumption LLM textual reports can transfer knowledge across iterations
    Stage 1 and Stage 4 rely on in-context learning from stored historical reports without fine-tuning; no evidence isolates this mechanism.
  • domain assumption Designs from 10 iterations converge to a good optimum
    Figure 5 shows monotone improvement for 3 kernels but no convergence proof for the full design space.

pith-pipeline@v1.3.0-alltime-deepseek · 9465 in / 14900 out tokens · 155967 ms · 2026-08-04T16:27:10.104641+00:00 · methodology

0 comments
read the original abstract

Designing optimal Coarse-Grained Reconfigurable Arrays (CGRAs) requires navigating a vast, interdependent hardware/software space bottlenecked by costly manual iteration. We present MACO, an open-source, multi-agent LLM framework that automates CGRA HW/SW co-design. MACO decomposes the design loop into four collaborative stages, HW/SW Co-design, Error Correction, Best-Design Selection, and Evaluation & Feedback, to iteratively optimize power, performance, and area (PPA). To accelerate convergence and efficiently traverse the design space, MACO introduces an exponentially decaying exploration strategy, EDA-guided LLM self-learning, and robust rule-based error correction. Evaluated against state-of-the-art baselines, MACO reduces power consumption by 25.9%, improves performance by 20.0%, and accelerates the search process by 5x. Finally, we validate MACO's physical design through a complete 7nm ASIC design flow.

Figures

Figures reproduced from arXiv: 2509.13557 by Cheng Tan, Deepak Patil, Jeff Zhang, Mahathi Krishna, Qing Zhong, Yuqi Sun, Zesong Jiang.

Figure 1
Figure 1. Figure 1: A Typical CGRA Design with Compiler and Architecture Components. coupling effects among parameters that could degrade perfor￾mance. Second, balancing performance and power efficiency is critical. Recent advances in LLMs offer an opportunity to tackle these challenges, by leveraging LLMs strong reasoning abili￾ties to design CGRAs and iteratively optimize them through continuous learning of CGRA domain know… view at source ↗
Figure 2
Figure 2. Figure 2: An Overview of the MALTA Framework for CGRA Design [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: The implementation of CGRA design selection with LLM self-learning based on EDA tool report feedback. CGRA design tool and synthesis tool. In the early iterations, synthesis tools provide accurate power and area analysis, while open-source CGRA tool [26] estimate speedup, enabling the selection of the best-performing design. Meanwhile, the fine￾grained judge also makes the best choice and learns from the r… view at source ↗
Figure 4
Figure 4. Figure 4: Comparison of power efficiency (performance/power) across 8 kernels for different methods [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Power efficiency improvement of typical kernels (fft, spmv, gemm) across iterations using MALTA. B. Result and Analysis MALTA framework based on different LLM models: Table III summarizes the one-shot results of MALTA across different models. As is shown in Table III, all models using MALTA are able to generate valid architectures that can be successfully mapped. However, it is worth noting that the applic… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

27 extracted references · 13 linked inside Pith

  1. [1]

    A survey of circuit foundation model: Foundation ai models for vlsi circuit design and eda.arXiv preprint arXiv:2504.03711, 2025

    Wenji Fang, Jing Wang, Yao Lu, Shang Liu, Yuchao Wu, Yuzhe Ma, and Zhiyao Xie. A survey of circuit foundation model: Foundation ai models for vlsi circuit design and eda.arXiv preprint arXiv:2504.03711, 2025

    Pith/arXiv arXiv 2025

  2. [2]

    Automated cpu design by learning from input-output examples

    Shuyao Cheng, Pengwei Jin, Qi Guo, Zidong Du, Rui Zhang, Xing Hu, Yongwei Zhao, Yifan Hao, Xiangtao Guan, Husheng Han, et al. Automated cpu design by learning from input-output examples. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, pages 3843–3853, 2024

    2024

  3. [3]

    Chatcpu: An agile cpu design and verification platform with llm

    Xi Wang, Gwok-Waa Wan, Sam-Zaak Wong, Layton Zhang, Tianyang Liu, Qi Tian, and Jianmin Ye. Chatcpu: An agile cpu design and verification platform with llm. InProceedings of the 61st ACM/IEEE Design Automation Conference, pages 1–6, 2024

    2024

  4. [4]

    Customizing a large language model for vhdl design of high-performance microprocessors.arXiv preprint arXiv:2505.09610, 2025

    Nicolas Dupuis, Ravi Nair, Shyam Ramji, Sean McClintock, Nishant Chauhan, Priyanka Nagpal, Bart Blaner, Ken Valk, Leon Stok, and Ruchir Puri. Customizing a large language model for vhdl design of high-performance microprocessors.arXiv preprint arXiv:2505.09610, 2025

    Pith/arXiv arXiv 2025

  5. [5]

    Large processor chip model.arXiv preprint arXiv:2506.02929, 2025

    Kaiyan Chang, Mingzhi Chen, Yunji Chen, Zhirong Chen, Dongrui Fan, Junfeng Gong, Nan Guo, Yinhe Han, Qinfen Hao, Shuo Hou, et al. Large processor chip model.arXiv preprint arXiv:2506.02929, 2025

    Pith/arXiv arXiv 2025

  6. [6]

    Tpu- gen: Llm-driven custom tensor processing unit generator.arXiv preprint arXiv:2503.05951, 2025

    Deepak Vungarala, Mohammed E Elbtity, Sumiya Syed, Sakila Alam, Kartik Pandit, Arnob Ghosh, Ramtin Zand, and Shaahin Angizi. Tpu- gen: Llm-driven custom tensor processing unit generator.arXiv preprint arXiv:2503.05951, 2025

    Pith/arXiv arXiv 2025

  7. [7]

    Gpt4aigchip: Towards next-generation ai accelerator design automation via large language models

    Yonggan Fu, Yongan Zhang, Zhongzhi Yu, Sixu Li, Zhifan Ye, Chaojian Li, Cheng Wan, and Yingyan Celine Lin. Gpt4aigchip: Towards next-generation ai accelerator design automation via large language models. In2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD), pages 1–9. IEEE, 2023

    2023

  8. [8]

    Fedchip: Federated llm for artificial intelligence accelerator chip design

    Mahmoud Nazzal, Khoa Nguyen, Deepak Vungarala, Ramtin Zand, Shaahin Angizi, Hai Phan, and Abdallah Khreishah. Fedchip: Federated llm for artificial intelligence accelerator chip design. In2025 IEEE International Conference on LLM-Aided Design (ICLAD), pages 93–99. IEEE, 2025

    2025

  9. [9]

    Deepcircuitx: A comprehensive repository-level dataset for rtl code understanding, generation, and ppa analysis.arXiv preprint arXiv:2502.18297, 2025

    Zeju Li, Changran Xu, Zhengyuan Shi, Zedong Peng, Yi Liu, Yun- hao Zhou, Lingfeng Zhou, Chengyu Ma, Jianyuan Zhong, Xi Wang, et al. Deepcircuitx: A comprehensive repository-level dataset for rtl code understanding, generation, and ppa analysis.arXiv preprint arXiv:2502.18297, 2025

    Pith/arXiv arXiv 2025

  10. [10]

    Mg-verilog: Multi-grained dataset towards enhanced llm- assisted verilog generation

    Yongan Zhang, Zhongzhi Yu, Yonggan Fu, Cheng Wan, and Yingyan Ce- line Lin. Mg-verilog: Multi-grained dataset towards enhanced llm- assisted verilog generation. In2024 IEEE LLM Aided Design Workshop (LAD), pages 1–5. IEEE, 2024

    2024

  11. [11]

    Sa-ds: A dataset for large language model-driven ai accelerator design generation

    Deepak Vungarala, Mahmoud Nazzal, Mehrdad Morsali, Chao Zhang, Arnob Ghosh, Abdallah Khreishah, and Shaahin Angizi. Sa-ds: A dataset for large language model-driven ai accelerator design generation. In 2025 IEEE International Symposium on Circuits and Systems (ISCAS), pages 1–4. IEEE, 2025

    2025

  12. [12]

    Hdlcopilot: Natural language exploration of hardware designs and libraries.arXiv preprint arXiv:2407.12749, 2024

    Manar Abdelatty, Jacob Rosenstein, and Sherief Reda. Hdlcopilot: Natural language exploration of hardware designs and libraries.arXiv preprint arXiv:2407.12749, 2024

    Pith/arXiv arXiv 2024

  13. [13]

    Verilogcoder: Autonomous verilog coding agents with graph-based planning and abstract syntax tree (ast)-based waveform tracing tool

    Chia-Tung Ho, Haoxing Ren, and Brucek Khailany. Verilogcoder: Autonomous verilog coding agents with graph-based planning and abstract syntax tree (ast)-based waveform tracing tool. InProceedings of the AAAI Conference on Artificial Intelligence, volume 39, pages 300– 307, 2025

    2025

  14. [14]

    Verigen: A large language model for verilog code generation.ACM Transactions on Design Automation of Electronic Systems, 29(3):1–31, 2024

    Shailja Thakur, Baleegh Ahmad, Hammond Pearce, Benjamin Tan, Brendan Dolan-Gavitt, Ramesh Karri, and Siddharth Garg. Verigen: A large language model for verilog code generation.ACM Transactions on Design Automation of Electronic Systems, 29(3):1–31, 2024

    2024

  15. [15]

    Autochip: Automating hdl generation using llm feedback.arXiv preprint arXiv:2311.04887, 2023

    Shailja Thakur, Jason Blocklove, Hammond Pearce, Benjamin Tan, Sid- dharth Garg, and Ramesh Karri. Autochip: Automating hdl generation using llm feedback.arXiv preprint arXiv:2311.04887, 2023

    Pith/arXiv arXiv 2023

  16. [16]

    Rtllm: An open- source benchmark for design rtl generation with large language model

    Yao Lu, Shang Liu, Qijun Zhang, and Zhiyao Xie. Rtllm: An open- source benchmark for design rtl generation with large language model. In2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC), pages 722–727. IEEE, 2024

    2024

  17. [17]

    Deeprtl: Bridging verilog understanding and generation with a unified represen- tation model.arXiv preprint arXiv:2502.15832, 2025

    Yi Liu, Changran Xu, Yunhao Zhou, Zeju Li, and Qiang Xu. Deeprtl: Bridging verilog understanding and generation with a unified represen- tation model.arXiv preprint arXiv:2502.15832, 2025

    Pith/arXiv arXiv 2025

  18. [18]

    Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open-source dataset and lightweight solution.arXiv preprint arXiv:2312.08617, 2023

    Shang Liu, Wenji Fang, Yao Lu, Qijun Zhang, Hongce Zhang, and Zhiyao Xie. Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open-source dataset and lightweight solution.arXiv preprint arXiv:2312.08617, 2023

    Pith/arXiv arXiv 2023

  19. [19]

    Chip-chat: Challenges and opportunities in conversational hardware design.arXiv preprint arXiv:2305.13243, 2023

    Jason Blocklove, Siddharth Garg, Ramesh Karri, and Hammond Pearce. Chip-chat: Challenges and opportunities in conversational hardware design.arXiv preprint arXiv:2305.13243, 2023

    Pith/arXiv arXiv 2023

  20. [20]

    Natural language is not enough: Benchmarking multi-modal generative ai for verilog generation

    Kaiyan Chang, Zhirong Chen, Yunhao Zhou, Wenlong Zhu, Kun Wang, Haobo Xu, Cangyuan Li, Mengdi Wang, Shengwen Liang, Huawei Li, et al. Natural language is not enough: Benchmarking multi-modal generative ai for verilog generation. InProceedings of the 43rd IEEE/ACM International Conference on Computer-Aided Design, pages 1–9, 2024

    2024

  21. [21]

    Origen: Enhancing rtl code generation with code-to-code aug- mentation and self-reflection

    Fan Cui, Chenyang Yin, Kexing Zhou, Youwei Xiao, Guangyu Sun, Qiang Xu, Qipeng Guo, Yun Liang, Xingcheng Zhang, Demin Song, et al. Origen: Enhancing rtl code generation with code-to-code aug- mentation and self-reflection. InProceedings of the 43rd IEEE/ACM International Conference on Computer-Aided Design, pages 1–9, 2024

    2024

  22. [22]

    Rtl++: Graph- enhanced llm for rtl code generation.arXiv preprint arXiv:2505.13479, 2025

    Mohammad Akyash, Kimia Azar, and Hadi Kamali. Rtl++: Graph- enhanced llm for rtl code generation.arXiv preprint arXiv:2505.13479, 2025

    Pith/arXiv arXiv 2025

  23. [23]

    A data-centric chip design agent framework for verilog code generation

    Kaiyan Chang, Wenlong Zhu, Kun Wang, Xinyang He, Nan Yang, Zhirong Chen, Dantong Jin, Cangyuan Li, Yunhao Zhou, Hao Yan, et al. A data-centric chip design agent framework for verilog code generation. ACM Transactions on Design Automation of Electronic Systems, 2025

    2025

  24. [24]

    Chipnemo: Domain-adapted llms for chip design.arXiv preprint arXiv:2311.00176, 2023

    Mingjie Liu, Teodor-Dumitru Ene, Robert Kirby, Chris Cheng, Nathaniel Pinckney, Rongjian Liang, Jonah Alben, Himyanshu Anand, Sanmitra Banerjee, Ismet Bayraktaroglu, et al. Chipnemo: Domain-adapted llms for chip design.arXiv preprint arXiv:2311.00176, 2023

    Pith/arXiv arXiv 2023

  25. [25]

    Large language model for verilog generation with code-structure-guided reinforcement learning.arXiv preprint arXiv:2407.18271, 2024

    Ning Wang, Bingkun Yao, Jie Zhou, Xi Wang, Zhe Jiang, and Nan Guan. Large language model for verilog generation with code-structure-guided reinforcement learning.arXiv preprint arXiv:2407.18271, 2024

    Pith/arXiv arXiv 2024

  26. [26]

    Opencgra: An open-source unified framework for modeling, testing, and evaluating cgras

    Cheng Tan, Chenhao Xie, Ang Li, Kevin J Barker, and Antonino Tumeo. Opencgra: An open-source unified framework for modeling, testing, and evaluating cgras. In2020 IEEE 38th International Conference on Computer Design (ICCD), pages 381–388. IEEE, 2020

    2020

  27. [27]

    Asap7: A 7-nm finfet predictive process design kit.Microelec- tronics Journal, 53:105–115, 2016

    Lawrence T Clark, Vinay Vashishtha, Lucian Shifren, Aditya Gujja, Saurabh Sinha, Brian Cline, Chandarasekaran Ramamurthy, and Greg Yeric. Asap7: A 7-nm finfet predictive process design kit.Microelec- tronics Journal, 53:105–115, 2016. 7

    2016