High-Level Synthesis of Efficient Pipelines with Visibility Control
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "High-Level Synthesis of Efficient Pipelines with Visibility Control".
Jane: Here's the gist of the paper. High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level (RTL) programs to sequential programs <ref:2607.18765#pg2> Among the forms of parallelism HLS exploits, pipelining demands fine-grained control over pipeline structure and hazard resolution to achieve competitive power, performance, and area (PPA) <ref:2607.18765#pg4>.
Tom: We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model, enabling rapid design-space exploration <ref:2607.18765#pg5>.
Jane: The Problem with Existing Tools Existing HLS tools either lack such control or sacrifice sequential semantics to provide it <ref:2607.18765#pg2>.
Tom: Traditional HLS tools keep sequential semantics but give up fine-grained control over the pipelining strategy <ref:2607.18765#pg4>.
Title and authors: Tom: So, this paper is called "High-Level Synthesis of Efficient Pipelines with Visibility Control". It sounds technical, but the authors are trying to take hardware design away from those complicated concurrent register-transfer level programs and move it into something sequential.
Jane: That's the core idea. They want to make designing hardware pipelines easier by letting you write code that looks more like a normal sequential program, but still get that fine-grained control over how the pipeline is structured and how hazards are handled.
Lu: It’s about using this concept to explore different pipeline strategies really fast, like stalling or bypassing, all within one sequential programming model.
Meng: But existing tools either don't have that level of control or they give up the sequential semantics to get it, which is a big trade-off.
Lalam: Basically, this paper introduces this new abstraction called visibility control to unify how you resolve hazards across different pipeline strategies like stalling, bypassing, speculation, and register renaming.
The paper's summary: Tom: So what’s the actual mechanism they propose? They introduce visibility control as a unified programming abstraction for hazard resolution. This abstraction boils down every hazard resolution strategy into two choices: what an earlier instruction exposes about its pending reads and writes on shared state, and how a later instruction reacts to that exposure.
Jane: That’s a really neat way to frame it because it lets you pick from four different dimensions of hazard resolution—per-state resolution, policy selection, per-address resolution, or picking an observation stage—which is much more flexible than what we see in other tools.
Lu: They build their model on speculative loop pipelining where each loop iteration overlaps with the next one. Then they resolve dependency hazards using this visibility control primitive called Var. And they also capture advisory state, like a branch predictor, through SpecVar, which doesn't need any hazard resolution at all because it doesn't affect correctness.
Meng: I’m interested in how they handle the actual implementation of this control. It sounds like they are putting this control into a sequential model that lets you have fine-grained pipelining strategy control.
Lalam: They instantiate visibility control in a sequential programming model that gives you fine-grained pipeline strategy control, and they use three abstractions: speculative loop pipelining for structure, Var for hazard resolution per variable, and SpecVar for advisory state like a branch history table.
The paper's improvements: Tom: The main improvement they show is that this model allows you to explore pipelining strategies while keeping the sequential semantics, which is something existing tools either lack or sacrifice. They claim this enables rapid design-space exploration.
Jane: They show that by using this approach, you can achieve competitive power, performance, and area PPA across three different case studies: in-order RISC-V cores, countif histograms, and an AES accelerator.
Lu: On the RISC-V cores specifically, they implemented stall, bypass, speculation and register renaming all using this model. The results show that their designs are one point two to one point eight times lower runtime and one point seven to three point nine times smaller area compared to PDL’s designs under static prediction or renaming strategies.
Meng: That comparison against PDL is significant because PDL fragments hazard resolution across different subsystems, which seems to be the weakness they are addressing by unifying it all in this one model.
Jane: And on the countif histograms, their designs match or exceed Kanagawa’s PPA across static, dynamic, and speculative hazard resolution strategies. That means they're keeping up with those concurrent tools on complex workloads.
Conclusion: Tom: So to wrap up the paper "High-Level Synthesis of Efficient Pipelines with Visibility Control," the main implication is that this sequential programming model lets you get fine-grained control over pipeline structure while still being able to rapidly explore different strategies like stalling or bypassing.
Jane: It’s about having a unified abstraction, visibility control, that lets you pick how to resolve hazards—whether it's per-variable resolution or policy selection—and then the compiler handles the rest efficiently by specializing each variable's hazard resolution for your chosen strategy.
Lu: The paper formalizes this pipeline behavior and sketches a proof of compiler correctness, showing that the pipeline actually refines the source program up to base-state commits. They show how this works across those three case studies, achieving competitive PPA against hand-written RTL.
Meng: For production work, it’s good that they show you can generate high-performance CPUs like RISC-V cores that are significantly smaller and faster than PDL designs without needing the complexity of register renaming.
Lalam: From my view, this paper shows how declarative instruction level parallelism support under sequential semantics can be achieved by separating the policy from the mechanism, letting you adjust your PPA tradeoffs directly.
KAIST · Seoul National University · FuriosaAI
cs.PL, cs.AR
Submitted: 2026-07-21
Updated: 2026-11-16
Comments: 30 pages
Code: https://github.com/ucb-bar/riscv-sodor
Project page: https://rust-lang.github.io/rfcs/1211-
License: http://creativecommons.org/licenses/by-nc-sa/4.0/
Importance score: 98/100
The gist: High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level (RTL) programs to sequential programs <ref:2607.18765#pg2> Among the forms of parallelism…
Key concepts
- High-Level Synthesis (HLS)
- HLS is a method that translates high-level code, like C++ or Rust, into hardware description languages for chips. The paper focuses on HLS tools that can handle complex pipelining—a technique where multiple operations happen in stages—by giving the programmer fine control over how these stages interact.
- Visibility Control
- This is a new programming abstraction that simplifies hazard resolution. It lets the designer choose what data an earlier instruction makes available and how a later instruction should react to that data. This choice unifies various complex pipeline strategies into simple programming decisions.
- Sequential Programming Model
- Instead of writing code that describes concurrent hardware, this model uses standard sequential programming structures. The tool maps these sequential programs into pipelines by using specific abstractions like 'speculative loop pipelining' and 'Var' controls to manage the pipeline structure and hazards.
Terminology
Summary
High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level (RTL) programs to sequential programs <ref:2607. p. 0 High-Level Synthesis of Efficient Pipelines with Visibility
Control
JUNGIN RHEE, KAIST, Korea
MINSEONG JANG, KAIST, Korea
JAEWOO KIM, Seoul National University, Korea
JEEHOON KANG, FuriosaAI, Korea
High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level
(RTL) programs to sequential programs. Among the forms of parallelism HLS exploits, pipelining demands
fine-grained control over pipeline structure and hazard resolution to achieve competitive power, performance,
and area (PPA). High-Level Synthesis of Efficient Pipelines with Visibility
Control
JUNGIN RHEE, KAIST, Korea
MINSEONG JANG, KAIST, Korea
JAEWOO KIM, Seoul National University, Korea
JEEHOON KANG, FuriosaAI, Korea
High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level
(RTL) programs to sequential programs. Among the forms of parallelism HLS exploits, pipelining demands
fine-grained control over pipeline structure and hazard resolution to achieve competitive power, performance,
and area (PPA). However, existing tools either lack such control or sacrifice sequential semantics to provide it. We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model,
enabling rapid design-space exploration.Where the paper says it
Where the paper says it
Where the paper says it
The Problem with Existing Tools
Existing HLS tools either lack such control or sacrifice sequential semantics to provide it <ref:2607.18765#pg2>. Traditional HLS tools keep sequential semantics but give up fine-grained control over the pipelining strategy <ref:2607. p. 0 The designer must navigate the PPA tradeoff by exploring strategies, yet no existing HLS tool
provides the three properties this exploration requires (Table 1a): (1) fine-grained control over the
pipelining strategy, to express diverse candidate strategies, (2) efficient implementation, so that
each explored strategy attains the PPA of hand-written RTL, and (3) sequential semantics, so that
switching strategies cannot introduce concurrency bugs. Traditional HLS tools [16, 22, 23] keep sequential semantics but give up fine-grained control
over the pipelining strategy. The compiler places stage boundaries, steered at most by indirect hints
such as initiation intervals [1], and decides how each hazard is resolved either statically [23] or
dynamically [16, 22]. Kanagawa [30] delivers fine-grained control over hazard resolution and an efficient implementation but gives up sequential semantics. However, that same code runs under concurrent semantics,
so every rewrite for strategy exploration risks introducing concurrency bugs. PDL [38, 42] aims for all three properties, but falls short of each because it fragments hazard
resolution across disjoint subsystems (§2.Where the paper says it
Where the paper says it
Where the paper says it
The Visibility Control Abstraction
The key enabler is visibility control, a unified programming abstraction for hazard resolution <ref:2607.18765#pg5>. This abstraction distills each hazard resolution strategy into two choices: what an earlier instruction exposes of its pending reads and writes on shared state, and how a later instruction reacts <ref:2607. p. 1 We make the following contributions. In §3, we introduce visibility control, which distills each hazard resolution strategy into two
choices: what an earlier instruction exposes of its pending reads and writes on shared state, and
how a later instruction reacts.Where the paper says it
Implementation via Sequential Model
We instantiate visibility control in a sequential programming model that gives fine-grained control over the pipelining strategy <ref:2607.18765#pg5>. The model comprises three abstractions: speculative loop pipelining controls the pipeline structure, mapping each loop to a pipeline whose internal stages are set by PDL’s separators <ref:2607. p. 8 The model comprises three abstractions: (§4. 1) speculative loop pipelining controls the pipeline
structure, mapping each loop to a pipeline whose internal stages are set by PDL [42]’s separators,
(§4. 1) speculative loop pipelining controls the pipeline
structure, mapping each loop to a pipeline whose internal stages are set by PDL [42]’s separators,
(§4. 2) the wrapper type Var controls hazard resolution per variable by instantiating visibility control,
and (§4. 2) the wrapper type Var controls hazard resolution per variable by instantiating visibility control,
and (§4. 3) the wrapper type SpecVar complements speculative loop pipelining and Var for advisory
state, such as a branch history table (BHT) accessed freely from multiple stages.Where the paper says it
Where the paper says it
Where the paper says it
Performance Gains Across Workloads
Our designs outperform those from sequential semantics HLS tools (PDL, Vitis HLS, Dynamatic) and match or exceed hand-written RTL and Kanagawa designs <ref:2607.18765#pg5>. On in-order RISC-V CPUs targeting a 7nm ASIC flow our designs achieve 1. p. 2 Our designs outperform those from sequentialsemantics HLS tools (PDL, Vitis HLS, Dynamatic), and match or exceed hand-written RTL and
Kanagawa designs, both built under concurrent semantics. On in-order RISC-V CPUs targeting a
7nm ASIC flow [37], our designs achieve 1. On in-order RISC-V CPUs targeting a
7nm ASIC flow [37], our designs achieve 1. 8× lower runtime and 1. On in-order RISC-V CPUs targeting a
7nm ASIC flow [37], our designs achieve 1. 8× lower runtime and 1. 8× lower runtime and 1. 9× smaller area than
PDL’s. They match hand-written RTL in cycle count and maximum frequency, staying within 5% in
area and 3% in power. On countif histograms, our designs match or exceed Kanagawa’s PPA across
static, dynamic, and speculative hazard resolution strategies.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Compiler Implementation Details
The compiler maps Rust’s Mid-level Intermediate Representation (MIR) to synthesizable Verilog <ref:2607.18765#pg5>. Phase 1 lifts the MIR control-flow graph into a structured IR (SIR), making the nesting structure of loops and branches explicit <ref:2607. p. 9 (We generalize program order to nested loops in §5. )
We adopt PDL’s structural mapping to compile the loop body, making pipeline structure directly
controllable through source changes.Where the paper says it
Formal Correctness Proof Sketch
We provide an informal correctness proof sketch that the formalized pipeline behavior refines the source semantics up to base-state commits <ref:2607.18765#pg5>. The proof establishes the refinement by simultaneous induction over loop iterations, maintaining three properties regarding load and store operations <ref:2607.18765#pg5>.
Efficiency in Compilation
Two static analyses generate only the registers and logic the design needs under the selected pipelining strategy <ref:2607.18765#pg5>. The program-order analysis eliminates comparators and loop indices wherever the program order of tokens is statically decidable <ref:2607. p. 5 Specifically, the following overheads occur in the CPU of Fig. 1a: (1) four redundant
ordering systems (three locks and a speculation module), each tracking program order and adding
per-instruction metadata as pipeline registers, and (2) unnecessary order comparison, since systems
rely on runtime comparators even when the program order can be statically determined from
pipeline structure, e. It
factors the program-order comparison between in-flight instructions into one mechanism shared
by every Var. It specializes each Var’s hazard resolution to the pipelining strategy, generating only
the necessary registers and combinational logic.Where the paper says it
Where the paper says it
Evaluation Results Summary
Our designs outperform PDL across all configurations and match Sodor, the hand-written RTL <ref:2607.18765#pg5>. Against PDL, they achieve 1. p. 2 In §7, we show across three case studies that the three properties let us explore pipelining
strategies and thereby achieve competitive PPA. Our designs outperform those from sequentialsemantics HLS tools (PDL, Vitis HLS, Dynamatic), and match or exceed hand-written RTL and
Kanagawa designs, both built under concurrent semantics. 8× lower runtime and 1. 9× smaller area than
PDL’s. They match hand-written RTL in cycle count and maximum frequency, staying within 5% in
area and 3% in power. On countif histograms, our designs match or exceed Kanagawa’s PPA across
static, dynamic, and speculative hazard resolution strategies.Where the paper says it
Where the paper says it
Where the paper says it
Future Work Directions
We are mechanizing the proof sketch of §5 <ref:2607.18765#pg5>. We are also developing advanced CPUs [7, 43], AI accelerators [14], and network accelerators [13, 25] as further case studies <ref:2607. p. 2 It specializes each Var’s hazard resolution to the pipelining strategy, generating only
the necessary registers and combinational logic. In §7, we show across three case studies that the three properties let us explore pipelining
strategies and thereby achieve competitive PPA. The loop pipelining is speculative because token 𝑖 can start before the pipeline knows that source
iteration 𝑖 exists. If an earlier token terminates the loop, the pipeline flushes all later tokens (step 5)
because their iterations do not occur in the source execution.Where the paper says it
Where the paper says it
Artifact Availability
This artifact contains the case study designs (RISC-V CPUs, countif histograms, and an AES cipher accelerator) evaluated in the paper <ref:2607.18765#pg5>. The artifact reproduces the tables in the paper without the RISC-V CPU synthesis results <ref:2607. p. 2 In the supplementary material [2], we provide the appendix and artifact. The appendix contains
(§A) the artifact description, (§B) PDL’s eighteen rules and the unsoundness evidence, (§C) the
compiler implementation, and (§D) the extended RISC-V evaluation results. In the supplementary material [2], we provide the appendix and artifact. The appendix contains
(§A) the artifact description, (§B) PDL’s eighteen rules and the unsoundness evidence, (§C) the
compiler implementation, and (§D) the extended RISC-V evaluation results. kang@furiosa. arXiv:2607. kang@furiosa. arXiv:2607. kang@furiosa. arXiv:2607. kang@furiosa. arXiv:2607.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
PDL Fragility Evidence
PDL’s sequential semantics guarantee is fragile because each subsystem is correct only under static rules its interface assumes <ref:2607.18765#pg4>. The rule set is unsound because two conditional release operations placed in different pipeline stages can commit out of order, producing a WAW hazard that the rules fail to reject <ref:2607. p. 5 (2) The rule set is unsound (§B. For instance, two conditional release operations placed in
different pipeline stages can commit out of order, producing a WAW hazard that the rules fail to
reject.Where the paper says it
The compiler translates Rust’s Mid-level Intermediate Representation (MIR) to synthesizable Verilog <ref:2607.18765#pg5>. The token layout after Phase 2 comprises the Valid bit, Loop index, Local memory (LM), and Published state (Spub) for each Var <ref:2607.18765#pg5>. Eager tentative commit eliminates pipeline registers for pc’s Sbatch, the bypass multiplexer, and the rest of the hazard-resolution network <ref:2607. p. 6 Waiting costs cycles but eliminates the bypass
network (the multiplexers and wiring that forwarding requires). The third pipeline resolves the control hazard on the program counter by speculation (Fig.Where the paper says it
Extended RISC-V Evaluation Breakdown
The extended RISC-V evaluation supplements §7.1 with per-benchmark CPI breakdowns (Table 6a) and same-frequency synthesis comparisons (Table 6b) <ref:2607. p. 0 Kanagawa [30] delivers fine-grained control over hazard resolution and an efficient implementation but gives up sequential semantics. Designers manually manage concurrent accesses to shared
state, choosing hazard resolution along four dimensions (Table 1b): (1) per-state resolution, where
Authors’ Contact Information: Jungin Rhee, KAIST, Daejeon, Korea, jungin. Specifically, the following overheads occur in the CPU of Fig. 1a: (1) four redundant
ordering systems (three locks and a speculation module), each tracking program order and adding
per-instruction metadata as pipeline registers, and (2) unnecessary order comparison, since systems
rely on runtime comparators even when the program order can be statically determined from
pipeline structure, e. Specifically, the following overheads occur in the CPU of Fig. 1a: (1) four redundant
ordering systems (three locks and a speculation module), each tracking program order and adding
per-instruction metadata as pipeline registers, and (2) unnecessary order comparison, since systems
rely on runtime comparators even when the program order can be statically determined from
pipeline structure, e.Where the paper says it
Where the paper says it
Where the paper says it
PPA Comparison Details
Our designs outperform PDL across all configurations and match Sodor, the hand-written RTL <ref:2607.18765#pg5>. When targeting PDL’s clock speeds, our processor uses 42–48% less area and 44–50% less power across the rv32i configurations <ref:2607. p. 0 (1) The pipeline structure, the number of stages and their boundaries,
fixes how deeply operations overlap. Adding stages shortens the critical path and raises clock
frequency, but costs pipeline registers, area, and power. We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model,
enabling rapid design-space exploration. The tool builds on visibility control, a novel programming abstraction
that unifies hazard resolution strategies including stalling, bypassing, speculation, deferred commit, and
register renaming. 8× lower runtime and 1. 9× smaller area than
PDL’s. kang@furiosa. arXiv:2607.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Countif Histogram Performance
Our designs match or exceed Kanagawa’s PPA across all three strategies while outperforming Vitis HLS and Dynamatic <ref:2607.18765#pg5>. The advantage over Kanagawa reflects a language-design tradeoff, as our tool exposes stage boundaries directly whereas Kanagawa exposes only a per-region concurrent-token count and delegates boundary placement to its scheduler <ref:2607.18765#pg5>.
AES Accelerator Optimization
Our implementation requires only 0.30× the LOC of the reference while preserving the sequential algorithmic flow <ref:2607. p. 2 On countif histograms, our designs match or exceed Kanagawa’s PPA across
static, dynamic, and speculative hazard resolution strategies. On an AES accelerator, viewing the
design as a sequential program surfaces two optimizations that reduce area over an RTL reference. On countif histograms, our designs match or exceed Kanagawa’s PPA across
static, dynamic, and speculative hazard resolution strategies. On an AES accelerator, viewing the
design as a sequential program surfaces two optimizations that reduce area over an RTL reference. 9× smaller area than
PDL’s. They match hand-written RTL in cycle count and maximum frequency, staying within 5% in
area and 3% in power. kang@furiosa. arXiv:2607.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Related Work Comparison
Our work provides declarative ILP support under sequential semantics, with sep placing stage boundaries and Var selecting the resolution strategy per access <ref:2607.18765#pg5>. The declarative level separates the policy from the mechanism, allowing the designer to navigate PPA tradeoffs by adjusting the policy <ref:2607. p. 1 G#𝑐
: Speculative only. Mechanism Per-state Resolution policy Per-address Selectable obs. However, that same code runs under concurrent semantics,
so every rewrite for strategy exploration risks introducing concurrency bugs. PDL [38, 42] aims for all three properties, but falls short of each because it fragments hazard
resolution across disjoint subsystems (§2.Where the paper says it
Where the paper says it
Artifact Description
This artifact contains the case study designs (RISC-V CPUs, countif histograms, and an AES cipher accelerator) evaluated in the paper <ref:2607.18765#pg5>. The artifact reproduces the tables in the paper without the RISC-V CPU synthesis results <ref:2607.18765#pg5>. For full details, refer to the README.md at the root of the code repository <ref:2607.18765#pg5>. The artifacts are available through Zenodo archival repository using its DOI <ref:2607.18765#pg5>.
PDL Semantics Fragility
The sequential semantics guarantee of PDL and XPDL rests on 18 rules <ref:2607.18765#pg4>. These rules are unsound because a rule-compliant program accepted by the compiler can still produce a pipeline with incorrect hazard resolution <ref:2607. p. 1 (3) Its guarantee of sequential semantics is fragile, resting on 18 code rules, many of
them path-sensitive, that govern each subsystem and their interactions. The rules are onerous, since
the designer must satisfy them by hand to pass the compiler, and unsound, since rule-compliant
programs can still produce incorrectly synchronized pipelines. Adding stages shortens the critical path and raises clock
frequency, but costs pipeline registers, area, and power. (2) Dependency hazard resolution keeps
the pipeline correct when overlapping execution breaks a sequential dependency on shared state. kang@furiosa. arXiv:2607.Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Sequential programming model for hardware design allows designers to write programs with purely sequential semantics while embedding fine-grained pipeline control, enabling rapid design-space exploration. This enables exploration of diverse candidate strategies like stalling, bypassing, speculation, deferred commit, and register renaming within a single sequential programming model.
-
Visibility control acts as a novel programming abstraction that unifies hazard resolution strategies by distilling each strategy into two choices:
what an earlier instruction exposes of its pending reads and writes on shared state
andhow a later instruction reacts.
This abstraction allows the designer to choose from four dimensions of hazard resolution, including per-state resolution, resolution policy, per-address resolution, and selectable observation stage. -
The compiler implements hazard resolution efficiently by factoring the program-order comparison between in-flight instructions into one mechanism shared by every Var and specializing each Var’s hazard resolution to the pipelining strategy. This results in a
compiled pipeline
thatoutperform[s] HLS tools with sequential semantics and achieve[s] PPA comparable to hand-written RTL.
-
The system can generate high-performance CPUs, such as RISC-V cores, that achieve 1.2–1.8 times lower runtime and 1.7–3.9 times smaller area compared to PDL designs under static prediction or renaming strategies. This demonstrates the ability to achieve competitive PPA while maintaining sequential semantics, matching or exceeding hand-written RTL and Kanagawa designs built under concurrent semantics.
-
The system can handle complex memory access patterns on countif histograms by matching or exceeding Kanagawa’s PPA across static, dynamic, and speculative hazard resolution strategies. This capability is achieved by exposing stage boundaries directly in code rather than relying on a scheduler to place them conservatively.
-
The tool can optimize non-pipelined designs like AES cipher accelerators by surfacing two optimizations:
the encryption and decryption paths are mutually exclusive
andthe program always initializes key memory before use.
These optimizations reduce LUT usage by 1.35 times and FF usage by 4.4 times at a maximum frequency of 179 MHz. -
The system supports declarative Instruction Level Parallelism (ILP) support under sequential semantics, with sep placing stage boundaries and Var selecting the resolution strategy per access. This allows the designer to navigate PPA tradeoffs by adjusting policies while the tool keeps the mechanism correct and efficient, providing a declarative level of support for ILP.
Abstract
High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level (RTL). Among the forms of parallelism HLS exploits, pipelining demands fine-grained control over pipeline structure and hazard resolution to achieve competitive power, performance, and area (PPA). However, existing tools either lack such control or sacrifice sequential semantics to provide it. We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model while generating synchronization logic only where needed to resolve the pipeline's potential hazards. The tool builds on visibility control, a novel programming abstraction that unifies hazard resolution techniques including stalling, bypassing, speculation, deferred commit, and register renaming. We evaluate on in-order RISC-V cores, histograms, and an AES accelerator. On RISC-V cores, we implement stall, bypass, speculation, and register renaming; on histograms, we implement scheduling strategies that previously required RTL or concurrent programming models. Compiled pipelines outperform HLS tools with sequential semantics and achieve PPA comparable to hand-written RTL.
Sources
Related papers
- The Best of Times, the Worst of Times: Moment-Based Analysis of Probabilistic Cost Structures
- Formal Verification of an Out-of-Order Multiprocessor against an In-Order Weak-Memory ISA
- Fuss-free cumulative universes: theory and practice
- Model Checking Probabilistic Multiparty Session Types
- A Type System for Communication-Safe Hardware Design
- RECURSUM: Automated Code Generation for Recurrence Relations Exceeds Expert Optimization via LayeredCodegen