Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

InTAR: Inter-Task Auto-Reconfigurable Accelerator Design for High Data Volume Variation in DNNs

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

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

Pith's one-line read InTAR shows that baking an execution-mode schedule into an FPGA's logic lets one accelerator switch between sequential and dataflow modes per task, reducing both pipeline stalls and off-chip memory traffic.

desk verdict Genuinely new static reconfiguration paradigm with solid internal results; SoTA speedups inflated by W4A8-vs-FP16 comparison without latency scaling. read the letter →

arxiv 2502.08807 v2 pith:L2SUI2RO submitted 2025-02-12 cs.AR cs.LG

Zifan He , Anderson Truong , Yingqi Cao , Jason Cong This is my paper · ORCID
classification cs.ARcs.LG
keywords FPGAacceleratorhighdatavolumevariationreconfigurablearchitecturedataflowexecutionsequentialhigh-levelsynthesistransformerprefillDNNinferenceacceleration
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

The paper introduces InTAR, a way to design FPGA accelerators for deep networks whose intermediate tensor sizes vary sharply from task to task. Its claim is that if the reconfiguration schedule is fixed before the circuit is built, a single accelerator can automatically switch among sequential, task-pipeline, and task-parallel execution at task boundaries, with only four cycles of switching overhead. This lets the hardware stream large intermediate data on-chip between dependent tasks and fall back to sequential execution when small intermediate data fits in scratchpad memory, avoiding both pipeline stalls and off-chip memory traffic. Across five multi-task kernels the paper reports 7.1x and 1.8x speedups over sequential and dataflow baselines, and on GPT-2 medium input prefill it reports 3.65-39.14x speedups over two state-of-the-art FPGA accelerators plus 1.66-7.17x power-efficiency gains over GPUs. The significance is that inter-task reconfiguration need not be a costly general-purpose overlay; an application-specific schedule with only necessary logic and interconnects makes the switch cheap and compatible with high-level synthesis.

What carries the argument

The mechanism is the static, stage-indexed reconfiguration schedule hardened into the circuit. The architecture template is a grid of compute cores, each containing a reconfigurable processing-element array, a scratchpad memory, a reduction unit, and a data movement control unit, with special function units inserted between cores for nonlinear operations. A global instruction reader pulls configuration instructions from a static buffer, patches loop bounds with the input size, and propagates them to cores; multiplexers keyed on the stage index reroute data sources, destinations, and precision. High-level synthesis conditional dataflow, implemented as if-else blocks on the stage index, lets the synthesis tool merge interconnects and logic across modes so unused paths are never added. A heuristic design-space exploration chooses the mode for each task from the dataflow graph, the on-chip memory budget, and the maximum intermediate size, with batching used for variable input sizes.

What would settle it

Run the FP16 baselines and the quantized InTAR design under identical data types on the same FPGA and compare end-to-end latency: if the speedup over the dataflow and sequential baselines largely disappears, the claimed gains come from quantization, not from inter-task reconfiguration.

Watch

Extended reading notes

Core claim

The central discovery is that inter-task reconfiguration can be made nearly free if the schedule is decided before synthesis rather than at runtime. A grid of compute cores and special function units executes tasks in one of three modes—sequential, task-pipeline, or task-parallel—selected by a stage index distributed by a global instruction reader. Each core's processing-element array, scratchpad memory, reduction unit, and data movement control reconfigure through multiplexers and loop-bound changes, with all four switching steps (read, modify, send, decode) fitting in four cycles. This design-time specialization keeps only the interconnects and control logic the schedule needs, avoiding the overhead of general coarse-grained reconfigurable arrays or dynamic partial reconfiguration. On five benchmark kernels the paper reports 7.1x over sequential and 1.8x over dataflow accelerators, and on GPT-2 medium prefill it reports 3.65-39.14x speedups over the two state-of-the-art FPGA baselines, with 1.66-7.17x power efficiency over GPUs.

Load-bearing premise

The reported speedups assume that comparing an 8-bit quantized InTAR design against FP16 baselines, with only DSP efficiency adjusted, still measures the architectural advantage of reconfiguration rather than the advantage of quantization.

Editorial extensions

If this is right

  • A single InTAR-style accelerator can execute DNNs whose intermediate tensor sizes vary by over two orders of magnitude without spilling intermediate data to off-chip memory, removing the main latency and energy cost of sequential execution.
  • Task-level reconfiguration costs only 10-20 ns, so switching modes during inference adds negligible overhead and can be triggered automatically from kernel arguments.
  • Because the design is generated with high-level synthesis and a template of compute cores plus special function units, new high-variation DNNs can be mapped to FPGAs quickly, and the same template ports across boards with different die counts.
  • For LLM input prefill, the resulting accelerator can outperform both dataflow and sequential FPGA accelerators by one to two orders of magnitude in speed and DSP efficiency, and beat GPUs in power efficiency for short sequences.

Reading between the lines

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

  • The same design-time-schedule principle could extend beyond DNNs to any high-variation streaming application, such as graph analytics or signal processing, where task dependencies and buffer capacities are known in advance; the paper mentions non-DNN high-variation applications only as future work.
  • Because switching cost is only 10-20 ns, the approach invites exploring finer-than-task or even per-layer reconfiguration, which could improve utilization further but would increase the multiplexer and control complexity the paper does not quantify.
  • The reported speedups combine architectural reconfiguration with W4A8 quantization; an orthogonal test would isolate the two by running the same quantized data type on all designs, which the paper does not do.
  • The static schedule means design-time search effort is amortized over every inference, so a more exhaustive design-space exploration than the heuristic could likely find better schedules at no runtime cost.
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 / 6 minor

Summary. The paper proposes InTAR, an FPGA accelerator design paradigm for DNN workloads with high data-volume variation (HDV) between tasks. InTAR groups computation into tasks and, at circuit design time, hardens a static schedule into the circuit that switches a grid of compute cores among sequential, task-pipelined, and task-parallel execution modes per task, with a claimed 4-cycle reconfiguration overhead. Designs are generated with HLS using stage-indexed conditional dataflow for data-movement, compute, and control reconfiguration, then placed and routed with TAPA/AutoBridge. The evaluation has two parts: (i) five multi-task HDV kernels (self-attention, FFN, multi-layer CNN, VAE, gating network) on an Alveo U280, reporting 1.8x geomean speedup over hand-optimized dataflow accelerators and 7.1x over sequential accelerators; and (ii) GPT-2 medium input prefilling on U280 and VPK180, reporting 3.65~39.14x speedup and 1.72~10.44x DSP-efficiency improvement over the Allo and DFX baselines, plus 1.66~7.17x power-efficiency improvement over GPUs. The central claim is that encoding reconfiguration schedules at circuit design time lets a single accelerator switch execution patterns per task, avoiding both dataflow pipeline stalls and off-chip traffic for intermediate data.

Significance. Significance if the headline comparisons are made fair: this is a solid and useful contribution. The paper identifies high data-volume variation as a concrete design driver, proposes a design point that avoids the generality overhead of CGRA and DPR by hardening model-specific schedules at circuit design time, and backs it with placed-and-routed implementations at 224-300 MHz with a low 4-cycle mode-switch cost. Credit is due for shipping code (https://github.com/OswaldHe/InTAR), measuring U280 latency via OpenCL profiling, implementing rather than only synthesizing the designs, and choosing the schedule by heuristic before synthesis with no sign of fitting to results; the five-kernel internal trends are consistent, and the GPT-2 medium prefill is a realistic full-model case. Two external-validity gaps separate the paper from its headline claims: the W4A8-versus-FP16 comparison with DFX (Major Comment 1) and the simulated/estimated VPK180 numbers (Major Comment 3). Both are fixable within a revision, and no circularity or fitted-free-parameter issue was found.

major comments (4)
  1. [Section VI.A, Table IV] Section VI.A, Table IV: the headline speedup over DFX is confounded by a precision mismatch. The text states that 'DFX is executed in FP16, and all other designs employ the W4A8 format. We scale the DSP efficiency for DFX to align the data type,' but only DSP efficiency is scaled, not latency. Since Allo, also W4A8, is reported at just 1.83x over DFX, a substantial part of the 14.64x (U280) and 39.14x (VPK180) speedups could come from 4-bit weight fetches, 8-bit datapaths, and reduced memory traffic rather than from inter-task reconfiguration; the 224/300 MHz InTAR frequencies versus 200 MHz for DFX add a further uncontrolled component. The abstract's '3.65~39.14x' range therefore inherits these confounds, and the GPU comparison in Section VI.B has the same issue since the GPUs run in BFloat16. Please add a W4A8 (or INT8) DFX baseline, or scale the DFX latency by a justified precision factor, or decompose the speedups into quantization, frequency, and scheduling contributions, and also report the DSP-efficiency scaling factor applied to DFX.
  2. [Section V.A, Figure 7] Section V.A, Figure 7: the core internal result, 1.8x over dataflow and 7.1x over sequential accelerators, rests on 'human-optimized dataflow and sequential accelerators, each designed in four weeks,' but the manuscript provides no architectural description, resource breakdown, or repository location for these baselines, so the comparison cannot be independently reproduced. Because the baselines are separate hand-written designs, the speedup also conflates the benefit of reconfiguration with the quality of the InTAR template itself; an ablation that fixes InTAR to a single execution mode on the same template would isolate the reconfiguration benefit. Please document the baseline architectures (or release them with the code) and add such a single-mode ablation.
  3. [Section VI.A] Section VI.A: the upper end of the reported speedup and power-efficiency range is not measured on hardware. The paper states that 'Due to a lack of access to a physical device, we employ QEMU and the Xilinx Power Design Manager to calculate the latency and estimate the power consumption of VPK180,' yet the 39.14x speedup over DFX and the 1.66~7.17x power-efficiency claims in the abstract and Section VI.B include these simulated and estimated VPK180 numbers without marking them as such. Please either label the simulated results explicitly in the headline claims or provide a measured result on a physical device.
  4. [Section III, paragraph preceding Figure 2] Section III, paragraph preceding Figure 2: three quantitative claims about prior reconfigurable accelerators appear without supporting evidence in this manuscript: '49% LUT reduction for a design with 3x throughput compared to [20] for multiple GEMMs,' a clock frequency of '2.41x that of [20],' and reconfiguration latency '106x faster than DPR [21].' No experiment in Sections V-VI measures these quantities, and Table II is only qualitative. Since these numbers are used to justify the core design point of model-specific, circuit-time-static schedules, please either add the supporting measurements or present these comparisons as qualitative expectations.
minor comments (6)
  1. [Section VI.A] The sentence 'with the same process node, INTAR on FPGAs attains higher power efficiency than GPUs' is ambiguous because the evaluated platforms span 16nm (U280), 12nm (T4), 7nm (VPK180 and A100), and 6nm (MI210); please state explicitly which comparison pairs share a process node.
  2. [Abstract and Section I] The accelerator name is rendered inconsistently across the paper (InTAR in the title and abstract, INTAR in Section I, and 'I NTAR' in several body-text passages and captions); please unify the notation.
  3. [Abstract, Section III.A] The abstract's phrase 'switches execution patterns automatically with a static schedule' reads as self-contradictory on first encounter; please clarify that switching is automatic at runtime but driven by a schedule hardened at circuit design time.
  4. [Section IV.B] Section IV.B states that 'we require the designer to manually write the reconfiguration designs based on the static schedule,' which should be reconciled with the abstract's claim of 'fast design generation' via HLS; please quantify the manual effort or qualify the claim.
  5. [Table III] Table III discloses that the on-chip memory constraints are artificial; since the Section V results rest on these constraints, please add a sentence on how representative they are of real deployment conditions (the GPT-2 study in Section VI avoids this limitation).
  6. [Section II-E, Figure 1] Section II-E and Figure 1 use V' when describing the linear projection of V without defining it; please define V' explicitly in the caption or text.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: InTAR's schedule is chosen by a stated heuristic before synthesis, and all performance claims are measured post-implementation against external or independently described baselines.

full rationale

The paper's central claim is that encoding a static inter-task reconfiguration schedule at circuit design time lets an accelerator switch between dataflow and sequential modes, reducing pipeline stalls and off-chip memory traffic. This claim is supported by a concrete design flow: Section IV.A describes a heuristic that selects execution modes based on memory constraints and task dependencies, and this schedule is fixed before circuit generation. The reported latencies and DSP efficiencies are measured after implementation using OpenCL profiling and power measurement tools, not derived from the schedule by construction. There is no fitted parameter that is later renamed as a prediction, and no equation in the paper equates the output metric to an input assumption. The comparisons against Allo and DFX use reported numbers from those prior works, which is standard external benchmarking rather than circular reasoning. Self-citations to TAPA, AutoBridge, and FlexCNN concern tooling and prior frameworks; they are not invoked as the justification for InTAR's core reconfiguration benefit, and the central evaluation does not depend on those citations for its correctness. The possible concern that DFX runs in FP16 while InTAR runs in W4A8 is a fairness or confound issue in the benchmark comparison, not a circularity in the derivation. Overall, no load-bearing step reduces to its own inputs, so the circularity score is 0.

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

The central contribution is a design paradigm, not a mathematical derivation, so the ledger here is mostly design parameters and domain assumptions. The parameters are chosen by resource-aware heuristics rather than fitted to match the reported performance, which keeps circularity low but leaves optimality unproven. The main benchmarking assumptions (precision comparability with baselines) are tracked as red flags rather than as free parameters.

free parameters (4)
  • Compute core grid dimensions (n rows, m columns) = e.g., VPK180: 4x2, U280: 3x2
    Selected per platform based on SLR layout and maximum number of tasks per stage; affects bandwidth and placement, not fit to measured latency.
  • PEA dimensions per core = Not reported numerically; chosen by DSE
    Computed to maximize utilization with limited cross-die communication; a design choice not a fitted constant.
  • Scratchpad memory size and port count = Maximum memory size required over all stages
    Set to the peak requirement of any stage; ties reconfiguration schedule to memory capacity.
  • Execution mode schedule per task = Per-application heuristic choices (e.g., Gating Network pipelines all tasks)
    Chosen by the heuristic DSE in Section IV.A; not optimized and explicitly acknowledged as not guaranteed optimal.
assumptions (4)
  • domain assumption Off-chip memory access for intermediate data dominates latency and energy in sequential FPGA execution.
    Motivates the benefit of switching to dataflow mode; Section II states sequential suffers high off-chip memory access overhead.
  • domain assumption On-chip memory capacity is the binding resource constraint that forces mode switching.
    The HDV testbench imposes memory constraints between min and max data sizes (Section V.A) to make kernels HDV.
  • domain assumption HLS conditional dataflow with if-else on stage index yields correct and efficient resource binding.
    The reconfiguration implementation in Section IV.B depends on the HLS toolset behavior, not formally verified.
  • domain assumption The five multi-task kernels and GPT-2 prefill are representative of HDV DNN workloads.
    Generalization beyond these benchmarks is claimed qualitatively; no theoretical guarantee of broad applicability.

how reviews work

0 comments
Cite this review

Pith. "Pith review of InTAR: Inter-Task Auto-Reconfigurable Accelerator Design for High Data Volume Variation in DNNs." pith.science (2026). https://pith.science/paper/L2SUI2RO

@misc{pith2026250208807,
  author       = {Pith},
  title        = {Pith review of: InTAR: Inter-Task Auto-Reconfigurable Accelerator Design for High Data Volume Variation in DNNs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/L2SUI2RO}},
  note         = {Machine review of arXiv:2502.08807}
}
abstract

The rise of deep neural networks (DNNs) has driven an increased demand for computing power and memory. Modern DNNs exhibit high data volume variation (HDV) across tasks, which poses challenges for FPGA acceleration: conventional accelerators rely on fixed execution patterns (dataflow or sequential) that can lead to pipeline stalls or necessitate frequent off-chip memory accesses. To address these challenges, we introduce the Inter-Task Auto-Reconfigurable Accelerator (InTAR), a novel accelerator design methodology for HDV applications on FPGAs. InTAR combines the high computational efficiency of sequential execution with the reduced off-chip memory overhead of dataflow execution. It switches execution patterns automatically with a static schedule determined before circuit design based on resource constraints and problem sizes. Unlike previous reconfigurable accelerators, InTAR encodes reconfiguration schedules during circuit design, allowing model-specific optimizations that allocate only the necessary logic and interconnects. Thus, InTAR achieves a high clock frequency with fewer resources and low reconfiguration time. Furthermore, InTAR supports high-level tools such as HLS for fast design generation. We implement a set of multi-task HDV DNN kernels using InTAR. Compared with dataflow and sequential accelerators, InTAR exhibits $\mathbf{1.8\times}$ and $\mathbf{7.1 \times}$ speedups correspondingly. Moreover, we extend InTAR to GPT-2 medium as a more complex example, which is $\mathbf{3.65 \sim 39.14\times}$ faster and a $\mathbf{1.72 \sim 10.44\times}$ more DSP efficient than SoTA accelerators (Allo and DFX) on FPGAs. Additionally, this design demonstrates $\mathbf{1.66 \sim 7.17\times}$ better power efficiency than GPUs. Code: https://github.com/OswaldHe/InTAR

Figures

Figures reproduced from arXiv: 2502.08807 by the authors.

Figure 1
Figure 1. Example of mapping computations of attention and linear projection of value matrix to the dataflow, sequential, hybrid accelerators, and I [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Left: Architecture template of INTAR. Compute cores (CC) compute linear operations (e.g., GEMM, ConvNet), and SFUs compute non-linear operations (e.g., softmax, GeLU). Each CC contains a scratchpad memory, a reconfigurable MAC unit array, a reduction unit, and a data movement control unit. Dashed lines indicate the candidates for connection between CCs and SFUs. Right: example architectures for each execution mode w… view at source ↗
Figure 3
Figure 3. Example of data movement reconfiguration. Left: In different stages, [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Example of compute reconfiguration. Left: The reconfigurable PEA [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Example of control reconfigurations in HLS. Left: loop-bound control. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 7
Figure 7. Figure 7: Speedup and DSP efficiency of INTAR over dataflow and sequential execution for the five multi-task kernels in the testbench. Values are normal￾ized from sequential accelerators. B. Analysis [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Left: Latency and DSP efficiency of INTAR (U280, VPK180), Allo, and DFX. Both designs of INTAR are significantly more DSP efficient. Right: Latency and power efficiency of INTAR (U280, VPK180), Allo [6], and GPU solutions for GPT-2 medium model. TABLE IV RESOURCE UTILI…

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. Reconfigurable Stream Network Architecture

    cs.AR 2024-11 conditional novelty 6.0 of 10

    A network-of-streams ISA abstraction lets a heterogeneous FPGA+AI-engine chip switch between DNN computations with minimal control overhead, achieving 6.1x lower latency and 2.4x-3.2x higher throughput than the prior ...

Reference graph

Works this paper leans on

46 extracted references · 33 canonical work pages · cited by 1 Pith paper

  1. [20]

    Overgen: Improving fpga usability through domain-specific overlay generation,

    S. Liu, J. Weng, D. Kupsh, A. Sohrabizadeh, Z. Wang, L. Guo, J. Liu, M. Zhulin, R. Mani, L. Zhang et al., “Overgen: Improving fpga usability through domain-specific overlay generation,” in 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 2022, pp. 35–56

    work page 2022

  2. [21]

    Hardware ab- stractions and hardware mechanisms to support multi-task execution on coarse-grained reconfigurable arrays,

    T. Kong, K. Koul, P. Raina, M. Horowitz, and C. Torng, “Hardware ab- stractions and hardware mechanisms to support multi-task execution on coarse-grained reconfigurable arrays,” arXiv preprint arXiv:2301.00861, 2023

    arXiv 2023

  3. [1]

    Unified language model pre-training for natural language understanding and generation,

    L. Dong, N. Yang, W. Wang, F. Wei, X. Liu, Y . Wang, J. Gao, M. Zhou, and H.-W. Hon, “Unified language model pre-training for natural language understanding and generation,” Advances in neural information processing systems , vol. 32, 2019

    2019

  4. [2]

    An image is worth 16x16 words: Transformers for image recognition at scale,

    A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly et al., “An image is worth 16x16 words: Transformers for image recognition at scale,” arXiv preprint arXiv:2010.11929 , 2020

    arXiv 2010

  5. [3]

    Llama 2: Open foundation and fine-tuned chat models,

    H. Touvron, L. Martin, K. Stone, P. Albert, A. Almahairi, Y . Babaei, N. Bashlykov, S. Batra, P. Bhargava, S. Bhosale et al. , “Llama 2: Open foundation and fine-tuned chat models,” arXiv preprint arXiv:2307.09288, 2023

    arXiv 2023

  6. [4]

    A review on large language models: Architectures, applications, taxonomies, open issues and challenges,

    M. A. K. Raiaan, M. S. H. Mukta, K. Fatema, N. M. Fahad, S. Sakib, M. M. J. Mim, J. Ahmad, M. E. Ali, and S. Azam, “A review on large language models: Architectures, applications, taxonomies, open issues and challenges,” IEEE Access, 2024

    work page 2024

  7. [5]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in neural information processing systems , vol. 30, 2017

    2017

  8. [6]

    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

Show all 46 references
  1. [7]

    Flexcnn: An end-to-end framework for composing cnn accelerators on fpga,

    S. Basalama, A. Sohrabizadeh, J. Wang, L. Guo, and J. Cong, “Flexcnn: An end-to-end framework for composing cnn accelerators on fpga,” ACM Transactions on Reconfigurable Technology and Systems , vol. 16, no. 2, pp. 1–32, 2023

    2023

  2. [8]

    Tpu v4: An optically reconfigurable supercomputer for machine learning with hardware sup- port for embeddings,

    N. Jouppi, G. Kurian, S. Li, P. Ma, R. Nagarajan, L. Nai, N. Patil, S. Subramanian, A. Swing, B. Towles et al. , “Tpu v4: An optically reconfigurable supercomputer for machine learning with hardware sup- port for embeddings,” in Proceedings of the 50th Annual International Sym...

    2023

  3. [9]

    Fet-opu: A flexible and efficient fpga-based overlay processor for transformer networks,

    Y . Bai, H. Zhou, K. Zhao, H. Wang, J. Chen, J. Yu, and K. Wang, “Fet-opu: A flexible and efficient fpga-based overlay processor for transformer networks,” in 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD) . IEEE, 2023, pp. 1–9

    2023

  4. [10]

    Hardware acceleration of fully quantized bert for efficient natural language processing,

    Z. Liu, G. Li, and J. Cheng, “Hardware acceleration of fully quantized bert for efficient natural language processing,” in 2021 Design, Automa- tion & Test in Europe Conference & Exhibition (DATE) . IEEE, 2021, pp. 513–516

    2021

  5. [11]

    Dnnexplorer: a framework for modeling and exploring a novel paradigm of fpga-based dnn accelerator,

    X. Zhang, H. Ye, J. Wang, Y . Lin, J. Xiong, W.-m. Hwu, and D. Chen, “Dnnexplorer: a framework for modeling and exploring a novel paradigm of fpga-based dnn accelerator,” in Proceedings of the 39th International Conference on Computer-Aided Design , 2020, pp. 1–9

    2020

  6. [12]

    Understanding the potential of fpga-based spatial accel- eration for large language model inference,

    H. Chen, J. Zhang, Y . Du, S. Xiang, Z. Yue, N. Zhang, Y . Cai, and Z. Zhang, “Understanding the potential of fpga-based spatial accel- eration for large language model inference,” ACM Transactions on Reconfigurable Technology and Systems , 2024

    2024

  7. [13]

    Ssr: Spatial sequential hybrid architecture for latency throughput tradeoff in transformer acceleration,

    J. Zhuang, Z. Yang, S. Ji, H. Huang, A. K. Jones, J. Hu, Y . Shi, and P. Zhou, “Ssr: Spatial sequential hybrid architecture for latency throughput tradeoff in transformer acceleration,” in Proceedings of the 2024 ACM/SIGDA International Symposium on Field Programmable Gate Arr...

    2024

  8. [14]

    Language models are unsupervised multitask learners,

    A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, I. Sutskever et al., “Language models are unsupervised multitask learners,” OpenAI blog , vol. 1, no. 8, p. 9, 2019

    2019

  9. [15]

    Deep residual learning for image recognition,

    K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2016, pp. 770–778

    2016

  10. [16]

    Aggregated residual transformations for deep neural networks,

    S. Xie, R. Girshick, P. Doll ´ar, Z. Tu, and K. He, “Aggregated residual transformations for deep neural networks,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2017, pp. 1492– 1500

    2017

  11. [17]

    Inter-layer scheduling space definition and exploration for tiled accelerators,

    J. Cai, Y . Wei, Z. Wu, S. Peng, and K. Ma, “Inter-layer scheduling space definition and exploration for tiled accelerators,” in Proceedings of the 50th Annual International Symposium on Computer Architecture , 2023, pp. 1–17

    2023

  12. [18]

    A fully pipelined and dynamically composable architecture of cgra,

    J. Cong, H. Huang, C. Ma, B. Xiao, and P. Zhou, “A fully pipelined and dynamically composable architecture of cgra,” in 2014 IEEE 22nd Annual International Symposium on Field-Programmable Custom Com- puting Machines. IEEE, 2014, pp. 9–16

    2014

  13. [19]

    A multi-neural network acceleration architecture,

    E. Baek, D. Kwon, and J. Kim, “A multi-neural network acceleration architecture,” in 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA) . IEEE, 2020, pp. 940–953

    2020

  14. [22]

    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 (TRETS), vol. 15, no. 4, pp. 1–42, 2022

    2022

  15. [23]

    Dfx: A low-latency multi-fpga appliance for accelerating transformer-based text generation,

    S. Hong, S. Moon, J. Kim, S. Lee, M. Kim, D. Lee, and J.-Y . Kim, “Dfx: A low-latency multi-fpga appliance for accelerating transformer-based text generation,” in 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 2022, pp. 616–630

    2022

  16. [24]

    Gengnn: A generic fpga framework for graph neural network acceler- ation,

    S. Abi-Karam, Y . He, R. Sarkar, L. Sathidevi, Z. Qiao, and C. Hao, “Gengnn: A generic fpga framework for graph neural network acceler- ation,” arXiv preprint arXiv:2201.08475 , 2022

    2022 arXiv

  17. [25]

    Zynqnet: An fpga-accelerated embedded convolutional neural network,

    D. Gschwend, “Zynqnet: An fpga-accelerated embedded convolutional neural network,” arXiv preprint arXiv:2005.06892 , 2020

    2005 arXiv

  18. [26]

    Flightllm: Efficient large language model inference with a complete mapping flow on fpgas,

    S. Zeng, J. Liu, G. Dai, X. Yang, T. Fu, H. Wang, W. Ma, H. Sun, S. Li, Z. Huang et al. , “Flightllm: Efficient large language model inference with a complete mapping flow on fpgas,” in Proceedings of the 2024 ACM/SIGDA International Symposium on Field Programmable Gate Arrays...

    2024

  19. [27]

    A cgra-based approach for accelerating convolutional neural networks,

    M. Tanomoto, S. Takamaeda-Yamazaki, J. Yao, and Y . Nakashima, “A cgra-based approach for accelerating convolutional neural networks,” in 2015 IEEE 9th International Symposium on Embedded Multicore/Many- core Systems-on-Chip. IEEE, 2015, pp. 73–80

    2015

  20. [28]

    Impact of fpga architecture on area and performance of cgra overlays,

    I. Taras and J. H. Anderson, “Impact of fpga architecture on area and performance of cgra overlays,” in 2019 IEEE 27th Annual Interna- tional Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE, 2019, pp. 87–95

    2019

  21. [29]

    Fpga dynamic and partial reconfiguration: A survey of architectures, methods, and applications,

    K. Vipin and S. A. Fahmy, “Fpga dynamic and partial reconfiguration: A survey of architectures, methods, and applications,” ACM Computing Surveys (CSUR), vol. 51, no. 4, pp. 1–39, 2018

    2018

  22. [30]

    Feather: A reconfigurable accelerator with data reordering support for low-cost on-chip dataflow switching,

    J. Tong, A. Itagi, P. Chatarasi, and T. Krishna, “Feather: A reconfigurable accelerator with data reordering support for low-cost on-chip dataflow switching,” in Proceedings of the 51th Annual International Symposium on Computer Architecture , ser. ISCA ’24. Argentina: Associa...

    2024

  23. [31]

    Opu: An fpga-based overlay processor for convolutional neural networks,

    Y . Yu, C. Wu, T. Zhao, K. Wang, and L. He, “Opu: An fpga-based overlay processor for convolutional neural networks,”IEEE Transactions on Very Large Scale Integration (VLSI) Systems , vol. 28, no. 1, pp. 35– 47, 2019

    2019

  24. [32]

    Light-opu: An fpga-based overlay processor for lightweight convolutional neural networks,

    Y . Yu, T. Zhao, K. Wang, and L. He, “Light-opu: An fpga-based overlay processor for lightweight convolutional neural networks,” in Proceedings of the 2020 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 2020, pp. 122–132

    2020

  25. [33]

    Deep learning with dynamic computation graphs,

    M. Looks, M. Herreshoff, D. Hutchins, and P. Norvig, “Deep learning with dynamic computation graphs,” arXiv preprint arXiv:1702.02181 , 2017

    2017 arXiv

  26. [34]

    Alveo u280 data center accelerator card data sheet

    “Alveo u280 data center accelerator card data sheet.” [Online]. Available: https://docs.xilinx.com/r/en-US/ds963-u280

  27. [35]

    Amd versal hbm series product selection guide

    “Amd versal hbm series product selection guide.” [Online]. Available: https://docs.amd.com/v/u/en-US/versal-hbm-product-selection-guide

  28. [36]

    A survey on vision transformer,

    K. Han, Y . Wang, H. Chen, X. Chen, J. Guo, Z. Liu, Y . Tang, A. Xiao, C. Xu, Y . Xuet al., “A survey on vision transformer,” IEEE transactions on pattern analysis and machine intelligence, vol. 45, no. 1, pp. 87–110, 2022

    2022

  29. [37]

    Graph attention networks,

    P. Veli ˇckovi´c, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y . Ben- gio, “Graph attention networks,” arXiv preprint arXiv:1710.10903, 2017

    2017 arXiv

  30. [38]

    Yolov3: An incremental improvement,

    A. Farhadi and J. Redmon, “Yolov3: An incremental improvement,” in Computer vision and pattern recognition , vol. 1804. Springer Berlin/Heidelberg, Germany, 2018, pp. 1–6

    2018

  31. [39]

    Vgg convolutional neural networks practical,

    A. Vedaldi and A. Zisserman, “Vgg convolutional neural networks practical,” Department of Engineering Science, University of Oxford , vol. 66, 2016

    2016

  32. [40]

    Zero-vae-gan: Generating unseen features for generalized and trans- ductive zero-shot learning,

    R. Gao, X. Hou, J. Qin, J. Chen, L. Liu, F. Zhu, Z. Zhang, and L. Shao, “Zero-vae-gan: Generating unseen features for generalized and trans- ductive zero-shot learning,” IEEE Transactions on Image Processing , vol. 29, pp. 3665–3680, 2020

    2020

  33. [41]

    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. Featherston, 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,” Int’l Symp. on Field-Programmable Gate Ar- rays...

    2018

  34. [42]

    Polybench: The polyhedral benchmark suite,

    L.-N. Pouchet et al. , “Polybench: The polyhedral benchmark suite,” URL: http://www. cs. ucla. edu/pouchet/software/polybench , vol. 437, pp. 1–1, 2012

    2012

  35. [43]

    Tapa: a scalable task-parallel dataflow programming framework for modern fpgas with co-optimization of hls and physical design,

    L. Guo, Y . Chi, J. Lau, L. Song, X. Tian, M. Khatti, W. Qiao, J. Wang, E. Ustun, Z. Fang et 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...

    2023

  36. [44]

    Fast inference of deep neural networks in FPGAs for particle physics,

    J. Duarte et al., “Fast inference of deep neural networks in FPGAs for particle physics,” JINST, vol. 13, no. 07, p. P07027, 2018

    2018

  37. [45]

    Amd versal premium series product selection guide

    “Amd versal premium series product selection guide.” [Online]. Available: https://docs.amd.com/v/u/en-US/versal-premium-psg

  38. [46]

    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 The 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 202...

    2021

Pith tools

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