Pith. sign in

REVIEW 4 major objections 5 minor 36 references

Pattern-Guided Design Space Exploration for FPGA Accelerator Design

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

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

Pith's one-line read Pattern-guided pruning cuts FPGA design-space exploration from 140 candidates to 29 while preserving the best synthesized latency.

desk verdict A plausible pattern-guided pruning layer for Allo, but the 4.83x reduction rests on an underspecified baseline the authors themselves concede needs strengthening. read the letter →

arxiv 2607.15068 v1 pith:BG4OON27 submitted 2026-07-16 cs.AR

Jialiang Zhang , Weiman Yan , Yuelin Zou This is my paper · ORCID
classification cs.AR
keywords FPGAhigh-levelsynthesis(HLS)designspaceexplorationcomputationpatternsscheduleoptimizationloopunrollingandpipeliningVitisHLSkernelcharacterization
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

This paper tries to establish that the schedule choices for an FPGA kernel — pipelining, unrolling, loop order, tiling, buffering — do not need to be explored as one giant combinatorial grid. If you know the kernel's computation pattern (elementwise, reduction, matrix-vector, matrix-matrix, stencil), you can restrict the search to a compact template of plausible schedules. The PATTERNDSE prototype does this inside the Allo scheduling interface, validates each generated schedule by execution, and ranks survivors before synthesis. On six kernels it evaluates 29 candidates instead of 140, a 4.83x reduction, and still recovers the exact best valid latency the baseline found. A sympathetic reader would care because expensive synthesis runs are the bottleneck in HLS design, and this suggests a cheap, interpretable way to prune them.

What carries the argument

The pattern template library — a set of five hand-authored mappings from kernel structure to schedule focus and search bounds (for example, elementwise kernels get a pipelined main loop with small unroll factors and no tiling, while GEMM gets selected loop orders with bounded unroll combinations). The templates produce candidate schedules through the Allo scheduling interface; each candidate is validated by LLVM execution and HLS code generation, then ranked by the estimator S(d) = bL(d)·(1+α·bR(d)), a product of estimated latency and a normalized resource-pressure penalty. The estimator only prioritizes candidates; final quality is always measured by Vitis HLS synthesis, which keeps the fra

What would settle it

Run PATTERNDSE on the same six kernels against a baseline that also evaluates only 29 candidates but samples them generically (or with a learning-based selector); if any such same-budget baseline finds a better valid Vitis HLS latency on a kernel, the claim that pattern pruning preserves the best outcome is falsified.

Watch

Extended reading notes

Core claim

PATTERNDSE's central claim is that computation-pattern information can prune unproductive HLS schedule combinations without sacrificing the best outcome. The paper demonstrates this by mapping five pattern classes to hand-built schedule templates, applying them through the Allo schedule object, filtering candidates that fail LLVM execution or HLS C/C++ code generation, scoring the rest with a lightweight pattern-aware estimator, and synthesizing the top candidates with Vitis HLS. Across vecadd, axpy, dot, matvec, gemm, and jacobi2d, the pattern-guided space holds 29 candidates versus 140 for the exhaustive-lite baseline, and the best valid latency is identical for every kernel within the eva

Load-bearing premise

The exhaustive-lite baseline is a fair and representative stand-in for unguided search; if its 140 candidates are padded with combinations no reasonable DSE would try, the 4.83x reduction is an artifact of the enumeration rather than of pattern knowledge.

Editorial extensions

If this is right

  • Design-space exploration can be front-loaded with pattern knowledge, cutting the number of expensive HLS synthesis runs by 4.83x on the six evaluated kernels (up to 12x for jacobi2d).
  • Because the best valid latency is identical to the baseline on every kernel, the pruned candidates appear to be genuinely unproductive within the evaluated bounded search.
  • Supporting a new kernel class requires only mapping it to an existing pattern template or adding a new rule, making the library extensible without changing the validation/ranking pipeline.
  • The estimator interface can later host calibrated analytical models or learning-based rankers, so the pruning layer can improve without altering the rest of the flow.
  • Pattern guidance yields the largest reductions for kernels with richer loop structure (gemm, jacobi2d), precisely where the generic schedule space is most combinatorial.

Reading between the lines

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

  • The real test is coverage: if the pattern library misses a kernel's actual structure, the fallback generic search takes over, so the 4.83x benefit should be expected to shrink as the benchmark suite broadens beyond the five pattern classes.
  • A same-budget comparison — giving an unguided search the same 29-candidate limit rather than 140 — would separate two effects: how much the pattern prior speeds search per candidate versus how much it simply shrinks the grid.
  • The estimator's role is only ranking, not early rejection of candidates below a threshold; adding synthesis feedback to the loop could convert the current pruning win into a quality win on kernels where the top-k selection misses the best schedule.
  • Since the best latency is recovered exactly on all six kernels, the pattern templates are arguably conservative; templates that include riskier schedules (deeper unrolling, explicit tiling) might trade a small quality loss for even larger reductions.
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 PATTERNDSE, a pattern-guided design space exploration front-end for FPGA kernels written in the Allo HLS framework. Five computation patterns (elementwise, reduction, matvec, GEMM, stencil) are mapped to compact schedule templates. For each kernel, PATTERNDSE generates candidate schedules, validates them via LLVM execution and HLS C code generation, ranks them with a heuristic estimator, and synthesizes selected candidates with Vitis HLS. On six kernels (vecadd, axpy, dot, matvec, gemm, jacobi2d), the paper reports reducing the number of HLS-evaluated candidates from 140 to 29 (4.83x) while recovering the same best valid Vitis HLS latency as an 'exhaustive-lite' baseline. The central claim is that computation-pattern information can prune unproductive schedule combinations without degrading the best observed HLS outcome.

Significance. If the central claim were fully supported, PATTERNDSE would be a useful practical pruning layer for HLS DSE: it is lightweight, end-to-end, and preserves the best latency on the evaluated kernels while cutting synthesis cost. The paper is clearly written and the authors are transparent about several limitations. However, the significance as presented is limited by three load-bearing gaps: the 'exhaustive-lite' baseline is not specified; the pattern templates are manually assigned per kernel rather than derived automatically; and the estimator and top-k selection are under-specified. These gaps make the headline 4.83x reduction and the 'same best latency' claim difficult to interpret as evidence for pattern-guided pruning specifically. The paper is a reasonable prototype demonstration, but the empirical claim needs substantial tightening before it can support the title's promise.

major comments (4)
  1. [§VI-A] The 'exhaustive-lite' baseline is not defined precisely enough to support the central comparison. The text says only that it applies 'a generic schedule template to each kernel' and is 'a bounded enumeration strategy,' but it does not specify the template's knobs, bounds, loop permutations, unroll factors, tiling choices, or how these are instantiated per kernel. Without this, the candidate counts in Table II (140 vs. 29) are not reproducible, and the 4.83x reduction ratio is uninterpretable: if the generic space contains many structurally legal but unlikely-to-be-productive combinations (as §VI-D concedes), the reduction may be an artifact of the baseline's construction. Please provide the full enumeration rule for the baseline for each kernel, and justify it as a fair representation of unguided search.
  2. [§IV-A] The pattern guidance is not automatic: the paper states that 'each supported kernel is mapped to a pattern template' (Section IV-A) and Table I shows a manual assignment. The pruning is therefore by construction — the authors decide, per kernel, which schedule axes and unroll factors are worth exploring. This reframes the contribution from 'computation-pattern information can prune' to 'hand-written schedule templates can prune.' To support the stated claim, the paper should either (a) provide a rule-based or automated pattern-mapping procedure that is not kernel-specific, or (b) explicitly state that the contribution is the template library plus validation/ranking flow, and discuss how a user would choose a pattern for a new kernel. As written, the six experiments cannot distinguish pattern knowledge from the authors' prior knowledge of good schedules for these exact kernels.
  3. [Eq. (2) and Algorithm 1] The ranking and top-k selection are under-specified. Equation (2) uses b_L(d), b_R(d), and α, but the paper does not give formulas for b_L and b_R, the value of α, or the value of k used in 'mark the top-k candidates.' It is also unclear whether all 29 pattern-guided candidates are sent to Vitis HLS or only the top-k subset; the abstract says 'HLS-evaluated candidates' is 29, which suggests all are synthesized, but Algorithm 1 implies selection. If only top-k are synthesized, the claim that the same best latency is recovered depends on the estimator's ranking accuracy and on k. If all 29 are synthesized, the top-k machinery is irrelevant to the reported result. Please clarify and report the estimator parameters and the sensitivity of the result to α and k.
  4. [§VI-D / §VIII] The evaluation does not yet rule out the possibility that any reasonable reduction of the 140-candidate baseline would recover the same best latency. The paper compares 29 pattern-guided candidates against the full 140, but does not compare against an equal-size random or heuristic subset of the baseline. A simple control — e.g., repeatedly sampling 29 candidates uniformly from the exhaustive-lite space and measuring how often the best latency is recovered — would show whether the pattern-guided subset is better than pruning alone. Without such a control, the central claim that 'pattern information' preserves quality is not empirically established. The limitations section correctly notes the need for stronger baselines, but the manuscript should include at least this minimal control to support its conclusion.
minor comments (5)
  1. [Algorithm 1] The algorithm's input list does not include k or the estimator parameters, but line 16 uses 'top-k.' Add k to the Require clause and state how k is chosen.
  2. [Equation (2)] Please define the normalization used for b_R(d) and explain the units or scale of b_L(d). Without this, the score S(d) is not reproducible.
  3. [Table II] The 'Reduction' column reports ratios such as 2.00x and 12.00x; consider also reporting the absolute reduction in candidate count to avoid confusion with percentage reductions shown in Fig. 3.
  4. [§V] The evaluation pipeline is described in prose, but no target FPGA part, clock period, or Vitis HLS version is given. These are standard details for HLS papers and should be included in §VI-A.
  5. [References] Reference [35] is not clearly connected to the sentence it supports and has an extremely long author list; please verify the citation and consider replacing it with a more focused reference on DSE evaluation methodology.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claim is an empirical comparison of two hand-specified search spaces, not a derivation that reduces to its inputs.

full rationale

PATTERNDSE's central claim—that pattern-guided pruning evaluates 29 candidates instead of 140 while recovering the same best Vitis HLS latency—is an empirical result obtained by running two search spaces through a real HLS tool. The pattern templates and the exhaustive-lite baseline are explicit inputs, not outputs of the derivation: Table I defines the schedule focus per pattern, and Algorithm 1 describes candidate generation, validation, and ranking. The estimator in Eq. (2) is used only to prioritize candidates; the paper states that 'Final quality is still measured by Vitis HLS' (Section IV-B), so the reported best latencies are not produced by the estimator. No equation in the paper makes the claimed reduction or latency-match hold by construction, and no parameter is fitted to the reported Vitis HLS outcomes and then renamed as a prediction. The paper does rely on hand-authored pattern templates and an underspecified baseline, but this is an external-validity concern, not circularity. The authors themselves note this in Section VIII: 'the evaluation currently compares against an exhaustive-lite baseline. Stronger baselines ... would further clarify where pattern guidance provides the largest benefit.' This limitation is weighed in the verdict but does not constitute a circular step. The few self-citations (e.g., [1], [2], [34], [35]) appear in background or related-work contexts and are not load-bearing for the paper's central empirical comparison; the main system citation, Allo [10], is an external tool that PATTERNDSE builds upon. Therefore no circularity is found.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The paper's result rests on several hand-chosen components: manual kernel-to-pattern mapping, undisclosed estimator parameters, and a self-defined baseline. These are the 'free parameters' of the empirical claim. No new entities (particles, forces, dimensions) are invented.

free parameters (4)
  • alpha (α) in estimator score = unspecified
    Eq. (2) S(d)=b_L(d)*(1+α*b_R(d)); α controls resource penalty but its value is not given.
  • top-k candidate count = 4/4/3/3/12/3 per kernel (inferred from Table II)
    Number of candidates forwarded to Vitis HLS; selection policy not stated.
  • Estimator latency/resource models (b_L, b_R) = unspecified
    No definitions provided for how b_L and b_R are computed; if coefficients exist, they are undisclosed.
  • Search bounds per kernel = unspecified
    The schedule parameter bounds defining both exhaustive-lite and pattern-guided spaces are not enumerated.
assumptions (4)
  • ad hoc to paper Each benchmark kernel is manually mapped to one of five pattern templates.
    Section IV-A states supported kernels are mapped to a template; this mapping is done by the authors, not extracted automatically. The claimed pruning benefit depends on this manual classification.
  • ad hoc to paper The exhaustive-lite generic schedule template is a fair representation of an unguided search.
    Section VI-A defines the baseline; if the generic template includes obviously unproductive combos, the reduction factor is inflated. No evidence the baseline matches common DSE practice.
  • domain assumption Vitis HLS latency results are deterministic and correctly interpreted.
    Latency comparison relies on single reports per candidate; no repeated runs or timing closure details. Standard in HLS DSE but still an assumption.
  • domain assumption The five patterns (elementwise, reduction, matvec, gemm, stencil) cover the relevant structure of the six kernels.
    Table I; the selection of these patterns is domain knowledge, not derived.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Pattern-Guided Design Space Exploration for FPGA Accelerator Design." pith.science (2026). https://pith.science/paper/BG4OON27

@misc{pith2026260715068,
  author       = {Pith},
  title        = {Pith review of: Pattern-Guided Design Space Exploration for FPGA Accelerator Design},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BG4OON27}},
  note         = {Machine review of arXiv:2607.15068}
}
read the original abstract

High-level synthesis (HLS) raises the abstraction level of FPGA accelerator design from hardware description languages to C/C++, but high-quality results still depend on schedule decisions such as pipelining, unrolling, tiling, reordering, and buffering. These decisions create a combinatorial design space, while many numerical kernels exhibit recurring computation patterns that suggest different optimization strategies. This paper presents PATTERNDSE, a lightweight pattern-guided design space exploration (DSE) framework for FPGA kernels written in Allo, a scheduling-oriented HLS programming system. PATTERNDSE maps recurring computation patterns, including elementwise maps, reductions, matrix-vector operations, matrix-matrix operations, and stencil-like updates, to compact schedule spaces. It then applies candidate schedules, validates functional correctness through LLVM execution, checks HLS C code generation, and uses a simple pattern-aware estimator to rank candidates before Vitis HLS synthesis. We evaluate PATTERNDSE on six representative kernels: vecadd, axpy, dot, matvec, gemm, and jacobi2d. Compared with an exhaustive-lite baseline, pattern-guided DSE reduces the number of HLS-evaluated candidates from 140 to 29, achieving a 4.83x overall search reduction and up to 12.0x reduction for individual kernels. Across all evaluated kernels, PATTERNDSE recovers the same best valid Vitis HLS latency as the exhaustive-lite baseline, demonstrating that computation-pattern information can prune unproductive schedule combinations while preserving high-quality HLS outcomes.

Figures

Figures reproduced from arXiv: 2607.15068 by the authors.

Figure 1
Figure 1. Simplified Allo-style GEMM kernel and schedule fragment. The [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Overview of PATTERNDSE workflow. TABLE I PATTERN TEMPLATES USED BY PATTERNDSE Pattern Kernels Schedule focus Elementwise vecadd, axpy Pipeline the main loop and try small unroll factors. Avoid tiling and loop permutations that do not expose reuse. Reduction dot Pipeline the reduction loop and test reduction-safe unroll fac￾tors while preserving accumula￾tion correctness. MatVec matvec Select between output-axis and … view at source ↗
Figure 3
Figure 3. Search-space reduction results. Left: number of HLS candidates evaluated by exhaustive-lite and PA [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Best valid Vitis HLS latency found by exhaustive-lite and PA [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 1 linked inside Pith

  1. [1]

    Stiff circuit system modeling via transformer,

    W. Yan, Y .-C. Chang, and W. Zhao, “Stiff circuit system modeling via transformer,”arXiv preprint arXiv:2510.24727, 2025

    arXiv 2025

  2. [2]

    Labeling cost sensitive batch active learning for brain tumor segmentation,

    M. Shen, J. Y . Zhang, L. Chen, W. Yan, N. Jani, B. Sutton, and O. Koyejo, “Labeling cost sensitive batch active learning for brain tumor segmentation,” in2021 IEEE 18th International Symposium on Biomedical Imaging (ISBI), 2021, pp. 1269–1273

    2021

  3. [3]

    Patternpaint: Practical layout pattern generation using diffusion-based inpainting,

    G. Zhou, B. Korrapati, G. R. Reddy, C.-C. Chang, J. Pan, J. Hu, Y . Chen, and D. G. Thakurta, “Patternpaint: Practical layout pattern generation using diffusion-based inpainting,” in2025 62nd ACM/IEEE Design Automation Conference (DAC), 2025, pp. 1–7

    2025

  4. [4]

    Diffusion- model-enhanced layout pattern generation for sub-3nm dfm,

    G. Zhou, C.-C. Chang, J. Zhang, J. Pan, and Y . Chen, “Diffusion- model-enhanced layout pattern generation for sub-3nm dfm,” in2025 IEEE/ACM International Conference On Computer Aided Design (IC- CAD), 2025, pp. 1–7

    2025

  5. [5]

    Dark silicon and the end of multicore scaling,

    H. Esmaeilzadeh, E. Blem, R. St. Amant, K. Sankaralingam, and D. Burger, “Dark silicon and the end of multicore scaling,” inProc. 38th Annual International Symposium on Computer Architecture, 2011, pp. 365–376

    2011

  6. [6]

    A reconfigurable fabric for accelerating large-scale datacenter services,

    A. Putnamet al., “A reconfigurable fabric for accelerating large-scale datacenter services,” inProc. 41st Annual International Symposium on Computer Architecture, 2014, pp. 13–24

    2014

  7. [7]

    A cloud-scale acceleration architecture,

    A. M. Caulfieldet al., “A cloud-scale acceleration architecture,” inProc. 49th Annual IEEE/ACM International Symposium on Microarchitecture, 2016

    2016

  8. [8]

    FPGA HLS today: Successes, challenges, and opportunities,

    J. Cong, J. Lau, G. Liu, S. Neuendorffer, P. Pan, K. Vissers, and Z. Zhang, “FPGA HLS today: Successes, challenges, and opportunities,” ACM Transactions on Reconfigurable Technology and Systems, vol. 15, no. 4, pp. 1–42, 2022

    2022

Show all 36 references
  1. [9]

    High-level synthesis design space explo- ration: Past, present, and future,

    B. C. Schafer and Z. Wang, “High-level synthesis design space explo- ration: Past, present, and future,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 39, no. 10, pp. 2628– 2639, 2020

    2020

  2. [10]

    Allo: A programming model for composable accelerator design,

    H. Chen, N. Zhang, S. Xiang, Z. Zeng, M. Dai, and Z. Zhang, “Allo: A programming model for composable accelerator design,”Proceedings of the ACM on Programming Languages, vol. 8, no. PLDI, pp. 593–620, 2024

    2024

  3. [11]

    The landscape of parallel computing research: A view from Berkeley,

    K. Asanovi ´c, R. Bod´ık, B. Catanzaro, J. Gebis, P. Husbands, K. Keutzer, D. Patterson, W. Plishker, J. Shalf, S. Williams, and K. Yelick, “The landscape of parallel computing research: A view from Berkeley,” University of California, Berkeley, Tech. Rep. UCB/EECS-2006-183, 2006

    2006

  4. [12]

    MachSuite: Benchmarks for accelerator design and customized architectures,

    B. Reagen, R. Adolf, Y . S. Shao, G.-Y . Wei, and D. Brooks, “MachSuite: Benchmarks for accelerator design and customized architectures,” in Proc. IEEE International Symposium on Workload Characterization, 2014, pp. 110–119

    2014

  5. [13]

    Rodinia: A benchmark suite for heterogeneous computing,

    S. Che, M. Boyer, J. Meng, D. Tarjan, J. W. Sheaffer, S.-H. Lee, and K. Skadron, “Rodinia: A benchmark suite for heterogeneous computing,” inProc. IEEE International Symposium on Workload Characterization, 2009, pp. 44–54

    2009

  6. [14]

    CHStone: A benchmark program suite for practical C-based high-level synthesis,

    Y . Hara, H. Tomiyama, S. Honda, H. Takada, and K. Ishii, “CHStone: A benchmark program suite for practical C-based high-level synthesis,” inProc. IEEE International Symposium on Circuits and Systems, 2008, pp. 1192–1195

    2008

  7. [15]

    Rosetta: A realistic high-level synthesis benchmark suite for software programmable FPGAs,

    Y . Zhou, U. Gupta, S. Dai, R. Zhao, N. Srivastava, H. Jin, J. Feath- erston, Y .-H. Lai, G. Liu, G. A. Velasquez, W. Wang, and Z. Zhang, “Rosetta: A realistic high-level synthesis benchmark suite for software programmable FPGAs,” inProc. ACM/SIGDA International Symposium on F...

    2018

  8. [16]

    MLPerf inference benchmark,

    V . J. Reddiet al., “MLPerf inference benchmark,” inProc. ACM/IEEE 47th Annual International Symposium on Computer Architecture, 2020, pp. 446–459

    2020

  9. [17]

    ScaleHLS: A scalable high-level synthesis framework with multi-level transforma- tions and optimizations,

    H. Ye, H. Jun, H. Jeong, S. Neuendorffer, and D. Chen, “ScaleHLS: A scalable high-level synthesis framework with multi-level transforma- tions and optimizations,” inProc. 59th ACM/IEEE Design Automation Conference, 2022, pp. 1355–1358

    2022

  10. [18]

    Decoupling algorithms from schedules for easy optimization of image processing pipelines,

    J. Ragan-Kelley, A. Adams, S. Paris, M. Levoy, S. Amarasinghe, and F. Durand, “Decoupling algorithms from schedules for easy optimization of image processing pipelines,”ACM Transactions on Graphics, vol. 31, no. 4, pp. 1–12, 2012

    2012

  11. [19]

    TVM: An automated end-to-end optimizing compiler for deep learning,

    T. Chen, T. Moreau, Z. Jiang, L. Zheng, E. Yan, H. Shen, M. Cowan, L. Wang, Y . Hu, L. Ceze, C. Guestrin, and A. Krishnamurthy, “TVM: An automated end-to-end optimizing compiler for deep learning,” in Proc. 13th USENIX Symposium on Operating Systems Design and Implementation, ...

    2018

  12. [20]

    HeteroCL: A multi-paradigm programming infrastructure for software-defined reconfigurable computing,

    Y .-H. Lai, Y . Chi, Y . Hu, J. Wang, C. H. Yu, Y . Zhou, J. Cong, and Z. Zhang, “HeteroCL: A multi-paradigm programming infrastructure for software-defined reconfigurable computing,” inProc. ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 2019, pp. 242–251

    2019

  13. [21]

    fpgaConvNet: A framework for mapping convolutional neural networks on FPGAs,

    S. I. Venieris and C.-S. Bouganis, “fpgaConvNet: A framework for mapping convolutional neural networks on FPGAs,” inProc. IEEE 24th Annual International Symposium on Field-Programmable Custom Computing Machines, 2016, pp. 40–47

    2016

  14. [22]

    DNNBuilder: An automated tool for building high-performance DNN hardware accelerators for FPGAs,

    X. Zhang, J. Wang, C. Zhu, Y . Lin, J. Xiong, W.-M. Hwu, and D. Chen, “DNNBuilder: An automated tool for building high-performance DNN hardware accelerators for FPGAs,” inProc. IEEE/ACM International Conference on Computer-Aided Design, 2018, pp. 1–8

    2018

  15. [23]

    In-datacenter performance analysis of a tensor processing unit,

    N. P. Jouppiet al., “In-datacenter performance analysis of a tensor processing unit,” inProc. 44th Annual International Symposium on Computer Architecture, 2017, pp. 1–12

    2017

  16. [24]

    Gemmini: Enabling systematic deep-learning archi- tecture evaluation via full-stack integration,

    H. Gencet al., “Gemmini: Enabling systematic deep-learning archi- tecture evaluation via full-stack integration,” inProc. 58th ACM/IEEE Design Automation Conference, 2021

    2021

  17. [25]

    LegUp: High-level synthesis for FPGA-based processor/accelerator systems,

    A. Canis, J. Choi, M. Aldham, V . Zhang, A. Kammoona, J. H. An- derson, S. Brown, and T. Czajkowski, “LegUp: High-level synthesis for FPGA-based processor/accelerator systems,” inProc. ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 2011, pp. 33–36

    2011

  18. [26]

    MLIR: A compiler infrastructure for the end of Moore’s law,

    C. Lattner, M. Amini, U. Bondhugula, A. Cohen, A. Davis, J. Pienaar, R. Riddle, T. Shpeisman, N. Vasilache, and O. Zinenko, “MLIR: A compiler infrastructure for the end of Moore’s law,”arXiv preprint arXiv:2002.11054, 2020

    2002 arXiv

  19. [27]

    VTR 7.0: Next generation architecture and CAD system for FPGAs,

    J. Luuet al., “VTR 7.0: Next generation architecture and CAD system for FPGAs,”ACM Transactions on Reconfigurable Technology and Systems, vol. 7, no. 2, pp. 1–30, 2014, article 6

    2014

  20. [28]

    AutoBridge: Coupling coarse-grained floorplanning and pipelining for high-frequency HLS design on multi-die FPGAs,

    L. Guo, Y . Chi, J. Wang, J. Lau, W. Qiao, E. Ustun, Z. Zhang, and J. Cong, “AutoBridge: Coupling coarse-grained floorplanning and pipelining for high-frequency HLS design on multi-die FPGAs,” in Proc. ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 2021, ...

    2021

  21. [29]

    TAPA: A scalable task-parallel dataflow programming framework for modern FPGAs with co-optimization of HLS and physical design,

    L. Guoet al., “TAPA: A scalable task-parallel dataflow programming framework for modern FPGAs with co-optimization of HLS and physical design,”ACM Transactions on Reconfigurable Technology and Systems, vol. 16, no. 4, pp. 1–31, 2023, article 63

    2023

  22. [30]

    Chisel: Constructing hardware in a Scala embedded language,

    J. Bachrach, H. V o, B. Richards, Y . Lee, A. Waterman, R. Avi ˇzienis, J. Wawrzynek, and K. Asanovi ´c, “Chisel: Constructing hardware in a Scala embedded language,” inProc. 49th Annual Design Automation Conference, 2012, pp. 1216–1225

    2012

  23. [31]

    OpenROAD: Toward a self-driving, open-source digital layout implementation tool chain,

    T. Ajayiet al., “OpenROAD: Toward a self-driving, open-source digital layout implementation tool chain,” inProc. Government Microcircuit Applications and Critical Technology Conference, 2019

    2019

  24. [32]

    On learning-based methods for design- space exploration with high-level synthesis,

    H.-Y . Liu and L. P. Carloni, “On learning-based methods for design- space exploration with high-level synthesis,” inProc. 50th Annual Design Automation Conference, 2013, pp. 1–7

    2013

  25. [33]

    AutoDSE: Enabling software programmers to design efficient FPGA accelerators,

    A. Sohrabizadeh, C. H. Yu, M. Gao, and J. Cong, “AutoDSE: Enabling software programmers to design efficient FPGA accelerators,”ACM Transactions on Design Automation of Electronic Systems, vol. 27, no. 4, pp. 1–27, 2022

    2022

  26. [34]

    From predict to generate: A cross-layer survey of generative ai for ic design and manufacturing,

    W. Yan, Z. Deng, M. Molter, R. Krishna, N. Rouf, S. S. Sofla, E. Thieme, S. Chatterjee, P. P. P. Linn, Y . Wen, X. Xiao, Z. Zhang, J. Huang, Y . Liu, Y . Zhou, P. Franzon, M. Swaminathan, E. Rosenbaum, and A. Aysu, “From predict to generate: A cross-layer survey of generative ...

    2026

  27. [35]

    Toward engineering agi: Benchmarking the engineering design capabilities of llms,

    X. Guo, Y . Li, X. Kong, Y . JIANG, X. Zhao, Z. Gong, Y . Zhang, D. Li, T. Sang, B. Zhu, G. Jun, Y . Huang, Y . Liu, Y . Xue, R. D. Kundu, Q. Lim, Y . Zhao, L. Granger, M. Younis, D. Keivan, N. Sabharwal, S. Sinha, P. Agarwal, K. Vandyck, H. Mai, Z. Wang, A. Venkatesh, A. Bari...

  28. [2025]

    Available: https://proceedings.neurips.cc/paper files/ paper/2025/file/664f777548205fb6e0cbb0965e8d2e16-Paper-Datasets and Benchmarks Track.pdf

    [Online]. Available: https://proceedings.neurips.cc/paper files/ paper/2025/file/664f777548205fb6e0cbb0965e8d2e16-Paper-Datasets and Benchmarks Track.pdf

    2025

Pith tools

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