Pith. sign in

REVIEW 3 major objections 5 minor 66 references

Stream-HLS: Towards Automatic Dataflow Acceleration

T0 review · 3 major / 5 minor · reviewed 2026-08-10 · deepseek-v4-flash

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

Pith's one-line read Stream-HLS automatically converts sequential multi-kernel C/C++ or PyTorch programs into globally scheduled streaming FPGA dataflow designs, beating manually tuned frameworks by up to 10.62x and prior automatic ones by up to 79.43x…

desk verdict A genuinely new open-source dataflow HLS framework whose end-to-end results are RTL-simulated and credible, but whose 'accurate model' claim needs qualification because the model can miss the synthesized II by 2x. read the letter →

arxiv 2501.09118 v1 pith:KHUDKURW submitted 2025-01-15 cs.AR

Suhail Basalama , Jason Cong This is my paper · ORCID
classification cs.AR
keywords FPGAhigh-levelsynthesisdataflowarchitecturestreamingFIFOMLIRlooppermutationdesignspaceexplorationMINLP
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 presents Stream-HLS, an end-to-end compiler that takes sequential C/C++ or PyTorch programs made of affine loop nests and automatically emits an FPGA dataflow architecture with streaming FIFO channels and matching host code, with no manual pragma tuning. The central claim is that the three decisive optimizations for multi-kernel accelerators—loop permutation, graph-level pipelining through shared-buffer-to-FIFO conversion, and adaptive per-node parallelization—should be chosen together, and that a closed-form analytical performance model makes this global choice tractable when cast as a mixed-integer nonlinear program. If correct, a programmer who can write a simple sequential kernel can get designs competitive with or faster than expert-tuned and prior automatic HLS flows; the paper reports geometric mean speedups up to 10.62x over manually optimized abstraction frameworks and 79.43x over automatically optimized ones. The paper also shows the model predicts RTL cycle counts closely for FIFO-only designs, while for fully parallelized designs the predictions diverge because the downstream tool does not always achieve the modeled initiation interval.

What carries the argument

The load-bearing object is the analytical performance model, whose input is an access function: a mapping from a node's loop induction variables to the indices of an array reference. Equality of the producer's write access function and the consumer's read access function, together with equal write/read counts, marks a shared buffer as convertible to a FIFO, and determines which predecessor event (first write or last write) gates the consumer's start time. The model's equations compute each node's start time $st(n)$, first write $fw(n)$, and last write $lw(n)$ in topological order, with dependency and epilogue terms; expanded, the same equations become linear in binary permutation variables and integer tiling variables, so the objective $\min lw(\mathrm{Sink})$ is a mixed-integer nonlinear program with permutation, tile-size, divisor, and DSP constraints. This machinery carries the argument because it reduces a design space of $3!^k$ permutations times a Cartesian product of divisor choices to one global optimization problem.

What would settle it

Take the Table 5 Residual Block Opt5 design, keep the Stream-HLS schedule identical but refactor only the generated code's style so that Vitis HLS reaches the predicted initiation interval for each node, and check whether RTL cycles drop to the predicted 1.05E+06; reaching it would localize the gap to backend code generation, while a persistent gap would show the closed-form model misses a structural effect.

Watch

Extended reading notes

Core claim

The core discovery is that the execution time of a dataflow graph of affine kernels can be written in closed form using three per-node quantities—absolute start time, first-write time, and last-write time—with FIFO and shared-buffer edges treated uniformly. An edge is FIFO-compatible exactly when the producer's write access function equals the consumer's read access function and the write/read counts match; otherwise the consumer must wait for the producer's last write. The model is then made symbolic in loop permutation and tile size, and the framework solves one combined MINLP that minimizes the sink's last-write time subject to one-permutation-per-node, matching tile sizes across dependent nodes, divisor, and DSP-count constraints. Stream-HLS implements this as MLIR passes, generates Vitis HLS code, and validates with cycle-accurate RTL simulation; its Opt5 designs outperform the compared baselines, and combined optimization beats solving the two scheduling problems separately on imbalanced workloads.

Load-bearing premise

The load-bearing premise is that the downstream high-level synthesis tool will actually hit the initiation interval the model predicts for every tiled and parallelized node; when it does not, the predicted schedule is not what gets built, and Table 5 shows the fully optimized Residual Block running at 2.09E+06 cycles against a prediction of 1.05E+06.

Editorial extensions

If this is right

  • For affine multi-kernel programs, manual pragma and schedule tuning can be replaced by an automatic pass; the paper's Opt5 designs outperform expert-tuned Allo and HeteroCL designs with geometric mean speedups up to 10.62x across the tested DSP limits.
  • Streaming FIFO conversion alone unlocks graph-level pipelining: optimizing loop order only (Opt2) gives 3.91x–7.28x over the FIFO-only baseline, and combined Opt5 reaches a geometric mean 314.89x over that baseline.
  • Solving loop permutation and node-level parallelization together (Opt5) beats solving them sequentially (Opt4), especially when node workloads are imbalanced; for balanced workloads the two approaches converge.
  • Global scheduling allocates DSPs to nodes in proportion to their workloads, so total latency approaches the latency of the slowest node rather than the sum of all nodes.
  • The design-space search itself is fast: geometric mean DSE runtime is 176.41x shorter than HIDA's DSE on the same benchmarks, with most solutions found in under two minutes.

Reading between the lines

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

  • A testable extension is to close the initiation-interval gap: if the generated code is refactored (without changing the schedule) so that the downstream tool hits the modeled II, Table 5 suggests the Opt5 speedups would grow, because the model's misses are one-sided and relative.
  • The same start/first-write/last-write formulation could be extended to off-chip memory by modeling a DRAM or HBM channel as a finite-capacity FIFO-like edge with bandwidth; the paper names off-chip bandwidth as future work.
  • The MINLP cost model is backend-agnostic, so it could be reused as a scheduling oracle inside other MLIR-based HLS compilers, provided their performance behavior matches the model's II assumptions.
  • The assumption that all operands live in fast partitioned on-chip memories is the main scope boundary; for real deployments with streaming data from host memory, bandwidth-aware scheduling would be needed, which the authors acknowledge.
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

3 major / 5 minor

Summary. The paper presents Stream-HLS, an MLIR-based framework that automatically converts multi-kernel affine C/C++ or PyTorch programs into dataflow HLS designs. The framework applies shared-buffer-to-FIFO conversion, loop permutation, and node-level parallelization through tiling, and uses an analytical performance model to drive a combined MINLP over loop permutations and tiling factors. The evaluation reports RTL-simulated cycle counts on ten benchmarks, showing large speedups over prior automated frameworks and manually optimized designs.

Significance. If the claims hold, Stream-HLS would be a substantial step toward end-to-end automation of dataflow HLS for multi-kernel affine programs, addressing an important practical problem. The strengths include an open-source implementation, use of RTL cycle-accurate simulation rather than HLS reports, and a performance model that is a closed-form function of the optimization variables rather than fitted to the speedup targets. However, the model's accuracy degrades in the fully optimized (Opt5) regime, which affects the 'accurate model' and 'global optimum' claims.

major comments (3)
  1. [§5.2, Table 5; §3.6, Eq. (3)] For Opt5 designs, Stream-HLS's predicted cycle counts are only 0.50x and 0.63x of the RTL-simulated counts for the Residual Block and DWSConv Block, respectively. Since the MINLP in Eq. (3) minimizes lw(Sink) computed from the same predicted initiation intervals, a systematic overestimate of II performance can cause the solver to select a schedule that is not optimal on the implemented hardware. The paper explicitly acknowledges in §5.2 that Vitis HLS may not achieve the requested II under node-level parallelization; therefore the abstract and contribution (3) should qualify the 'accurate performance model' claim to the regime where the requested II is actually achieved, or the model should be calibrated with post-synthesis II values.
  2. [§5.4, Table 10] In the two applications with the largest performance-model error in Table 5 (Residual Block and DWSConv Block), Table 10 shows that Opt5 yields exactly the same RTL cycles as Opt4 (2.09E+6 and 1.35E+5, respectively). Thus the combined MINLP provides no measurable benefit in the cases where the model is least reliable. This does not invalidate the RTL-simulated speedups over prior frameworks in Table 7, but it weakens the claim in §5.4 that the combined optimization generally outperforms solving the two MINLPs sequentially; the paper should explain why the combined approach fails to improve these cases.
  3. [§5.1, contribution (4)] The MINLP solver reached its 20-minute timeout for Opt4 and Opt5 of the residual block and multi-head self attention block. Since no proof of optimality is available for timed-out runs of a non-convex MINLP, the descriptions 'global coordinated loop scheduling' and 'globally optimized' overstate what is established. The authors should either report the MIP gap for those runs or change the wording to 'graph-wide' or 'best schedule found within the time limit'.
minor comments (5)
  1. [Abstract and contribution (5)] The phrase 'up to 79.43x and 10.62x geometric means' is inaccurate because a geometric mean is a single summary value; rephrase to 'by geometric means of 10.62x (HeteroCL) and 79.43x (POM)' or similar.
  2. [§5.3, Table 7] The column header 'Medium (220, 2560, 9024) DSPs' is ambiguous; clarify that each application reports cycle counts under three DSP limits, and explain the vertical-bar notation in the table.
  3. [§5.3] The word 'Conversly' should be 'Conversely'.
  4. [§5.2] The phrase 'further code instrumentation that are hard to predict' should read 'that is hard to predict'.
  5. [Table 5] The parenthetical ratios in the 'Stream-HLS Cycles' and 'Vitis Cycles' columns should be defined explicitly as predicted/estimated cycles divided by RTL-simulated cycles, so the reader can interpret the 0.50x and 0.63x entries without ambiguity.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the analytical model is closed-form over design variables and validated against independent RTL simulation.

full rationale

Stream-HLS's central derivation is the performance model in Section 3.5.2 (Table 3), expanded in Table 4 for loop-permutation indicators and in Eq. 2/3 for tiling factors. The objective min lw(Sink) is a closed-form recurrence in the design variables (permutations, tile sizes, II_n, U_n); it is not built from the speedup targets in Table 7 or Table 10, and no fitted parameter is renamed as a prediction. Validation in Section 5.2 compares model estimates to independent cycle-accurate RTL simulation, and the paper explicitly discloses that under Opt5 Vitis HLS sometimes misses the requested II (e.g., Residual Block predicted 1.05E+06 vs RTL 2.09E+06 cycles, 0.50x); this is an accuracy limitation rather than a circular dependency, because the model's inputs are not obtained from the RTL numbers it predicts. The II_n and U_n node properties are asserted in Section 3.5.1 without a derivation, which is a completeness gap but not circularity. Self-citations and citations to prior same-group tools (HLS dialect and translation modules from [58,59], benchmark and baseline frameworks) are implementation and comparison attributions, not load-bearing justification for the model or the MINLP optimum. No uniqueness theorem, ansatz-by-citation, or definitional identification of prediction with input appears in the paper.

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

No fitted free parameters were identified; the tiling factors and permutation indicators are optimization variables, and II_n and U_n are asserted as calculable per node. The main assumptions are affine input scope, the linear time model, II achievability by Vitis HLS, FIFO conversion conditions, and on-chip memory. The paper explicitly acknowledges the II and memory limits in Sections 5.2 and 7.

assumptions (6)
  • domain assumption Input programs are affine kernels: perfectly nested loops with constant bounds and affine array accesses.
    Section 3.2 defines the supported input. The abstract's claim of arbitrary C/C++ or PyTorch software is stronger than this; the framework does not handle dynamic bounds or irregular control flow.
  • domain assumption The achievable initiation interval II_n and DSP factor U_n for every node are calculable from the loop nest and memory references.
    Section 3.5.1 asserts this but gives no closed form or measurement procedure. The MINLP objective in Table 4 depends on these values.
  • domain assumption A linear time function t(indices) = II_n times a linear index expression captures relative first and last read and write times of each node.
    Section 3.5.1 defines the time function; Section 5.2 shows it overestimates performance for optimized designs because Vitis may not achieve the assumed II.
  • ad hoc to paper Vitis HLS achieves the II selected by Stream-HLS for tiled and parallelized nodes.
    Section 5.2 explicitly states that after node-level parallelization Vitis may not achieve the requested II, causing Stream-HLS Opt5 predictions as low as 0.50x of RTL cycles.
  • domain assumption Shared buffers can be converted to FIFOs if write count equals read count and access order matches (Cond. 1 and Cond. 2).
    Section 3.1 states these as necessary conditions; the framework retains shared buffers when they fail, limiting graph-level pipelining.
  • domain assumption Input and output data reside in fast partitioned on-chip memories, ignoring DDR and HBM bandwidth.
    Section 7 lists support for off-chip bandwidth as future work, so the performance model is limited to on-chip data movement.
invented entities (1)
  • Multi-dimensional array-of-FIFO stream types and operations in the Stream-HLS MLIR dialect
    purpose: Represent tiled streaming communication between parallelized producer and consumer nodes inside the generated HLS code (Listing 3, Section 4.3).
    This is a compiler abstraction introduced by the paper; its existence is evidenced by the open-source implementation, but it has no external falsifiable prediction beyond the code itself.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Stream-HLS: Towards Automatic Dataflow Acceleration." pith.science (2026). https://pith.science/paper/KHUDKURW

@misc{pith2026250109118,
  author       = {Pith},
  title        = {Pith review of: Stream-HLS: Towards Automatic Dataflow Acceleration},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/KHUDKURW}},
  note         = {Machine review of arXiv:2501.09118}
}
abstract

High-level synthesis (HLS) has enabled the rapid development of custom hardware circuits for many software applications. However, developing high-performance hardware circuits using HLS is still a non-trivial task requiring expertise in hardware design. Further, the hardware design space, especially for multi-kernel applications, grows exponentially. Therefore, several HLS automation and abstraction frameworks have been proposed recently, but many issues remain unresolved. These issues include: 1) relying mainly on hardware directives (pragmas) to apply hardware optimizations without exploring loop scheduling opportunities. 2) targeting single-kernel applications only. 3) lacking automatic and/or global design space exploration. 4) missing critical hardware optimizations, such as graph-level pipelining for multi-kernel applications. To address these challenges, we propose a novel methodology and framework on top of the popular multi-level intermediate representation (MLIR) infrastructure called Stream-HLS. Our framework takes a C/C++ or PyTorch software code and automatically generates an optimized dataflow architecture along with host code for field-programmable gate arrays (FPGAs). To achieve this, we developed an accurate analytical performance model for global scheduling and optimization of dataflow architectures. Stream-HLS is evaluated using various standard HLS benchmarks and real-world benchmarks from transformer models, convolution neural networks, and multilayer perceptrons. Stream-HLS designs outperform the designs of prior state-of-the-art automation frameworks and manually-optimized designs of abstraction frameworks by up to $79.43\times$ and $10.62\times$ geometric means respectively. Finally, the Stream-HLS framework is modularized, extensible, and open-sourced at \url{https://github.com/UCLA-VAST/Stream-HLS} (\url{https://doi.org/10.5281/zenodo.14585909}).

Figures

Figures reproduced from arXiv: 2501.09118 by the authors.

Figure 1
Figure 1. Stream-HLS Framework Overview While designing hardware accelerators with hardware descrip￾tion languages (HDLs) such as Verilog and VHDL attain the best speedups and energy efficiency, this process demands significant hardware expertise and can span several months to years. Fortu￾nately, advancements in high-level synthesis (HLS) have elevated the abstraction level from HDLs to C/C++. As a result, HLS com￾bined with… view at source ↗
Figure 2
Figure 2. Dataflow Graph and Stream-HLS Architecture of [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Execution 3mm Execution Traces under Different Loop Permutations and Parallelization Factors We identified three critical but often conflicting optimizations that determine the overall performance. The design space for these optimizations, even for this simple example, is massive. 2.1 Node-level Pipelining Loop pipelining is one of the most important optimizations in HLS. Ideally, with enough resources, a loop can b… view at source ↗
Figures from the paper (5 more)
Figure 5
Figure 5. Figure 5: Dataflow Canonicalization 3.3.2 Addressing Cond. 1. Many of the nodes of an application involve some data reuse in their input or output arrays. Let us take a simple example of matrix multiplication followed by matrix addition as shown in Listing 1. 1 float C [32][32];…
Figure 4
Figure 4. Figure 4: Main Passes of Stream-HLS Kernel Pipeline [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 6
Figure 6. Figure 6: Dataflow Graph Example Nodes can have an arbitrary number of different inputs and a single output. The single output can then be an input to one or more other nodes. Each node 𝑛 contains critical information relevant to its performance in hardware (see [PITH_FULL_IMAG…
Figure 7
Figure 7. Figure 7: The First Case of the 𝑙𝑤(𝑛): when a predecessor node 𝑛 ′ produces its data before node 𝑛 consumes it Stalls [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]
Figure 8
Figure 8. Figure 8: The Second Case of the 𝑙𝑤(𝑛): when a consumer node 𝑛 must wait (stall) for data from its predecessor node 𝑛 ′ • 𝑓 𝑤(𝑛) represents the absolute time for the first write of node 𝑛. It is calculated as the sum of the absolute starting time of the node (𝑠𝑡(𝑛)) and the rela…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

66 extracted references · 50 canonical work pages

  1. [1]

    Circuit IR Compilers and Tools

    2024. Circuit IR Compilers and Tools. https://circt.llvm.org/

    work page 2024

  2. [2]

    Yunsheng Bai, Atefeh Sohrabizadeh, Yizhou Sun, and Jason Cong. 2022. Improv- ing GNN-based accelerator design automation with meta learning. InProceedings of the 59th ACM/IEEE Design Automation Conference . 1347–1350

    work page 2022

  3. [3]

    Suhail Basalama, Atefeh Sohrabizadeh, Jie Wang, Licheng Guo, and Jason Cong

    work page

  4. [4]

    Tal Ben-Nun, Johannes de Fine Licht, Alexandros N Ziogas, Timo Schneider, and Torsten Hoefler. 2019. Stateful dataflow multigraphs: A data-centric model for performance portability on heterogeneous architectures. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. 1–14

    work page 2019

  5. [5]

    Mark Bohr. 2007. A 30 year retrospective on Dennard’s MOSFET scaling paper. IEEE Solid-State Circuits Society Newsletter 12, 1 (2007), 11–13

    work page 2007

  6. [6]

    Uday Bondhugula, Albert Hartono, Jagannathan Ramanujam, and Ponnuswamy Sadayappan. 2008. A practical automatic polyhedral parallelizer and locality optimizer. In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation . 101–113

    work page 2008

  7. [7]

    Anderson, Stephen Brown, and Tomasz Czajkowski

    Andrew Canis, Jongsok Choi, Mark Aldham, Victor Zhang, Ahmed Kammoona, Jason H. Anderson, Stephen Brown, and Tomasz Czajkowski. 2011. LegUp: high-level synthesis for FPGA-based processor/accelerator systems (FPGA ’11). Association for Computing Machinery, New York, NY, USA, 33–36. https: //doi.org/10.1145/1950413.1950423

    arXiv 2011

  8. [8]

    Andrew Canis, Jongsok Choi, Blair Fort, Ruolong Lian, Qijing Huang, Nazanin Calagar, Marcel Gort, Jia Jun Qin, Mark Aldham, Tomasz Czajkowski, Stephen Brown, and Jason Anderson. 2013. From software to accelerators with LegUp high-level synthesis. In 2013 International Conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES). 1–9. h...

    arXiv 2013

Show all 66 references
  1. [9]

    David Castells-Rufas, Santiago Marco-Sola, Juan Carlos Moure, Quim Aguado, and Antonio Espinosa. 2022. FPGA acceleration of pre-alignment filters for short read mapping with HLS. IEEE Access 10 (2022), 22079–22100

    2022

  2. [10]

    Caulfield, Eric S

    Adrian M. Caulfield, Eric S. Chung, Andrew Putnam, Hari Angepat, Jeremy Fowers, Michael Haselman, Stephen Heil, Matt Humphrey, Puneet Kaur, Joo- Young Kim, Daniel Lo, Todd Massengill, Kalin Ovtcharov, Michael Papamichael, Lisa Woods, Sitaram Lanka, Derek Chiou, and Doug Burger...

    2016

  3. [11]

    Hongzheng Chen, Niansong Zhang, Shaojie Xiang, Zhichen Zeng, Mengjia Dai, and Zhiru Zhang. 2024. Allo: A Programming Model for Composable Accelerator Design. Proc. ACM Program. Lang. 8, PLDI, Article 171 (jun 2024), 28 pages. https://doi.org/10.1145/3656401

    2024 doi

  4. [12]

    Yuze Chi, Jason Cong, Peng Wei, and Peipei Zhou. 2018. SODA: Stencil with optimized dataflow architecture. In 2018 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 1–8

    2018

  5. [13]

    Yuze Chi, Licheng Guo, Jason Lau, Young-kyu Choi, Jie Wang, and Jason Cong

  6. [14]

    Nitin Chugh, Vinay Vasista, Suresh Purini, and Uday Bondhugula. 2016. A DSL compiler for accelerating image processing pipelines on FPGAs. In Proceedings of the 2016 International Conference on Parallel Architectures and Compilation . 327–338

    2016

  7. [15]

    Eric Chung, Jeremy Fowers, Kalin Ovtcharov, Michael Papamichael, Adrian Caulfield, Todd Massengill, Ming Liu, Daniel Lo, Shlomi Alkalay, Michael Hasel- man, Maleen Abeydeera, Logan Adams, Hari Angepat, Christian Boehn, Derek Chiou, Oren Firestein, Alessandro Forin, Kang Su Gat...

    2018

  8. [16]

    Jason Cong, Jason Lau, Gai Liu, Stephen Neuendorffer, Peichen Pan, Kees Vissers, and Zhiru Zhang. 2022. FPGA HLS today: successes, challenges, and opportuni- ties. ACM Transactions on Reconfigurable Technology and Systems (TRETS) 15, 4 (2022), 1–42

    2022

  9. [17]

    Jason Cong and Jie Wang. 2018. PolySA: Polyhedral-based systolic array auto- compilation. In 2018 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 1–8

    2018

  10. [18]

    Tiziano De Matteis, Johannes de Fine Licht, and Torsten Hoefler. 2020. FBLAS: Streaming linear algebra on FPGA. In SC20: International conference for high performance computing, networking, storage and analysis . IEEE, 1–13

    2020

  11. [19]

    Robert H Dennard, Jin Cai, and Arvind Kumar. 2018. A perspective on today’s scaling challenges and possible future directions. In Handbook of Thin Film Deposition. Elsevier, 3–18

    2018

  12. [20]

    Lorenzo Ferretti, Giovanni Ansaloni, and Laura Pozzi. 2018. Lattice-traversing design space exploration for high level synthesis. In 2018 IEEE 36th International Conference on Computer Design (ICCD) . IEEE, 210–217

    2018

  13. [21]

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. InProceedings of the IEEE Conference on Computer Vision and Pattern Recognition . 770–778

    2016

  14. [22]

    James Hegarty, John S Brunhaver, Zachary DeVito, Jonathan Ragan-Kelley, Noy Cohen, Steven Bell, Artem Vasilyev, Mark Horowitz, and Pat Hanrahan. 2014. Darkroom: compiling high-level image processing code into hardware pipelines. ACM Trans. Graph. 33, 4 (2014), 144–1

    2014

  15. [23]

    Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. 2017. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861 (2017)

    2017 arXiv

  16. [24]

    Sitao Huang, Kun Wu, Hyunmin Jeong, Chengyue Wang, Deming Chen, and Wen- Mei Hwu. 2021. Pylog: An algorithm-centric python-based FPGA programming and synthesis flow. IEEE Trans. Comput. 70, 12 (2021), 2015–2028

    2021

  17. [25]

    Dillon Huff, Steve Dai, and Pat Hanrahan. 2021. Clockwork: Resource-efficient static scheduling for multi-rate image processing applications on FPGAs. In 2021 IEEE 29th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE, 186–194

    2021

  18. [26]

    Lana Josipovic, Andrea Guerrieri, and Paolo Ienne. 2021. Synthesizing General- Purpose Code Into Dynamically Scheduled Circuits. IEEE Circuits and Systems Magazine 21, 2 (2021), 97–118. https://doi.org/10.1109/MCAS.2021.3071631

    2021

  19. [27]

    Lana Josipović, Andrea Guerrieri, and Paolo Ienne. 2022. From C/C++ Code to High-Performance Dataflow Circuits. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 41, 7 (2022), 2142–2155. https://doi. org/10.1109/TCAD.2021.3105574

    2022

  20. [28]

    Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre-luc Cantin, Clifford Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazi...

    2017

  21. [29]

    David Koeplinger, Matthew Feldman, Raghu Prabhakar, Yaqi Zhang, Stefan Had- jis, Ruben Fiszel, Tian Zhao, Luigi Nardi, Ardavan Pedram, Christos Kozyrakis, and Kunle Olukotun. 2018. Spatial: a language and compiler for application accelerators. SIGPLAN Not. 53, 4 (jun 2018), 29...

    2018

  22. [30]

    Yi-Hsiang Lai, Yuze Chi, Yuwei Hu, Jie Wang, Cody Hao Yu, Yuan Zhou, Jason Cong, and Zhiru Zhang. 2019. HeteroCL: A Multi-Paradigm Programming Infrastructure for Software-Defined Reconfigurable Computing. In Proceedings of the 2019 ACM/SIGDA International Symposium on Field-Pr...

    2019

  23. [31]

    Yi-Hsiang Lai, Hongbo Rong, Size Zheng, Weihao Zhang, Xiuping Cui, Yun- shan Jia, Jie Wang, Brendan Sullivan, Zhiru Zhang, Yun Liang, Youhui Zhang, Jason Cong, Nithin George, Jose Alvarez, Christopher Hughes, and Pradeep Dubey. 2020. SuSy: A Programming Model for Productive Co...

    2020

  24. [32]

    Chris Lattner and Vikram Adve. 2004. LLVM: A compilation framework for lifelong program analysis & transformation. In International symposium on code generation and optimization, 2004. CGO 2004. IEEE, 75–86

    2004

  25. [33]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Olek- sandr Zinenko. 2020. MLIR: A compiler infrastructure for the end of Moore’s law. arXiv preprint arXiv:2002.11054 (2020)

    2020 arXiv

  26. [34]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Olek- sandr Zinenko. 2021. MLIR: Scaling compiler infrastructure for domain specific computation. In 2021 IEEE/ACM International Symp...

    2021

  27. [35]

    llvm. 2023. Torch-MLIR Project. https://github.com/llvm/torch-mlir. Suhail Basalama and Jason Cong

    2023

  28. [36]

    Michael Lo, Zhenman Fang, Jie Wang, Peipei Zhou, Mau-Chung Frank Chang, and Jason Cong. 2020. Algorithm-hardware co-design for BQSR acceleration in genome analysis toolkit. In 2020 IEEE 28th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM) ...

    2020

  29. [37]

    Kingshuk Majumder and Uday Bondhugula. 2023. HIR: An mlir-based inter- mediate representation for hardware accelerator description. In Proceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 4 . 189–201

    2023

  30. [38]

    William S Moses, Lorenzo Chelini, Ruizhe Zhao, and Oleksandr Zinenko. 2021. Polygeist: Raising C to polyhedral MLIR. In 2021 30th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE, 45–59

    2021

  31. [39]

    Fahad Bin Muslim, Liang Ma, Mehdi Roozmeh, and Luciano Lavagno. 2017. Efficient FPGA implementation of OpenCL high-performance computing appli- cations via high-level synthesis. IEEE Access 5 (2017), 2747–2762

    2017

  32. [40]

    Rachit Nigam, Sachille Atapattu, Samuel Thomas, Zhijing Li, Theodore Bauer, Yuwei Ye, Apurva Koti, Adrian Sampson, and Zhiru Zhang. 2020. Predictable accelerator design with time-sensitive affine types. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language ...

    2020

  33. [41]

    Rachit Nigam, Samuel Thomas, Zhijing Li, and Adrian Sampson. 2021. A com- piler infrastructure for accelerator generators. In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. 804–817

    2021

  34. [42]

    Ampl Optimization. 2024. https://ampl.com/

    2024

  35. [43]

    Gurobi Optimization. 2024. https://www.gurobi.com/downloads/ampl-and- gurobi/

    2024

  36. [44]

    Louis-Noël Pouchet and Tomofumi Yuki. 2012. Polybench: The polyhedral benchmark suite. URL: http://www.cs.ucla.edu/pouchet/software/polybench (2012)

    2012

  37. [45]

    Stéphane Pouget, Louis-Noël Pouchet, and Jason Cong. 2024. Automatic Hard- ware Pragma Insertion in High-Level Synthesis: A Non-Linear Programming Approach. arXiv preprint arXiv:2405.12304 (2024)

    2024 arXiv

  38. [46]

    Robert R Schaller. 1997. Moore’s law: past, present and future. IEEE Spectrum 34, 6 (1997), 52–59

    1997

  39. [47]

    Atefeh Sohrabizadeh, Yunsheng Bai, Yizhou Sun, and Jason Cong. 2023. Robust GNN-based representation learning for HLS. In 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD) . IEEE, 1–9

    2023

  40. [48]

    Atefeh Sohrabizadeh, Cody Hao Yu, Min Gao, and Jason Cong. 2022. AutoDSE: Enabling software programmers to design efficient FPGA accelerators. ACM Transactions on Design Automation of Electronic Systems (TODAES) 27, 4 (2022), 1–27

    2022

  41. [49]

    James Thomas, Pat Hanrahan, and Matei Zaharia. 2020. Fleet: A framework for massively parallel streaming on FPGAs. In Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems. 639–651

    2020

  42. [50]

    Yaman Umuroglu, Nicholas J Fraser, Giulio Gambardella, Michaela Blott, Philip Leong, Magnus Jahre, and Kees Vissers. 2017. FINN: A framework for fast, scal- able binarized neural network inference. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field-programma...

    2017

  43. [51]

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. Advances in Neural Information Processing Systems 30 (2017)

    2017

  44. [52]

    Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, Pierre-Antoine Manzagol, and Léon Bottou. 2010. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion.Journal of machine learning research 11, 12 (2010)

    2010

  45. [53]

    Jie Wang, Licheng Guo, and Jason Cong. 2021. AutoSA: A polyhedral compiler for high-performance systolic arrays on FPGA. InThe 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays . 93–104

    2021

  46. [54]

    Dennis Weller, Fabian Oboril, Dimitar Lukarski, Juergen Becker, and Mehdi Tahoori. 2017. Energy efficient scientific computing on FPGAs using OpenCL. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field- Programmable Gate Arrays. 247–256

    2017

  47. [55]

    AMD Xilinx. [n. d.]. Alveo U280 Data Center Accelerator Card. https://www. xilinx.com/publications/product-briefs/alveo-u280-product-brief.pdf

  48. [56]

    AMD Xilinx. 2023. Merlin. https://github.com/Xilinx/merlin-compiler

    2023

  49. [57]

    AMD Xilinx. 2023. Vitis High-Level Synthesis. https://www.xilinx.com/products/ design-tools/vitis.html

    2023

  50. [58]

    Hanchen Ye, Cong Hao, Jianyi Cheng, Hyunmin Jeong, Jack Huang, Stephen Neuendorffer, and Deming Chen. 2022. Scalehls: A new scalable high-level synthesis framework on multi-level intermediate representation. In 2022 IEEE International Symposium on High-Performance Computer Arc...

    2022

  51. [59]

    Hanchen Ye, Hyegang Jun, and Deming Chen. 2024. HIDA: A Hierarchical Dataflow Compiler for High-Level Synthesis. In Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1 . 215–230

    2024

  52. [60]

    Chen Zhang, Guangyu Sun, Zhenman Fang, Peipei Zhou, and Jason Cong. 2023. Caffeine: Towards uniformed representation and acceleration for deep convo- lutional neural networks. In Proceedings of the ACM Turing A ward Celebration Conference-China 2023. 47–48

    2023

  53. [61]

    Weichuang Zhang, Jieru Zhao, Guan Shen, Quan Chen, Chen Chen, and Minyi Guo. 2024. An Optimizing Framework on MLIR for Efficient FPGA-based Accel- erator Generation. In 2024 IEEE International Symposium on High-Performance Computer Architecture (HPCA)

    2024

  54. [62]

    Yichi Zhang, Junhao Pan, Xinheng Liu, Hongzheng Chen, Deming Chen, and Zhiru Zhang. 2021. FracBNN: Accurate and FPGA-efficient binary neural net- works with fractional activations. In The 2021 ACM/SIGDA International Sympo- sium on Field-Programmable Gate Arrays . 171–182

    2021

  55. [63]

    Jieru Zhao, Liang Feng, Sharad Sinha, Wei Zhang, Yun Liang, and Bingsheng He. 2017. COMBA: A comprehensive model-based analysis framework for high level synthesis of real applications. In 2017 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 430–437

    2017

  56. [64]

    Ruizhe Zhao, Jianyi Cheng, Wayne Luk, and George A Constantinides. 2022. POLSCA: Polyhedral high-level synthesis with compiler transformations. In2022 32nd International Conference on Field-Programmable Logic and Applications (FPL). IEEE, 235–242

    2022

  57. [2021]

    In 2021 IEEE 29th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM)

    Extending high-level synthesis for task-parallel programs. In 2021 IEEE 29th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE, 204–213

    2021

  58. [2023]

    ACM Transactions on Reconfigurable Technology and Systems 16, 2 (2023), 1–32

    FlexCNN: An End-to-End Framework for Composing CNN Accelerators on FPGA. ACM Transactions on Reconfigurable Technology and Systems 16, 2 (2023), 1–32

    2023

Pith tools

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