Reference. Predictable accelerator design with time-sensitive affine types
Cite
Cited by (5)
Parameterized Hardware Design with Latency-Abstract Interfaces nigam-2026-parameterized
Unifying Static and Dynamic Intermediate Languages for Accelerator Generators kim-2024-unifying
Compilers for accelerator design languages (ADLs) translate high-level languages into application-specific hardware. ADL compilers rely on a hardware control interface to compose hardware units. There are two choices: static control, which relies on cycle-level timing; or dynamic control, which uses explicit signalling to avoid depending on timing details. Static control is efficient but brittle; dynamic control incurs hardware costs to support compositional reasoning. Piezo is an ADL compiler that unifies static and dynamic control in a single intermediate language (IL). Its key insight is that the IL’s static fragment is a refinement of its dynamic fragment: static code admits a subset of the run-time behaviors of the dynamic equivalent. Piezo can optimize code by combining facts from static and dynamic submodules, and it opportunistically converts code from dynamic to static control styles. We implement Piezo as an extension to an existing dynamic ADL compiler, Calyx. We use Piezo to implement a frontend for an existing ADL, a systolic array generator, and a packet-scheduling hardware generator to demonstrate its optimizations and the static–dynamic interactions it enables.
Stepwise Debugging for Hardware Accelerators berlstein-2023-stepwise
Modular Hardware Design with Timeline Types nigam_amorim_sampson_2023
Modular design is a key challenge for enabling large-scale reuse of hardware modules. Unlike software, however, hardware designs correspond to physical circuits and inherit constraints from them. Timing constraints—which cycle a signal arrives, when an input is read—and structural constraints—how often a multiplier accepts new inputs—are fundamental to hardware interfaces. Existing hardware design languages do not provide a way to encode these constraints; a user must read documentation, build scripts, or in the worst case, a module’s implementation to understand how to use it. We present Filament, a language for modular hardware design that supports the specification and enforcement of timing and structural constraints for statically scheduled pipelines. Filament uses timeline types, which describe the intervals of clock-cycle time when a given signal is available or required. Filament enables safe composition of hardware modules, ensures that the resulting designs are correctly pipelined, and predictably lowers them to efficient hardware.
A compiler infrastructure for accelerator generators nigam-2021-a
Cites 59 works (0 here)
External (59)
- Enabling Programmable Transport Protocols in High-Speed NICs (2020)
- Predictable Accelerator Design with Time-Sensitive Affine Types: Supplemental Material (2020)
- A new golden age for computer architecture (2019)
- HeteroCL: A Multi-Paradigm Programming Infrastructure for Software-Defined Reconfigurable Computing (2019)
- A Golden Age of Hardware Description Languages: Applying Programming Language Techniques to Improve Design Productivity (2019)
- A Configurable Cloud-Scale DNN Processor for Real-Time AI (2018)
- Spatial: a language and compiler for application accelerators (2018)
- Darwin: A Genomics Co-processor Provides up to 15,000X Acceleration on Long Read Assembly (2018)
- Programming heterogeneous systems from an image processing DSL (2017)
- Vivado Design Suite User Guide: High-Level Synthesis (2017)
- A pythonic approach for rapid hardware prototyping and instrumentation (2017)
- Linear Haskell: practical linearity in a higher-order polymorphic language (2017)
- In-Datacenter Performance Analysis of a Tensor Processing Unit (2017)
- Programmatic Control of a Compiler for Generating High-performance Spatial Hardware (2017)
- Rigel: flexible multi-rate image processing hardware (2016)
- Generating Configurable Hardware from Parallel Patterns (2016)
- From high-level deep neural models to FPGAs (2016)
- Fast Actors. In International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE!) (2015)
- Hardware system synthesis from Domain-Specific Languages (2014)
- Darkroom: compiling high-level image processing code into hardware pipelines (2014)
- PyMTL: A Unified Framework for Vertically Integrated Computer Architecture Research (2014)
- A reconfigurable fabric for accelerating large-scale datacenter services (2014)
- MachSuite: Benchmarks for Accelerator Design and Customized Architectures (2014)
- The rust language (2014)
- LINQits: big data on little clients (2013)
- Rely-guarantee references for refinement types over aliased mutable data (2013)
- Bambu: A modular framework for the high level synthesis of memory-intensive applications (2013)
- Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines (2013)
- Chisel: Constructing hardware in a Scala embedded language (2012)
- Uniqueness and Reference Immutability for Safe Parallelism (2012)
- High-level synthesis: productivity, performance, and software constraints (2012)
- CoRAM: an in-fabric memory architecture for FPGA-based computing (2011)
- High-Level Synthesis for FPGAs: From Prototyping to Deployment (2011)
- Practical Affine Types (2011)
- Lime: a Java-compatible and synthesizable language for heterogeneous architectures (2010)
- CλaSH: Structural Descriptions of Synchronous Hardware Using Haskell (2010)
- A type and effect system for deterministic parallel Java (2009)
- CHiMPS: A C-level compilation flow for hybrid CPU-FPGA architectures (2008)
- AutoPilot: A Platform-Based ESL Synthesis System (2008)
- Resources, concurrency, and local reasoning (2007)
- Gotcha Again: More Subtleties in the Verilog and SystemVerilog Standards That Every Engineer Should Know (2007)
- Platform-Based Behavior-Level and System-Level Synthesis (2006)
- An efficient and versatile scheduling algorithm based on SDC formulation (2006)
- Linear Regions Are All You Need (2006)
- Effective static race detection for Java (2006)
- LOCKSMITH: context-sensitive correlation analysis for race detection (2006)
- SPARK: A Parallelizing Approach to the High-Level Synthesis of Digital Circuits (2004)
- Bluespec System Verilog: efficient, correct RTL from high level specifications (2004)
- Region-based Memory Management in Cyclone (2002)
- “Use-once” variables and linear objects: storage management, reflection and multi-threading (1995)
- Bounded Linear Logic: A Modular Approach to Polynomial-Time Computability (1992)
- International Symposium on Field-Programmable Gate Arrays (FPGA)
- Amazon EC2 F1 Instances
- Stratus High-Level Synthesis
- Intel High Level Synthesis Compiler
- HardCaml: Register Transfer Level Hardware Design in OCaml
- Catapult High-Level Synthesis
- Halide-to-Hardware
- SDAccel: Enabling Hardware-Accelerated Software