Parameterized Hardware Generation for Scalable Accelerators

34 concepts30 papers1 proposal

Traditional hardware design treats architecture as a static blueprint. If you design a cryptographic engine or a neural network accelerator for a high-end FPGA, porting it to a low-power IoT device often requires a complete rewrite of the Register-Transfer Level (RTL) code.

Parameterized hardware generation shifts this paradigm from writing specific hardware instances to writing hardware generators.

Think of a parameterized hardware generator as a function:

$$\text{Generator}(\text{Constraints}, \text{Workload}) \longrightarrow \text{Optimized RTL}$$

Instead of hardcoding the number of processing elements, the width of data buses, or the size of on-chip caches, designers build templates with compile-time or synthesis-time "knobs." When compiled, the generator automatically instantiates the exact amount of parallelism and memory structures needed to maximize performance without exceeding the target platform's physical resource limits.


The Dimensions of Architectural Flexibility

To understand why parameterized generation works, we must first look at what can actually be parameterized. In A Formalism of DNN Accelerator Flexibility, Kao et al. formalize this adaptability across four core axes known as TOPS: Tiling (data block sizing), Order (iteration sequencing), Parallelism (spatial workload distribution), and Shape (logical processing element reconfiguration).

By exposing these dimensions as parameters, a single architectural template can adapt to wildly different deployment scenarios. For instance, De Matteis et al. demonstrate in FBLAS: Streaming Linear Algebra on FPGA how a template-based generation system can translate high-level linear algebra specifications into specialized hardware kernels simply by adjusting vectorization width and tile sizes. Similarly, Ghanathe et al. in MAFIA: Machine Learning Acceleration on FPGAs for IoT Applications leverage a library of pre-optimized hardware templates configurable via a parallelism factor to scale matrix operations for edge devices.

   [ High-Level Specification ]
                │
                ▼
   ┌─────────────────────────┐
   │   Hardware Generator    │◄─── Knobs: Vectorization Width,
   └─────────────────────────┘            Tile Size, Core Count
                │
                ├──────────────────────────────┐
                ▼                              ▼
   ┌─────────────────────────┐    ┌─────────────────────────┐
   │  Low-Power Edge Device  │    │  High-Performance Cloud │
   │  (Small Area, Low Power)│    │ (Max Parallelism/Area)  │
   └─────────────────────────┘    └─────────────────────────┘

This parameterization is particularly vital for security and cryptography. In Complete and Improved FPGA Implementation of Classic McEliece, Chen et al. show that adjusting a single compile-time parameter—the column-block width of a computation engine—allows the same underlying architecture to scale from resource-constrained embedded devices to high-performance servers, trading off silicon area for execution speed. Taking this a step further, Pan et al. introduce a framework in Finesse: An Agile Design Framework for Pairing-based Cryptography via Software/Hardware Co-Design that utilizes an abstraction layer to dynamically configure bit-width, core count, and pipeline depth to meet specific mathematical curves and security requirements.


Adapting to Physical Resource Constraints

The primary reason parameterized generation works so well for FPGA and ASIC deployments is that it automates the process of "fitting" an algorithm onto a chip's physical fabric.

When deploying a computer vision model or graph algorithm, the available hardware resources—such as Look-Up Tables (LUTs) or processing units—dictate the upper bound of performance. Bouganis et al. show in A Scalable FPGA-based Architecture for Depth Estimation in SLAM that a parameterized design allows core logic to be optimized for high-throughput on large chips or power efficiency on smaller, resource-constrained devices.

Instead of manually rewriting the pipeline when moving between chips, high-level synthesis (HLS) or hardware construction languages handle the scaling. As Wakabayashi et al. demonstrate in Nested-Pipeline Delta-Stepping Scalable FPGA Accelerator for Parallel Single-Source Shortest Path with High-Level Synthesis, parameterized scaling leverages HLS to adjust the number of parallel processing elements through configuration changes rather than manual logic redesign. This resource-aware scaling is pushed to its logical conclusion by Galimberti et al. in HLS-based acceleration of the BIKE post-quantum KEM on embedded-class heterogeneous SoCs, where different combinations of sub-operations are selectively offloaded based on the exact LUT and Flip-Flop budget of the target chip.


Tuning Memory and Dataflow to the Workload

Scaling the compute units is only half the battle; the memory hierarchy must scale alongside them to prevent the "memory wall." Parameterized templates allow memory architectures to adapt to the specific structural characteristics of a dataset or workload.

In Programmable FPGA-based Memory Controller, Wijeratne et al. show that configuring architectural parameters like cache associativity and scheduler batch sizes during the synthesis phase allows developers to balance performance against logic resource constraints. When dealing with sparse data structures, Wijeratne et al. demonstrate in Towards Programmable Memory Controller for Tensor Decomposition that adjusting cache line width, associativity, and buffer sizes during synthesis to match the specific sparsity and dimensions of a target dataset ensures that hardware resources are perfectly optimized for the data's unique shape.

On the dataflow side, He et al. in Configurable 2D-3D CNNs Accelerator for FPGA-Based Hyperspectral Imagery Classification show how parameterizing parallelization factors for tiling, unrolling, and pipelining allows a processing engine array to be reconfigured for different model requirements without altering the underlying logic.

Furthermore, parameterization can happen dynamically or be decoupled entirely from the compute logic:


Automated Design Space Exploration and Compositionality

How do we find the optimal parameters out of millions of possibilities? By combining parameterized templates with automated hardware compilers and exploration frameworks.

Dai et al. show in An Adaptable and Scalable Generator of Distributed Massive MIMO Baseband Processing Systems that using high-level hardware construction languages to create parameterized generators enables the automatic production of synthesizable RTL code in minutes. This rapid generation enables frameworks like SoC-Tuner, proposed by Chen et al. in SoC-Tuner: An Importance-guided Exploration Framework for DNN-targeting SoC Design, to automatically explore the design space by varying architectural features like cache sizes and bus widths, finding the Pareto-optimal balance between speed, power, and area without manual RTL coding.

┌──────────────────────────┐
│ Parameterized Template   │◄─── Tile Count, Interconnect, Memory Sizes
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ Automated Exploration    │───► Evaluates Performance, Area, Power
└────────────┬─────────────┘
             │ (Iterative Optimization)
             ▼
┌──────────────────────────┐
│ Optimized Architecture   │───► Synthesizable RTL
└──────────────────────────┘

To make these generators truly scalable, the underlying modules must be composable. Benz et al. solve this in A High-performance, Energy-efficient Modular DMA Engine Architecture by using standardized ready-valid handshaking between internal hardware modules. This allows components to be mixed and matched within a parametric design framework, scaling a single architecture from ultra-low-power configurations to high-performance manycore systems simply by adjusting buffer sizes and transaction limits.

Ultimately, this end-to-end automation allows frameworks like the one proposed by Tumeo et al. in SO(DA): End-to-end Generation of Specialized Reconfigurable Architectures (Invited Talk) to customize tile count, interconnect topology, and functional units to automatically generate specialized Coarse-Grained Reconfigurable Architectures (CGRAs) tailored perfectly to the target application.

Key Foundational Work

Chisel: constructing hardware in a Scala embedded language (2012) — contributed 2 concept elements to this direction.
Augmenting Platform-Based Design with Synthesis Tools (2003) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_parameterized_hardware_generation_44d2dbd7,
  title = {parameterized hardware generation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parameterized-hardware-generation/rdr_44d2dbd7dc8f4bbd86b858c423d38a4b},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_parameterized_hardware_generation_44d2dbd7_v1,
  title = {parameterized hardware generation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parameterized-hardware-generation/rdr_44d2dbd7dc8f4bbd86b858c423d38a4b/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake