WorksComputer Science
Superscalar Loop Processors
Abstract
To sustain the computational demands of modern ML and HPC workloads, programmable accelerators integrate large arrays of processing elements (PEs), typically built around single-issue in-order cores to maximize integration density and energy efficiency. As a result, each PE's instruction throughput is upper-bounded at one instruction per cycle (IPC), often suffering from significant underutilization of its functional units (FUs). Conventional superscalar processors can improve FU utilization by increasing IPC, but they typically incur substantial area and energy overheads. This work proposes the Superscalar Loop Processor (SLP) architecture, a lightweight approach to superscalar execution that targets regular, compute-intensive loop kernels. We present the SLP execution model, which exploits the static structure of these workloads to enable efficient multiple-issue execution without the complexity of dynamic out-of-order scheduling. We demonstrate the SLP architecture through an open-source prototype implementation, Schnizo, developed as an enhancement of a tiny RV32I core with floating-point support. Across several ML and HPC microkernels, Schnizo achieves substantially higher IPC and FPU utilization than the scalar baseline while retaining the efficiency of lightweight in-order designs. These results demonstrate that SLPs can provide an efficient architectural solution for programmable accelerators targeting regular, compute-intensive workloads.
Introduction
The growth of machine learning (ML) workloads has created an unprecedented demand for computational capacity [1]. Empirical studies show that model quality improves predictably with additional compute [2, 3], driving rapid expansion of data centers and specialized accelerators. Recent analyses report that frontier-model training compute continues to grow at roughly 4-5× per year [4] and inference is scaling even faster due to the explosive increase in token generation linked to agentic workloads [5].
To meet this demand, modern accelerators integrate an ever-increasing number of arithmetic or functional units (FUs) [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]. Area efficiency (FLOPS/mm) has thus become a primary design objective, as it enables designers to pack more compute resources onto a chip, under a fixed silicon budget. At the same time, energy has become a constraint on how much compute infrastructure can be deployed, with hyperscalers investing in dedicated power plants to scale their data centers [17]. As such, energy efficiency (FLOPS/W) has also become a critical design goal, as it enables deploying more compute infrastructure within a fixed power budget.
While integrating more FUs can effectively boost peak performance, attaining this performance requires sustaining a high FU utilization. As most kernels involve a mix of compute and non-compute instructions [18], e.g. for data movement and control operations, compute utilization critically depends on instruction throughput. This is evident in the dot product kernel illustrated in Figure 1a. As only one in six instructions performs a floating-point (FP) arithmetic operation, a processor with an IPC (instructions per cycle) of 1 can achieve only 17% of its peak FP performance. The following equations capture these relationships:
Figure 1. (a) Dot product loop and sample schedules on idealized scalar (top, 17% FPU utilization) and superscalar (bottom, 100% FPU utilization) cores. (b) Architectural design space. Contour lines indicate equal Area Eff. × IPC.
While scalar in-order cores offer high area and energy efficiency [19, 15, 20, 21, 6], they achieve limited instruction throughput (IPC ≤ 1). On the other hand, superscalar out-of-order (OoO) cores provide excellent instruction throughput across a wide range of applications, but require large structures such as reorder buffers and dynamic scheduling logic, which incur substantial area and energy costs [22, 23, 24, 25]. Figure 1b illustrates this design space.
In practice, many modern programmable accelerators, including graphics processing units (GPUs), rely on large arrays of relatively simple execution units and in-order scheduling structures to exploit data- (DLP) or thread-level parallelism (TLP), rather than on complex OoO cores or scheduling structures to extract instruction-level parallelism (ILP) within individual instruction streams [15, 6, 9, 26]. This suggests that the area- and energy-efficiency of simple replication-friendly designs outweighs the IPC advantage of traditional superscalar pipelines on the regular, computationally-intensive kernels found in ML workloads [27, 28, 29].
A complementary way to improve FU utilization is to increase the operation density, i.e., reduce the number of instructions required per useful operation. This approach uses custom instructions to fuse common instruction sequences [30, 31, 32]. Notable examples include zero-overhead loops (ZOLs) (or hardware loops) [33, 34, 35, 18, 36, 37, 38, 39, 30, 40], post-increment load/store instructions [41, 42, 30] and stream semantic registers (SSRs) [43, 44], which transform the dot product code as shown in Figure 2a to Figure 2c. Although these techniques are often adopted in in-order cores to compensate for limited instruction throughput, they remain orthogonal to the tradeoff between efficiency and instruction throughput.
Figure 2. Dot product kernel leveraging several extensions: (a) ZOL, (b) ZOL and post-increment loads, (c) ZOL and SSRs. Highlighted in red is the loop body, and annotated under the loop is the FPU operation density within the loop.
This tradeoff leads to a central question: can we design a lightweight superscalar processor that provides high instruction throughput while retaining the efficiency benefits of simple in-order designs? More specifically, can we trade the flexibility of traditional OoO superscalar processors for a more efficient design that still achieves high throughput on regular, compute-intensive kernels?
In this work, we propose Superscalar Loop Processors (SLPs), a lightweight processor architecture that specializes superscalar execution for regular loop kernels. Rather than supporting general-purpose OoO execution, SLPs extract ILP exclusively within regular loop bodies. By constraining the scope of superscalar execution, SLPs achieve high FU utilization without incurring the overhead of OoO scheduling, bridging the gap between scalar efficiency and superscalar throughput for regular, compute-intensive workloads. We envision SLPs as an enhancement to the processing elements (PEs) of high-throughput programmable accelerators, such as GPUs and many-cores, where execution is dominated by regular loop kernels. They are not meant to replace OoO cores, which remain essential for latency-sensitive and irregular workloads.
This paper makes the following contributions:
We provide a critical analysis of earlier pseudo-dual-issue execution methods, identifying their potential and limitations and formulating the design challenges to be addressed.
Based on these insights, we introduce the SLP architecture, a lightweight multiple-issue execution method for regular loop kernels, and present an implementation-agnostic algorithm for its operation.
We implement the SLP architecture in Schnizo1, an RTL prototype developed as an extension of a lightweight RV32I core, detailing the key hardware structures and control mechanisms required to support its execution model.
We characterize Schnizo’s scalability across key architectural parameters, and assess its performance on a diverse set of microkernels. On simple linear algebra kernels, Schnizo achieves a geometric mean 4.4× speedup over scalar execution and 72% higher area efficiency than a scalar design.
Each contribution is developed in a dedicated section, with Sections II to V covering contributions 1 through 4, respectively.
Background
We base our work on the open-source Snitch processor [19], represented in Figure 3. Snitch is a tiny RV32I core with an in-order, single-issue and single-stage pipeline, optionally coupled to a 4-stage double-precision FP coprocessor. FP instructions are fetched by the Snitch core and offloaded to the FP coprocessor. A scoreboard is used to track in-flight coprocessor instructions, providing limited latency tolerance at low cost. Despite its single-stage pipeline, implementation results in GlobalFoundries’ 22 nm FDX technology [19] show that Snitch achieves a 1 GHz clock frequency in typical operating conditions. With a footprint of only 21 kGE (kilo gate equivalents), it occupies the extreme end of the design space in Figure 1b, with high efficiency, but limited instruction throughput.
Figure 3. Architecture of Snitch and its FP coprocessor.
High FU utilization is restored through the operation density knob. Two ISA extensions are dedicated to this purpose: SSRs [43] and the floating point repetition (FREP) extension [19].
As shown in Figure 2c, SSRs eliminate load, store and address generation instructions in the hot loop, by programming all memory accesses once (in compressed form), outside the loop. This applies to regular memory access patterns (affine streams) only and is achieved by streaming operands through a dedicated prefetcher, while temporarily altering architectural register semantics (for ft0 and ft1 in our example).
The FREP extension, on the other hand, eliminates branch instructions by implementing a zero-overhead loop buffer (ZOLB) [33, 34, 35, 39, 38, 40, 19] which can cache and loop over short sequences of FP instructions. Differently from prior designs, the ZOLB is implemented in the FP coprocessor, allowing it to independently issue instructions from the buffer, while the Snitch core is free to fetch and execute other instructions from the instruction cache; a novel scheme its authors refer to as pseudo-dual issue execution.
As shown in Figure 4a, this scheme effectively creates two separate, independent “threads” of instructions, asynchronously executing across the two decoupled domains, and each maintaining their own architectural state: the FP thread state comprises of the FP register file (RF) and the ZOLB state, while the integer thread state comprises of the integer RF and the program counter. However, for a single thread of integer and FP instructions to be separable into said independent threads of integer-only and FP-only instructions, there can be no dependencies between the integer and FP instructions involved. This excludes all FP conversion, compare and move instructions, as well as FP loads and stores, thereby severely limiting the applicability of the approach.
Figure 4. (a) FREP schedule and (b) programming model.
Colagrande and Benini [45] identified this issue and proposed COPIFT, a software methodology that enables pseudo-dual-issue execution even in the presence of dependencies. It does so by enabling communication between the two threads through the L1 memory and by increasing the dependency distance via tiling and software pipelining transformations. While effective, the COPIFT methodology introduces a significantly complex programming model as well as non-negligible pipeline fill and drain overheads. In a follow-up work, they proposed COPIFTv2 [46], which refines this scheme by enabling fine-grained communication and synchronization between the two threads through dedicated FIFOs. Although this design eliminates much of the complexity of the original approach, it still requires the programmer to explicitly manage communication between the two threads, either through modified SSR-like register semantics or through explicit push/pop instructions, which incur additional overhead.
Despite its limitations, the pseudo-dual issue model is appealing because it exposes ILP with minimal hardware overhead, preserving the area and energy efficiency of a single-issue in-order design. It relies on a single-issue instruction frontend that dispatches instructions in order to the appropriate FUs, incrementally setting up superscalar execution. It then exploits the invariant nature of loops to realize superscalar benefits across successive iterations without additional hardware complexity. As such, it pioneers an approach to superscalar execution that we set out to extend in this work.
The current pseudo-dual-issue model has two main limitations:
Originally conceived as a specialized mechanism for overlapping integer and FP execution, it does not readily generalize to multiple FUs or to FUs without a dedicated architectural RF. For instance, it cannot directly parallelize integer arithmetic and integer load/store operations. Moreover, because only the FP domain implements ZOLs, integer instructions must still be iterated explicitly in software, leading to the awkward programming model shown in Figure 4b.
Dependencies across threads require explicit communication and synchronization. As a result, extracting ILP requires the programmer or compiler to statically partition a loop body into multiple communicating instruction streams and to expose the required communication and synchronization mechanisms in the ISA. The resulting code is thus tied to a specific machine configuration (FU counts, latencies, and interconnect characteristics) hindering performance portability or binary compatibility across implementations.
To address these limitations, we set out to:
Generalize the pseudo-dual issue model into a native multiple-issue execution model for loops that supports arbitrary FUs and exposes a coherent programming model.
Handle dependencies between concurrently executing instruction streams dynamically in hardware, transparently to software and with zero instruction overhead.
In the next section, we show how the SLP architecture addresses these challenges.
Architecture
The SLP architecture builds on the key idea of leveraging single-issue in-order execution in the first iteration of a loop to incrementally set up the FUs for superscalar execution. The FUs then replay subsequent iterations largely asynchronously. In the following, we refer to the first phase as the Dataflow Construction Phase (DCP) and the second as the Dataflow Execution Phase (DEP).
To eliminate the awkward programming model of the pseudo-dual issue approach and generalize it to arbitrary multiple issue, we move away from Snitch’s asymmetric processor-coprocessor design. Instead, all FUs are treated uniformly, and each is equipped with its own ZOLB. The programmer or compiler defines a single unified hardware loop, as in Figure 2a. During the first iteration (DCP), the SLP’s frontend fetches the loop body instructions one by one and dispatches each instruction to the appropriate FU, where it is buffered. Unlike Snitch, the frontend is not tied to any specific FU. In subsequent iterations, the frontend remains idle, and each FU independently replays its buffered instructions using dedicated ZOL logic. Once all FUs complete all loop iterations, the hardware loop terminates and the frontend resumes normal scalar execution.
The frontend and ZOL logic are relatively simple when each FU is guaranteed to access a disjoint subset of architectural registers, as in Snitch’s pseudo-dual issue model. Under this assumption, the instruction streams dispatched to different FUs are independent and can therefore execute fully asynchronously. However, this assumption becomes too restrictive when scaling to multiple FUs and limits its applicability to realistic workloads. To remove this constraint, the architecture must at least support true (RAW) dependencies between instructions assigned to different FUs. This requires detecting such dependencies and synchronizing the FUs accordingly. The same issue arises for false (WAW, WAR) dependencies, unless they are eliminated through register renaming. In that case, the architecture additionally requires a mechanism to commit renamed, or physical-register, state back to the architectural state.
To this end, we extend the frontend to extract dependency information during DCP and record it directly in the ZOLB entry of each instruction. During DEP, the FUs use this information to dynamically determine when instructions become ready for execution. In this sense, execution during DEP follows a dataflow-like model that is established during DCP.
For the dataflow construction logic, we draw heavily from conventional OoO superscalar processors. The key simplification relative to a conventional design is that this logic is active only during DCP and needs to process at most one instruction per cycle, since the issue width in this phase is one. The main advantage of SLPs follows directly from this observation: by exploiting the invariant structure of loops, where the dataflow graph remains unchanged across iterations, SLPs can decouple the issue width used for dataflow construction from the issue width realized during execution.
To illustrate the general operation of the SLP architecture, we present an implementation-agnostic SLP approach based on Tomasulo’s algorithm [47]. In this formulation, the ZOLB associated with each FU serves as a reservation station (RS) for loop body instructions. The SLP frontend is augmented with a register map table (RMT) that tracks the latest producer tag for each architectural register. When an instruction is dispatched during DCP, the frontend reads the producer tags of its source operands from the RMT and updates the destination register entry accordingly, following Tomasulo’s dependency-tracking scheme. The source operand tags are then recorded with the instruction in the corresponding RSs. Once the first loop iteration completes, the frontend signals the FUs to enter DEP. During DEP, all RSs can issue instructions independently and in parallel. Within an RS, instructions need not issue strictly in program order: any instruction may issue as soon as its dependencies, as recorded during DCP, are satisfied. However, each RS must track the loop iteration index for all of its instructions.
The iteration index is required for two reasons. First, it serves the original purpose required by the ZOL logic, namely to determine when all loop iterations have completed. Second, it is needed to preserve false dependencies. In Tomasulo’s algorithm, each RS entry is assigned a unique tag. This guarantees that every in-flight instruction within an iteration is uniquely identified, preventing false dependency violations. In our adaptation, by contrast, the same RS entry issues the same instruction across multiple iterations, and therefore does not uniquely identify a single in-flight instruction. Reusing a tag in a subsequent loop iteration requires ensuring that the previous value associated with that tag is no longer needed, that is, that all reads of that value have completed. This condition is trivially satisfied in the absence of loop-carried dependencies, that is, when all values produced in a given iteration are fully consumed within that same iteration. In this case, it is sufficient to synchronize all RSs at the end of each iteration, thereby preventing instructions from different iterations from being issued concurrently. The frontend can aggregate the iteration indices from all RSs, determine when an iteration has completed globally, and then advance all RSs to the next iteration. This approach, however, does not support loop-carried dependencies and can exploit ILP only within a single iteration.
Before addressing this limitation, we note that the same principles can be applied to modern superscalar designs based on a physical RF [48, 49, 50, 51], by assigning physical registers during DCP and preserving these assignments across DEP iterations. The same restriction as in the Tomasulo-based formulation applies: a physical register cannot be implicitly reassigned to an instruction issue in a subsequent iteration until all reads of its previous value have completed. This condition can be enforced by disallowing loop-carried dependencies and by preventing instructions from different iterations from being simultaneously in flight.
This policy can be viewed as a coarse-grained physical register reclamation strategy. In conventional free-list-based designs, a physical register is typically reclaimed when the next instruction writing the same architectural register commits, thereby superseding the previous mapping [48, 52]. In contrast, our approach commits at the granularity of an entire loop iteration. Once all instructions in the current iteration have committed, all physical registers associated with the previous iteration are reclaimed at once, allowing the next iteration to begin. As noted above, this strategy requires only a single counter per RS and an aggregation mechanism in the frontend. A more fine-grained physical register reclamation strategy, for example based on a free-list or reference counting scheme [53, 54, 55], would allow instructions from different iterations to be in flight simultaneously and would therefore enable support for loop-carried dependencies. We demonstrate such an implementation in Section IV-A. In this section, we presented an implementation-agnostic algorithm to illustrate the high-level operation of the SLP architecture and to highlight the similarities and differences with conventional superscalar designs. This discussion is by no means exhaustive, but is intended to convey the key principles of the approach. In the next section, we present Schnizo and examine the main design challenges of a concrete SLP implementation in greater detail.
Implementation
Figure 5 illustrates the high-level microarchitecture of Schnizo.2 As in Snitch, Schnizo’s scalar pipeline implements a tiny RV32I core with a single-stage, in-order, single-issue design, which can optionally integrate Snitch’s 4-stage double-precision SIMD-capable FPU as a tightly-coupled FU. Schnizo further inherits Snitch’s lightweight scoreboard-based latency-tolerance mechanism. Finally, we generalize Snitch’s ZOL support by moving the loop-control logic into the shared instruction frontend, allowing ZOLs to contain arbitrary instructions rather than only FP instructions.
Figure 5. Architecture of a two-FU-cluster Schnizo core.
On top of this, we implement the SLP extension, highlighted in yellow in Figure 5. The SLP extension can be disabled at design time, enabling the same design to be configured as a simple Snitch-compatible scalar core, and providing a clean baseline for comparison. Thanks to the pipeline registers at the issue interface cutting combinational paths, the extension is also minimally intrusive when enabled, i.e., it does not significantly affect the timing of the scalar pipeline and regular or ZOL execution. In addition, we support both SLP and ZOL execution modes through a unified mechanism. As shown in Figure 6, a 1-bit flag is added to the ZOL instruction to select whether a loop should be executed in SLP or in ZOL mode, on an individual basis. The ZOL mode also serves as a fallback when a loop cannot execute in SLP mode, for example because of resource constraints or unsupported instruction patterns in the loop body. Concrete cases are presented in Section IV-D.

Figure 6. ZOL instruction encoding.
The SLP extension is implemented through four main hardware components, shown in Figure 5: RSs, an operand delivery network (ODN), a ZOL controller, and SLP-specific extensions to the dispatch stage for dependency tracking and register renaming. We describe each component in detail in the following sections.
Reservation Station
The RS is the core of the dataflow execution logic. Each RS is associated with a disjoint set of FUs, which we refer to as an FU cluster. The FU cluster defines the granularity at which ILP is extracted: each FU cluster can issue at most one instruction per cycle, but separate FU clusters can issue in parallel. Grouping multiple FUs into a single cluster can be beneficial when the cost of a separate cluster per FU, with its own RS and ODN ports, outweighs the benefit of parallel execution across the FUs. This is relevant for FUs executing different classes of instructions, such as an LSU (Load-Store Unit) and an ALU (Arithmetic Logic Unit). By contrast, there is no benefit in grouping multiple FUs of the same type within a cluster, since the same functionality would already be provided by a single FU.
Figure 7 illustrates the architecture of the RS. As described in Section III, the RS in an SLP serves two purposes: it caches the loop-body instructions assigned to its associated FUs and schedules their execution. It can therefore store up to one loop body instruction per RS entry. To reduce implementation complexity, Schnizo restricts scheduling within an RS to in-order issue, thereby limiting ILP to inter-RS parallelism. As a result, only one instruction within an RS is eligible for dispatch at any given time. This instruction is tracked by the dispatch index (), which advances whenever an instruction is dispatched.
For an instruction to be issued3 by the RS, its source operands must be available. The RS is therefore responsible for generating the requests needed to retrieve the operands of the selected instruction. Our design adopts a distributed physical register file (PRF) organization [49, 56, 22, 57, 58], in which the RSs store the results of the loop-body instructions they hold. This organization is aligned with the targeted dataflow execution model: results remain close to the producing FUs and are forwarded through the ODN directly to consumers, rather than being written back to and later read from a centralized PRF. We further distinguish between static and dynamic operands. Static operands comprise immediates and architectural register values that are not modified within the loop and therefore remain constant throughout execution.
Figure 7. Architecture of the reservation station (RS).
Figure 8. RS metadata.
Dynamic operands comprise values produced by loop-body instructions and are therefore updated during loop execution.
Each RS includes a private “constant memory” (CM) to store static operands. We support instructions with up to two static operands, served through two read ports into the CM. In addition, every RS contains a PRF with one entry per RS entry to store the results produced by its instructions. The PRF has a single write port, which is sufficient to sustain the average result-production rate of the associated FU cluster given the maximum issue rate of one instruction per cycle per RS. To support FUs that may return results out of order, such as a variable-latency FPU, a tag is sent to the FU together with the instruction at issue time. This tag uniquely identifies the PRF entry associated with the instruction and must be returned by the FU alongside the result, allowing the RS to determine which entry must capture the result. The PRF provides a design-time configurable number of read ports, matching the number of incoming result requests from the ODN that it can serve per cycle. Each read port is paired with a dedicated res_req_handler module to serve these requests. In Sections V-A and V-C, we will evaluate the impact of the number of read ports on area and performance.
When an instruction is selected for dispatch, requests for static operands are sent to the CM, while requests for dynamic operands are placed on the ODN. Operand requests on the ODN are arbitrated and served independently, so the source operands requested by an RS may return at different times. To handle this, the RS includes dedicated registers to buffer the returned operands and track their readiness information until all operands are available, at which point the instruction can be issued to the corresponding FU.
Because the physical and architectural RFs are decoupled, a mechanism is needed to ensure that the architectural register state is consistent at loop completion. To this end, when an instruction result is captured by the RS in its final loop iteration, it writes the result both to the PRF and back to the architectural RF. The RS stores a flag (do_writeback) for each instruction, indicating whether this instruction is the final writer of its architectural destination within the loop and if it should therefore write back to architectural RF in the last loop iteration. This information is recorded during DCP, as described in Section IV-C.
As mentioned in Section III, supporting loop-carried dependencies requires a more fine-grained physical register reclamation strategy than the one described so far. We adopt a simple reference-counting scheme in which each RS tracks, for every physical register, the number of consumers the register it holds (consumer_count) and reclaims the register only once all consumers have been served (consumed_by == consumer_count). An instruction can then start a new iteration as soon as the physical register allocated to the previous iteration has been reclaimed. This enables instructions from different iterations to be simultaneously in flight across RSs without violating false dependencies. If a result is simultaneously consumed by multiple instructions, the consumed_by counter needs to be incremented by the number of simultaneous consumers. To this end, the result requests arriving at the RS carry a bitmask (dest_mask) identifying all the consumers requesting a result. A popcount unit in each res_req_handler module counts the number of consumers in the bitmask and increments the consumed_by counter of the corresponding physical register accordingly. During DCP, the same mechanism is used to determine and record the total consumer_count for each physical register.
As described in Section III, the SLP architecture leverages the assumption that the dataflow graph remains static across iterations. To satisfy this requirement, we restrict the approach to straight-line loop bodies, that is, loop bodies consisting of a single basic block [59]. In such loops, any loop-carried define-use dependence through a fixed architectural register has distance one. By definition, a value produced in iteration can reach a use in a later iteration only along a definition-clear path [59], and in a straight-line loop, such a path cannot cross more than one loop boundary. Consequently, the maximum loop-carried dependence distance [60] in our design is . In other words, an instruction issued in iteration can request operands produced either in the same iteration () or in the previous one ().
To preserve true dependencies, each physical register is additionally tagged with the iteration flag of the instruction that produced its value. When an instruction issued in iteration requests an operand produced in the same iteration () or in the previous (), it includes this information in the request. At the producer side, the iteration tag carried by the request is compared against that of the produced value, and the request is stalled until the two tags match. In practice, storing the full iteration index is unnecessary; it is sufficient to store , where denotes the maximum loop-carried dependence distance among in-flight instructions. As discussed, in our case, so the iteration index reduces to a 1-bit iteration tag.
Operand Delivery Network
As mentioned in Section IV-A, Schnizo selects at most one instruction per RS at any time to request operands from the ODN. In contrast, modern OoO processors typically maintain more in-flight instructions waiting in the issue queues than can be issued simultaneously [22], [49]. As a result, they usually implement both a wakeup network, to drive the issue-queue wakeup/select logic, and a separate operand network, comprising the PRF read path and bypass network, to retrieve and forward operand values to the selected instructions [61]. In Schnizo the selection logic is static, so a separate wakeup network is not required. The ODN thus implements only the operand network, namely a mechanism to request and forward operands from producers to consumers.
The ODN handles two transactions: operand requests, issued by consumers (RSs) to request a value from a specific producer, and operand responses, issued by producers to return that value.
As described in Section IV-A, every RS places a request on the ODN for each dynamic operand required by its currently selected instruction. Each operand request carries two pieces of information: a tag identifying the producer’s physical register holding the value, and a 1-bit iteration tag, as described in Section IV-A.
As shown in Figure 9, all operand requests are routed to the producers through the request crossbar (XBAR). The request XBAR provides full connectivity between the consumer RSs and producer RS entries, allowing requests targeting different RS entries to be served in parallel. When multiple requests target the same RS entry, they may either request the same value or differ in the 1-bit iteration tag. In the latter case, the request that matches the iteration of the currently available result is served. In the former case, matching requests are coalesced into a single request, and the corresponding response is multicast to all requesters through the response XBAR. To this end, matching requests are collected into a bitmask (dest_mask), where each bit identifies an operand-request port.
Figure 9. Architecture of the ODN.
Upon receiving a result request, the target RS checks whether the requested value is available and whether the request matches its iteration tag. If both conditions hold, it drives the value together with the dest_mask onto the response XBAR.
The response XBAR returns the values requested on the request XBAR back to the consumers that placed the requests. It provides full crossbar connectivity between the producer (result) ports and consumer (operand) ports, allowing responses targeting different consumer ports to be delivered in parallel. The response XBAR is multicast-capable: a value on a producer port can be delivered simultaneously to all consumer ports recorded in the dest_mask. Because packets on the response XBAR carry operand values of up to 64-bits, its complexity is higher than that of the request XBAR, whose payload consists only of the iteration tag and producer RS entry. As a result, the number of read ports into each RS’s PRF, which equals the number of producer ports on the response XBAR, has a significant impact on the complexity of the ODN. We evaluate this tradeoff in Section V-A. On the consumer side, when an operand response arrives, the RS captures the value in its operand buffers and updates the corresponding readiness information.
Loop Controller and Register Renaming
The remaining components of the SLP extension are the loop controller and the dispatch stage.
The loop controller manages processor state in the presence of ZOLs. From its perspective, the processor can operate in one of five execution modes: regular, ZOL, DCP1, DCP2 and DEP. In regular mode, the processor executes instructions one by one, as in a conventional scalar core. When a ZOL instruction is fetched, the controller transitions to either ZOL or DCP1 mode, depending on the value of the enable_slp flag introduced in Section IV. As described earlier, execution in the DCP states remains in order, with the instruction frontend still responsible for dispatching instructions. Relative to regular and ZOL execution, the key differences are that 1) all FUs are considered for dispatch, 2) the register-renaming stage is enabled, and 3) instructions are routed to the RSs, where the associated bookkeeping information is updated. When multiple FUs of the same type are present, instructions are assigned to them in round-robin order to balance the load during superscalar execution. Finally, if an unsupported instruction is encountered, as listed in Section IV-D, the core falls back to ZOL without any performance penalty: no work is lost and no instructions are replayed. The loop controller transitions to ZOL state for the remaining instructions and loop iterations, while discarding the recorded DCP state.
While Section III described the DCP phase under a simplified assumption, loop-carried dependencies require two DCP passes over the loop body to fully resolve operand sources for all instructions. Consider the dot product kernel in fig:2a, which contains a loop-carried dependency from instruction 5 to instruction 2 through register t0. When instruction 2 is dispatched during DCP1, the RMT entry for t0 is still empty since instruction 5 has not yet been encountered. Without a mechanism to update the RS entry holding instruction 2 after instruction 5 is dispatched in DCP1, that is, once the producer of has been identified and recorded in the RMT, the RS would incorrectly classify the operand as static, causing instruction 2 to use the wrong value in subsequent iterations.
To resolve this issue, we introduce a second DCP iteration. When the first loop iteration completes (DCP1), the loop controller transitions to the DCP2 state and branches back to the first loop instruction to execute the second loop iteration of the original program. In this phase, like in DCP1, instructions are still issued one by one, in order, by the instruction frontend. When instruction 2 is dispatched during DCP2, the RMT entry for now points to the PRF entry allocated to instruction 5, allowing the correct producer to be recorded in the RS entry holding instruction 2. In addition, each RS entry stores a 1-bit flag (is_from_prev_iter) for every operand, which is set if the producer is recorded during DCP2 and cleared otherwise. This flag indicates whether the operand is produced in the same iteration in which it is consumed or in the previous one. During DEP, the RS consults this flag when issuing operand requests on the ODN to drive the 1-bit iteration tag described in Section IV-A. Operands that are still not mapped in the RMT during DCP2 are guaranteed to be static and are therefore written by the RS into its CM.
Similarly, the DCP2 phase is also used to resolve the do_writeback flag, which determines whether an instruction updates the architectural register state in the final loop iteration, as described in Section IV-A. When an instruction is dispatched during DCP1, it is not yet possible to determine whether it is the last instruction in program order to write its destination register. To address this, the RMT state is frozen at the end of DCP1. When the instruction is revisited during DCP2, the RMT is consulted to determine whether the last producer recorded for its destination register is the instruction itself; if so, the do_writeback flag is set.
Upon completion of DCP2, the loop controller transitions to DEP, during which the instruction frontend is disabled and the RSs operate independently. The loop controller then monitors the progress of the RSs and determines loop completion by aggregating their individual completion states.
Limitations
As motivated in Section I, the SLP architecture seeks to balance performance and flexibility against hardware cost and efficiency. It does so by specializing to a class of regular programs, thereby enabling a simpler and more efficient design.
As described in Section IV-A, the main limitation of the current SLP design is the lack of support for control flow within the loop body, as the dataflow graph must remain static across iterations. As a result, conditional branches (beq, bne, and similar instructions) and indirect jumps (jr, jalr) are disallowed. These instructions are detected at runtime during DCP and handled gracefully by falling back to regular ZOL execution. This limitation could further be partially mitigated through predication [62, 63]. By converting control dependences into data dependences, predication preserves a straight-line loop body and a static dataflow graph across iterations, making it conceptually compatible with the SLP execution model. Another possible mitigation is to extend the ZOL logic to support nested loops, which prior work has shown can be achieved at low cost [40]. For brevity, we leave the exploration of such techniques to future work, where their hardware/software implications and quantitative impact can be studied in depth. Unconditional jumps (j, jal) are supported in principle, but only if the resulting inlined loop body still fits within the available RS capacity.
Several resource limitations constrain the applicability of the SLP approach to generic workloads. These include running out of RS entries or CM entries in any target FU, as well as exceeding the maximum supported consumer count for a result. Again, all such conditions are detected at runtime during DCP and handled gracefully by falling back to regular ZOL execution. These limitations could also be mitigated through compiler transformations such as loop fission (or distribution) [60, 64, 65], which partitions a large loop body into multiple smaller loops that fit within the available SLP resources. This trades some of the benefits of a single larger loop body for lower per-loop resource requirements. Evaluating the effectiveness of these techniques for SLP is left for future work.
Furthermore, although this is not an intrinsic limitation of the SLP architecture, the current Schnizo implementation does not enforce any ordering guarantees between memory operations mapped to different LSUs. In the presence of memory dependencies, e.g. a load following (in program order) a store to the same address, this can result in incorrect single-thread behaviour. To prevent this, by default Schnizo’s dispatcher assigns all memory instructions to a single LSU, even if multiple LSUs are present in the hardware, serializing all memory operations and therefore guaranteeing their in-order execution. We note that this constraint can result in a significant performance limitation for low arithmetic intensity kernels, such as the AXPY and DOT kernels adopted in our evaluation. However, this constraint is only required for correctness in the presence of dependent memory operations. It can be safely relaxed when all memory operations in a loop can be guaranteed to be independent. This is the case for all but the EXP kernel adopted in our evaluation. To this end, we provide an additional bit in the zol instruction (relax_mem.), shown in Figure 6, which allows the programmer or compiler to relax this constraint on a per-loop basis, when all memory operations in a loop can be proven independent, e.g. through pointer-alias analysis [66, 67]. Accordingly, in our evaluation we set the relax_mem. bit to 1 for all but the EXP kernel.
Finally, while precise exceptions are supported in regular, ZOL and DCP modes, they are not supported in DEP, as DEP does not enforce in-order commit. Support for exceptions in DEP could nevertheless be added by treating DEP as a speculative region and rolling back to the pre-DEP state in the event of an exception. Since the architectural RF remains unchanged until the final loop iteration, the RF state can be restored without additional hardware, by deferring writeback to the architectural RF until loop termination. For exceptions that occur after stores have been committed to the memory hierarchy, however, RF rollback alone cannot restore the full pre-loop architectural state. Restart-based recovery remains safe in this case only if the loop writes to output-only locations disjoint from its inputs (i.e., the loop is idempotent [68]): re-execution will not be affected by the non-restored output values, and these values will be overwritten. If, on the other hand, stores overwrite loop inputs, update shared state, or otherwise create externally visible side effects that cannot be undone, RF rollback alone is insufficient. Supporting precise DEP exceptions for such loops would require additional mechanisms, such as store buffering, which we leave to future work. We further note that, in the intended deployment context of SLPs, namely high-throughput programmable accelerators targeting regular loop kernels, strict precise-exception support is often relaxed in practice. In such systems, exceptions are commonly employed as mechanisms for debugging, error reporting, or kernel failure detection, rather than as a general-purpose precise trap-and-resume control-flow mechanism comparable to CPU exceptions. GPUs for instance often report exceptions imprecisely [69], [70], [71], omit hardware trap support for certain exception classes, such as floating-point exceptions, [72] or support precise reporting through optional debug modes or single-stepping mechanisms, which trade performance for precision [73], [74]. In Schnizo, regular or ZOL execution provides such a precise fallback mode, while DEP should be understood as the high-throughput mode in which exceptions are imprecise unless restartability assumptions are met.
Results
For area evaluation, we implement the RS, the request and response XBARs, and the full Schnizo core in GlobalFoundries’ 12 nm LP+ technology using Fusion Compiler 2023.12, with a 1 GHz frequency target under worst-case conditions (SS, 125 °C, 0.72 V). For performance evaluation, we integrate Schnizo into an L1 cluster equipped with a local L1 Scratch-Pad Memory (SPM) and I, derived from the Snitch cluster [19]. Performance is evaluated through cycle-accurate RTL simulation of the Schnizo cluster in QuestaSim 2023.4 at the target frequency. All benchmark codes are implemented in bare-metal C++ and inline assembly, compiled with a custom C++ runtime and compiler toolchain for Snitch based on LLVM 15 at the highest optimization level (-O3). All codes are further manually optimized, through a combination of software pipelining and $4 \times loop unrolling, to hide the 4-cycle FPU and L1 memory latencies. For transparency and reproducibility, all codes are open source5.
Scalability
We evaluate the scalability of Schnizo by varying the number of RSs, RS entries, CM entries and result ports on the ODN. The number of RSs determines the degree of parallelism that can be extracted across FUs, while the number of RS entries determines the maximum loop-body size that can be supported in superscalar execution, and more generally the flexibility of SLP mode. Similarly, the number of CM entries determines the maximum number of static operands supported in SLP mode. The number of result ports determines how many operands an RS can deliver in parallel, which can affect performance for workloads with imbalanced producer-consumer patterns.
Figure 10a shows the area of the RS as a function of the number of RS entries, for a fixed number of CM entries (NumCme=4). We further vary the number of result ports. The results show that area scales near-linearly with the number of RS entries ( in all cases). Specifically, total area increases by 1.45 kGE, 1.90 kGE and 2.02 kGE per additional RS entry for 1-, 2- and 3-port RSs, respectively. Sequential and combinational logic contribute similarly: sequential logic is dominated by the flip-flop-heavy RS storage, whereas combinational logic is dominated primarily by operand multiplexing. For a fixed number of RS entries, RS area also scales with the number of CM entries, as shown in Figure 10e (NumRse=4). Again, the trend is near-linear (), with an increase of 0.78 kGE, 0.79 kGE and 0.78 kGE per additional CM entry for 1-, 2- and 3-port RSs, respectively, as the constant storage is independent of the number of result ports.
Figures 10c and 10d show the area of the request and response XBARs, respectively, as a function of the number of RSs. We further vary the number of result ports, as described above. Both XBARs are purely combinational and scale near-linearly with the number of RSs: the request XBAR at 0.94, 1.26, and 1.40 kGE/RS () for 1, 2, and 3 result ports, respectively; and the response XBAR at 2.58, 5.33, and 8.30 kGE/RS (). As we can see, increasing the number of result ports on the request and response XBARs itself leads to a near-linear increase in the cost per RS, at 0.23 kGE/RS () and 2.86 kGE/RS () per additional result port on the request and response XBARs, respectively, reducing the scalability of the architecture. In § 5-C, we explore the performance implications of reducing the number of result ports. Due to the coalescing logic described in Section IV-B, the request XBAR area also grows with the number of RS entries per RS, as shown in Figure 10b (NumResultPorts=3, NumRs=3). Specifically, we observe a near-linear growth (), at 0.15 kGE/RS entry.
Figure 10. Area of the RS as a function of the number of RS entries (a) and CM entries (e); area of the request XBAR as a function of the number of RS entries (b) and RSs (c); and area of the response XBARs as a function of the number of RSs (d).
To evaluate the overall area of Schnizo, we implement the different configurations summarized in Table I. As shown, both Snitch and the scalar Schnizo configuration fit within a modest footprint of at most kGE, making them suitable for integration in both resource-constrained and massively-parallel system-on-chips (SoCs). The scalar Schnizo-FP configuration further integrates Snitch’s 64-bit SIMD-capable FPU as an additional FU. This configuration is equivalent to the Snitch core complex shown in Figure 3, while saving on the ZOLB and SSR-dedicated area. Hence, we use Schnizo-FP as a baseline for the superscalar configurations.
| Config. | ALU F | ALU R | ALU C | LSU F | LSU R | LSU C | FPU F | FPU R | FPU C | Tot. F | Tot. R | Tot. C | §Area [kGE] | †Area Incr. |
| Snitch | 1 | - | - | 1 | - | - | 0 | - | - | 2 | - | - | 23 | 0.2× |
| Schnizo | 1 | - | - | 1 | - | - | 0 | - | - | 2 | - | - | 20 | 0.2× |
| Schn.-FP | 1 | - | - | 1 | - | - | 1 | - | - | 3 | - | - | 103 | 1.0× |
| Small | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 3 | 3 | 3 | 134 | 1.3× |
| LA | 3 | 4 | 4 | 3 | 4 | 4 | 1 | 4 | 4 | 7 | 28 | 28 | 264 | 2.6× |
| MC | 3 | 32 | 16 | 1 | - | - | 2 | 32 | 16 | 6 | 160 | 80 | 601 | 5.8× |
| TR | 2 | 32 | 16 | 1 | 32 | 64 | 2 | 32 | 16 | 5 | 160 | 128 | 696 | 6.8× |
| GP-S | 1 | 128 | 32 | 1 | 32 | 64 | 1 | 64 | 32 | 3 | 224 | 128 | 769 | 7.5× |
| GP-L | 3 | 32 | 16 | 3 | 32 | 64 | 1 | 64 | 32 | 7 | 256 | 272 | 1061 | 10.3× |
Table I. Scalar and superscalar core configurations with varying number of FUs (F), RS entries (R) and CM entries (C). § Does not include FP DIV/SQRT unit. † Relative to the Schnizo-FP configuration.
We evaluate multiple superscalar configurations, tuned for different kernel groups, as defined in Table II: linear algebra (LA), Monte Carlo (MC), and transcendental function (TR) kernels. We further evaluate the smallest theoretically-possible configuration (Small) and two general-purpose (GP) configurations balanced to meet the requirements of all microkernels: a smaller one (GP-Small) with 3 FUs, and a larger one (GP-Large) with 7 FUs. We order the configurations in Table I by total number of RS entries and CM entries. As shown, the
| Kernel | Group | Unr. Fac. | #Instructions ALU | #Instructions FPU | #Instructions LSU | #Instructions Tot. | #Co-nst. | Ideal IPC GP-L | Ideal IPC Spec. |
| axpy | LA | †1× | 3 | 1 | 3 | 7 | 7 | 7 | 7 |
| dot | LA | 4× | 2 | 4 | 8 | 14 | 10 | 3.5 | 3.5 |
| exp | TR | 4× | 22 | 40 | 28 | 90 | 86 | 2.2 | 3.2 |
| log | TR | 4× | 34 | 40 | 16 | 90 | 62 | 2.2 | 4.5 |
| pi_lcg | MC | 4× | 20 | 28 | 0 | 48 | 28 | 1.7 | 3.4 |
| pi_xoshiro | MC | 4× | 84 | 28 | 0 | 112 | 36 | 4 | 4 |
| poly_lcg | MC | 4× | 20 | 40 | 0 | 60 | 32 | 1.5 | 3 |
| poly_xoshiro | MC | 4× | 84 | 40 | 0 | 124 | 40 | 3.1 | 4.4 |
Table II. Microkernel loop body instruction mix. Reported instruction counts already account for unrolling. † 4× in scalar Snitch and Schnizo configurations.
Small configuration, with a single RS entry and CM entry per FU, introduces only a 30% overhead relative to Schnizo-FP, while theoretically tripling IPC, thanks to the low complexity of Schnizo’s superscalar scheduling logic. In practice, however, larger RS entry and CM entry counts are required to support realistic loop bodies, as discussed in Section IV-D. The smallest useful configuration (LA), providing up to 28 RS entries and CM entries, incurs an area overhead of 156% relative to Schnizo-FP.
More broadly, total core area increases monotonically with the number of RS entries and CM entries, consistent with the trends observed in Figure 10, indicating that area growth in Schnizo is driven primarily by total RS storage rather than by the number of RSs. This exposes a direct flexibility-cost tradeoff in Schnizo: supporting larger, more complex, or more heavily unrolled loop bodies requires provisioning additional RS entries, and the cost of this increased architectural flexibility grows almost linearly with RS storage, as observed above. By contrast, increasing the number of RSs, and thus the degree of parallelism exposed by the architecture, incurs only a modest marginal cost, as Schnizo’s scheduling logic scales gracefully with issue width.
Performance
We evaluate Schnizo’s performance on a set of microkernels extracted from, or representative of, a range of ML and HPC applications, ported from Snitch [19], [45]. We adopt these kernels for a detailed design-space analysis, as they exhibit diverse instruction mixes and dependency patterns. Table II reports the instruction mix of each microkernel, broken down by FU type, together with its ideal IPC, defined as:
The denominator is the number of cycles required by the most heavily utilized FU, under the idealized assumption that each FU can sustain a throughput of one instruction per cycle and that data dependencies, scheduling effects, and other pipeline bottlenecks do not limit execution. This metric therefore captures the maximum ILP that a workload exhibits on an architecture with a given FU mix. If a workload is perfectly balanced across FUs, that is, if is equal for all , then , where denotes the total number of FUs, i.e., the architecture’s degree of parallelism. For each workload, we compare the IPC measured on Schnizo against this ideal IPC, which provides an upper bound on the performance attainable by any concrete architecture with the same FU mix.
To demonstrate Schnizo’s wider applicability to ML kernels, we further implement 11 workloads from the NonGEMM benchmark suite [28], including all operators from the most time-consuming non-GEMM operator groups (excluding memory operators) listed by the authors in Table I, i.e., all normalization, element-wise arithmetic, activation, and logit computation operators.
We first evaluate the performance impact of the DCP phases by benchmarking the AXPY kernel on Schnizo-GP-L across varying problem sizes, as shown in Figure 11. For smaller problem sizes, the sequential DCP phases have a more pronounced impact, as they account for a larger fraction of total execution. Fitting Amdahl’s-law-derived curves [75] to the empirical data shows that, as this sequential fraction approaches zero, Schnizo’s performance asymptotically approaches the ideal IPC (7) and FPU utilization (1) achieved in DEP. We further note that this effect is theoretically independent of the loop body size: the fitted curve parameters , , and do not depend on the number of loop body instructions, as proven in Section A.
Figure 11. IPC (left) and FPU utilization (right) of the AXPY kernel on Schnizo-GP-L, for varying problem sizes.
In Figure 12 we extend the analysis to all microkernels, reporting both the performance achieved at the largest problem size that fits within a 128 KiB L1 SPM and the asymptotic performance. With exception of the kernels involving element-wise divisions (DIV, GELU and SILU), which are bottlenecked by the multi-cycle latency of the FP division unit, almost all other microkernels achieve a significant fraction of their ideal IPCs. Across these kernels, Schnizo achieves a geomean 92% fraction of the ideal IPCs and 92% FPU utilization at the maximum problem size, and a 95% fraction and 95% utilization asymptotically, demonstrating Schnizo’s effectiveness in extracting parallelism from real workloads.
Figure 12. Scalar vs. superscalar performance across microkernels on the Schnizo-GP-L configuration.
To measure the impact on real-world ML workloads, we profile 547 non-GEMM layers extracted from 16 widely-adopted ML models using the NonGEMM framework [28]. All layers are mapped to our non-GEMM kernels, with parameters set to the corresponding layer-specific problem sizes. Figure 13 reports the speedup achieved on Schnizo-GP-L through SLP execution, on the per-model cumulative runtime of all profiled layers.
Figure 13. Speedup of non-GEMM operators across 16 ML models (cumulative speedup in orange).
Tradeoffs
The previous evaluation was conducted on the 7-FU Schnizo-GP-L configuration, assuming an idealized ODN with one result port per RS entry, in order to stress the throughput of the architecture. However, as shown in Section V-A, the number of result ports has a significant impact on area. In Figure 14, we therefore study the performance tradeoff as a function of the number of result ports per RS. The red lines indicate the performance levels reported in Figure 12. As shown, three result ports per RS are sufficient to reach 100% of the geomean IPC attained with the fully-connected ODN, while this fraction drops to 97% and 79% for two and one result ports, respectively. Notably, AXPY and DOT are unaffected by the reduction in result ports because their balanced producer-consumer patterns never generate simultaneous requests for different results from the same producer RS.
Figure 14. Performance for varying numbers of result ports per RS.
In Section V-A, we observed that flexibility incurs a significant cost in area, and in Section V-B we evaluated performance on a flexible superscalar configuration that satisfies the RS entry and CM entry requirements of all microkernels. We now examine Schnizo’s area-performance tradeoff. We evaluate the performance of the microkernel groups defined in Table II on the respective specialized Schnizo configurations6 presented in Table I. All configurations feature less than or equal to 7 FUs as in Schnizo-GP-L, and reallocate them to better match the instruction mix of each group, increasing geomean ideal IPC across all microkernels by 16% to 4 (Table II). Figure 15 reports geomean performance across the microkernels in each group. The scalar datapoints all correspond to the same Schnizo-FP configuration and therefore have identical area, but are evaluated separately on the different microkernel groups; the resulting differences are minimal, as all microkernels achieve IPCs close to 1 (Figure 12).
Figure 15. Area-performance comparison. Area-efficiency contour lines are represented in MIPS/kGE.
Notably, Schnizo-LA achieves an area efficiency of 16.5 MIPS/kGE, 72% higher than its scalar counterpart. All other Schnizo configurations fall short of their scalar counterparts, albeit delivering geomean speedups of up to 2.6× across configurations. The core-level area-efficiency metric is conservative for the many-core setting targeted by SLPs. At cluster or chip level, improvements in IPC translate almost directly into higher throughput, whereas increases in PE area are partially amortized by fixed non-core overheads, such as L1 memories and interconnects. To account for this effect, we add a fixed 223 kGE overhead per core, corresponding to the per-core share of an 8-core Snitch cluster’s L1 memory and interconnect area [19]. Under this model, Schnizo-LA’s area-efficiency advantage over the scalar baseline increases from 72% to 195%.
To put the Schnizo-LA datapoint in context, we compare it against a recent open-source vector processor, Spatz, a state-of-the-art area-efficient architecture for vectorizable kernels. The Spatz-LA datapoint reports the area of a 4-lane double-precision Spatz configuration and its geomean performance on AXPY and DOT, taken from TROOP [76] and normalized by the number of lanes. Performance numbers were calculated as the equivalent number of scalar instructions per cycle required to achieve the reported FPU utilizations on a scalar RISC-V core, multiplied by Spatz’ 1 GHz clock frequency. While Spatz achieves a comparable performance per lane to Schnizo-LA, its area efficiency is 46% lower, owing to the vector RF alone accounting for 80% of Schnizo-LA’s total area.
Finally, the figure also compares Schnizo against open-source state-of-the-art (SoA) OoO processors. Unfortunately, to the best of our knowledge, the only modern superscalar processors for which public core-only area data, excluding caches, is available are CVA6S+ [77] and C910 [78]. To enable a benchmark-agnostic comparison, we plot each processor’s theoretical peak performance, defined as the product of its issue width and reported clock frequency. Even under this unfavorable assumption, the specialized Schnizo configurations still achieve higher performance and area efficiency, primarily due to CVA6S+’s and C910’s comparably lower issue widths (2 and 3, respectively). This highlights the different design point: conventional OoO cores incur significant area overheads to retain general-purpose flexibility even at modest issue widths, whereas Schnizo specializes for regular loops to expose wider loop-mode issue with lower-complexity hardware. We note, however, that this is not intended as a direct or fully fair comparison in terms of area and area efficiency, since these processors target fully-flexible general-purpose computing, whereas Schnizo is tailored to accelerator-oriented workloads. Accordingly, we expect a significant portion of their area to be devoted to features, such as branch prediction, that are not essential for accelerator-oriented workloads [79]. A fair comparison against a stripped-down OoO core will be developed in future work. Nevertheless, the comparison suggests that performance competitive with conventional OoO architectures can be achieved at a reduced area footprint, and that SLPs represent an effective solution in this direction.
Related Work
Loop-oriented specializations. In Section II we discussed how our work builds on prior loop-oriented processor specializations, including hardware loops [33, 34, 35, 18, 36, 37, 38, 39, 30, 40], zero-overhead loop buffers (ZOLBs) [33, 34, 35, 39, 38, 40, 19], Snitch’s pseudo-dual-issue execution model [19], and its software-assisted extensions COPIFT [45] and COPIFTv2 [46]. Pseudo-dual issue showed that a simple single-issue frontend can incrementally construct a superscalar schedule across loop iterations, but only for trivial, fully separable loop schedules. COPIFT and COPIFTv2 relax this restriction, but do so by shifting communication and synchronization back to software, resulting in a more complex and less transparent programming model. SLPs retain the key insight behind this line of work, namely the loop-local reuse of an execution schedule across iterations, while replacing explicit software-managed inter-thread communication with hardware dependency tracking.
Conventional OoO superscalar execution. In Section III we compared SLPs with conventional OoO superscalar processors. SLPs borrow several core mechanisms from conventional designs, including dependence tracking [47, 48, 49], register renaming [47, 48, 49], and physical-register reclamation [48, 52, 53, 54, 55], but use them to construct a schedule only during the first iteration of a loop. This is the key distinction from general-purpose OoO execution: an OoO core continuously solves a dynamic scheduling problem for arbitrary code, whereas SLPs specialize for regular loops and amortize schedule construction across iterations by leveraging dataflow graph invariance. This specialization further allows the issue width used during dataflow construction to be decoupled from the issue width realized during execution, substantially simplifying the scheduling logic. This comes at the cost of reduced generality, as SLPs trade the flexibility of general-purpose OoO execution for lower scheduling complexity and improved area and energy efficiency.
Loop specialization in OoO processors. Loop-oriented specializations have also been explored in superscalar designs. Loop caches [80], [81], [82], [83] exploit the fact that hot loops repeatedly execute the same instructions, reducing instruction-cache access, fetch, branch prediction, and (in some designs) decode work by caching and replaying instructions or decoded micro-ops for small loops.
Revolver [84] moves this idea closer to the backend: it keeps two unrolled copies of a loop resident in an OoO core’s issue queues, from which they are replayed to further eliminate repeated rename, allocate and dispatch work. Revolver and SLPs therefore share the idea of caching loop execution state beyond the frontend. In this sense, Revolver can be viewed as realizing the SLP principle as an energy-saving mode within a conventional OoO processor, while still relying on the costly machinery of general-purpose OoO execution. Standalone SLPs, by contrast, realize this principle in a loop-specialized architecture, enabling superscalar execution in lightweight in-order PEs without a conventional OoO backend. Thus, Revolver preserves the flexibility of general-purpose OoO processors while reaping the energy-efficiency benefits of the SLP paradigm, whereas standalone SLPs trade off this flexibility to further realize the SLP paradigm’s area-efficiency benefits. This difference is also reflected in their cached state: Revolver stores two unrolled loop bodies and assigns two physical destination registers to each result-producing loop instruction, whereas Schnizo stores a single loop body in its RSs and reuses a single physical register across iterations. This distinction is important at the lightweight PE design point, critical for accelerator integration, targeted by Schnizo, where RS and PRF storage are primary area contributors.
Finally, LoopFrog [85] leverages loop regularity by spawning future loop iterations as speculative “threadlets” inside a wide OoO core. While their approach targets parallelism across loop iterations, our approach exposes ILP within a loop iteration, making the two approaches largely orthogonal. Moreover, while LoopFrog handles inter-iteration dependencies speculatively, squashing threadlets upon ordering violations, SLPs support loop-carried dependencies directly through explicit dependency recording.
Statically-scheduled superscalar architectures. Other low-complexity alternatives to OoO superscalar execution include architectures that shift scheduling from hardware to software, such as VLIW [86], [87], EDGE [88], [89], and TTA-style processors [90]. Like SLPs, these architectures aim to exploit ILP without incurring the full hardware cost of dynamic scheduling. The key difference is where the schedule resides. In VLIW, EDGE and TTA-style architectures, much of the execution schedule and communication structure is determined statically by the compiler and encoded in the program representation, which must therefore reflect the target machine organization. In SLPs, by contrast, software still presents an ordinary scalar loop body, and the hardware derives a loop-local schedule dynamically during the first loop iteration. This removes the need for compiler support to derive and encode implementation-specific schedules in the binary, thereby improving portability across implementations.
Vector processors. Vector processors are a natural comparison point for SLPs as both architectures target regular loop kernels, yet do so through different abstractions. Vector programs are typically derived from loop programs through loop vectorization, whereas SLPs treat scalar loops as first-class citizens. Thus, although both architectures target the same class of programs, the vector and loop abstractions lead to concrete differences in scheduling, live state granularity, and the way ILP is exposed. Specifically, vector processors expose ILP by chaining dependent vector operations within the pipelined vector datapath [91], [92], but cannot overlap the scalar operations in the surrounding stripmining loop, such as reductions, scalar recurrences, or address-generation logic. These operations have been observed to become a bottleneck with short vectors [93], [94], which are commonly employed in resource-constrained and massively-parallel configurations [94], [95]. Short vectors are attractive precisely because vector processors track live state at vector granularity: increasing the vector length increases vector RF capacity requirements and, in turn, hardware cost. SLPs, by contrast, track live state at vector-element granularity. Therefore, their state requirements do not scale with vector length or, equivalently, with the number of loop iterations. To this end, coupling an SLP that can capture ILP uniformly across all stripmining loop operations to a vector processor that can efficiently extract DLP could represent a promising approach. We leave a detailed exploration of this design point, as well as a quantitative comparison against vector processors, to future work.
Conclusion
In this work, we introduced Superscalar Loop Processors (SLPs), a lightweight superscalar architecture specialized for regular, compute-intensive loop kernels. Unlike conventional OoO superscalar processors, SLPs solve the dynamic scheduling problem only in the first iteration of a loop and reuse the resulting dependence information in subsequent iterations. By decoupling the issue width used for schedule construction from the issue width realized during execution, SLPs can achieve multiple-issue execution without incurring the full complexity of dynamic OoO scheduling. While standalone SLPs restrict superscalar execution to regular loops, the SLP paradigm could be realized as a specialized execution mode in a generalpurpose OoO core, preserving support for arbitrary code while possibly improving energy efficiency on hot loops.
We presented Schnizo, a working prototype of the SLP architecture developed as an enhancement to a tiny RV32I core. We release Schnizo as open-source hardware to support future architectural research on SLPs. Through its design, we highlighted both the general challenges and the practical solutions involved in building effective SLPs. At the same time, Schnizo represents only one point in the SLP design space. Alternative implementations based on a centralized physical RF, more aggressive pipelining, or shared constant memories across FUs remain open for exploration together with their associated tradeoffs.
We evaluated the scalability of Schnizo, showing that the degree of parallelism can be efficiently scaled, whereas extending support to larger loop bodies incurs storage costs that grow linearly. Although our proof-of-concept implementation is built entirely from flip-flops (FFs), all structures expose low port counts and therefore lend themselves to more area-efficient SRAM-based implementations. Such implementations could mitigate the cost of scaling to larger loop bodies, both in the sequential storage elements and the mux-heavy combinational port logic.
On a diverse set of loop microkernels, Schnizo delivers substantial improvements in IPC and FPU utilization over the scalar baseline, reaching up to a geomean 92% of the ideal IPC and FPU utilization attainable on an ideal architecture with the same degree of parallelism. On simple linear algebra kernels, a specialized Schnizo configuration achieves a geomean speedup of 4.4× over scalar execution while improving core area efficiency by 72%.
Overall, these results show that SLPs offer a compelling path for programmable many-core accelerators targeting regular, compute-intensive workloads, delivering higher FU utilization while preserving the efficiency advantages of lightweight cores that are key to scaling performance.
Acknowledgements
This work has received funding from the Swiss State Secretariat for Education, Research, and Innovation (SERI) under the SwissChips initiative.
Independence of Performance on Loop-Body Size
Given a loop with loop-body instructions and iterations, attaining IPC of and , respectively, in DCP and DEP mode, the following equations hold, by definition of IPC:
Again, by definition of IPC, the overall IPC of the loop is given by:
This formula reflects the empirically-validated curves in Figure 11, where , , and are given by:
That is, , , and are constants that do not depend on , and the overall IPC is only a function of the number of iterations .
References
- [1]D. Amodei and D. Hernandez, “Ai and compute,” OpenAI Blog, 2018. [Online]. Available: https://openai.com/research/ai-and-compute
- [2]J. Kaplan, S. McCandlish, T. Henighan, T. B. Brown, B. Chess, R. Child, S. Gray, A. Radford, J. Wu, and D. Amodei, “Scaling laws for neural language models,” arXiv preprint arXiv:2001.08361, 2020. [Online]. Available: https://arxiv.org/abs/2001.08361
- [3]J. Hoffmann, S. Borgeaud, A. Mensch, E. Buchatskaya, T. Cai, E. Rutherford, D. de Las Casas, L. A. Hendricks, J. Welbl, A. Clark, T. Henighan, E. Noland, K. Millican, G. van den Driessche, B. Damoc, A. Guy, S. Osindero, K. Simonyan, E. Elsen, O. Vinyals, J. W. Rae, and L. Sifre, “An empirical analysis of compute-optimal large language model training,” in Advances in Neural Information Processing Systems, vol. 35, 2022, pp. 30016–30030. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2022/file/c1e2faff65f58870935f114ebe04a3e5-Paper-Conference.pdf
- [4]J. Sevilla and E. Roldán, “Training compute frontier AI models grows by 4–5x per year,” Epoch AI, Tech. Rep., May 2024. [Online]. Available: https://epoch.ai/blog/training-compute-of-frontier-ai-models-grows-by-4-5x-per-year
- [5]OpenAI, “The state of enterprise ai,” OpenAI, Tech. Rep., 2025. [Online]. Available: https://cdn.openai.com/pdf/7ef17d82-96bf-4dd1-9df2-228f7f377a29/the-state-of-enterprise-ai-2025-report.pdf
- [6]D. C. Jung, M. Ruttenberg, P. Gao, S. Davidson, D. Petrisko, K. Li, A. K. Kamath, L. Cheng, S. Xie, P. Pan, Z. Zhao, Z. Yue, B. Veluri, S. Muralitharan, A. Sampson, A. Lumsdaine, Z. Zhang, C. Batten, M. Oskin, D. Richmond, and M. B. Taylor, “Scalable, programmable and dense: The hammerblade open-source RISC-V manycore,” in Proceedings of the Annual International Symposium on Computer Architecture (ISCA). IEEE, 2024, pp. 770–784. [Online]. Available: https://doi.org/10.1109/ISCA59077.2024.00061
- [7]D. Abts, J. Ross, J. Sparling, M. Wong-VanHaren, M. Baker, T. Hawkins, A. Bell, J. Thompson, T. Kahsai, G. Kimmell, J. Hwang, R. Leslie-Hurd, M. Bye, E. R. Creswick, M. Boyd, M. Venigalla, E. Laforge, J. Purdy, P. Kamath, D. Maheshwari, M. Beidler, G. Rosseel, O. Ahmad, G. Gagarin, R. Czekalski, A. Rane, S. Parmar, J. Werner, J. Sproch, A. Macías, and B. Kurtz, “Think fast: A tensor streaming processor (TSP) for accelerating deep learning workloads,” in Proceedings of the Annual International Symposium on Computer Architecture (ISCA). IEEE, 2020, pp. 145–158. [Online]. Available: https://doi.org/10.1109/ISCA45697.2020.00023
- [8]A. Firoozshahian, J. Coburn, R. Levenstein, R. Nattoji, A. Kamath, O. Wu, G. Grewal, H. Aepala, B. Jakka, B. Dreyer, A. Hutchin, U. Diril, K. Nair, E. K. Aredestani, M. Schatz, Y. Hao, R. Komuravelli, K. Ho, S. Abu Asal, J. Shajrawi, K. Quinn, N. Sreedhara, P. Kansal, W. Wei, D. Jayaraman, L. Cheng, P. Chopda, E. Wang, A. Bikimundla, A. Karthik Sengottuvel, K. Thottempudi, A. Narasimha, B. Dodds, C. Gao, J. Zhang, M. Al-Sanabani, A. Zehtabioskuie, J. Fix, H. Yu, R. Li, K. Gondkar, J. Montgomery, M. Tsai, S. Dwarakapuram, S. Desai, N. Avidan, P. Ramani, K. Narayanan, A. Mathews, S. Gopal, M. Naumov, V. Rao, K. Noru, H. Reddy, P. Venkatapuram, and A. Björlin, “Mtia: First generation silicon targeting meta’s recommendation systems,” in Proceedings of the 50th Annual International Symposium on Computer Architecture, ser. ISCA ’23. New York, NY, USA: Association for Computing Machinery, 2023. [Online]. Available: https://doi.org/10.1145/3579371.3589348
- [9]J. Choquette, “NVIDIA Hopper H100 GPU: Scaling Performance,” IEEE Micro, vol. 43, no. 3, pp. 9–17, 2023.DOI
- [10]J. Coburn, C. Tang, S. A. Asal, N. Agrawal, R. Chinta, H. Dixit, B. Dodds, S. Dwarakapuram, A. Firoozshahian, C. Gao, K. Gondkar, T. Graf, J. Hu, J. Huang, S. Hughes, A. Hutchin, B. Jakka, G. J. Chen, I. Kalyanaraman, A. Kamath, P. Kansal, E. Kazi, R. Levenstein, M. Maddury, A. Mastro, S. Medaiyese, P. Modi, J. Montgomery, S. Nadathur, A. Nagpal, A. Narasimha, M. Naumov, E. Ozer, J. Park, P. Ramani, H. Reddy, D. Reiss, D. Roy, S. Sekar, A. Sharma, P. Shetty, A. Sukumaran-Rajam, E. Tal, M. Tsai, S. Varshini, R. Wareing, O. Wu, X. Xie, J. Yang, H. Yu, T. Zargar, Z. Zeng, F. Zhang, A. Matthews, X. Jiao, J. Zhang, E. Menage, T. E. Stokke, and M. Souroiri, “Meta’s second generation ai chip: Model-chip co-design and productionization experiences,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture, ser. ISCA ’25. New York, NY, USA: Association for Computing Machinery, 2025, pp. 169–1702. [Online]. Available: https://doi.org/10.1145/3695053.3731409
- [11]R. Prabhakar, R. Siwarakamarishnan, D. Gandhi, Y. Du, M. Wang, X. Song, K. Zhang, T. Gao, A. Wang, X. Li, Y. Sheng, J. Brot, D. Sokolov, A. Vivek, C. Leung, A. Sabnis, J. Bai, T. Zhao, M. Gottscho, D. Jackson, M. Luttrell, M. K. Shah, Z. Chen, K. Liang, S. Jain, U. Thakker, D. Huang, S. Jairath, K. J. Brown, and K. Oloukotun, “Sambanova sm410: Scaling the ai memory wall with dataflow and composition of experts,” in Proceedings of the 2024 57th IEEE/ACM International Symposium on Microarchitecture, ser. MICRO ’24. IEEE Press, 2024, pp. 1353–1366. [Online]. Available: https://doi.org/10.1109/MICRO61859.2024.00100
- [12]J. Vaskevich and D. Capalija, “Blackhole & TT-Metalium: The standalone AI computer and its programming model,” in 2024 IEEE Hot Chips 36 Symposium (HCS), 2024, pp. 1–30.
- [13]S. Lie, “Wafer-scale AI: GPU impossible performance,” in Proceedings of the 36th IEEE Hot Chips Symposium (HCS). IEEE, 2024, pp. 1–71.DOI
- [14]A. Price, S. Pareek, J. Cabezas, D. Clarke, B. Ozgul, F. Barat, Y. Fu, S. Münz, D. Stuart, P. Schlangen, P. Duarte, S. Date, I. Paul, J. Weng, S. Santan, V. Kathail, A. Sirasao, and J. Noguera, “AMD XDNAT NPU in ryzen™ AI processors,” IEEE Micro, vol. 44, no. 6, pp. 62–71, 2024.
- [15]P. Scheffler, T. Benz, V. Potocnik, T. Fischer, L. Colagrande, N. Wistoff, Y. Zhang, L. Bertaccini, G. Ottavi, M. Eggimann, M. Cavalcante, G. Paulin, F. K. Gürkaynak, D. Rossi, and L. Benini, “Occamy: A 432-core dual-chiplet dual-hbm2e 768-dp-flop/s risc-v system for 8-to-64-bit dense and sparse computing in 12-nm finfet,” IEEE Journal of Solid-State Circuits, vol. 60, no. 4, pp. 1324–1338, 2025.
- [16]H. Liao, J. Tu, J. Xia, H. Liu, X. Zhou, H. Yuan, and Y. Hu, “Ascend: A scalable and unified architecture for ubiquitous deep neural network computing : Industry track paper,” in 2021 IEEE International Symposium on High-Performance Computer Architecture (HPCA), 2021, pp. 789–801.DOI
- [17]Stanford Institute for Human-Centered Artificial Intelligence, “Ai index report 2025,” 2025. [Online]. Available: https://hai.stanford.edu/ai-index/2025-ai-index-report
- [18]D. Talla, L. John, and D. Burger, “Bottlenecks in multimedia processing with simd style extensions and architectural enhancements,” IEEE Transactions on Computers, vol. 52, no. 8, pp. 1015–1031, 2003.
- [19]F. Zaruba, F. Schuiki, T. Hoefler, and L. Benini, “Snitch: A tiny pseudo dual-issue processor for area and energy efficient execution of floating-point intensive workloads,” IEEE Transactions on Computers, vol. 70, no. 11, pp. 1845–1860, 2021. [Online]. Available: https://doi.org/10.1109/TC.2020.3027900
- [20]B. Baas, Z. Yu, M. Meeuwsen, O. Sattari, R. Apperson, E. Work, J. Webb, M. Lai, T. Mohsenin, D. Truong, and J. Cheung, “Asap: A fine-grained many-core platform for dsp applications,” IEEE Micro, vol. 27, no. 2, pp. 34–45, 2007.DOI
- [21]B. Bohnenstiel, A. Stillmaker, J. Pimentel, T. Andreas, B. Liu, A. Tran, E. Adeagbo, and B. Baas, “A 5.8 pj/op 115 billion ops/sec, to 1.78 trillion ops/sec 32nm 1000-processor array,” in 2016 IEEE Symposium on VLSI Circuits (VLSI-Circuits), 2016, pp. 1–2.
- [22]S. Palacharla, N. P. Jouppi, and J. E. Smith, “Complexity-effective superscalar processors,” Proceedings of the 24th Annual International Symposium on Computer Architecture (ISCA), 1997.
- [23]G. Kucuk, D. Ponomarev, O. Ergin, and K. Ghosе, “Complexity-effective reorder buffer designs for superscalar processors,” IEEE Transactions on Computers, vol. 53, no. 6, pp. 653–665, 2004.DOI
- [24]D. Folegnani and A. González, “Energy-effective issue logic,” in Proceedings of the 28th Annual International Symposium on Computer Architecture, ser. ISCA ’01. New York, NY, USA: Association for Computing Machinery, 2001, p. 230–239. [Online]. Available: https://doi.org/10.1145/379240.379266
- [25]M. Huang, J. Renau, and J. Torrellas, “Energy-efficient hybrid wakeup logic,” in Proceedings of the International Symposium on Low Power Electronics and Design, 2002, pp. 196–201.
- [26]T. Miyajima and L. Fukuoka, “Benchmarking the cerebras wafer scale engine-2 architecture,” in Proceedings of the SC ’25 Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis, ser. SC Workshops ’25. New York, NY, USA: Association for Computing Machinery, 2025, pp. 818–822. [Online]. Available: https://doi.org/10.1145/3731599.3767438
- [27]S. Feng, B. Hou, H. Jin, W. Lin, J. Shao, R. Lai, Z. Ye, L. Zheng, C. H. Yu, Y. Yu, and T. Chen, “Tensorir: An abstraction for automatic tensorized program optimization,” in Proceedings of the ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). Association for Computing Machinery, 2023, pp. 804–817. [Online]. Available: https://doi.org/10.1145/3575693.3576933
- [28]R. Karami, S.-C. Kao, and H. Kwon, “Understanding the performance horizon of the latest ml workloads with nongemm workloads,” in 2025 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), 2025, pp. 1–14.arxiv.org/abs/2404.11788
- [29]N. Vasile, O. Zinenko, T. Theodoridis, P. Goyal, Z. DeVito, W. S. Moses, S. Verdoolaege, A. Adams, and A. Cohen, “Tensor comprehensions: Framework-agnostic high-performance machine learning abstractions,” 2018. [Online]. Available: https://arxiv.org/abs/1802.04730
- [30]M. Gautschi, P. D. Schiavone, A. Traber, I. Loi, A. Pullini, D. Rossi, E. Flamand, F. K. Gürkaynak, and L. Benini, “Near-threshold risc-v core with dsp extensions for scalable iot endpoint devices,” IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 25, no. 10, pp. 2700–2713, 2017.arxiv.org/abs/1608.08376
- [31]E. Cui, T. Li, and Q. Wei, “Risc-v instruction set architecture extensions: A survey,” IEEE Access, vol. 11, pp. 24696–24711, 2023.DOI
- [32]C. Galuzzi and K. F. Kere, “The instruction-set extension problem: A survey,” ACM Trans. Reconfigurable Technol. Syst., vol. 4, no. 2, May 2011. [Online]. Available: https://doi.org/10.1145/1968502.1968509
- [33]R. Bajwa, M. Hiraki, H. Kojima, D. Gorny, K. Nitta, A. Shridhar, K. Seki, and K. Sasaki, “Instruction buffering to reduce power in processors for signal processing,” IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 5, no. 4, pp. 417–424, 1997.DOI
- [34]G.-R. Uh, Y. Wang, D. Whalley, S. Jinturkar, C. Burns, and V. Cao, “Effective exploitation of a zero overhead loop buffer,” in ACM SIGPLAN 1999 Workshop on Languages, Compilers, and Tools for Embedded Systems (LCTES), 1999, p. 10–19.
- [35]Y.-L. Tsao, W.-H. Chen, W.-S. Cheng, M.-C. Lin, and S.-J. Jou, “Hardware nested looping of parameterized and embedded dsp core,” in IEEE International Systems-on-Chip Conference (SOC), 2003, pp. 49–52.
- [36]N. Kavvadias and S. Nikolaidis, “Elimination of overhead operations in complex loop structures for embedded microprocessors,” IEEE Transactions on Computers, vol. 57, no. 2, pp. 200–214, 2008.DOI
- [37]N. Kavvadias and K. Masselos, “Efficient hardware looping units for fpgas,” in IEEE Computer Society Annual Symposium on VLSI (ISVLSI), 2010, pp. 35–40.
- [38]Z. Wei, P. Liu, J. Kong, and R. Ying, “Low-power microarchitecture of zero-overhead nested loops in embedded processors,” in International Symposium on Intelligent Signal Processing and Communication Systems (ISPACS), 2010, pp. 1–4.DOI
- [39]K. Vadivel, M. Wijtvelt, R. Jordans, and H. Corporaal, “Loop overhead reduction techniques for coarse grained reconfigurable architectures,” in Euromicro Conference on Digital System Design (DSD), 2017, pp. 14–21.DOI
- [40]L. Colagrande, L. Leone, M. Coco, A. Deaconeasa, and L. Benini, “Towards zero-stall matrix multiplication on energy-efficient risc-v clusters for machine learning acceleration,” in 2025 IEEE/ACM International Symposium on Low Power Electronics and Design (ISLPED), 2025, pp. 1–7.arxiv.org/abs/2506.10921
- [41]E. Fan, X. Guan, F. Hu, H. Shi, H. Zhou, and J. Yao, “Postiz: Extending post-increment addressing for loop optimization and code size reduction,” in Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization, ser. CGO ’25. New York, NY, USA: Association for Computing Machinery, 2025, p. 600–613. [Online]. Available: https://doi.org/10.1145/3696443.3708935
- [42]E. Lee and D. Messerschmitt, “Pipeline interleaved programable dsp’s: Architecture,” IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 35, no. 9, pp. 1320–1333, 1987.
- [43]F. Schuiki, F. Zaruba, T. Hoefler, and L. Benini, “Stream semantic registers: A lightweight RISC-V ISA extension achieving full compute utilization in single-issue cores,” IEEE Transactions on Computers, vol. 70, no. 2, pp. 212–227, 2021. [Online]. Available: https://doi.org/10.1109/TC.2020.2987314
- [44]P. Scheffler, F. Zaruba, F. Schuiki, T. Hoefler, and L. Benini, “Sparse stream semantic registers: A lightweight isa extension accelerating general sparse linear algebra,” IEEE Trans. Parallel Distrib. Syst., vol. 34, no. 12, p. 3147–3161, Dec. 2023. [Online]. Available: https://doi.org/10.1109/TPDS.2023.3322029
- [45]L. Colagrande and L. Benini, “Dual-issue execution of mixed integer and floating-point workloads on energy-efficient in-order risc-v cores,” in 2025 62nd ACM/IEEE Design Automation Conference (DAC), 2025, pp. 1–7.DOI
- [46]——, “Late breaking results: Boosting efficient dual-issue execution on lightweight risc-v cores,” in 2026 Design, Automation & Test in Europe Conference (DATE), 2026, pp. 1–3.
- [47]R. M. Tomasulo, “An efficient algorithm for exploiting multiple arithmetic units,” IBM Journal of Research and Development, vol. 11, no. 1, pp. 25–33, 1967.DOI
- [48]K. C. Yeager, “The mips r10000 superscalar microprocessor,” IEEE Micro, vol. 16, no. 2, p. 28–40, Apr. 1996. [Online]. Available: https://doi.org/10.1109/40.491460
- [49]R. Kessler, “The alpha 21264 microprocessor,” IEEE Micro, vol. 19, no. 2, pp. 24–36, 1999.DOI
- [50]R. Balasubramonian, S. Dwarkadas, and D. Albonesi, “Reducing the complexity of the register file in dynamic superscalar processors,” in Proceedings, 34th ACM/IEEE International Symposium on Microarchitecture. MICRO-34, 2001, pp. 237–248.
- [51]J. Tseng and K. Asanovic, “Banked multiported register files for high-frequency superscalar microprocessors,” in 30th Annual International Symposium on Computer Architecture, 2003. Proceedings., 2003, pp. 62–71.
- [52]J. Smith and G. Sohi, “The microarchitecture of superscalar processors,” Proceedings of the IEEE, vol. 83, no. 12, pp. 1609–1624, 1995.DOI
- [53]M. Moudgill, K. Pingali, and S. Vassiliadis, “Register renaming and dynamic speculation: an alternative approach,” in Proceedings of the 26th Annual International Symposium on Microarchitecture, ser. MICRO 26. Washington, DC, USA: IEEE Computer Society Press, 1993, p. 202–213.
- [54]H. Akkary, R. Rajwar, and S. Srinivasan, “Checkpoint processing and recovery: towards scalable large instruction window processors,” in Proceedings. 36th Annual IEEE/ACM International Symposium on Microarchitecture. 2003. MICRO-36, 2003, pp. 423–434.
- [55]S. Battle, A. D. Hilton, M. Hempstead, and A. Roth, “Flexible register management using reference counting,” in IEEE International Symposium on High-Performance Computer Architecture, 2012, pp. 1–12.DOI
- [56]K. Farkas, P. Chow, N. Jouppi, and Z. Vranesic, “The multicluster architecture: reducing cycle time through partitioning,” in Proceedings of 30th Annual International Symposium on Microarchitecture, 1997, pp. 149–159.
- [57]G. S. Sohi, S. E. Breach, and T. N. Vijaykumar, “Multiscalar processors,” SIGARCH Comput. Archit. News, vol. 23, no. 2, p. 414–425, May 1995. [Online]. Available: https://doi.org/10.1145/225830.224451
- [58]J. E. Smith, “Instruction-level distributed processing,” Computer, vol. 34, no. 4, p. 59–65, Apr. 2001. [Online]. Available: https://doi.org/10.1109/2.917541
- [59]A. V. Aho, M. S. Lam, R. Sethi, and J. D. Ullman, Compilers: Principles, Techniques, and Tools, 2nd ed. Pearson, 2006.
- [60]R. Allen and K. Kennedy, Optimizing Compilers for Modern Architectures: A Dependence-based Approach. Morgan Kaufmann, 2001.
- [61]M. Taylor, W. Lee, S. Amarasinghe, and A. Agarwal, “Scalar operand networks,” IEEE Transactions on Parallel and Distributed Systems, vol. 16, no. 2, pp. 145–162, 2005.
- [62]J. R. Allen, K. Kennedy, C. Porterfield, and J. Warren, “Conversion of control dependence to data dependence,” in Proceedings of the 10th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, ser. POPL ’83. New York, NY, USA: Association for Computing Machinery, 1983, p. 177–189. [Online]. Available: https://doi.org/10.1145/567067.567085
- [63]S. A. Mahlke, D. C. Lin, W. Y. Chen, R. E. Hank, and R. A. Bringmann, “Effective compiler support for predicated execution using the hyperblock,” in Proceedings of the 25th Annual International Symposium on Microarchitecture, ser. MICRO 25. Washington, DC, USA: IEEE Computer Society Press, 1992, p. 45–54.
- [64]K. Kennedy and K. McKinley, “Loop distribution with arbitrary control flow,” in Supercomputing ’90:Proceedings of the 1990 ACM/IEEE Conference on Supercomputing, 1990, pp. 407–416.
- [65]U. K. Banerjee, Loop Transformations for Restructuring Compilers: The Foundations. USA: Kluwer Academic Publishers, 1993.DOI
- [66]M. Hind, “Pointer analysis: haven’t we solved this problem yet?” in Proceedings of the 2001 ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering, ser. PASTE ’01. New York, NY, USA: Association for Computing Machinery, 2001, p. 54–61. [Online]. Available: https://doi.org/10.1145/379605.379665
- [67]U. Banerjee, Dependence Analysis. Kluwer Academic Publishers, 1997.DOI
- [68]M. de Kruijf and K. Sankaralingam, “Idempotent processor architecture,” in Proceedings of the 44th Annual IEEE/ACM International Symposium on Microarchitecture, ser. MICRO-44. New York, NY, USA: Association for Computing Machinery, 2011, p. 140–151. [Online]. Available: https://doi.org/10.1145/2155620.2155637
- [69]J. Menon, M. De Kruijf, and K. Sankaralingam, “igpu: exception support and speculative execution on gpus,” in Proceedings of the 39th Annual International Symposium on Computer Architecture, ser. ISCA ’12. USA: IEEE Computer Society, 2012, p. 72–83.DOI
- [70]I. Tanasie, I. Gelado, M. Jorda, E. Ayguade, and N. Navarro, “Efficient exception handling support for gpus,” in Proceedings of the 50th Annual IEEE/ACM International Symposium on Microarchitecture, ser. MICRO-50 ’17. New York, NY, USA: Association for Computing Machinery, 2017, p. 109–122. [Online]. Available: https://doi.org/10.1145/3123939.3123950
- [71]NVIDIA Corporation, CUDA-GDB Documentation: GPU Error Reporting, NVIDIA, 2026, accessed 2026-04-04. [Online]. Available: https://docs.nvidia.com/cuda/cuda-gdb/index.html#gpu-error-reporting
- [72]X. Li, I. Laguna, B. Fang, K. Swirydowicz, A. Li, and G. Gopalakrishnan, “Design and evaluation of gpu-fpx: A low-overhead tool for floating-point exception detection in nvidia gpus,” in Proceedings of the 32nd International Symposium on High-Performance Parallel and Distributed Computing, ser. HPDC ’23. New York, NY, USA: Association for Computing Machinery, 2023, p. 59–71. [Online]. Available: https://doi.org/10.1145/3588195.3592991
- [73]Advanced Micro Devices, Inc., ROCgdb Documentation: AMD GPU Memory Violation Reporting, AMD, 2026, accessed 2026-04-04. [Online]. Available: https://rocm.docs.amd.com/projects/ROCgdb/en/amd-staging/ROCgdb/gdb/doc/gdb/AMD-GPU.html#amd-gpu-memory-violation-reporting
- [75]G. M. Amdahl, “Validity of the single processor approach to achieving large scale computing capabilities,” in Proceedings of the April 18-20, 1967, Spring Joint Computer Conference, ser. AFIPS ’67 (Spring). New York, NY, USA: Association for Computing Machinery, 1967, p. 483–485. [Online]. Available: https://doi.org/10.1145/1465482.1465560
- [76]N. K. Purayil, D. Shen, M. Perotti, and L. Benini, “Troop: At-the-roofline performance for vector processors on low operational intensity workloads,” in 2025 IEEE 43rd International Conference on Computer Design (ICCD), 2025, pp. 594–601.DOI
- [77]Z. Fu, R. Tedeschi, G. Ottavi, N. Wistoff, C. Fuguet, D. Rossi, and L. Benini, “Ramping up open-source risc-v cores: Assessing the energy efficiency of superscalar, out-of-order execution,” in Proceedings of the 22nd ACM International Conference on Computing Frontiers (CF ’25). ACM, 2025, pp. 12–20.DOI
- [78]C. Chen, X. Xiang, C. Liu, Y. Shang, R. Guo, D. Liu, Y. Lu, Z. Hao, J. Luo, Z. Chen, C. Li, Y. Pu, J. Meng, X. Yan, Y. Xie, and X. Qi, “Xuantie-910: A commercial multi-core 12-stage pipeline out-of-order 64-bit high performance risc-v processor with vector extension,” in 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA), 2020, pp. 52–64.DOI
- [79]K. Kliakis, S. Xydis, and D. Soudris, “Repurposing gpu microarchitectures with light-weight out-of-order execution,” IEEE Transactions on Parallel and Distributed Systems, vol. 33, no. 2, pp. 388–402, 2022.
- [80]J. Kim, M. Gupta, and W. Mengno-Smith, “The filter cache: an energy efficient memory structure,” in Proceedings of 30th Annual International Symposium on Microarchitecture, 1997, pp. 184–193.
- [81]N. Bellas, I. Hajj, C. Polychronopoulos, and G. Stamoulis, “Energy and performance improvements in microprocessor design using a loop cache,” in Proceedings 1999 IEEE International Conference on Computer Design: VLSI in Computers and Processors (Cat. No.99CB37040), 1999, pp. 378–383.
- [82]L. H. Lee, B. Moyer, and J. Arends, “Instruction fetch energy reduction using loop caches for embedded applications with small tight loops,” in Proceedings. 1999 International Symposium on Low Power Electronics and Design (Cat. No.99TH8477), 1999, pp. 267–269.
- [83]T. Anderson and S. Agarwala, “Effective hardware-based two-way loop cache for high performance low power processors,” in Proceedings 2000 International Conference on Computer Design, 2000, pp. 403–407.
- [84]M. Hayenga, V. R. K. Naresh, and M. H. Lipasti, “Revolver: Processor architecture for power efficient loop execution,” in 2014 IEEE 20th International Symposium on High Performance Computer Architecture (HPCA), 2014, pp. 591–602.DOI
- [85]M. Erdos, U. Bora, A. Bhosale, B. Lytton, A. M. Zaidi, A. W. Chadwick, Y. Guo, G. Gabrielli, and T. Jones, “Loopfrog: In-core hint-based loop parallelization,” in Proceedings of the 58th IEEE/ACM International Symposium on Microarchitecture, ser. MICRO ’25. New York, NY, USA: Association for Computing Machinery, 2025, p. 490–503. [Online]. Available: https://doi.org/10.1145/3725843.3756051
- [86]J. A. Fisher, “Very long instruction word architectures and the eli-512,” SIGARCH Comput. Arch. News, vol. 11, no. 3, p. 140–150, Jun. 1983. [Online]. Available: https://doi.org/10.1145/1067651.801649
- [87]R. P. Colwell, R. P. Nix, J. J. O’Donnell, D. B. Papworth, and P. K. Rodman, “A vliw architecture for a trace scheduling compiler,” in Proceedings of the Second International Conference on Architectural Support for Programming Languages and Operating Systems, ser. ASPLOS II. New York, NY, USA: Association for Computing Machinery, 1987, p. 180–192. [Online]. Available: https://doi.org/10.1145/36206.36201
- [88]K. Sankaranam, R. Nagarajan, R. McDonald, R. Desikan, S. Drolia, M. Govindan, P. Gratz, D. Gulati, H. Hanson, C. Kim, H. Liu, N. Ranganathan, S. Sethumadhavan, S. Sharif, P. Shivakumar, S. W. Keckler, and D. Burger, “Distributed microarchitectural protocols in the trips prototype processor,” in 2006 39th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO’06), 2006, pp. 480–491.
- [89]D. Burger, S. Keckler, K. McKinley, M. Dahlin, L. John, C. Lin, C. Moore, J. Burrill, R. McDonald, and W. Yoder, “Scaling to the end of silicon with edge architectures,” Computer, vol. 37, no. 7, pp. 44–55, 2004.
- [90]H. Corporaal, “Design of transport triggered architectures,” in Proceedings of 4th Great Lakes Symposium on VLSI, 1994, pp. 130–135.
- [91]R. M. Russell, “The cray-1 computer system,” Commun. ACM, vol. 21, no. 1, p. 63–72, Jan. 1978. [Online]. Available: https://doi.org/10.1145/359327.359336
- [92]K. Aravonci and J. Wawrzynak, “Vector microprocessors,” Ph.D. dissertation, 1998, aAI9901978.
- [93]L. Villa, R. Espasa, and M. Valero, “A performance study of out-of-order vector architectures and short registers,” in Proceedings of the 12th International Conference on Supercomputing, ser. ICS ’98. New York, NY, USA: Association for Computing Machinery, 1998, p. 37–44. [Online]. Available: https://doi.org/10.1145/277830.277844
- [94]C. R. Lazo, E. Reggiani, C. R. Morales, R. Figueras Bagué, L. A. Villa Vargas, M. A. Ramírez Salinas, M. V. Cortés, O. Sabri Ünsal, and A. Cristal, “Adaptable register file organization for vector processors,” in 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA), 2022, pp. 786–799.
- [95]M. Perotti, S. Riedel, M. Cavalcante, and L. Benini, “Spatz: Clustering compact risc-v-based vector units to maximize computing efficiency,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 44, no. 7, pp. 2488–2502, 2025.arxiv.org/abs/2309.10137













