Year: 2026
Type: dissertation
Abstract: Deep learning is now deployed at scales ranging from microcontrollers that spot a keyword on a single battery charge to models whose power draw is quoted in units of entire power plants. The efficiency these workloads demand is increasingly delivered by dataflow accelerators: highly parallel, often quantized datapaths, fed from software-managed scratchpads and driven by a host processor. Such accelerators are orders of magnitude more efficient than general-purpose processors, but in practice hard to use. Their programming models are far poorer than those of graphics processing units, and a chip takes years to design while neural network architectures change in months. The result is the hardware lottery: an idea succeeds partly because it fits the hardware that happens to be available and well supported, rather than on its merits alone. Compilers are the natural way out: escaping that lottery means making it cheap to explore combinations of algorithm, soft- and hardware. Production compilers, however, are built around a representation that models a machine as scalar registers, fine-grained instructions and a cache. A dataflow accelerator is none of those things. This thesis therefore asks which hardware primitives and compiler-visible semantics such an accelerator must expose for a compiler to exploit it effectively (the interface question), how a compiler can driveit as close to its theoretical roofline as possible (the performance question), and, when a programmable accelerator and its compiler are generated from one specification, how fast a design iteration becomes and what the design choices this opens up cost in silicon area and in cycles (the cost question). The thesis first argues that these are questions about representation. A compiler can only optimize on the facts its representation states. Applying a standard pipeline of MLIR (multi-level intermediate representation), a widely used compiler framework, to a matrix multiplication produces correct scalar code that uses none of the hardware an accelerator provides, and what that pipeline discards is exactly what an accelerator would have required. On memory, the compiled program does not state in which memory a buffer lives or how its data is laid out, and it contains neither a loop that splits the work into tiles nor the transfers that move those tiles into the accelerator's local memory. Since the weights of realistic networks do not fit in that memory, such a program is not merely slow on the accelerator: it cannot run on it at all. On control, no operation stands for an accelerator invocation, and the configuration one requires has no cost model and is written as volatile stores, a form that forbids the very transformations its cost calls for. On compute, the target is not described in any form the compiler can read, so every accelerator needs a backend built for it alone. Three contributions close these gaps in turn, moving from a fixed accelerator to a generated one. HTVM, a deep learning compiler, addresses memory on a fixed heterogeneous system- on-chip, combining a graph-level pattern matcher with a tiling solver that sizes tiles to fit the accelerator's local memory and keeps transfers contiguous. It deploys the full MLPerf Tiny benchmark suite on the DIANA chip and reaches one to two orders of magnitude over running on its processor alone, at a runtime overhead measured rather than assumed: a few percent on convolutions, against 54.5% on the fastest fully connected layer, where too few compute cycles are available to hide the setup work. That gap motivates the second contribution. Accelerators can be configuration-bound: a performance ceiling that the classical roofline model cannot express. A configuration roofline is introduced, relating an algorithm's operation-to-configuration intensity to a system's configuration bandwidth, and separating sequentially from concurrently configured accelerators. accfg, an extension of MLIR for accelerator configuration, makes configuration representable as state with a lifetime rather than as opaque side effects, which enables two passes, redundant setup elimination and configuration-computation overlap. These yield a geomean speedup of 11% on Gemmini and 2× on OpenGeMM, two existing accelerators whose hardware was not modified. The third contribution, PHS (programmable hardware synthesis), removes the assumption that the hardware is given. It synthesizes a programmable dense linear algebra accelerator and the software that drives it from one MLIR description, lowering the same affine maps into a processing element array through CIRCT, the hardware compiler framework built on MLIR, and into the address generators that feed it, so the two cannot disagree about the dataflow. This makes the cost question answerable by measurement. Accelerating a vector addition at all buys 7.9× fewer cycles for 7.9% more cluster logic; multiplexing four operations onto one array costs 3.3× less area than four separate accelerators; and the periphery, not the datapath, dominates, at 7,384 against 235 𝜇m2 at eight lanes in TSMC 16 nm. A floating point lane costs 22 times its integer counterpart, which is enough to reverse the conclusion that extra operations are cheap. One design iteration, from MLIR input to a simulation verified against a golden reference, takes 40 to 62 seconds. Taken together, the primitives an accelerator must expose are few, and the same ones return in all three contributions: an access map per operand together with the layout and memory space of its buffer, configuration as tracked state plus whether it may proceed concurrently with computation, and the operation set of the datapath with its spatial unrolling. Each contribution works the same way: find a fact the compiler is not given, state it at the level where it still holds, and write the passes that use it. What this costs is a representation and a handful of passes, not a new compiler. That is what makes design questions cheap to answer. Whether an array should have eight lanes or sixteen is decided by compiling both and simulating them, in about a minute each, instead of by first writing the hardware description, the register map, the driver and the tests for each by hand. The efficiency that dataflow accelerators offer therefore becomes reachable by the people writing deep learning software, rather than only by the specialists who build the chips. That is what it takes to stop a lottery from deciding which ideas get tried, and it is how the deep learning systems built on these accelerators get faster and cheaper to run.
Source: Lirias
Author: Van Delm, Josse
Language: English
Subfield: Hardware and Architecture
Field: Computer Science
Domain: Physical Sciences
Open Access status: green
OpenAlex ID: W7225360533
