WorksComputer Science
Bottom-Up FPGA Reconfigurable Accelerator Overlay Generation
Abstract
Programmable FPGA overlays run new workloads without re-synthesis, yet they pay twice. An overlay adds a second layer of programmability on top of the FPGA's own overhead. Moreover, overlay generators usually start from a regular template, so they spend logic on switches and links that the workloads never use, and they close timing at low clocks. We present a flow that instead grows an overlay bottom-up from the dataflow graphs of the workloads it must run. The flow clusters workloads by structural similarity, ranks shared slots with spectral descriptors of each operation's surroundings, and adds only the units and links a workload lacks. It builds every unit on native hard blocks, with their internal pipeline registers, dual-ported memories and double-pumped DSPs, and it uses fixed-function engines where wider data types exceed the overlay's 16-bit lanes. Workloads then switch by configuration alone. On an AMD VCK5000, across 17 workloads from three suites and against OverGen rebuilt for the same board, our images run at 250-400 MHz instead of 35-50 MHz. As a result, they are 9.52-10.33x faster in geometric mean, and up to 36.97x, while using 19.4-22.1x less of the FPGA and 9.67-10.51x less estimated board energy.
Introduction
Spatial accelerators execute computations through interconnected functional units (FUs), in contrast to the von Neumann execution model, which runs instructions from a stored program in memory. This exposes parallelism and makes data movement through the interconnects an explicit design parameter. Stream-Dataflow [83], Plasticine [90], and Spatial [56] illustrate how this can be achieved by organizing architectures and their programming models around the workload structures. However, their effectiveness depends on the match between the workload’s requirements and the available computation, communication, and storage resources.
Field-programmable gate arrays (FPGAs) offer a way to adapt these resources to a workload at a finer level of granularity, as they come with a bit-reconfigurable fabric that allows designers to specialize both computation and data movement. However, they require design either at the register-transfer-level (RTL) or via High-level synthesis (HLS). The former requires substantial engineering effort, and the latter raises the programming abstraction at the cost of searching for efficient implementation parameters [29, 30, 100]. Besides, the designed accelerator can only run the underlying workload. Thus, even the slightest change in the workload algorithm requires altering the generated hardware, which must undergo time-consuming FPGA synthesis and physical implementation. This makes design iteration costly and in-depth explorations unfeasible.
For this purpose, FPGA overlays have been introduced. An overlay is a programmable architecture implemented on the FPGA once, while a compiler only performs a fast mapping of workloads to it [19, 31, 51, 64]. It has shown effectiveness in many applications, such as neural-network and language-model inference [1, 44, 91, 115, 118], image and signal processing [8, 26], programmable packet parsing [77, 78], and privacy-preserving computation [39, 116]. Yet, it presents a central design problem: the overlay must maintain sufficient flexibility to execute workloads with as little hardware overhead as possible to preserve fast compilation and scalability.
This overhead is added on top of the fact that an FPGA already needs roughly 20–35× the area, 3–4× the delay and 14× the dynamic power of an ASIC for the same logic [59], and an overlay adds a second layer of programmability on top, often achieving a lower clock. However, architectures mapped to FPGAs can be efficiently pipelined thanks to their capable fabrics. Besides, building the overlay from the device’s hard-block primitives and leveraging their micro-architectural features, such as internal registers and native operations, helps recover much of this loss.
Architecture-generation frameworks, more generally than just FPGA overlays, address this problem through workload-driven specialization. DSAGEN [110] explores architecture description graphs, OverGen [69] specializes FPGA overlays using workload and memory information, and REVAMP refines computational and supporting resources for an application domain [9]. Other approaches specialize programmable processor families, streaming custom instructions, or dataflow templates [18, 30, 34, 36, 37, 75, 102], with static and profile-guided analysis helping automate architectural choices [74]. However, each search is expressed through a chosen representation, a set of legal transformations, and an initial hardware organization that is not necessarily efficient. These choices determine the cost and selection of the architecture being searched. For instance, a central problem is that many frameworks start from a rectangular-shaped hardware layout and optimize for workloads’ DFGs that generally come in a converging/reduction shape. This makes optimizing these architectures to fit workload requirements compound a non-matching layout. They also overlook two FPGA-specific axes. The first is that FUs and how well they map onto hard blocks set the upper bound on clock frequency and, hence, on throughput. The second is the routing between them, which sets a lower bound on area, with a double effect: the overlay’s reconfigurable switches require multiplexers and crossbars built from logic, and the FPGA itself spends a large share of its area connecting that logic [59].
A complementary direction constructs shared hardware from workload graphs. RADISH and APEX generate configurable computational structures from application graphs [79, 80, 111]. AS-Overlays mines recurring graph patterns across applications to specialize processing-element cores within a retained interconnect organization [76]. DeCO further demonstrates that a DSP-based overlay can be shaped around the stage-wise requirements of workload DFGs rather than a uniform rectangular hardware organization [49]. These results motivate a more specific question: how should workloads be clustered, corresponding operations identified, and shared hardware constructed when the implementation must respect the capabilities and execution constraints of native FPGA resources, in both compute and routing? To address this multi-level question, we introduce a bottom-up overlay generation flow.
The first issue therefore is deciding which workloads should share an overlay. An application domain or benchmark suite label does not specify the structure of a DFG. For example, two workloads from the experiments, fir and fft can both be classified as signal processing despite their different dependency patterns. The workloads considered in § 5 contain such differences. To solve this issue, we address the extraction of structural descriptors using workload similarity clustering so that workload clustering depends on shared operations instead of semantic labels alone.
The second issue is the construction of the shared architecture overlay. This architecture should be based on what operations the workloads need and what their interconnection patterns looks like, neighbor-to-neighbor and beyond. This guarantees that the end result will not just approximate what compute, interconnect, and memory components are needed in isolation. Instead, these should help grow the architecture by adding components in patterns, based on an analysis of each workload’s requirements. For this, our flow uses spectral graph analysis to guide the growth process based on detected patterns that connect operations. The spectral analysis helps provide information about an operation’s structural context beyond its neighborhood. Thus, the architecture grows by reusing compatible resources and adding resources or connections when the selected correspondence cannot accommodate a workload. Therefore, the interconnect grows only where the workloads need it, which addresses the routing axis.
The third issue is realizing this graph efficiently on the FPGA. Conventionally, arithmetic operations are assigned to digital signal processing (DSP) hard blocks, and arrays to hard block memories (BRAMs/URAMs). These hard blocks are optimized for these purposes and are much more efficient than the general-purpose resources of an FPGA. However, synthesizing operators to these blocks does not necessarily capture their full micro-architectural features or constraints. Prior work exploited native DSP operations, internal pipelining, and runtime sharing, blocks cascading and DSP-memory organization, and programmable computation around distributed memory blocks [11, 22, 48, 49, 50, 51, 54, 85, 92, 93, 96]. Our flow makes supported operations, timing, and storage interfaces explicit through native templates, and memory and streaming plans. It also leverages the AMD Versal hard blocks as they provide more capabilities than previous generations [3, 4].
Our flow combines these solutions in the automatic flow shown in Figure 1. An MLIR-assisted frontend prepares programs for workload DFG extraction used for workload clustering and architecture overlay construction. Each cluster defines the workloads that will share an overlay, and the spectral analysis guides the overlay’s growth in compute, memory, and interconnect. We build the overlay using operations supported by FPGA hard blocks and account for memory layout and pipeline timing. These choices guide RTL generation and the configurations used to run each workload. The resulting overlay can execute the corresponding cluster of workloads using their generated configurations, as well as unseen workloads whose DFGs are subsets of those in the cluster. This allows workload changes without having to repeat FPGA synthesis and physical implementation. The resulting image runs each clustered workload as a mode selected by its configuration.

Figure 1. Overview of our flow: group, grow, map to hard blocks, and switch modes.
To summarize, our contributions are as follows:
A workload-clustering method based on structure similarity rather than domain and benchmark-suite labels.
An architecture overlay growth method based on spectral analysis that constructs shared computation and connectivity using the computational and memory patterns present in the workload clusters.
Native hard block resource templates and explicit storage and execution descriptions that leverage the micro-architectural features to allow programmable operators, pipelining, and memory interfacing.
An MLIR-assisted prototype and evaluation framework that distinguishes architecture construction, workload configuration, and implementation variants.
We evaluate our flow against OverGen [69], checking every output word-for-word. We demonstrate that our images are 9.52× faster in geometric mean with one image per suite and 10.33× with similarity clusters, while using 19.4–22.1× less fabric and 9.67–10.51× less estimated board energy.
Background
In this section, we introduce the concepts used by our flow. The first is the native FPGA resources that make an overlay both programmable and fast. The second is the similarity measure that decides which workloads share an overlay. The third is the spectral analysis that reveals the structure each cluster’s overlay must provide.
FPGA Resources and Implementation
An FPGA combines general-purpose configurable logic, such as lookup tables (LUTs) and flip-flops (FFs), hard blocks, such as digital signal processing (DSP) blocks for arithmetic and block RAMs/UltraRAMs (BRAMs/URAMs), and programmable routing resources to implement an accelerator design.
The hard blocks can run in many modes and can be pipelined through internal registers to enable higher clock rates. For instance, a DSP can run different arithmetic operations on different data types [3], and a BRAM/URAM can store data in different sizes and organize its read and write scheme in several ways [4]. These modes can be configured at runtime, enabling overlay programmability.
On the other hand, communication with external memory can add latency. For this, a burst transfers a contiguous block of words in a single request to reduce the communication overhead. The data can also be reused, which increases latency if not kept on-chip. For this, a scratchpad memory block holds explicitly loaded data on-chip.
Using these resources requires significant engineering effort to design the accelerator in RTL and a time-consuming hardware implementation. HLS and hardware-oriented languages automate part of the translation from a higher-level description, but the resulting hardware still requires the time-consuming implementation [56, 100]. Therefore, A change to the datapath or its pipeline structure is expensive. Overlays address this cost by implementing a reusable programmable architecture.
FPGA Overlays and Workload Mapping
An overlay implements a programmable architecture on the FPGA. Typically, it is composed of configurable functional units (FUs), storage, and selectable connections. Mapping a workload assigns its operations to compatible units and arranges the movement using these overlay components without having to handle the low-level FPGA bit-configurable components [48, 69].
This creates two levels of configuration. The FPGA image establishes the hardware, including its available functional units, routing structures, and primitive attributes. A workload configuration selects functions and paths within that hardware, as illustrated in Figure 2. For example, the shared compute graph in Figure 1 can support a reduction or a chain by changing operation and operand selections. In our current native generator, configurations for the selected workloads are incorporated during hardware construction, and invocation selects one of those workload modes.

Figure 2. Our deployment flow.
The benefit of reusing an overlay depends on the cost of the flexibility it contains. Supporting another workload may require an additional operation, a new operand source, more storage, or a different memory interface. Each such requirement can increase the resources or control needed by the overlay. Conversely, compatible workloads may share much of their implementation. Therefore, the workload set should be selected before constructing the overlay architecture. Thus, the clustering method must identify useful opportunities for sharing based on the workloads’ compute and memory access patterns.
Comparing DFGs with Cosine Similarity
In order to cluster workloads based on their compute and memory access patterns. A workload’s DFG describes both the operations it needs and the dependencies between them. When considering workloads for a common overlay, we first compare their computational requirements. This identifies workloads with similar demands for operation types before examining how they are connected. Figure 3 shows two DFGs that compute and . The path graph produces , while the reuse graph produces . Both require the same operators but differ in dependencies.
Figure 3. DFGs of path and reuse workloads.
We represent a workload by a feature vector , where each coordinate counts a particular property across all workloads. For instance, for a vector containing only multiplication and addition counts results in the two graphs having . To detect this similarity, we define the cosine similarity as
where measures how much the vectors differ and . For nonnegative features, a score of means that the vectors have the same feature proportions. A score of means that they have no nonzero coordinates in common. For instance, the and vectors have similarity . Thus, the comparison helps distinguish workloads with similar components from those with differing ones. This helps cluster workloads that guide an overlay construction.
Generally, our flow also includes resource-kind and dependency features in its vectors, as described in § 3.4. Such features capture aggregate interaction patterns. However, they still represent the overall workload and do not convey information about the interactions that occur. Thus, feature similarity is used to cluster similar workloads. Once a cluster is created, we use spectral analysis to describe individual operations and their surroundings. This enables distinguishing between two decisions: which workloads to cluster together and what patterns should be present for workloads within one cluster to be represented.
Graph Signals and Fourier Analysis
The operator count does not describe the extra connection in . Therefore, the operation’s neighbourhood should be analyzed. For this, we tag vertex properties (such as the type of operation), propagate the tags through graph connections using the heat diffusion model [28], and record the resulting values at each vertex. Applying the model at several scales captures local and broader interaction patterns. The graph Fourier transform (GFT) expresses these interactions in terms of patterns [97]. For this, we use graph signals that assign a numerical value to each vertex to describe a property. For instance, an addition tag assigns one at the addition vertex and zero at the others. Thus, in vertex order , both and in Figure 3 graphs have the same initial signal .
For this example, we keep the compute connections and treat them as undirected during analysis. This gives a three-vertex path for and a triangle for . The adjacency matrix of an analysis graph with vertices has when vertices and are connected and zero otherwise. This means that because the analysis graph is undirected. As the degree of a vertex is its number of neighbours, we also use the degree matrix , which places these counts on its diagonal and has zero entries elsewhere, so . This leads to the combinatorial Laplacian that expresses the local differences. Its action on a signal at vertex is .
has vertex degrees . Adding the reuse edge between and in gives every vertex degree two. The corresponding Laplacians are as in Eq. (2). This added connection changes the matrix even though the operation-count vector and initial addition tag are unchanged.
Although very similar, the two graphs allow propagating values differently. To extract the propagation patterns, we express the signal as a combination of patterns associated with these connections. Since is symmetric, its eigenvectors can be chosen orthogonal and of unit length. An eigenvector satisfies , so applying to the pattern is equivalent to scaling it by . Collecting the eigenvectors as the columns of gives and , where is diagonal and contains the nonnegative eigenvalues . These patterns form a basis for the vertex signal components [42]. Figure 4 shows ’s constant pattern , unit-varying pattern , and middle-versus-endpoints pattern .

Figure 4. Fourier modes and addition tags after applying the heat diffusion model.
Besides, the eigenvalue measures how much a pattern varies across connected vertices. ’s three patterns have eigenvalues , , and . This means that the constant pattern has no variation across edges, while the other patterns vary increasingly strongly.
In order to determine how much each pattern contributes to the tag signal, the GFT is used , and its inverse reconstructs the signal. Each coefficient is the contribution of pattern [97]. For the addition tag on the DFG, . This means that all three patterns have contributions.
The heat diffusion model propagates this property (i.e. the addition) by attenuating each coefficient and reconstructing the vertex values:
Coefficient is multiplied by , so patterns with greater variation are attenuated more strongly. This reduces the signal’s overall variation across edges as information about the addition propagates through the graph.
At the illustrative scale , the path’s components at and are attenuated by and , respectively. Reconstruction gives . This means that the first multiplication receives less of the addition tag than the second because it is separated from the addition by another operation.
For the graph, the same eigenvectors form a valid basis, but their eigenvalues are , , and . Thus, the extra edge changes the attenuation of from to at the same scale. Applying the model to the same initial tag gives . The two multiplication vertices now receive equal values because both connect directly to the addition and occupy symmetric positions in this undirected analysis graph. Figure 4 shows how the additional connection changes the neighbourhood description at , although its operation type and the overall operation count remain the same.
Repeating the calculation for different vertex properties and diffusion scales produces a description of each vertex’s surroundings. Smaller scales keep more local detail, while larger scales mix information over broader parts of the graph [42, 97]. We use these reconstructed vertex values as descriptors.
The example shows how connectivity affects the tags that are propagated. For architecture construction, our flow uses tags for compatible resource kinds and labelled input and output ports, as described in § 3.5.1. This representation preserves the roles and operand positions required by the generator.
Overlay Generation
Our flow clusters workloads with similar structure, maps their operations onto shared hardware, and adds the required connections. Figure 5 draws the same workload (bgr2grey § 5) on both overlays. OverGen [69] routes it through 22 of its 35 switches and 65 of its 349 links, whereas our overlay uses 16 of its 43 links and 6 of its 8 selectors. This shows that not only does our flow grow the necessary FUs and links based on the workload, but it also does the same for switching/operand-selection, which has been demonstrated to consume a lot of the FPGA fabric [19, 73, 106]. The overlay is programmed by selecting the FU operations and operand-selector paths. This eliminates a lot of unneeded logic across the whole workloads’ set (§5.5) and shrinks the time-to-run (§5.7).

Figure 5. OverGen (a) vs. our overlay (b), one mode in bold.
| Unit | Operations | Result |
| i16×4 FU | MADD, MUL, ADD, SUB AND, OR, XOR, PASS | , , , mod bitwise; |
| i16×4 fixed-op | MAX, DIV HSUM, JOIN | signed max ; trunc lane sums; packed low halves |
| i64 engines | ADD, MUL, LT | , mod ; signed |
| f64 FP cores | ADD, SUB, MUL, DIV, SQRT | each rounded to nearest even |
| f32 FP cores | ADD, SUB, MUL, NEG | rounded; exact |
Table 1. Operations by data type.
Supported Graphs and Execution Model
Here, we define the terminology, the supported graph representation, and the execution model.
A workload is a finite directed acyclic graph . Vertices specify operations; an edge supplies the result of to operand of . Memory vertices name bounded arrays and their accesses. A frame evaluates this graph once; a run executes a bounded sequence of frames. This form expresses the control.
An overlay contains hardware slots and connections of an architecture . A slot’s kind specifies the operations it supports. The mapping is injective: each workload uses a different slot for each vertex, while different workloads may share slots. We call one implemented FPGA design an image, which holds a single overlay. Producing it requires synthesis and physical implementation. Each workload the overlay supports is a mode of that image, selected at runtime by writing its configuration, the FU operations, operand selectors and memory bindings, into control registers. Thus, switching workloads costs a register write, whereas supporting a workload outside the image requires reimplementation, i.e., a new image.
Functional Units from Native DSP Paths
Our general FUs drive four Versal DSP58s [3] with one opcode, treating a 64-bit word as four 16-bit lanes. Each block pairs a signed multiplier with a 58-bit arithmetic unit as shown in Figure 6; its operation is chosen at runtime, whereas the mode (integer, floating-point) and pipeline are chosen at design time. For wider types, dedicated units are used instead: a 64-bit integer product is built from three 32-bit ones, and 32- and 64-bit floating-point runs on vendor IP built from DSP58s in integer mode. Besides programmable FUs, a grown overlay may contain fixed-op units, each performing one operation the FU does not provide, such as division by a constant or a signed maximum.

Figure 6. DSP58 [3] pipeline registers and double pumping.
In most designs, DSP blocks can run at twice the clock rate of the surrounding fabric logic [94], leaving them idle for part of each clock period. For this, our flow enables double pumping, which runs DSP at twice the logic clock frequency, doubling the work per cycle. As Figure 6 shows, an in-kernel mixed-mode clock manager (MMCM) [2] generates that clock, so two lanes share one DSP.
Memory Semantics and Physical Allocation
Each array has a fixed size in 64-bit words, and a word holds one 64-bit integer or float, two 32-bit floats, or four 16-bit integers. Most follow affine access, in which a frame advances by a fixed stride from a starting offset. Gather and scatter accesses instead point directly to a whole word. The affine writers that share an output are checked to ensure they never collide. In addition, reads and writes keep program order, and unwritten outputs stay zero.
The words are stored in banked memory components, with consecutive words mapped to consecutive banks. Each pass across the banks fills the next row, and a bank that outgrows one memory block stacks another memory block. The compiler tries banking over banks, favoring the least memory, then the fewest rounds lost to bank conflicts, then the fewest blocks and banks. In addition, compatible arrays that never overlap in the same storage. Figure 7 shows the native memory types [4] and a window that keeps words for reuse; its overlap depends on the executor.

Figure 7. Native memory using RAMB36E5/URAM288E5 [4].
Like DSPs (§ 3.2), BRAM and UltraRAM can run faster than the surrounding logic clock. For this, our flow can enable dual-porting, which uses both ports of each BRAM and UltraRAM to serve two accesses per bank per cycle instead of one, and double pumping doubles this to four accesses per bank per cycle.
Structural Workload clustering
Our flow clusters workloads by cosine similarity (§ 2.3), so that each cluster tends to need the same units and interactions. The feature vectors count opcodes, slot kinds and arities, directed connections by operand port, and graph size and depth (Table 2).
| Family | Counts |
| Operations | Each opcode. |
| Kinds | Each FU, memory, constant or specialised kind. |
| #Ops. | Operations by operand count (e.g. 1 for PASS, 2 for ADD, 3 for MADD). |
| Edges | Each class : source kind, destination kind, operand port. |
| Shape | Vertices, edges, DAG depth and maximum fan-out. |
Table 2. Features of the native workload descriptor.
Each workload starts in its own cluster. The candidates are the 32 most similar pairs plus each workload’s three nearest neighbors. We visit candidates in descending similarity. For a pair , let and be the clusters currently holding the two workloads, and
the cost of an overlay supporting every workload in . The merged cluster has at most four workloads and costs less than the two clusters separately
For native workloads, each proposed cluster gets one trial architecture , built by the neighbor-count method of § 3.5.2, and , the heuristic score of Eq. (6). A final pass assigns each remaining workload to its remaining neighbors, in the same order and under the same test.
Spectral Matching and Incremental Growth
Once workloads are clustered, each cluster’s overlay is grown one workload at a time. For that, we study how each operation is described by its surroundings and then match it to an existing overlay slot or grow a new one.
Spectral Descriptors with Operand Roles
After clustering workloads, operation matching is performed to determine which
slots and kinds (as defined in § 3.1) are required for the overlay. In practice, a slot’s kind is fixed at design time, for example, an FU in a given DSP mode, while the operation it performs is chosen per workload mode at runtime. Matching needs to describe how operations connect. Figure 8 illustrates how matching expands each operation into a centre vertex and one vertex per port, and each dependency into a vertex that records its word format. After that, we deduce distinct tags (as defined in § 2.4) that identify resource kinds, port roles, and word formats on the expanded graph .

Figure 8. Port expansion of one DFG edge preserves endpoint roles and operand positions in an undirected graph.
To capture how interaction patterns are represented in the graphs, we use spectral analysis (§ 2.4). We treat each tag as a heat source that diffuses along its edges [42, 97] (Section 2.4). With the matrix marking each vertex’s tag and the Laplacian of the expanded graph, the heat after time is
The row of at an operation describes the diffused heat of tags that has reached it: at it comes mostly from and its own ports, and by it reflects the operations around it. Reading it at gives a fingerprint of its surroundings at three distances (Figure 9a). The same construction gives for each slot of the overlay architecture .

Figure 9. Diffusion fingerprints (a), incremental assign. (b).
The cost of placing in an existing slot is the difference between their neighbor counts, which estimates the connections added or left unused. This quantity is increased by , where is the mean squared difference between and , and . Adding the nudges the selection towards considering far neighboring patterns and not only neighboring connections during the selection. In addition, the factor is picked so that , so that it stays below the equivalent of one connection. This matching method selects only from slots whose wiring fits equally well, favoring the one whose surroundings most closely resemble ’s. This is enhanced by the incremental assignment discussed in § 3.5.2.
Incremental Assignment and Graph Growth
Another descriptor counts ’s incoming and outgoing edges separately by the neighbor’s kind and the destination operand port. Thus, we define as the distance for a slot on . The candidates are the existing slots, plus one new slot for each vertex of . A vertex of kind takes an existing slot of the same kind at cost:
, or a new slot at the cost:
, where is 64 for a constant, 1024 for an FU, 4096 for a URAM load and 2048 for any other kind. Each cost also receives a random offset below , so that equal costs maintain the same order in every run. Finally, the Hungarian assignment method [58] finds the injective, compatible mapping that minimizes (Figure 9b). Unused new slots are removed, and the connections become .
Candidate Selection
Once all workloads are mapped, the architecture is scored as a whole, including storage and connections. Let and count compute and constant slots, and and the planned BRAM and URAM blocks, sized for at most 512 frames per mode and taking each resource’s maximum across modes. In the connection union, counts the distinct sources of operand of slot , and the distinct slot–port pairs that drives. The terms
estimate result-register bits (the store and scatter slots hold no result), multiplexer bits, multiplexer depth (zero when empty) and fanout beyond four. Under spectral construction, two candidates compete. Each builds the architecture by adding workloads one at a time. The first uses the order in which the workloads were given to the flow, while the second uses a shuffled order. Since workloads are treated one at a time, this can lead to different architectures. Each candidate is then augmented by moving an operation to a new slot, to one of up to eight slots of its kind that its workload does not use, or by swapping with a same-kind operation of its workload. The selected candidate is the one that lowers in Eq. (6).
The Automatic Flow
Our flow compiles supported programs into a graph-based overlay and separately builds architectures from fixed-function engines or micro-programs. An engine is an RTL implementation with its own controller; a microprogram lists memory and arithmetic operations for an executor. These inputs follow distinct paths in Figure 10.

Figure 10. Compiler and system-generation flow.
Source Normalization and Graph Extraction
Our front end builds on MLIR, using its built-in families of intermediate representation (IR) called dialects and types [61, 71]. ClangIR lifts C into MLIR [70], and a restricted adapter rewrites it into the dialects of Table 3. The result is enhanced by promoting local storage to values, simplifying operations and removing repeated expressions [72]. Then, an extractor emits the finalized DFGs, which are clustered, matched and grown into an overlay (§ 3.4–§ 3.5) or lowered into typed pipelines (§ 4.2).
| Stage | Main operation and output |
| Compiler-generated compute | |
| Frontend | Translate supported C to CIR, then normalize it in MLIR. |
| DFG admission | Validate extracted source DFGs or supplied native graphs, including memory interfaces. |
| Native growth | Construct and verify shared native graphs; emit programmable RTL, modes, and memory bindings. |
| Typed lowering | Share compatible fixed-operation units and align data, mode, and valid signals. |
| Storage | Emit declared RAMs, FIFOs, and delays; optionally buffer the typed compute input. |
| System generation | |
| Workload set | Use supplied membership or group typed workload records by similarity and estimated cost. |
| Backends | Compose supplied engines, derive program issue tables, or generate restricted graph overlap and queues. |
| Memory wrapper | Add burst transfers, FIFOs, and scratchpad storage with sequential load, compute, and store phases. |
| Checks and build | Run path-specific functional and RTL checks, then implement modules or images and report timing and resources. |
Table 3. Compiler and system-generation stages.
The frontend accepts a single-block function with one result and one to eight arguments of the supported types (§ 3.2), turning each argument and the result into a stream. Unsupported control flow, calls, pointers, types and conversions are rejected. C leaves signed overflow undefined, so we give no guarantee for programs whose signed arithmetic overflows, even though our hardware simply keeps the low bits. The C frontend reads data only through its arguments and writes only its result. Besides, any other memory access must be expressed as an explicit DFG.
Architecture Construction and Lowering
This stage turns graphs into RTL along one of two paths. The native path builds a programmable overlay that several workloads share by switching modes at runtime, which requires every unit to work on a common word format, namely four 16-bit lanes. Graphs with other types take the typed path, trading sharing for a fixed pipeline built around the graph’s own types. In this case, workloads can share fixed operators if they satisfy the rules of § 3.2.
On the native path, the generator constructs the overlay as in § 3: it emits the matched units, operand selectors, connections, and memory bindings. Then it loads every FU in the selected mode, which remains fixed until the run ends.
On the typed path, the generator instead lowers each graph to a fixed pipeline of operators on scalar or 4-lane i8, i32 or f32 values. Before lowering, a rewrite turns four signed-byte products of the same two input vectors, summed by an i32 adder tree, into a single dot-product unit, which two cascaded DSP blocks compute natively [3].
Pipeline Latency and Execution Control
Each DSP and BRAM contains optional internal registers, such as the ones in Figure 6. Enabling them shortens the clock period. The price is latency. Each enabled register delays the arrival by one cycle; thus, operands of the same operation must still arrive in the same cycle.
The native path keeps the registers enabled and lets a controller absorb their latency. Its reference controller issues an operation once its predecessors have completed and its PE can accept operands. The results stay available until consumed, and frames run one after another. Figure 11(a) shows the capture and completion steps this adds around the three native stages of a DSP block.

Figure 11. Reference-controller timing (a), op. pipelining (b)
The typed pipeline hides latency entirely by planning arrivals in advance and accepting new work each cycle. It passes tokens, each carrying one invocation’s arguments and mode, with all inputs entering at stage zero. This also means that an operation waits for its slowest operand, and each faster operand is delayed by the difference in their arrival times. Figure 11(b) illustrates the alignment.
A result leaves the pipeline as soon as the next stage is ready to accept it. If it is busy, a shared enable signal freezes the whole pipeline until it is ready. Otherwise, a new token enters every cycle.
Explicit Storage and FIFO Composition
A pipeline that accepts a token every cycle is only as fast as the data that feeds it. However, access to external memory is slow. Therefore, storage is declared explicitly in the source, and the generator builds each buffer from BRAM/URAM memory primitives with known timing [5]. A static one-dimensional array declaration selects a FIFO, RAM, or delay line, and the computation may not access the array in any other way. Reads return after one cycle from a FIFO, two from a BRAM, and three from a URAM. Delay lines share the pipeline’s enable, and reset clears their valid bits.
The data source and the pipeline rarely run in step, so an optional FIFO buffers it at the input. The data is written whenever it is available and read whenever the pipeline can accept a token. Each FIFO word holds all the arguments of one invocation, so a single read supplies a complete token. The FIFO delivers each value one cycle after it is requested and keeps it visible for only that cycle. If the pipeline is stalled in that cycle, the value would be lost, so the adapter holds it until the pipeline takes it and only then requests the next one. This preserves all values but can slow the input to below one token per cycle.
Bulk Transfers and Pipelined Memory
Off-chip memory is mostly the slowest component in a design. A DDR round trip costs tens of cycles, and an engine that waits for each reply before issuing the next spends most of its time idle. The memory-wrapper generator removes that wait by staging each kernel’s data on-chip. From an existing build, it records memory addresses and its array layouts, it derives per-mode transfer regions: address ranges copied through a private URAM scratchpad. Each run then proceeds in three phases, a bulk load, the computation and a bulk store (Figure 12), with loads moving up to 256 words per burst and keeping up to 16 requests in flight.

Figure 12. Memory phases around one scratchpad.
During the computation, the engines no longer see DDR at all. The scratchpad accepts a request every cycle and returns replies in order, so an engine can keep issuing while earlier requests are pending, provided it respects the dependencies between them. FIFOs absorb stalls within each phase. Beyond hiding latency, staging turns scattered accesses into large transfers and keeps reused data close to the compute.
Execution Backends and Local Reuse
The bottlenecks of workloads are different. Some are shaped by irregular loops and data reuse, some by long floating-point latencies, and some by the cost of running one frame at a time. No single way to execute operations serves them all, so the flow offers several backends. Each specifies how operations execute and how they access memory. The grown overlay works on 16-bit lanes, so for workloads that need 64-bit or floating-point types, its compute is replaced by fixed-function engines or a micro-programmed executor, while the image around them grows in the same way. All three below are distinct from the typed static pipeline.
Fixed-Function Engines
A fixed-function engine is hand-written RTL for one workload, with its loop schedule and data reuse built in. Re-deriving these from C would only lose quality, so system generation takes such engines as they are.
Micro-Programmed Executor
Floating-point operators take many cycles, so a single loop iteration would leave them idle most of the time. This backend fills that time by interleaving up to 16 independent iterations, each keeping its own context of 16 registers, while operands shared by the group load only once. Loads, multiplication/division, and addition are issued on separate paths. Each path keeps its own order and issues one operation per cycle once its operands and unit are ready. A value with one writer and one reader can pass straight through a result queue, and multiplication and addition are rounded separately.
The generator derives the issue tables from the microprograms, while each workload keeps its own loop controller. A register-readiness table is checked one cycle ahead and corrected for writes landing in the current cycle. Besides, memory hazards are respected. A load never passes an earlier store to the same element (RAW), a store never passes the load of its own element (WAR), and stores to the same element keep their order (WAW); only stores to different elements may reorder.
Grown-Overlay Execution
The reference controller of § 4.3 finishes one frame before starting the next, leaving much of the graph idle. This executor allows successive frames to overlap while respecting strict rules. In active mode, every node fires exactly once per frame and consumes its operands, and every value has exactly one consumer. Under these rules, operands and load responses arrive in frame order, so frames remain separate without tagging each value, and queues hold values as producers and consumers drift apart.
Experimental Results
We compare our flow with OverGen [69] on Versal, using common inputs and reference outputs. We measure speedup, resource usage, image-generation cost, clustering effects, and energy consumption.
Experimental Setup
All designs use a VCK5000/Versal VC1902 [3], Vitis/Vivado 2022.1, and the same platform shell with one DDR channel. We evaluate 17 of OverGen’s 19 workloads: five MachSuite, five DSP, and seven Vision workloads. We omit derivative and convert-bit from the Vision suite: the released OverGen compiler fails on both, and the released derivative source does not match the published dimensions and channel layout.
| Suite | Workload | Type | Input size | Cluster | OverGen |
| MachSuite | stencil-3d | i64 | ( interior) | , 50 | |
| MachSuite | stencil-2d | i64 | , 3×3 filter | , 50 | |
| MachSuite | gemm | i64 | matrices | , 50 | |
| MachSuite | crs | f64 | 494 rows, 1,638 nonzeros | , 50 | |
| MachSuite | ellpack | f64 | 494 rows × 4 slots | , 50 | |
| DSP | cholesky | f64 | matrix | , 36 | |
| DSP | fft | c-f32 | 4,096 points | , 36 | |
| DSP | fir | f64 | 1,024 samples, 199 taps | , 36 | |
| DSP | solver | f64 | matrix, 48 vector | , 36 | |
| DSP | mm | f64 | matrices | , 36 | |
| Vision | acc-sqr | i16x4 | , 35 | ||
| Vision | acc-weight | i16x4 | , 35 | ||
| Vision | accumulate | i16x4 | , 35 | ||
| Vision | bgr2grey | i16x4 | , 35 | ||
| Vision | blur | i16x4 | , 35 | ||
| Vision | channel-ext | i16p6 | , 35 | ||
| Vision | vecmax | i16x4 | , 35 |
Table 4. Evaluated workloads and their OverGen baselines.
c-f32: complex f32; Packed. Cl.: cluster. : released/generated overlay with cores, at the programmed clock in MHz.
We evaluate nine cluster images. Three suite cluster images are defined by the suite name, and six cluster images are defined by the resulting cosine similarity clustering. Within an image, switching modes selects the workload. Every image grows from its workloads’ DFGs, adding components only as they are needed and sharing what the workloads have in common. For Vision, these components are FUs and connections. MachSuite and DSP need 64-bit and floating-point types that the 16-bit fabric does not express, so their compute is replaced by coarser components, a fixed-function engine per MachSuite workload and a shared micro-programmed executor for DSP (§ 4.6), while each cluster still shares one copy of every floating-point core and one memory system. Together they exercise the mechanisms of § 4. The typed static pipeline is validated separately.
For the measurements, we run one warm-up and five timed invocations, checking every output, and we report the medians. The speedup is defined as OverGen’s median time over ours, and aggregates are the geometric means across all 17 workloads, weighted equally.
Constructing the OverGen Baseline
OverGen’s artifact targets another board and toolchain, so quoting its paper numbers would compare different hardware; we instead rebuilt it on the VCK5000, aiming for its best performance. This took three kinds of repair. Toolchain: we reconstructed the build environment, reconciled architecture-description formats, and compiled with deterministic, routing-checked mappings. Hardware: we rebuilt missing queues, memories and floating-point blocks, coordinated operand handshakes, and replaced the original board’s hard-wired capacities and interfaces. Generated overlays also needed fixes to backpressure, indirect accesses, port numbering, vector widths, switch paths and accumulator and output selection, and the searched 5-core MachSuite design, too large for the device, became a 3-core one. Workloads: we corrected initialization, timing, work partitioning and unsupported source constructs. Every retained result matches the reference word for word, and each workload uses the fastest correct median.
Execution Performance
Suite images run faster than OverGen in geometric mean and similarity cluster images , and all 17 workloads are faster under both, by – and – respectively (Figure 13). Similarity clustering helps DSP the most, lifting it from to , because only the smaller DSP similarity-cluster images close timing with double pumping (§ 3.3). solver is the exception, as each step waits for the previous one, so the extra multiplier throughput is unused, and the 250 MHz core clock used as the slow clock in double pumping makes it 27% slower.

Figure 13. Speedup over the correct OverGen configuration.
Effects of Workload Clustering
Clustering mostly preserves workload cycle count. Each cluster image runs its workloads for the same number of cycles as the suite image, to within 0.13%. However, before dual-porting, clustering enabled two Vision cluster images to close timing at 359 and 400 MHz, compared to 321 MHz for the suite image, which made Vision faster and all workloads faster. Dual porting then raised the Vision suite image to 360 MHz, which narrowed the gains to . Double-pumping also hid the clustering effect, as only the DSP cluster images close timing at twice the clock, and the frequencies of cluster images were reduced to 250 MHz to close timing. This means that clustering can benefit designs that double-pumping and dual-porting may not improve.
Resource Consumption
Routed compute-unit counts cover execution, storage, control and transfer logic. We evaluate the board resource usage of our images and OverGen on the benchmark suite. We do not show the breakdown per component due to space limits. The gap is large, with our images using 3,509–31,665 LUTs against OverGen’s 586,223–788,479 (Figure 14). The clocks differ as much: even on the larger, older UltraScale+ VU9P, OverGen’s own paper reports only 92.87 MHz for a quad-core design [69], against 250–400 MHz for our images. FF, DSP, and BRAM usage stays below 2.1% of the device, while only URAM, which holds the scratchpads, reaches 6.91%. The new memory techniques do cost logic, especially double pumping, as the pumped DSP cluster needs 31,665 LUTs, and runs its core at 250 MHz, with its RAMs and multipliers at 500 MHz. Besides, the interconnects explain much of the gap. OverGen’s reconfigurable switches alone take 47,430–96,040 LUTs, more than our largest image, whereas our flow builds only the connections its workloads use. In summary, in geometric mean, OverGen’s image uses more LUTs than our suite image and more than our cluster image, and our images use – less total fabric area than OverGen.

Figure 14. Compute-unit resources (% of device, log) and .
Ablation
Our flow applies several optimization stages to the generated overlay (§§ § 3.4–§ 6). Figure 15 retraces them, reporting each earlier configuration’s runtime relative to the final suite images (). The steps are cumulative, and the ablation disables one at a time.

Figure 15. Effect of each optimization on suite images ().
Across all 17 workloads, the initial 100 MHz DDR images () run 92.51× slower than . Registering the DDR interfaces and raising the clock () only narrows this to 60.30×, because serialized DDR requests still dominate. Bulk transfers into an UltraRAM scratchpad () bring it to 16.84×, but engines still wait for each request and operation in turn. Pipelined engines () eliminate that wait by keeping many requests in flight, pipelining operands, and interleaving up to 16 independent DSP iterations, which cuts the gap to 4.46×. Engines with local reuse () then keep sparse-row and matrix accumulations local, reuse selected data, split DSP issue into load, multiply/divide and add paths, and overlap Vision frames through ordered queues, all while preserving arithmetic order. This leaves 1.41× and shrinks Vision’s gap from 10.88× to 1.94×.
The final step uses the hard blocks’ spare speed (§ 3.3). Dual porting removes the remaining 1.28× for MachSuite and 1.94× for Vision, whose clock also rises from 321 to 360 MHz. DSP stays at 1.00×: its dual-port variant brought no gain and its double-pumped suite image did not close timing, so pumping helps only its smaller cluster images (Figure 13).
Generation and Implementation Cost
A new image is quick to generate. However, it is slow to implement. A suite image takes 43.5–80.0 minutes, with 96.6–99.6% of that time spent on FPGA implementation, and the remaining time is allocated to functional simulation and RTL generation. This makes our suite image 7.1–10.89× quicker to reach a runnable overlay than OverGen. Even the two cluster images covering a suite’s workloads are still 2.5–4× faster at reaching a runnable overlay than OverGen. Its implementation alone runs 4.9–6.6 hours. Besides, its architecture search adds 0.5–3.5 hours compared to 5.97 seconds for all clustering cost combined. Compiling workloads remains cheap in both our flow and OverGen.
Board Power and Energy
We evaluate energy per kernel call from measured board power. Idle power barely separates the designs: 33.01–33.39 W for our images and 33.51–34.12 W for OverGen. Thus, the energy consumption follows runtime (Figure 16): OverGen needs 9.67× the suite images’ product, from 6.58× for MachSuite to 11.85× for Vision, and cluster images need 0.92× that of the suite images. This demonstrates that growing overlay out of workload requirements outperforms optimizing initial hardware organization in energy consumption. It also shows that clustering saves a little more energy as their hardware is more specialized.

Figure 16. Energy consumption.
Related Work
Our work touches on three aspects: overlays that make FPGAs programmable, generators that tailor an architecture to its workloads, and custom compilers that map programs onto the resulting architecture.
Overlays. Overlays trade some implementation efficiency for fast compilation and portability [19, 31, 64, 87], and also serve virtualization, HLS debugging, and fault recovery [52, 57, 81]. They now target neural networks and language models [1, 27, 44, 47, 91, 115, 118], image and signal processing [8, 26, 45], packet parsing and encrypted computation [39, 77, 78, 116], on execution models ranging from time-multiplexed pipelines [46, 63] to SIMT and many-core processors that scale across dies, and HBM and clusters [7, 12, 13, 14, 15, 16, 38, 55, 82]. This diversity is precisely why the architecture underneath should be specialized.
Workload-driven generation and merging. Generators tune FUs, precision, connectivity, and storage from workload information and compiler feedback [9, 69, 103, 104, 110], building on dataflow templates, reconfigurable dataflow generators, and specialized processors [18, 34, 36, 37, 74, 75, 102]. OverGen, our baseline, varies compute, network, and scratchpad resources within an architecture graph [69], and Plasticine and MAERI show the value of pairing computation with memory and reduction structures [60, 90]. Datapath merging instead reuses blocks and connections across DFGs [32, 80, 101], found through frequent subgraphs and patterns [76, 79, 111] or shaped around DFG stages [49, 113]. These approaches work top-down by having generators prune or tune a predefined template, and merging combines complete data paths. Our flow instead grows bottom-up, starting from the workloads’ operations and adding only the units and connections they need, with workload grouping and spectral descriptors deciding what to share.
Native resources and mapping. DSP-based overlays use native modes, internal pipelining, and forwarding [22, 23, 48, 50, 51], with compilers that map, share, cascade, and multipump DSPs [92, 93, 94, 96]; memory-centric overlays instead act around distributed storage [11, 54, 84, 85]. Overlay compilers place, schedule, and route DFGs [20, 21, 33, 107], helped by graph-aware mapping, equivalent expressions, and communication motifs [66, 67, 114], and extend to control overlays and runtime compilation [35, 112]. Our flow makes operations, memory interfaces, and pipeline timing explicit during construction, uses spectral matching [97, 105] only to rank candidates, and leaves dependencies, ports, and compatibility rules to decide what is built.
HLS and infrastructure. HLS [29] gains from templates, stencil and systolic transformations [25, 30, 109], guided or learned exploration [98, 99, 100] and joint code optimization [88, 89]; floorplanning, pipelining, stream networks and overlay interfaces raise physical quality [10, 40, 41, 43, 65, 108], and modular or partially reconfigurable flows cut implementation effort [6, 68, 86]. Although they provide automation, these still build a single accelerator or rebuild hardware as needs change, whereas each of our images switches workloads by configuration alone. Similar to flows that use MLIR, custom accelerator IRs, and architecture-description toolchains [17, 24, 53, 61, 62, 95, 117], our flow uses MLIR only for its frontend and grows the overlay and emits RTL in its own stages.
Conclusion
We presented a framework that grows programmable FPGA overlays from the dataflow graphs of the workloads they must run. It groups workloads by structural similarity, uses spectral descriptors to match their operations and connections, and builds shared hardware that respects operation semantics, data types, operand roles and execution constraints. The supported workloads then switch modes on one implemented image, with no new synthesis or place and route.
To further accelerate the resulting overlays, we leverage the hard blocks’ native capabilities. We use DSP controls that provide programmable arithmetic, internal registers that set the pipeline, and dual-ported or double-pumped memories and multipliers that leverage the hard blocks’ spare speed. We also use an MLIR-assisted frontend, graph analysis, and RTL generation to keep the hardware and its configurations consistent.
On a VCK5000, with Vision running on grown overlays and MachSuite and DSP on fixed-function engines and a micro-programmed executor, our images run all 17 workloads faster than OverGen rebuilt for the same board: 9.52× in geometric mean with one image per suite and 10.33× with similarity clusters, and up to 36.97×. It does so while using 19.4–22.1× less FPGA fabric usage and 9.67–10.51× less estimated board energy. Clustering alone cuts logic by up to 60% without changing cycle counts, and double pumping helps most where arithmetic dominates, on the DSP clusters.
Future work will extend the frontend to support complex control flow, additional operations and data types, and dynamic memory access patterns that dataflow execution supports.
Acknowledgments
Claude AI helped with parts of the coding and tweaking figures and tables. ChatGPT helped improve clarity.
References
References
- [1]Mohamed S. Abdelfattah, David Han, Andrew Bitar, Roberto DiCicco, Shane O’Connell, Nitika Shanker, Joseph Chu, Ian Prins, Joshua Fender, Andrew C. Ling, and Gordon R. Chiu. 2018. DLA: Compiler and FPGA Overlay for Neural Network Inference Acceleration. In 2018 28th International Conference on Field Programmable Logic and Applications (FPL). 411–418. doi:10.1109/FPL.2018.00077
- [2]Advanced Micro Devices, Inc. 2022. Clocking Wizard LogiCORE IP Product Guide (PG065). Advanced Micro Devices, Inc. https://docs.amd.com/r/en-US/pg065-clk-wiz. Version 6.0.
- [3]Advanced Micro Devices, Inc. 2022. Versal ACAP DSP Engine Architecture Manual. Advanced Micro Devices, Inc. https://docs.amd.com/r/en-US/am004-versal-dsp-engine Version 1.2.1.
- [4]Advanced Micro Devices, Inc. 2026. Versal Adaptive SoC Memory Resources Architecture Manual. Advanced Micro Devices, Inc. https://docs.amd.com/r/en-US/am007-versal-memory Version 1.2.1.
- [5]Advanced Micro Devices, Inc. 2026. Versal Architecture AI Core Series Libraries Guide (UG1353). https://docs.amd.com/r/en-US/ug1353-versal-architecture-ai-libraries Version 2026.1, June 23, 2026.
- [6]Zeyad Tariq Aklah. 2017. A Hybrid Partially Reconfigurable Overlay Supporting Just-In-Time Assembly of Custom Accelerators on FPGAs. Ph.D. Dissertation. University of Arkansas, Fayetteville. https://scholarworks.uark.edu/etd/1928/
- [7]Muhammad Al Kadi, Benedikt Jantzen, and Michael Hoeber. 2016. GPU: An SIMD-Architecture for FPGAs. In Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA). 254–263. doi:10.1145/2847263.2847273
- [8]Yuexin Bai, Zong Zhang, Zhiyuan Ma, Enhao Tang, and Jun Yu. 2025. DSP-OPU: An FPGA-based overlay processor for digital signal processing. Electronic Research Archive 33, 5 (2025), 2698–2718. doi:10.3934/era.2025119DOI
- [9]Thilini Kaushalya Bandara, Dhananjaya Wijerathne, Tulika Mitra, and Li-Shiuan Peh. 2022. RE VAMP: A Systematic Framework for Heterogeneous CGRA Re-ali-zation. In Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. 918–932. doi:10.1145/3503222.3507772
- [10]Suhail Basalama and Jason Cong. 2025. Stream-HLS: Towards Automatic Dataflow Acceleration. In Proceedings of the 2025 ACM/SIGDA International Symposium on Field Programmable Gate Arrays. 103–114. doi:10.1145/3706628.3708878DOI
- [11]Suhail Basalama, Atiyehshadat Panahi, Ange-Thierry Ishimwe, and David Andrews. 2020. SPAR-2: A SIMD Processor Array for Machine Learning in IoT Devices. In 2020 3rd International Conference on Data Intelligence and Security (ICDIS). 141–147. doi:10.1109/ICDIS50059.2020.00025
- [12]Riadh Ben Abdelhamid. 2023. Energy-efficient many-core overlay architecture for reconfigurable chips. Ph.D. Dissertation. University of Tsukuba. doi:10.15068/0000208220
- [13]Riadh Ben Abdelhamid, Vladislav Valek, Kevin Klein, and Dirk Koch. 2025. Design Space Exploration of Fast RISC-V Processors for Scalable Kilo-Core FPGA Systems. In 2025 35th International Conference on Field-Programmable Logic and Applications (FPL). 282–290. doi:10.1109/FPL68685.2025.00046
- [14]Riadh Ben Abdelhamid, Yoshiki Yamaguchi, and Taisuke Boku. 2019. MITRACA: A Next-Gen Heterogeneous Architecture. In 2019 IEEE 13th International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC). 304–311. doi:10.1109/MCSoC.2019.00050
- [15]Riadh Ben Abdelhamid, Yoshiki Yamaguchi, and Taisuke Boku. 2021. A Highly-Efficient and Tightly-Connected Many-Core Overlay Architecture. IEEE Access 9 (2021), 65277–65292. doi:10.1109/ACCESS.2021.3074171
- [16]Riadh Ben Abdelhamid, Yoshiki Yamaguchi, and Taisuke Boku. 2023. A Scalable Many-core Overlay Architecture on an HBM2-enabled Multi-Die FPGA. ACM Transactions on Reconfigurable Technology and Systems 16, 1 (2023), 15:1–15:33. doi:10.1145/3547657
- [17]Mohamed Bouaziz and Suhaib A. Fahmy. 2024. Leveraging MLIR for Efficient Irregular-Shaped CGRA Overlay Design: (PhD Forum Paper). In 2024 IEEE 35th International Conference on Application-Specific Systems, Architectures and Processors (ASAP). 204–205. doi:10.1109/ASAP61560.2024.00048DOI
- [18]Andrew Boutros, Eriko Nurvitadhi, and Vaughn Betz. 2021. Specializing for Efficiency: Customizing AI Inference Processors on FPGAs. In 2021 International Conference on Microelectronics (ICM). 62–65. doi:10.1109/ICM52667.2021.9664938
- [19]Alexander Brant and Guy G. F. Lemieux. 2012. ZUMA: An Open FPGA Overlay Architecture. In 2012 IEEE 20th International Symposium on Field-Programmable Custom Computing Machines (FCCM). 93–96. doi:10.1109/FCCM.2012.25DOI
- [20]Davor Capalija. 2017. Architecture, Mapping Algorithms and Physical Design of Mesh-of-Functional-Units FPGA Overlays for Pipelined Execution of Data Flow Graphs. Ph.D. Dissertation. University of Toronto. https://hdl.handle.net/1807/78948
- [21]Davor Capalija and Tarek S. Abdelrahman. 2013. A High-Performance Overlay Architecture for Pipelined Execution of Data Flow Graphs. In 2013 23rd International Conference on Field Programmable Logic and Applications (FPL). 1–8.DOI
- [22]Hui Yan Cheah, Fredrik Brosser, Suhaib A. Fahmy, and Douglas L. Maskell. 2014. The iDEA DSP Block-Based Soft Processor for FPGAs. ACM Transactions on Reconfigurable Technology and Systems 7, 3, Article 19 (2014), 23 pages. doi:10.1145/2629443DOI
- [23]Hui Yan Cheah, Suhaib A. Fahmy, and Nachiket Kapre. 2015. On Data Forwarding in Deeply Pipelined Soft Processors. In Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA). 181–189. doi:10.1145/2684764.26849067
- [24]Hongzheng Chen, Niansong Zhang, Shaojie Xiang, Zhichen Zeng, Mengjia Dai, and Zhiru Zhang. 2024. Allo: A Programming Model for Composable Accelerator Design. Proceedings of the ACM on Programming Languages 8, PLDI, Article 171 (2024), 28 pages. doi:10.1145/3656401DOI
- [25]Yuze Chi, Jason Cong, Peng Wei, and Peipei Zhou. 2018. SODA: Stencil with Optimized Dataflow Architecture. In Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD). Article 116, 8 pages. doi:10.1145/3240765.3240850DOI
- [26]Ziaul Choudhury, Anish Gulati, and Suresh Purini. 2023. FlowPix: Accelerating Image Processing Pipelines on an FPGA Overlay using a Domain Specific Compiler. ACM Transactions on Architecture and Code Optimization 20, 4 (2023), 60:1–60:25. doi:10.1145/3629523DOI
- [27]Ziaul Choudhury, Shashwat Shrivastava, Lavanya Ramapantulu, and Suresh Purini. 2022. An FPGA Overlay for CNN Inference with Fine-grained Flexible Parallelism. ACM Transactions on Architecture and Code Optimization 19, 3 (2022), 34:1–34:26. doi:10.1145/3519598DOI
- [28]Fan R. K. Chung. 1997. Spectral Graph Theory. CBMS Regional Conference Series in Mathematics, Vol. 92. American Mathematical Society, Providence, RI, Chapter 10: Heat Kernels.
- [29]Jason Cong, Bin Liu, Stephen Neuendorffer, Juanjo Noguera, Kees Vissers, and Zhiru Zhang. 2011. High-Level Synthesis for FPGAs: From Prototyping to Deployment. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 30, 4 (2011), 473–491. doi:10.1109/TCAD.2011.2110592
- [30]Jason Cong, Peng Wei, Cody Hao Yu, and Peng Zhang. 2018. Automated Accelerator Generation and Optimization with Composable, Parallel and Pipeline Architecture. In Proceedings of the ACM/IEEE Design Automation Conference (DAC). 1–6. doi:10.1145/3195970.3195999DOI
- [31]James Coole and Greg Stitt. 2010. Intermediate Fabrics: Virtual Architectures for Circuit Portability and Fast Placement and Routing. In Proceedings of the International Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS). 13–22. doi:10.1145/1878961.1878966DOI
- [32]James Coole and Greg Stitt. 2015. Adjustable-Cost Overlays for Runtime Compilation. In Proceedings of the IEEE International Symposium on Field-Programmable Custom Computing Machines (FCCM). 21–24. doi:10.1109/FCCM.2015.49DOI
- [33]Lucas Bragança Da Silva, Ricardo Ferreira, Michael Caneschi Cane, Marcelo M. Menezes, Maria D. Vieira, Jeronimo Penha, Peter Jamieson, and José Augusto M. Nacif. 2019. READy: A Fine-Grained Multithreading Overlay Framework for Modern CPU-FPGA Dataflow Applications. ACM Transactions on Embedded Computing Systems 18, 5s (2019), 56:1–56:20. doi:10.1145/3358187
- [34]Lucas Bragança da Silva, César Grandis, Jeronimo Penha, José Augusto M. Nacif, and Ricardo S. Ferreira. 2025. Reconfigurable Domain-Specific Architectures Based on Coarse-Grained Operators in High-Performance FPGAs. Concurrency and Computation: Practice and Experience 37, 15–17 (2025), e70170. doi:10.1002/cpe.70170DOI
- [35]Mitchel Dickerson, Anand Srinivasan, and Michael Franz. 2026. Practical Python FPGA Acceleration with Fast Just-In-Time Compilation and Configuration. ACM Transactions on Architecture and Code Optimization 23, 1, Article 31 (2026), 25 pages. doi:10.1145/3797265DOI
- [36]Anna Drewes, Vitalii Burtsev, Bala Gurumurthy, Martin Wilhelm, David Broneske, Gunter Saake, and Thilo Pionteck. 2024. An Architectural Template for FPGA Overlays Targeting Data Flow Applications. In 2024 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). 162–168. doi:10.1109/IPDPSW63119.2024.00042DOI
- [37]Pedro Duarte, Pedro Tomás, and Gabriel Falcão. 2017. SCRATCH: An End-to-End Application-Aware Soft-GPU Architecture and Trimming Tool. In Proceedings of the Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). 165–177. doi:10.1145/3123939.3123953DOI
- [38]Mahmoud Ahmed Elshamy, Veronica Iskandar, Diana Goehringer, and Mohamed A. Abd El Ghany. 2023. A Near-Memory Dynamically Programmable Many-Core Overlay. In 2023 IEEE 16th International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC). 268–275. doi:10.1109/MCSOC60832.2023.00047
- [39]Xin Fang, Stratis Ioannidis, and Miriam Leeser. 2017. Secure Function Evaluation Using an FPGA Overlay Architecture. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays. 257–266. doi:10.1145/3020078.3021746DOI
- [40]Licheng Guo, Yuze Chi, Jason Lau, Linghao Song, Xingyu Tian, Moazin Khatti, Weikang Qiao, Jie Wang, Ecenur Ustun, Zhenman Fang, Zhiru Zhang, and Jason Cong. 2023. TAPA: A Scalable Task-Parallel Dataflow Programming Framework for Modern FPGAs with Co-Optimization of HLS and Physical Design. ACM Transactions on Reconfigurable Technology and Systems 16, 4, Article 63 (2023), 31 pages. doi:10.1145/3609335
- [41]Licheng Guo, Yuze Chi, Jie Wang, Jason Lau, Weikang Qiao, Ec enur Ustun, Zhiru Zhang, and Jason Cong. 2021. 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. 81–92. doi:10.1145/3431920.3439289
- [42]David K. Hammond, Pierre Vandergheynst, and Rémi Gribonval. 2011. Wavelets on Graphs via Spectral Graph Theory. Applied and Computational Harmonic Analysis 30, 2 (March 2011), 129–150. doi:10.1016/j.acha.2010.04.005DOI
- [43]Zifan He, Andersson Truong, Yingqi Cao, and Jason Cong. 2025. InTAR: Inter-Task Auto-Reconfigurable Accelerator Design for High Data Volume Variation in DNNs. In 2025 IEEE 33rd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 123–132. doi:10.1109/FCCM62733.2025.00047
- [44]Zicheng He, Anhao Zhao, Xiaoyu Shen, Chen Wu, and Lei He. 2026. SkipOPU: An FPGA-based Overlay Processor for Large Language Models with Dynamically Allocated Computation. ACM Transactions on Reconfigurable Technology and Systems (2026). doi:10.1145/3837086 Just Accepted.DOI
- [45]Lenos Ioannou, Abdullah Al-Dujaili, and Suhaib A. Fahmy. 2020. High Throughput Spatial Convolution Filters on FPGAs. IEEE Transactions on Very Large Scale Integration (VLSI) Systems 28, 6 (2020), 1392–1402. doi:10.1109/TVLSI.2020.2987202DOI
- [46]Lenos Ioannou and Suhaib A. Fahmy. 2019. Lightweight Programmable DSP Block Overlay for Streaming Neural Network Acceleration. In 2019 International Conference on Field-Programmable Technology (ICFPT). 355–358. doi:10.1109/ICFPT47387.2019.00066DOI
- [47]Lenos Ioannou and Suhaib A. Fahmy. 2022. Streaming Overlay Architecture for Lightweight LSTM Computation on FPGA SoCs. ACM Transactions on Reconfigurable Technology and Systems 16, 1, Article 8 (2022), 26 pages. doi:10.1145/3543069DOI
- [48]Abhishek Kumar Jain, Suhaib A. Fahmy, and Douglas L. Maskell. 2015. Efficient Overlay Architecture Based on DSP Blocks. In 2015 IEEE 23rd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE, 25–28. doi:10.1109/FCCM.2015.15
- [49]Abhishek Kumar Jain, Xiangwei Li, Pranjul Singhai, Douglas L. Maskell, and Suhaib A. Fahmy. 2016. DeCO: A DSP Block Based FPGA Accelerator Overlay with Low Overhead Interconnect. In 2016 IEEE 24th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 1–8. doi:10.1109/FCCM.2016.10
- [50]Abhishek Kumar Jain, Douglas L. Maskell, and Suhaib A. Fahmy. 2016. Throughput Oriented FPGA Overlays Using DSP Blocks. In 2016 Design, Automation & Test in Europe Conference & Exhibition (DATE). 1628–1633. https://abhishekkumarjain.github.io/files/DATE2016.pdf
- [51]Abhishek Kumar Jain, Douglas L. Maskell, and Suhaib A. Fahmy. 2022. Coarse Grained FPGA Overlay for Rapid Just-In-Time Accelerator Compilation. IEEE Transactions on Parallel and Distributed Systems 33, 6 (2022), 1478–1490. doi:10.1109/TPDS.2021.3116859
- [52]Al-Shahna Jamal. 2018. An FPGA Overlay Architecture Supporting Software-like Compile Times During On-chip Debug of High-level Synthesis Designs. Master of Applied Science thesis. University of British Columbia. doi:10.14288/1.0370945
- [53]Rohan Juneja, Pranav Dangi, Thilini Kaushalya Bandara, Zhaoying Li, Dhananjaya Wijerathne, Li-Shi uan Peh, and Tulika Mitra. 2025. Building an Open CGRA Ecosystem for Agile Innovation. In 2025 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). 1–9. doi:10.1109/ICCAD62669.2025.11240628 Invited paper.
- [54]MD Ar a fat Kabir, Nathaniel Fredricks, Tendayi Kamucheka, Joel Mandebi, Miao-qing Huang, Jason D. Bakos, and David Andrews. 2025. DA-VinCi: A Deep-Learning Accelerator Overlay Using In-Memory Computing. ACM Transactions on Reconfigurable Technology and Systems 18, 4 (2025), 46:1–46:38. doi:10.1145/3770756DOI
- [55]Himan Khan Zandi, Yvon Savaria, and Jean-Pierre David. 2017. A data driven CGRA Overlay Architecture with embedded processors. In 2017 15th IEEE International New Circuits and Systems Conference (NEWCAS). 269–272. doi:10.1109/NEWCAS.2017.8010157
- [56]David Koeplinger, Matthew Feldman, Raghu Prabhakar, Yaqi Zhang, Stefan Hadjis, Ruben Fiszel, Tian Zhao, Luigi Nardi, Ardavan Pedram, Christos Kozyrakis, and Kunle Olukotun. 2018. Spatial: A Language and Compiler for Application Accelerators. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’18). Association for Computing Machinery, 296–311. doi:10.1145/3192366.3192379DOI
- [57]Alexandra Kourfalli and Dirk Stroobandt. 2019. In-circuit fault tolerance for FPGAs using dynamic reconfiguration and virtual overlays. Microelectronics Reliability 102 (2019), 113438. doi:10.1016/j.microrel.2019.113438
- [58]H. W. Kuhn. 1955. The Hungarian Method for the Assignment Problem. Naval Research Logistics Quarterly 2, 1–2 (March 1955), 83–97. doi:10.1002/nav.3800020109DOI
- [59]Ian Kuon and Jonathan Rose. 2007. Measuring the Gap Between FPGAs and ASICs. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 26, 2 (2007), 203–215.
- [60]Hyokjun Kwon, Ananda Samajdar, and Tushar Krishna. 2018. MAERI: Enabling Flexible Dataflow Mapping over DNN Accelerators via Reconfigurable Interconnects. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). 461–475. doi:10.1145/3173162.3173176
- [61]Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilyache, and Oleksandr Zinenko. 2021. MLIR: Scaling Compiler Infrastructure for Domain Specific Computation. In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE, 2–14. doi:10.1109/CGO51591.2021.9370308DOI
- [62]Jean-Christophe Le Lann, Théotime Bollengier, Mohammad Najem, and Loïc Lagadec. 2018. An Integrated Toolchain for Overlay-centric System-on-chip. In 2018 13th International Symposium on Reconfigurable Communication-centric Systems-on-Chip (ReCoSoC). 1–8. doi:10.1109/ReCoSoC.2018.8449388
- [63]Xiangwei Li, Abhishek Kumar Jain, Douglas L. Maskell, and Suhaib A. Fahmy. 2018. A Time-Multiplexed FPGA Overlay with Linear Interconnect. In 2018 Design, Automation & Test in Europe Conference & Exhibition (DATE). 1075–1080. doi:10.23919/DATE.2018.8342171DOI
- [64]Xiangwei Li and Douglas L. Maskell. 2019. Time-Multiplexed FPGA Overlay Architectures: A Survey. ACM Transactions on Design Automation of Electronic Systems 24, 5, Article 54 (2019), 19 pages. doi:10.1145/3339861DOI
- [65]Xiangwei Li, Kizhappatt Vipin, Douglas L. Maskell, Suhaib A. Fahmy, and Abhishek Kumar Jain. 2020. High Throughput Accelerator Interface Framework for a Linear Time-Multiplexed FPGA Overlay. In Proceedings of the IEEE International Symposium on Circuits and Systems (ISCAS). 1–5. doi:10.1109/ISCAS45731.2020.9181072DOI
- [66]Zhaoying Li, Pranav Dangi, Chenyang Yin, Thilini Kaushalya Bandara, Rohan Juneja, Cheng Tan, Zhenyu Bai, and Tulika Mitra. 2025. Enhancing CGRA Efficiency Through Aligned Compute and Communication Provisioning. In Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1. 410–425. doi:10.1145/3669940.3707230DOI
- [67]Zhaoying Li, Dan Wu, Dhananjaya Wijerathne, and Tulika Mitra. 2022. LISA: Graph Neural Network based Portable Mapping on Spatial Accelerators. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA). 444–459. https://www.computer.org/csdl/proceedings/hpca/2022/02/9244a1d7/1A9C22dfDOI
- [68]Leo Liu, Jay Weng, and Nachiket P Gupsh, Atefeh Sohrabizadeh, Zhengrong Wang, Licheng Guo, Jiuyang Liu, Maxim Zhulin, Rishabh Mani, Lucheng Zhang, Jason Cong, and Tony Nowatzki. 2022. OverGen: Improving FPGA Usability through Domain-specific Overlay Generation. In 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 35–56. doi:10.1109/MICRO56248.2022.00018
- [69]Leo Liu, Jay Weng, and Nachiket P Gupsh, Atefeh Sohrabizadeh, Zhengrong Wang, Licheng Guo, Jiuyang Liu, Maxim Zhulin, Rishabh Mani, Lucheng Zhang, Jason Cong, and Tony Nowatzki. 2022. OverGen: Improving FPGA Usability through Domain-specific Overlay Generation. In 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 35–56. doi:10.1109/MICRO56248.2022.00018DOI
- [70]LLVM Project. [n. d.]. ClangIR. Clang documentation. https://clang.llvm.org/docs/CIR/index.html Accessed November 12, 2026.
- [71]LLVM Project. [n. d.]. MLIR Language Reference. Online documentation. https://mlir.llvm.org/docs/LangRef/ Accessed November 12, 2026.
- [72]LLVM Project. [n. d.]. MLIR Passes. Online documentation. https://mlir.llvm.org/docs/Passes/ Accessed November 12, 2026.
- [73]Roman Lysecky, Kris Miller, Frank Vahid, and Kees Vissers. 2005. Firm-Core Virtual FPGA for Just-in-Time FPGA Compilation. In Proceedings of the 2005 ACM/SIGDA 13th International Symposium on Field-Programmable Gate Arrays (FPGA). ACM, 271. doi:10.1145/1046192.1046233
- [74]Rui Ma. 2024. Automatically Specialized FPGA overlays: a trade-off between programmability, performance, and area. Ph. D. Dissertation. The University of Texas at Austin. doi:10.26153/tsw/54309
- [75]Rui Ma, Jia-Ching Hsu, Tian Tan, Eriko Nurvitadhi, David Sheffield, Rob Pelt, Martin Langhammer, Jaewong Sim, Aravind Dasu, and Derek Chiou. 2021. Specializing FPGA for Persistent Deep Learning. ACM Transactions on Reconfigurable Technology and Systems 14, 2 (2021), 10:1–10:23. doi:10.1145/3457886DOI
- [76]Joel Mandebi Mbongue, Dhananjaya Wijerathne, Mohamed Cherubini, and Christopher Bobda. 2019. Automatic Generation of Application-Specific FPGA Overlays with Rapid-Wright. In 2019 International Conference on Field-Programmable Technology (ICFPT). 303–306. doi:10.1109/ICFPT47387.2019.00053
- [77]Parisa Mashreghi-Moghaddam, Tarek Ould-Bachir, and Yvon Savaria. 2023. An Area-efficient Memory-based Architecture for P4-programmable Streaming Parsers in FPGAs. In 2023 IEEE International Symposium on Circuits and Systems (ISCAS). 1–5. doi:10.1109/ISCAS46773.2023.10182176
- [78]Parisa Mashreghi-Moghaddam, Tarek Ould-Bachir, and Yvon Savaria. 2024. Prism-Parser: A Framework for Implementing Efficient P4-Programmable Packet Parsers on FPGA. Future Internet 16, 9 (2024), 307. doi:10.3390/fi16090307
- [79]Jackson Melchert, Kathleen Feng, Caleb Donovick, Ross Daly, Ritvik Sharma, Clark Barrett, Mark A. Horowitz, Pat Hanrahan, and Priyanka Raina. 2023. APEX: A Framework for Automated Processing Element Design Space Exploration using Frequent Subgraph Analysis. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3 (ASPLOS). 33–45. doi:10.1145/3582016.3582070DOI
- [80]Nahri Moreano, Edson Borin, Cid de Souza, and Guido Araujo. 2005. Efficient Datapath Merging for Partially Reconfigurable Architectures. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 24, 7 (2005), 969–980. doi:10.1109/TCAD.2005.850844DOI
- [81]Mohamad Najem, Théotime Bollengier, Jean-Christophe Le Lann, and Loïc Lagadec. 2017. Extended overlay architectures for heterogeneous FPGA cluster management. Journal of Systems Architecture 78 (2017), 1–14. doi:10.1016/j.sysarc.2017.06.001DOI
- [82]Matthew Naylor, Simon W. Moore, and David Thomas. 2019. Tinsel: A Manythreaded Overlay for FPGA Clusters. In 2019 29th International Conference on Field Programmable Logic and Applications (FPL). 375–383. doi:10.1109/FPL.2019.00066DOI
- [83]Tobias Nowatzki, Vinay Gangadhar, Newsha Ardalani, and Karthikeyan Sankaralingam. 2017. Stream-Dataflow Acceleration. In Proceedings of the 44th Annual International Symposium on Computer Architecture (ISCA ’17). Association for Computing Machinery, 416–429. doi:10.1145/3079856.3080255DOI
- [84]Atiyehsadat Panahi. 2022. A Memory-Centric Customizable Domain-Specific FPGA Overlay for Accelerating Machine Learning Applications. Ph. D. Dissertation. University of Arkansas, Fayetteville. https://scholarworks.uark.edu/etd/4618/
- [85]Atiyehsadat Panahi, Suhail Balsalama, Ange-Thierry Ishimwe, Joel Mandebi Mbongue, and David Andrews. 2021. A Customizable Domain-Specific Memory-Centric FPGA Overlay for Machine Learning Applications. In 2021 31st International Conference on Field-Programmable Logic and Applications (FPL). 24–27. doi:10.1109/FPL53798.2021.00012DOI
- [86]Dongjoon Park and André DeHon. 2024. REFINE: Runtime Execution Feedback for Incremental Evolution on FPGA Designs. In Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA). 108–118. doi:10.1145/3626202.3637560DOI
- [87]Artur Podobas, Kentaro Sano, and Satoshi Matsuoka. 2020. A Survey on Coarse-Grained Reconfigurable Architectures From a Performance Perspective. IEEE Access 8 (2020), 146719–146743. doi:10.1109/ACCESS.2020.3012084DOI
- [88]Stéphane Pouget, Michael Lo, Louis-Noël Pouchet, and Jason Cong. 2025. Holistic Optimization Framework for FPGA Accelerators. ACM Transactions on Design Automation of Electronic Systems 31, 1, Article 7 (2025), 37 pages. doi:10.1145/3769307DOI
- [89]Stéphane Pouget, Louis-Noël Pouchet, and Jason Cong. 2025. A Unified Framework for Automated Code Transformation and Pragma Insertion. In Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA). 187–198. doi:10.1145/3706628.3708873DOI
- [90]Raghu Prabhakar, Yaqi Zhang, David Koeplinger, Matt Feldman, Tian Zhao, Stefan Hadjis, Ardavan Pedram, Christos Kozyrakis, and Kunle Olukotun. 2017. Plasticine: A Reconfigurable Architecture for Parallel Patterns. In Proceedings of the International Symposium on Computer Architecture (ISCA). 389–402. doi:10.1145/3079856.3080256DOI
- [91]Kai Qian, Haodong Lu, Yinqiu Liu, Zexu Zhang, and Kun Wang. 2025. End-to-end Compilation is All FPGAs Need: A Unified Overlay-based FPGA Compiler for Deep Learning. In Proceedings of the 30th Asia and South Pacific Design Automation Conference. 258–264. doi:10.1145/3658617.3697562DOI
- [92]Bajaj Ronak and Suhaib A. Fahmy. 2016. Improved Resource Sharing for FPGA DSP Blocks. In Proceedings of the International Conference on Field Programmable Logic and Applications (FPL). 1–4. doi:10.1109/FPL.2016.7577373DOI
- [93]Bajaj Ronak and Suhaib A. Fahmy. 2016. Mapping for Maximum Performance on FPGA DSP Blocks. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 35, 4 (2016), 573–585. doi:10.1109/TCAD.2015.2474363DOI
- [94]Bajaj Ronak and Suhaib A. Fahmy. 2017. Multimapping Flexible DSP Blocks for Resource Reduction on Xilinx FPGAs. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 36, 9 (2017), 1471–1482. doi:10.1109/TCAD.2016.2629421DOI
- [95]Amirali Sharifian, Reza Hojabr, Navid Rahimi, Sihao Liu, Apala Guha, Tony Nowatzki, and Arrvindh Shriraman. 2019. An Intermediate Representation for Transforming and Optimizing the Microarchitecture of Application Accelerators. In Proceedings of the Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). 940–953. doi:10.1145/3352460.3358292DOI
- [96]Runbin Shi, Yuhao Ding, Xuechao Wei, He Li, Hang Liu, Hayden Kwok-Hay So, and Caiwen Ding. 2020. FTDL: A Tailored FPGA-Overlay for Deep Learning with High Scalability. In 2020 57th ACM/IEEE Design Automation Conference (DAC). 1–6. doi:10.1109/DAC18072.2020.9218581
- [97]David I. Shuman, Sunil K. Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. 2013. The Emerging Field of Signal Processing on Graphs: Extending High-Dimensional Data Analysis to Networks and Other Irregular Domains. IEEE Signal Processing Magazine 30, 3 (May 2013), 83–98. doi:10.1109/MSP.2012.2235192DOI
- [98]Atefeh Sohrabizadeh, Yunsheng Bai, Yizhou Sun, and Jason Cong. 2022. Automated Accelerator Optimization Aided by Graph Neural Networks. In Proceedings of the ACM/IEEE Design Automation Conference (DAC). 55–60. doi:10.1145/3489517.3530409DOI
- [99]Atefeh Sohrabizadeh, Yunsheng Bai, Yizhou Sun, and Jason Cong. 2023. Robust GNN-Based Representation Learning for HLS. In Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD). 1–9. doi:10.1109/ICCAD57390.2023.10323853DOI
- [100]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 27, 4, Article 32 (2022), 27 pages. doi:10.1145/3494534DOI
- [101]Mirjana Stojilović, David Novo, Lazar Saranovac, Philip Brisk, and Paolo Ienne. 2012. Selective Flexibility: Breaking the Rigidity of Datapath Merging. In Proceedings of the Design, Automation and Test in Europe Conference and Exhibition (DATE). 1543–1548. doi:10.1109/DATE.2012.6167618
- [102]Gongjin Sun, Seongyoung Kang, Jane He, Se-Min Lim, and Sang-Woo Jun. 2025. RISC-V Overlay with Streaming Asynchronous Custom Instructions. In 2025 IEEE 36th International Conference on Application-specific Systems, Architectures and Processors (ASAP). 57–64. doi:10.1109/ASAP65064.2025.00018DOI
- [103]Cheng Tan, Thierry Tamba, Jeff (Jun) Zhang, Bo Fang, Tong Geng, Gu-Yeon Wei, David Brooks, Antonino Tumeo, Ganesh Gopalakrishnan, and Ang Li. 2022. ASAP: Automatic Synthesis of Area-Efficient and Precision-Aware CGRAs. In Proceedings of the ACM International Conference on Supercomputing (ICS). Article 4, 13 pages. doi:10.1145/3524059.3532359DOI
- [104]Cheng Tan, Chenhao Xie, Ang Li, Kevin J. Barker, and Antonino Tumeo. 2021. AURORA: Automated Refinement of Coarse-Grained Reconfigurable Accelerators. In Proceedings of the Design, Automation and Test in Europe Conference and Exhibition (DATE). 1388–1393. doi:10.23919/DATE51398.2021.9473955DOI
- [105]Shinji Umeyama. 1988. An Eigendecomposition Approach to Weighted Graph Matching Problems. IEEE Transactions on Pattern Analysis and Machine Intelligence 10, 5 (1988), 695–703. doi:10.1109/34.6778DOI
- [106]Anuj Vaishnav, Khoa Dang Pham, and Dirk Koch. 2018. A Survey on FPGA Virtualization. In 2018 28th International Conference on Field Programmable Logic and Applications (FPL). IEEE, 131–138. doi:10.1109/FPL.2018.00031DOI
- [107]Maria Vieira, Michael Canesche, Lucas Braganca, Josué Campos, Mateus Silva, Ricardo Ferreira, and José A. Nacif. 2021. RESHAPE: A Run-Time Dataflow Hardware-Based Mapping for CGRA Overlays. In 2021 IEEE International Symposium on Circuits and Systems (ISCAS). 1–5. doi:10.1109/ISCAS51556.2021.9401168
- [108]Chengyue Wang, Xiaofang Zhang, Jason Cong, and James C. Hoe. 2025. Reconfigurable Stream Network Architecture. In Proceedings of the 52nd Annual International Symposium on Computer Architecture. 1848–1866. doi:10.1145/3695053.3731088DOI
- [109]Jie Wang, Licheng Guo, and Jason Cong. 2021. AutoSA: A Polyhedral Compiler for High-Performance Systolic Arrays on FPGA. In The 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays. 93–104. doi:10.1145/3431920.3439292DOI
- [110]Jian Weng, Sihao Liu, Vidushi Dadu, Zhengrong Wang, Preyas Shah, and Tony Nowatzki. 2020. SUSTAIN: Synthesizing Programmable Spatial Accelerators. In 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA). 268–281. doi:10.1109/ISCA45697.2020.00032DOI
- [111]Max Willsey, Vincent T. Lee, Alvin Cheung, Rastislav Bodík, and Luis Ceze. 2019. Iterative Search for Reconfigurable Accelerator Blocks With a Compiler in the Loop. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 38, 3 (2019), 407–418. doi:10.1109/TCAD.2018.2878194DOI
- [112]David Wilson and Greg Stitt. 2017. A Scalable, Low-Overhead Finite-State Machine Overlay for Rapid FPGA Application Development. arXiv:1705.02732 [cs.AR] doi:10.48550/arXiv.1705.02732 Presented at the 3rd International Workshop on Overlay Architectures for FPGAs (OLAF 2017).DOI
- [113]David Wilson, Greg Stitt, and James Coole. 2018. A Recurrently Evolved Overlay Architecture for Rapid FPGA Application Development. In Proceedings of the 9th International Symposium on Highly-Efficient Accelerators and Reconfigurable Technologies. 4:1–4:6. doi:10.1145/3241793.3241797DOI
- [114]Jackson Woodruff, Thomas Koehler, Alexander Brauckmann, Chris Cummins, Sam Ainsworth, and Michael F. P. O’Boyle. 2023. Rewriting History: Repurposing Domain-Specific CGRAs. arXiv:2309.09112 [cs.AR] https://arxiv.org/abs/2309.09112
- [115]Chen Wu, Shaoqiang Lu, Yangbo Wei, Junhong Qian, Jinlong Yan, Zhanfei Chen, Rumin Zhang, Xiao Shi, and Lei He. 2025. FPGA Overlay Processor for LLM with HBM-Aware Multi-Die Architecture. In 2025 International Conference on Field Programmable Technology (ICFPT). 248–251. doi:10.1109/ICFPT67023.2025.00048DOI
- [116]Yang Yang, Rajgopal Kannan, Viktor K. Prasanna. 2025. OLA: An FPGA-based Overlay Accelerator for Privacy Preserving Machine Learning with Homomorphic Encryption. In Proceedings of the 2025 ACM/SIGDA International Symposium on Field Programmable Gate Arrays. 127–138. doi:10.1145/3706628.3708868
- [117]Hanchen Ye, Cong Hao, Jianyi Cheng, Huynmin Jeong, Jack Huang, Stephen Neuendorffer, and Deming Chen. 2022. ScaleHLS: A New Scalable High-Level Synthesis Framework on Multi-Level Intermediate Representation. In Proceedings of the IEEE International Symposium on High-Performance Computer Architecture (HPCA). 741–755. doi:10.1109/HPCA53966.2022.00060DOI
- [118]Yunxuan Yu, Chen Wu, Tiandong Zhao, Kun Wang, and Lei He. 2020. OPU: An FPGA-Based Overlay Processor for Convolutional Neural Networks. IEEE Transactions on Very Large Scale Integration (VLSI) Systems 28, 1 (2020), 35–47. doi:10.1109/TVLSI.2019.2939726DOI
