Papers for

fpga hardware engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Heuristic optimization improves FPGA memory channel resource use

Heuristic-Driven Resource Optimization for Decoupled Memory Channels on FPGAs

Abstract: Determining OpenCL channel depths for Decoupled Access-Execute (DAE) architectures in High-Level Synthesis (HLS) is critical for balancing performance and hardware efficiency. Conventional static analysis tools often over-provision these memory channels to ensure performance safety, leading to significant resource stranding. This paper presents an expansion of an LLVM-based static analysis framework, originally proposed for automated DAE generation, by introducing a hardware-aware refinement layer. We identify a counter-intuitive Performance Inversion Paradox linked to baseline memory stalls, where high-stall, grid-based kernels reach peak performance at minimal channel depths and suffer up to a 61% throughput degradation when depths are increased. We propose a Heuristic Refinement Layer that optimizes OpenCL channel depths based on this correlation between baseline stalls and performance saturation. Experimental results demonstrate that our expanded framework successfully identifies the Minimal Peak Performance point across various benchmarks. By avoiding the performance traps of standard over-provisioning, we achieve a 2.52x improvement in Resource Efficiency for an illustrative HotSpot application. This approach maintains peak execution speedup while ensuring the leanest possible hardware profile, outperforming conservative tool-based static predictions.

Sun 18 OctHardware ArchitectureDistributed, Parallel, and Cluster Computing
The gist
Memory controllers on specialized chips like FPGAs need the right size channels to work well without wasting parts. The authors found that making memory channels bigger can actually slow down some programs, a surprising result they call a Performance Inversion Paradox. They created a new method that uses smart rules to choose the best channel size, balancing fast speed with less wasted hardware. Their tests showed this approach can double how efficiently resources are used while keeping top performance.
Open → 2610.25528v1

Lightweight risc-v cores boost fpga speed and efficiency

Minimum RISC-V: Maximum FPGA Efficiency

Abstract: RISC-V processors are now widely available for FPGAs, with most FPGA vendors replacing their proprietary soft-CPU architectures with this instruction-set architecture (ISA). Although contemporary FPGAs are increasingly resource- and feature-rich, a soft processor system---including memory---often occupies a disproportionately large footprint and delivers only modest performance relative to the potential of the target device. In this work we first design a lightweight but deeply pipelined RISC-V core that can run above 700 MHz in a mid-range device and that is capable of retiring one instruction per clock under ideal conditions. We then develop and demonstrate a new optimization method that compiles the final application binary and a specialized processor instance contemporaneously. The method expands each instruction into an application-specific encoding, removes unused datapath and decode logic during synthesis, and yields cores that remain assembler-compatible with the original program while no longer being binary-compatible with a general-purpose RISC-V. We implement example designs on RV32I (base integer), RV32M (integer multiply), and RV32F (single-precision floating-point) configurations. Our optimized RISC-V is as small as 170 ALMs and closes timing at 775 MHz in an Altera Agilex-5 device. Finally, we show that these processors can be packed into a deterministic area and stepped-and-repeated continuously without material impact on performance, enabling predictable multi-core density planning.

Thu 15 OctHardware Architecture
The gist
Small processors built using the RISC-V instruction set usually take up more space and run slower than they could on FPGA chips. The authors built a very small and fast RISC-V processor that runs at over 700 MHz and can handle one instruction per clock cycle when conditions are perfect. They also created a way to customize the processor to only include the parts an application really needs, making it even smaller and faster. Although these special processors still understand the original program’s assembly instructions, they aren’t compatible with all RISC-V binary files anymore. The authors tested their designs on different RISC-V configurations and showed that many of these processors could fit into an FPGA predictably without slowing down.
Open → 2610.21552v1

Spectral graph reuse speeds vision graph neural networks on FPGAs

SpecReuse: Spectral Graph Reuse for Efficient Vision GNN Inference on FPGAs

Abstract: Dynamic Image Graph Construction (DIGC) is the primary performance bottleneck in FPGA acceleration of Vision Graph Neural Networks (ViGs), reconstructing graph connectivity at every layer through irregular, memory-intensive computation. Existing FPGA accelerators optimize DIGC but still execute it unconditionally, making repeated graph reconstruction a persistent source of latency and energy consumption. We propose the SpecReuse algorithm, which computes compact spectral descriptors of intermediate features and reuses previously constructed graphs when descriptor drift remains below a calibrated threshold. We further present the SpecReuse accelerator, an FPGA architecture that realizes graph reuse through lightweight hardware for spectral descriptor extraction and reuse control while remaining compatible with existing graph-construction accelerators. Experimental results demonstrate up to a $2.69\times$ speedup in end-to-end inference and approximately 58--65\% lower energy per inference with negligible FPGA resource overhead and minimal loss in classification accuracy.

Tue 15 SeptDistributed, Parallel, and Cluster Computing
The gist
Vision graph neural networks use graphs to understand images, but rebuilding these graphs at every step slows down and drains energy from specialized chips called FPGAs. The authors created a new method called SpecReuse that checks whether the graph needs to be rebuilt by looking at a small summary of the data instead of always doing the full reconstruction. This makes the process up to 2.7 times faster and saves more than half the energy, with almost no impact on how well the network recognizes images. They also built hardware that supports this approach on FPGAs without needing much extra space.
Open → 2609.17718v1