Module-per-Object: a Human-Driven Methodology for C++-based High-Level Synthesis Design

TL;DR

The paper introduces Module-per-Object (MpO), a human-driven C++ methodology for high-level FPGA design that enhances code quality, modularity, and hardware efficiency, making FPGA programming more accessible to software developers.

Contribution

It presents a novel MpO methodology leveraging modern C++ features to improve FPGA HLS design, combining high abstraction with efficient hardware generation for both hardware and software developers.

Findings

MpO achieves FPGA designs comparable to hand-written VHDL.

MpO improves resource utilization and performance over traditional C-based HLS.

MpO enhances code readability, modularity, and reduces code duplication.

Abstract

High-Level Synthesis (HLS) brings FPGAs to audiences previously unfamiliar to hardware design. However, achieving the highest Quality-of-Results (QoR) with HLS is still unattainable for most programmers. This requires detailed knowledge of FPGA architecture and hardware design in order to produce FPGA-friendly codes. Moreover, these codes are normally in conflict with best coding practices, which favor code reuse, modularity, and conciseness. To overcome these limitations, we propose Module-per-Object (MpO), a human-driven HLS design methodology intended for both hardware designers and software developers with limited FPGA expertise. MpO exploits modern C++ to raise the abstraction level while improving QoR, code readability and modularity. To guide HLS designers, we present the five characteristics of MpO classes. Each characteristic exploits the power of HLS-supported modern C++ features to build C++-based hardware modules. These characteristics lead to high-quality software descriptions and efficient hardware generation. We also present a use case of MpO, where we use C++ as the intermediate language for FPGA-targeted code generation from P4, a packet processing domain specific language. The MpO methodology is evaluated using three design experiments: a packet parser, a flow-based traffic manager, and a digital up-converter. Based on experiments, we show that MpO can be comparable to hand-written VHDL code while keeping a high abstraction level, human-readable coding style and modularity. Compared to traditional C-based HLS design, MpO leads to more efficient circuit generation, both in terms of performance and resource utilization. Also, the MpO approach notably improves software quality, augmenting parametrization while eliminating the incidence of code duplication.