Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

Large Processor Chip Model

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper argues that large language models can automate the full computer-architecture design stack, with a 3D Gaussian Splatting case study reporting over 20% end-to-end performance improvement for a CPU-NPU simulator and a 1.41×…

desk verdict A useful roadmap paper whose quantitative 'effectiveness' claims are not supported by the reported experiments. read the letter →

arxiv 2506.02929 v1 pith:4ZPYUGM5 submitted 2025-06-03 cs.AR

Kaiyan Chang , Mingzhi Chen , Yunji Chen , Zhirong Chen , Dongrui Fan , Junfeng Gong , Nan Guo , Yinhe Han
show 35 more authors
Qinfen Hao Shuo Hou Xuan Huang Pengwei Jin Changxin Ke Cangyuan Li Guangli Li Huawei Li Kuan Li Naipeng Li Shengwen Liang Cheng Liu Hongwei Liu Jiahua Liu Junliang Lv Jianan Mu Jin Qin Bin Sun Chenxi Wang Duo Wang Mingjun Wang Ying Wang Chenggang Wu Peiyang Wu Teng Wu Xiao Xiao Mengyao Xie Chenwei Xiong Ruiyuan Xu Mingyu Yan Xiaochun Ye Kuai Yu Rui Zhang Shuoming Zhang Jiacheng Zhao
This is my paper · ORCID
classification cs.AR
keywords LargeProcessorChipModelLLM-drivendesigncomputerarchitectureautomationhardware-softwareco-design3DGaussianSplattingspaceexplorationsimulatorgenerationRTL
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

Large language models, the paper argues, can take over the entire computer-architecture design pipeline, from compilers and simulators to hardware-software partitioning, design-space exploration, and RTL generation. The proposed Large Processor Chip Model (LPCM) organizes this automation in three levels, with Level 1 keeping humans in charge while LLMs assist, Level 2 giving agents cross-layer control, and Level 3 making the model fully autonomous. To show the approach is more than a proposal, the paper runs a Level-1 case study on 3D Gaussian Splatting, where an LLM generates CPU and NPU simulator configurations and a design-space search picks parameters that the authors report achieve over 20% end-to-end improvement over CPU-only execution. The paper is a position paper, so most of the higher levels are described as future pathways rather than demonstrated results.

What carries the argument

The load-bearing mechanism is the three-level LPCM pipeline and its modular LLM agents: a query agent picks a workload implementation, a compiler agent rewrites code and emits extended instructions, a partitioning agent splits work between software and hardware, CPU and co-processor design-space agents explore parameters, a simulator agent evaluates candidates, and an HDL generation agent produces RTL. In the case study, only the Level-1 part is exercised, centered on LLM-generated simulator configuration plus a design-space search over eight CPU and six NPU parameters, including systolic-array dimensions and SRAM size. Level 1 is the human-centric stage, where the LLM produces code and configurations that human experts review.

What would settle it

Run the final CPU-NPU design on real silicon, or on an FPGA-validated cycle-accurate simulator matched to the same technology node and memory system as the comparison GPU, and measure actual throughput and power; if the measured speedup does not approach 1.41×, the paper's central quantitative claim fails. Alternatively, replace the LLM-driven design-space search with a random or human-baseline search over the same parameters and show the LLM's chosen configuration does not beat the baseline.

Watch

Extended reading notes

Core claim

The central claim is that a single LLM-based system can, in principle, automate the full stack of computer system architecture design, and that the path to full automation can be staged into human-centric, agent-orchestrated, and model-governed levels. The 3D Gaussian Splatting study is presented as the first concrete demonstration of the Level-1 slice: a general-purpose LLM, without fine-tuning, configures a CPU simulator and an accelerator simulator, a design-space exploration module sweeps CPU and NPU parameters, and the resulting CPU-NPU configuration is reported to beat CPU-only execution by over 20 percent while the final accelerator design lands at 5.24 mm² and 1.2 W with a 1.41× speedup over a high-performance GPU.

Load-bearing premise

The quantitative results assume that the pre-RTL simulator's cycle counts are a faithful proxy for real hardware performance, so the reported 20% and 1.41× improvements are only as strong as that simulator's accuracy against actual silicon, particularly when compared with a different GPU.

Editorial extensions

If this is right

  • If LPCM works as proposed, each stage of chip design—compiler retargeting, binary translation, simulator construction, hardware-software partitioning, design-space exploration, and RTL generation—can be partially or fully automated by LLMs, shortening design cycles from months or years to days.
  • The three-level roadmap implies that cross-layer optimization across compiler, operating system, and microarchitecture becomes tractable at Level 2 and Level 3, enabling hardware-software co-design that is hard to reach with single-stage optimizers.
  • The Level-1 3D Gaussian Splatting result suggests that even an out-of-the-box general-purpose LLM can help configure a CPU-NPU simulator and find a design point that outperforms a CPU-only baseline by over 20 percent in the simulator's own metrics.
  • A working LPCM would lower the barrier to domain-specific accelerator design for emerging workloads, allowing a new algorithm to receive a tailored architecture without a dedicated hardware team.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the 20 percent improvement is measured entirely inside a pre-RTL simulator, so the headline number should be read as a simulation prediction; whether it survives on real silicon depends on how faithfully that simulator models memory bandwidth, timing, and power.
  • Editorial inference: the 1.41× speedup over a high-performance GPU compares a simulated, uncalibrated accelerator with real library-optimized GPU hardware, so a fair test would require the same technology node and software stack, or a fabricated test chip.
  • Editorial inference: a natural way to test the framework's generality is to run the same Level-1 LLM configuration and design-space search on a second workload, such as transformer inference or a graph algorithm, and check whether the LLM-generated simulator configurations still beat a tuned CPU-only baseline.
  • Editorial inference: at Level 3, the main risk shifts from design speed to verification, because autonomously generated HDL would need formal verification and coverage guarantees before tape-out, a step the paper lists as a challenge but does not yet solve.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes the Large Processor Chip Model (LPCM), an LLM-driven framework intended to automate computer system architecture design end to end. The framework is organized into three levels of automation (Human-Centric, Agent-Orchestrated, Model-Governed), and the paper discusses how six modules—compiler, binary translation, simulator, hardware/software partitioning, design space exploration, and HDL generation—would evolve through these levels. To demonstrate the approach, the authors present a 3D Gaussian Splatting (3DGS) case study at Level 1. The case study uses DeepSeek-V3 to configure a Gem5 CPU simulator and a Gem5-Aladdin NPU simulator, reports a "over a 20% improvement" in end-to-end simulated performance for CPU-NPU versus CPU-only execution, and claims a final design with area 5.24 mm², power 1.2 W, and "1.41× speedup over a high-performance NVIDIA A100 GPU." The paper also discusses challenges and future directions for Levels 2 and 3.

Significance. If the LPCM vision were realized, it could be an influential position statement for LLM-based computer architecture design, and the paper usefully organizes a scattered literature into a three-level automation taxonomy. The manuscript's strength is its breadth: it articulates concrete roles for LLMs across compilers, binary translation, simulation, partitioning, DSE, and RTL generation, and it identifies real bottlenecks such as cross-layer optimization and verification. The case study, however, is the only quantitative evidence for the central 'effectiveness' claim, and that evidence is not currently reliable. The 20% figure is an internal comparison within one uncalibrated simulator, and the 1.41× A100 comparison lacks a denominator, a clock frequency, and any calibration between Gem5-Aladdin ticks and real A100 performance. The paper also contains a direct internal inconsistency: Section 7.2.1 states that the HDL generation module is currently at Level 3, while the rest of the paper explicitly frames the 3DGS case study as a Level 1 implementation.

major comments (4)
  1. [§8.2 and Figure 10] The claim of a "1.41× speedup over a high-performance NVIDIA A100 GPU" is unsupported. The only performance datum shown for the LPCM design is "Perf: 7.04×10^10 Ticks" in Figure 10. No clock frequency is given, so ticks cannot be converted to seconds; no A100 reference runtime is given, so the speedup ratio has no denominator; and no calibration of Gem5-Aladdin's pre-RTL timing model to A100 hardware is described. The area and power figures (5.24 mm² and 1.2 W) also appear without a synthesis tool, technology node, or cell library, so they cannot be independently reproduced. Since these numbers are the entire basis for the case study's 'effectiveness' claim, the claim should either be removed or rephrased as an internal simulation-only comparison with explicit caveats.
  2. [§4.2] The "over a 20% improvement in end-to-end performance" is reported without sufficient methodology. The text does not state how end-to-end performance was measured (simulation ticks, simulated cycles, or wall-clock time), what the exact CPU-only and CPU-NPU configurations were, how many runs were performed, or whether any error bars or variance statistics were computed. The description of the DSE search (eight CPU configurations and six NPU parameters) is also too terse to judge whether the reported improvement is meaningful or an artifact of the sampled configurations. Please provide the actual configurations, the measurement protocol, and the raw results.
  3. [§8.2 and §4.2] The validation is internal to the same simulation toolchain that produces the performance numbers. The NPU simulator is generated by an LLM using Gem5-Aladdin template modules, integrated into Gem5-Aladdin, and then evaluated with a Gem5-Aladdin simulation of the 3DGS workload. This can demonstrate that an LLM can configure a simulator, but it cannot demonstrate that the resulting NPU would achieve the claimed hardware-level speedups on real silicon. The A100 comparison in §8.2 is especially affected, because no external benchmark, silicon measurement, or independent performance model is used to ground the ratio. Please either remove the hardware-level claims or supplement them with a validation study against measured hardware.
  4. [§7.2.1] There is a direct internal inconsistency about the current development stage. Section 7.2.1 states: "We describe HDL generation across the following three levels. Currently, we are at level 3." This contradicts the rest of the paper, including Section 1.4 and Section 8, which present the 3DGS case study as a Level 1 implementation and describe Level 3 as future work. Since the paper's central claim is about demonstrating Level 1, this statement needs to be corrected or explicitly qualified.
minor comments (5)
  1. [Throughout] There are multiple typos and formatting artifacts: "categroies" (Section 1.1), "an essential role" (Section 1), "T raditional" and "V ary" (Section 1.1), and inconsistent spacing in "LL VM" throughout. A careful proofreading pass is needed.
  2. [Figure 10] The performance annotation "Perf: 7.04×10^10Ticks" lacks proper superscript formatting and, more importantly, any unit explanation. Please clarify whether this is a processor cycle count, a simulated time unit, or something else.
  3. [§4.2] The generated SE.py script and the Gem5-Aladdin NPU configuration are described verbally but no code, configuration files, or reproducibility artifacts are provided. For a paper about automated design, releasing these artifacts would substantially strengthen the demonstration.
  4. [§8.2] The selection of the 3DGS implementation from repository [99] is described as the result of "a comprehensive search across multiple GitHub repositories" and comparison of "quality metrics such as implementation completeness, code efficiency, and documentation quality," but no details of the candidate set, the comparison procedure, or the scoring criteria are given. Please specify how the choice was made.
  5. [References] Reference [99] is cited as a GitHub URL without a version, commit hash, or access date. Since GitHub repositories change over time, please include a permanent identifier or archival version.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the framework proposal and the case-study performance figures are empirical simulation reports, not derivations that reduce to their own inputs.

full rationale

The paper is a position/framework paper whose central claim is a proposal for end-to-end automated architecture design, not a theorem derived from equations. The Level 1 case study reports a 20% end-to-end improvement of the CPU-NPU Gem5-Aladdin simulator over CPU-only simulation (Section 4.2) and a 1.41x speedup over an NVIDIA A100 with 5.24 mm2 and 1.2 W (Section 8.2). These are measurements produced by a pre-existing simulator, Gem5-Aladdin, which the LLM was used to configure. Using the same simulator to evaluate the LLM-configured design weakens the external validity of the numbers, but it does not make the result equal to an input by construction: no equation in the paper defines the performance in terms of the LLM prompt, and no fitted parameter is renamed as a prediction. The 1.41x speedup is unsupported because Figure 10 gives only 7.04e10 ticks with no clock frequency and no A100 baseline runtime, but that is a correctness/evidence gap, not circular reasoning. Self-citations such as ChipGPT [25], ITERTL [95], and MoDSE [58] appear as background or related work and are not load-bearing for the paper's central claim. Section 8.3.2 explicitly acknowledges verification and trustworthiness challenges, which is a stated limitation rather than a hidden circular step. Therefore no significant circularity is identified.

Assumptions & free parameters 1 free parameters · 3 assumptions · 0 invented entities

The central claims rest on three unproven assumptions about simulator fidelity and search optimality, plus one hand-chosen constraint set for the case study. None of these are independently validated with external measurements.

free parameters (1)
  • 3DGS case-study design constraints (area < 6 mm², power < 2 W) = meeting area = 5.24 mm², power = 1.2 W in the reported final design
    These self-imposed targets are chosen by the authors rather than derived from workload analysis or a stated technology node; the 'success' of the case study is judged against them (Section 8.2).
assumptions (3)
  • domain assumption Simulator validation: passing functional workload tests (GEMV, GEMM, 3DGS) is sufficient to establish that the LLM-generated simulator configuration is 'valid and accurate'.
    The paper uses these functional tests to conclude correctness of the generated CPU/NPU simulator modules, but functional correctness does not imply the performance model is accurate (Section 4.2).
  • domain assumption Gem5-Aladdin's pre-RTL simulation ticks are a faithful and directly comparable proxy for real hardware performance, including the NVIDIA A100 GPU.
    The 20% and 1.41x claims rely on comparing simulated ticks to real GPU performance without any calibration or stated methodology (Sections 4.2, 8.2).
  • ad hoc to paper The DSE process, which samples eight CPU and six NPU configurations, identifies the 'optimal' architecture for the 3DGS workload.
    No search space definition, reproducibility of the search, or comparison against exhaustive exploration is provided, so 'optimal' is asserted rather than demonstrated (Section 8.2).

how reviews work

0 comments
Cite this review

Pith. "Pith review of Large Processor Chip Model." pith.science (2026). https://pith.science/paper/4ZPYUGM5

@misc{pith2026250602929,
  author       = {Pith},
  title        = {Pith review of: Large Processor Chip Model},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4ZPYUGM5}},
  note         = {Machine review of arXiv:2506.02929}
}
read the original abstract

Computer System Architecture serves as a crucial bridge between software applications and the underlying hardware, encompassing components like compilers, CPUs, coprocessors, and RTL designs. Its development, from early mainframes to modern domain-specific architectures, has been driven by rising computational demands and advancements in semiconductor technology. However, traditional paradigms in computer system architecture design are confronting significant challenges, including a reliance on manual expertise, fragmented optimization across software and hardware layers, and high costs associated with exploring expansive design spaces. While automated methods leveraging optimization algorithms and machine learning have improved efficiency, they remain constrained by a single-stage focus, limited data availability, and a lack of comprehensive human domain knowledge. The emergence of large language models offers transformative opportunities for the design of computer system architecture. By leveraging the capabilities of LLMs in areas such as code generation, data analysis, and performance modeling, the traditional manual design process can be transitioned to a machine-based automated design approach. To harness this potential, we present the Large Processor Chip Model (LPCM), an LLM-driven framework aimed at achieving end-to-end automated computer architecture design. The LPCM is structured into three levels: Human-Centric; Agent-Orchestrated; and Model-Governed. This paper utilizes 3D Gaussian Splatting as a representative workload and employs the concept of software-hardware collaborative design to examine the implementation of the LPCM at Level 1, demonstrating the effectiveness of the proposed approach. Furthermore, this paper provides an in-depth discussion on the pathway to implementing Level 2 and Level 3 of the LPCM, along with an analysis of the existing challenges.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

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

    cs.AR 2025-09 reject novelty 6.0 of 10

    A multi-agent LLM framework that iteratively co-designs CGRA hardware and software parameters, reporting power and performance improvements over LLM and manual baselines.

Reference graph

Works this paper leans on

45 extracted references · 34 canonical work pages · cited by 1 Pith paper

  1. [1]

    A new golden age for computer architecture

    1 Hennessy J L, Patterson D A. A new golden age for computer architecture. Communications of the ACM, 2019, 62: 48–60 2 Berkeley Logic Synthesis and Verification Group. Abc: A system for sequential logic synthesis and formal verification. URL https://people.eecs.berkeley.edu/∼alanmi/abc/ 3 Edwards T. Open circuit design. URL http://opencircuitdesign.com/ ...

    work page 2019

  2. [2]

    Dagon: Technology binding and local optimization by dag matching

    1984, 1984 10 Keutzer K. Dagon: Technology binding and local optimization by dag matching. In: Proceedings of the 24th ACM/IEEE Design Automation Conference,

    work page 1984

  3. [10]

    Chipnemo: Domain-adapted llms for chip design

    26–31 21 Liu M, Ene T, Kirby R, et al. Chipnemo: Domain-adapted llms for chip design. CoRR, 2023, abs/2311.00176. URL https://doi.org/10.48550/arXiv.2311.00176 22 Liu S, Fang W, Lu Y, et al. Rtlcoder: Outperforming GPT-3.5 in design RTL generation with our open-source dataset and lightweight solution. CoRR, 2023, abs/2312.08617. URL https://doi.org/10.485...

    arXiv doi:10.48550/arxiv.2311.00176 2023

  4. [12]

    Divide-and-conquer approach for multi-phase statistical migration for source code (t)

    1–6 28 Nguyen A T, Nguyen T T, Nguyen T N. Divide-and-conquer approach for multi-phase statistical migration for source code (t). In: 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE),

    work page 2015

  5. [15]

    Refining decompiled c code with large language models

    119–130 39 Wong W K, Wang H, Li Z, et al. Refining decompiled c code with large language models. arXiv preprint arXiv:2310.06530, 2023 40 Armengol-Estap´ e J, Rocha R C, Woodruff J, et al. Forklift: An extensible neural lifter. arXiv preprint arXiv:2404.16041, 2024 41 Tan H, Luo Q, Li J, et al. Llm4decompile: Decompiling binary code with large language mo...

    arXiv 2023

  6. [16]

    03152 44 Jiang N, Becker D U, Michelogiannakis G, et al

    URL https://arxiv.org/abs/2007. 03152 44 Jiang N, Becker D U, Michelogiannakis G, et al. A detailed and flexible cycle-accurate network-on-chip simulator. In: 2013 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS),

    work page 2007

  7. [21]

    Simulated annealing

    628–633 53 Van Laarhoven P J, Aarts E H, van Laarhoven P J, et al. Simulated annealing. 1987, 1987 54 Selman B, Gomes C P. Hill-climbing search. Encyclopedia of cognitive science, 2006, 81: 10 55 Ipek E, McKee S A, Caruana R, et al. Efficiently exploring architectural design spaces via predictive modeling. In: J P Shen, M Martonosi, eds., Proceedings of t...

    work page 1987

  8. [23]

    A High-accurate Multi-objective Exploration Framework for Design Space of CPU

    142:1–142:6 57 Wang D, Yan M, Liu X, et al. A High-accurate Multi-objective Exploration Framework for Design Space of CPU. In: DAC’23: 60th ACM/IEEE Design Automation Conference, San Francisco, California, USA, July 9 - 13, 2023, 2023 58 Wang D, Yan M, Teng Y, et al. MoDSE: A high-accurate multiobjective design space exploration framework for CPU microarc...

    work page 2023

Show all 45 references
  1. [24]

    Accurate and efficient regression modeling for microarchitectural performance and power prediction

    99–108 60 Lee B C, Brooks D M. Accurate and efficient regression modeling for microarchitectural performance and power prediction. In: J P Shen, M Martonosi, eds., Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating...

    2006

  2. [25]

    ArchRanker: A ranking approach to design space exploration

    185–194 61 Chen T, Guo Q, Tang K, et al. ArchRanker: A ranking approach to design space exploration. In: ACM/IEEE 41st International Symposium on Computer Architecture, ISCA 2014, Minneapolis, MN, USA, June 14-18, 2014,

    2014

  3. [27]

    McPAT-Calib: A RISC-V BOOM Microarchitecture Power Modeling Framework

    1–9 64 Zhai J, Bai C, Zhu B, et al. McPAT-Calib: A RISC-V BOOM Microarchitecture Power Modeling Framework. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 2023, 42: 243–256 65 Wang D, Yan M, Teng Y, et al. A High-accurate Multi-objective Ensemble...

    2023

  4. [29]

    Cross-program design space exploration by ensemble transfer learning

    12:1–12:10 67 Li D, Yao S, Wang S, et al. Cross-program design space exploration by ensemble transfer learning. In: S Parameswaran, ed., 2017 IEEE/ACM International Conference on Computer-Aided Design, ICCAD 2017, Irvine, CA, USA, November 13-16, 2017,

    2017

  5. [31]

    A transfer learning framework for high-accurate cross-workload design space exploration of cpu

    39–52 69 Wang D, Yan M, Teng Y, et al. A transfer learning framework for high-accurate cross-workload design space exploration of cpu. In: 2023 IEEE/ACM International Conference On Computer Aided Design (ICCAD), 2023 70 Xue R, Wu H, Yan M, et al. Metadse: A few-shot meta-learn...

    2023

  6. [32]

    Meta-model Assisted Optimization for Design Space Exploration of Multi-Processor Systems-on-Chip

    1–6 72 Mariani G, Palermo G, Silvano C, et al. Meta-model Assisted Optimization for Design Space Exploration of Multi-Processor Systems-on-Chip. In: A N´ u˜ nez, P P Carballo, eds., 12th Euromicro Conference on Digital System Design, Architectures, Methods and Tools, DSD 2009,...

    2009

  7. [33]

    Multi-processor system-on-chip Design Space Exploration based on multi-level modeling techniques

    383–389 73 Mariani G, Palermo G, Silvano C, et al. Multi-processor system-on-chip Design Space Exploration based on multi-level modeling techniques. In: W A Najjar, M J Schulte, eds., Proceedings of the 2009 International Conference on Embedded Computer Systems: Architectures,...

    2009

  8. [34]

    Design-Space Exploration and Runtime Resource Management for Multicores

    118–124 74 Mariani G, Palermo G, Zaccaria V, et al. Design-Space Exploration and Runtime Resource Management for Multicores. ACM Trans. Embed. Comput. Syst., 2013, 13 75 Wang H, Zhu Z, Shi J, et al. An accurate ACOSSO metamodeling technique for processor architecture design sp...

    2013

  9. [37]

    OSCAR: An Optimization Methodology Exploiting Spatial Correlation in Multicore Design Spaces

    120–125 80 Mariani G, Palermo G, Zaccaria V, et al. OSCAR: An Optimization Methodology Exploiting Spatial Correlation in Multicore Design Spaces. IEEE Trans. Comput. Aided Des. Integr. Circuits Syst., 2012, 31: 740–753 81 Mei L, Houshmand P, Jain V, et al. Zigzag: Enlarging jo...

    2012

  10. [38]

    Polysa: Polyhedral-based systolic array auto-compilation

    209–224 83 Cong J, Wang J. Polysa: Polyhedral-based systolic array auto-compilation. In: 2018 IEEE/ACM International Conference on Computer-Aided Design (ICCAD),

    2018

  11. [39]

    Autosa: A polyhedral compiler for high-performance systolic arrays on fpga

    1–8 84 Wang J, Guo L, Cong J. Autosa: A polyhedral compiler for high-performance systolic arrays on fpga. In: The 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays,

    2021

  12. [40]

    Aladdin: A pre-rtl, power-performance accelerator simulator enabling large design space exploration of customized architectures

    93–104 85 Shao Y S, Reagen B, Wei G Y, et al. Aladdin: A pre-rtl, power-performance accelerator simulator enabling large design space exploration of customized architectures. ACM SIGARCH Computer Architecture News, 2014, 42: 97–108 86 Blocklove J, Garg S, Karri R, et al. Chip-...

    2014

  13. [41]

    URL https://doi.org/10.1109/MLCAD58807.2023.10299874 87 Thakur S, Blocklove J, Pearce H, et al

    1–6. URL https://doi.org/10.1109/MLCAD58807.2023.10299874 87 Thakur S, Blocklove J, Pearce H, et al. Autochip: Automating HDL generation using LLM feedback. CoRR, 2023, abs/2311.04887. URL https://doi.org/10.48550/arXiv.2311.04887 88 DeLorenzo M, Chowdhury A B, Gohil V, et al....

    2023

  14. [42]

    Co-designing accelerators and soc interfaces using gem5-aladdin

    URL https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/ 48 Shao Y S, Xi S L, Srinivasan V, et al. Co-designing accelerators and soc interfaces using gem5-aladdin. In: 2016 49th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO),

    2016

  15. [43]

    URL https://doi.org/10.23919/DATE56975.2023.10137086 91 Liu M, Pinckney N R, Khailany B, et al

    1–6. URL https://doi.org/10.23919/DATE56975.2023.10137086 91 Liu M, Pinckney N R, Khailany B, et al. Verilogeval: Evaluating large language models for verilog code generation. In: IEEE/ACM International Conference on Computer Aided Design, ICCAD 2023, San Francisco, CA, USA, O...

    2023

  16. [44]

    URL https://doi.org/10.1109/ICCAD57390.2023.10323812 92 Nadimi B, Zheng H

    1–8. URL https://doi.org/10.1109/ICCAD57390.2023.10323812 92 Nadimi B, Zheng H. A multi-expert large language model architecture for verilog code generation. CoRR, 2024, abs/2404.08029. URL https://doi.org/10.48550/arXiv.2404.08029 93 Zhao Y, Huang D, Li C, et al. Codev: Empow...

    2023

  17. [45]

    URL https://doi.org/10.1109/ASP-DAC58780.2024.10473904 95 Wu P, Guo N, Xiao X, et al

    722–727. URL https://doi.org/10.1109/ASP-DAC58780.2024.10473904 95 Wu P, Guo N, Xiao X, et al. ITERTL: an iterative framework for fine-tuning llms for RTL code generation. CoRR, 2024, abs/2407.12022. URL https://doi.org/10.48550/arXiv.2407.12022 96 ul Islam M, Sami H, Gaillard...

    2024

  18. [46]

    URL https://doi.org/10.1609/aaai.v39i1.32007 98 Zhao Y, Zhang H, Huang H, et al

    300–307. URL https://doi.org/10.1609/aaai.v39i1.32007 98 Zhao Y, Zhang H, Huang H, et al. MAGE: A multi-agent engine for automated RTL code generation. CoRR, 2024, abs/2412.07822. URL https://doi.org/10.48550/arXiv.2412.07822 99 GitHub - mmt-at/diff-gaussian-rasterization: C K...

    2024 doi arXiv

  19. [1987]

    Boils: Bayesian optimisation for logic synthesis

    341–347 11 Grosnit A, Malherbe C, Tutunov R, et al. Boils: Bayesian optimisation for logic synthesis. In: 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE),

    2022

  20. [1988]

    Toward an open-source digital flow: First learnings from the openroad project

    282–283 14 Ajayi T, Chhabria V A, Foga¸ ca M, et al. Toward an open-source digital flow: First learnings from the openroad project. In: Proceedings of the 56th Annual Design Automation Conference 2019,

    2019

  21. [2006]

    Efficient design space exploration via statistical sampling and adaboost learning

    195–206 56 Li D, Yao S, Liu Y, et al. Efficient design space exploration via statistical sampling and adaboost learning. In: DAC, Austin, TX, USA, June 5-9, 2016,

    2016

  22. [2009]

    Machine-learning based simulated annealer method for high level synthesis design space explo- ration

    106–109 8 Mahapatra A, Schafer B C. Machine-learning based simulated annealer method for high level synthesis design space explo- ration. In: Proceedings of the 2014 Electronic System Level Synthesis Conference (ESLsyn),

    2014

  23. [2010]

    An Efficient Design Space Exploration Methodology for Multi-Cluster VLIW Sci China Inf Sci 32 Architectures based on Artificial Neural Networks

    261–272 78 Mariani G, Palermo G, Silvano C, et al. An Efficient Design Space Exploration Methodology for Multi-Cluster VLIW Sci China Inf Sci 32 Architectures based on Artificial Neural Networks. In: Proc. IFIP International Conference on Very Large Scale Integration VLSI - So...

    2008

  24. [2012]

    Improving performance estimation for fpga-based accelerators for convolutional neural networks

    119–128 17 Ferianc M, Fan H, Chu R S, et al. Improving performance estimation for fpga-based accelerators for convolutional neural networks. In: Applied Reconfigurable Computing. Architectures, Tools, and Applications: 16th International Symposium, ARC 2020, Toledo, Spain, Apr...

    2020

  25. [2013]

    Qemu, a fast and portable dynamic translator

    86–96 45 Bellard F. Qemu, a fast and portable dynamic translator. 2005: 41 46 DeepSeek-AI, Liu A, Feng B, et al. Deepseek-v3 technical report,

    2005

  26. [2014]

    Multi-objective optimization in cpu design space exploration: Attention is all you need

    85–96 62 Xue R, Wu H, Yan M, et al. Multi-objective optimization in cpu design space exploration: Attention is all you need. arXiv preprint arXiv:2410.18368, 2024 63 Bai C, Sun Q, Zhai J, et al. BOOM-Explorer: RISC-V BOOM Microarchitecture Design Space Exploration Framework. I...

    2024 arXiv

  27. [2015]

    Multicube Explorer: An Open Source Framework for Design Space Exploration of Chip Multi-Processors

    689–694 76 Zaccaria V, Palermo G, Castro F, et al. Multicube Explorer: An Open Source Framework for Design Space Exploration of Chip Multi-Processors. In: M Beigl, F J Cazorla-Almeida, eds., ARCS ’10 - 23th International Conference on Architecture of Computing Systens 2010, Wo...

    2010

  28. [2016]

    System level hardware/software partitioning based on simulated annealing and tabu search

    1–12 49 Eles P, Peng Z, Kuchcinski K, et al. System level hardware/software partitioning based on simulated annealing and tabu search. Design automation for embedded systems, 1997, 2: 5–32 50 Lo V M. Heuristic algorithms for task assignment in distributed systems. IEEE Transac...

    1997

  29. [2017]

    Generative and multi-phase learning for computer systems optimization

    201–208 68 Ding Y, Mishra N, Hoffmann H. Generative and multi-phase learning for computer systems optimization. In: S B Manne, H C Hunter, E R Altman, eds., Proceedings of the 46th International Symposium on Computer Architecture, ISCA 2019, Phoenix, AZ, USA, June 22-26, 2019,

    2019

  30. [2018]

    Codebert: A pre-trained model for programming and natural languages, 2020 31 Wang Y, Wang W, Joty S, et al

    2552–2562 30 Feng Z, Guo D, Tang D, et al. Codebert: A pre-trained model for programming and natural languages, 2020 31 Wang Y, Wang W, Joty S, et al. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation, 2021 32 Zhong M, Ly...

    2020

  31. [2019]

    Machine learning predictive modelling high-level synthesis design space exploration

    1–4 15 Carrion Schafer B, Wakabayashi K. Machine learning predictive modelling high-level synthesis design space exploration. IET computers & digital techniques, 2012, 6: 153–159 16 Zuluaga M, Krause A, Milder P, et al. ” smart” design space sampling to predict pareto-optimal ...

    2012

  32. [2020]

    Chip placement with deep reinforcement learning

    3–13 18 Mirhoseini A, Goldie A, Yazgan M, et al. Chip placement with deep reinforcement learning. arXiv preprint arXiv:2004.10746, 2020 19 He Y, Bao F S. Circuit routing using monte carlo tree search and deep neural networks. arXiv preprint arXiv:2006.13607, 2020 20 Alawieh M ...

    2004 arXiv

  33. [2021]

    Learning c to x86 translation: An experiment in neural compilation

    902–914 35 Armengol-Estap´ e J, O’Boyle M F. Learning c to x86 translation: An experiment in neural compilation. arXiv preprint arXiv:2108.07639, 2021 36 Guo Z C, Moses W S. Enabling transformers to understand low-level programs. In: 2022 IEEE High Performance Extreme Computin...

    2021 arXiv

  34. [2022]

    Replace: Advancing solution quality and routability validation in global placement

    1193–1196 12 Cheng C K, Kahng A B, Kang I, et al. Replace: Advancing solution quality and routability validation in global placement. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 2018, 38: 1717–1730 13 Singh K J, Wang A R, Brayton R K, et al. ...

    2018

  35. [2023]

    Efficient design space exploration by knowledge transfer

    379–383 66 Li D, Wang S, Yao S, et al. Efficient design space exploration by knowledge transfer. In: Proceedings of the Eleventh IEEE/ACM/IFIP International Conference on Hardware/Software Codesign and System Synthesis, CODES 2016, Pittsburgh, Pennsylvania, USA, October 1-7, 2016,

    2016

  36. [2024]

    Chateda: A large language model powered autonomous agent for eda

    URL https://openreview.net/forum? id=jKnW7r7de1 24 Wu H, He Z, Zhang X, et al. Chateda: A large language model powered autonomous agent for eda. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 2024 25 Chang K, Wang Y, Ren H, et al. Chipgpt: How f...

    2024 doi

  37. [2025]

    3d gaussian splatting for real-time radiance field rendering

    URL https://arxiv.org/abs/2412.19437 47 Kerbl B, Kopanas G, Leimk¨ uhler T, et al. 3d gaussian splatting for real-time radiance field rendering. ACM Transactions on Graphics, 2023,

    2023 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.