High-Level Synthesis of Efficient Pipelines with Visibility Control

arXiv:2607.18765 · cs.PL, cs.AR · Submitted 2026-07-21 · Read on arXiv

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

Where the paper says it

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).

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. p. 0
Where the paper says it

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).

18765#pg4>. We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model, enabling rapid design-space exploration <ref:2607. p. 0
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

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.

18765#pg4>. Kanagawa delivers fine-grained control over hazard resolution and an efficient implementation but gives up sequential semantics <ref:2607. p. 0
Where the paper says it

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.

18765#pg4>. PDL aims for all three properties but falls short of each because it fragments hazard resolution across disjoint subsystems <ref:2607. p. 1
Where the paper says it

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.

18765#pg4>.

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

Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

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.

18765#pg5>, Var controls hazard resolution per variable by instantiating visibility control <ref:2607. p. 8
Where the paper says it

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.

18765#pg5>, and SpecVar complements speculative loop pipelining and Var for advisory state, such as a branch history table (BHT) accessed freely from multiple stages <ref:2607. p. 8
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

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.

2–1.8× lower runtime and 1. p. 2
Where the paper says it

On in-order RISC-V CPUs targeting a 7nm ASIC flow [37], our designs achieve 1. 8× lower runtime and 1.

p. 2
Where the paper says it

On in-order RISC-V CPUs targeting a 7nm ASIC flow [37], our designs achieve 1. 8× lower runtime and 1.

7–3.9× smaller area than PDL’s <ref:2607. p. 2
Where the paper says it

8× lower runtime and 1. 9× smaller area than PDL’s.

18765#pg5>. On countif histograms, our designs match or exceed Kanagawa’s PPA across static, dynamic, and speculative hazard resolution strategies <ref:2607. p. 2
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

(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.

18765#pg5>. Phase 2 lowers SIR into two kinds of Verilog modules, where each instantiated Var is emitted as a dedicated module that encapsulates internal state registers and its hazard-resolution network <ref:2607.18765#pg5>.

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

Where the paper says it

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.

18765#pg5>. The state-reachability analysis specializes each network to the published states reachable under the pipelining strategy, shrinking the pipeline registers that carry them <ref:2607. p. 2
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

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.

2–1.8× lower runtime and 1.7–3.9× smaller area <ref:2607. p. 2
Where the paper says it

8× lower runtime and 1. 9× smaller area than PDL’s.

18765#pg5>. Against Sodor at the same 1250 MHz clock frequency, our designs stay within +2 to +5% area and −3 to +1% power <ref:2607. p. 2
Where the paper says it

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.

18765#pg5>. The parity stems from our unified compilation, which enables cross-module optimization across the main pipeline and Vars <ref:2607.18765#pg5>.

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

Where the paper says it

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.

18765#pg5>. These workloads demand TLP and DLP, and several workloads demand reordered execution of tokens <ref:2607. p. 9
Where the paper says it

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.

18765#pg5>. We are extending the model accordingly, integrating TLP and DLP from the prior literature and designing a disciplined concurrency that relaxes the in-order execution while preserving sequential reasoning <ref:2607.18765#pg5>.

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

Where the paper says it

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.

p. 2
Where the paper says it

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.

18765#pg5>. For full details, refer to the README.md at the root of the code repository <ref:2607. p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

18765#pg5>. The artifacts are available through Zenodo archival repository using its DOI <ref:2607. p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

18765#pg5>.

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

Where the paper says it

(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.

18765#pg4>.

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

Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

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.

18765#pg5>. Sources of PDL overhead include four redundant ordering systems, which add per-instruction metadata as pipeline registers <ref:2607. p. 5
Where the paper says it

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.

18765#pg5>. PDL performs unnecessary order comparison using runtime comparators for priority calculation and arbitration <ref:2607. p. 5
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

(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.

18765#pg5>. Even with register renaming, which substantially increases design complexity, the core remains 1. p. 0
Where the paper says it

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× smaller and 1. p. 2
Where the paper says it

8× lower runtime and 1. 9× smaller area than PDL’s.

3× faster than PDL’s <ref:2607. p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

18765#pg5>. The parity stems from our unified compilation, which enables cross-module optimization across the main pipeline and Vars <ref:2607.18765#pg5>.

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

Where the paper says it

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.

18765#pg5>. Viewing the design as sequential code surfaces optimization opportunities, such as deduplication of shared states and eliminating redundant initialization logic <ref:2607. p. 2
Where the paper says it

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.

18765#pg5>. A direct port matches its LUT and FF counts while reaching a higher maximum frequency (196 MHz vs. p. 2
Where the paper says it

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.

128 MHz, a 1.53× improvement) <ref:2607. p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

18765#pg5>.

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

Where the paper says it

G#𝑐 : Speculative only. Mechanism Per-state Resolution policy Per-address Selectable obs.

18765#pg5>. PDL uniquely aims at declarative hazard resolution from a sequential program but achieves it only partially <ref:2607. p. 1
Where the paper says it

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.

18765#pg5>.

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

Where the paper says it

(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.

18765#pg4>. The execution trace in Fig. p. 0
Where the paper says it

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.

18b confirms the violation of program order <ref:2607. p. 0
Where the paper says it

kang@furiosa. arXiv:2607.

18765#pg4>.

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

  1. 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.

  2. 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 and how 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.

  3. 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 that outperform[s] HLS tools with sequential semantics and achieve[s] PPA comparable to hand-written RTL.

  4. 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.

  5. 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.

  6. The tool can optimize non-pipelined designs like AES cipher accelerators by surfacing two optimizations: the encryption and decryption paths are mutually exclusive and the 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.

  7. 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