SystemC Modeling
Using SystemC to model High-Level Synthesis (HLS) designs enables a wide range of hardware design types to be modeled and efficiently verified before HLS. SystemC enables comprehensive hardware aspects to be modeled, including modules and module hierarchy, ports, signals, concurrent processes, reset signals, and precise timing control. All major HDL simulators support simulation of mixed testbench and design hierarchies that seamlessly integrate SystemC, SystemVerilog, and VHDL modules for complete design verification. Within SystemC HLS models, libraries such as MatchLib facilitate transaction interfaces and provide essential building block IP models. These models leverage both fixed-point and floating-point datatypes to accurately represent limited numerical precision, saturation, and rounding operations. The extensive C++ libraries for HLS empower designers to model complex math functions, DSP operations, and various hardware functionalities, making SystemC a powerful solution for modern hardware design workflows.
-
SystemC Modeling Featured Content
-
Verifying Hardware at the Source: Why a User-Visible HLS Scheduling Contract Matters in an Age of AI-Generated Design
This paper describes a methodology that shifts verification to the pre-HLS C++/SystemC model, enabled by a small, user-visible scheduling contract that constrains interface behavior while leaving block internals free to optimize. The result is reusable verification intent, performance-accurate source models, compositional reasoning, and—as AI increasingly authors hardware—trust based on checkable artifacts rather than authorship. -
Architectural Design and Synthesis of a Matrix Multiplication Block Using Catapult HLS and Matchlib
Whitepaper presents a HW design approach that enables rapid and precise block modeling at a higher level than RTL, followed by automatic synthesis to RTL using HLS. We demonstrate how fast and accurate architectural exploration leads to optimal designs, which can then be synthesized directly into RTL and integrated into the traditional RTL-to-silicon flow. The design process leverages Matchlib, an open-source library originally developed by NVIDIA Research and now supported in HLS tools. -
HLS Transactor Modeling Guide
This paper walks through three approaches to modeling transactors for custom protocols in HLS models. We use a very simple but representative custom protocol and discuss some of the pros and cons of the three different approaches. -
Fixing Design Stuttering Problems in Catapult HLS
This paper describes Matchlib example 73_stutter_fix, which is an example of a "stuttering" issue that can arise when a process has multiple message-passing interfaces (or "MIOs") that have external communication paths between them that have latency. The term "stuttering" refers to the problem where a design is intended to process transactions at an optimal rate (e.g. II=1), but the actual design is unable to meet that rate and instead stutters. -
MatchLib Toolkit
MatchLib is a new open-source SystemC library originally developed by NVIDIA Research to enable digital hardware to be accurately and efficiently designed and verified at a high level of abstraction, leveraging commercial High-Level Synthesis tools.
-
NVIDIA: High-Level Synthesis in Agile System-on-Chip Flows: Overview and Techniques
Catapult High-Level Synthesis has been successfully employed within NVIDIA for multiple generations of system-on-chip research demonstrations. This talk provides a brief overview of NVIDIA Research’s use of Catapult HLS and highlights some useful features and flows of the Connections library, such as the ability to back-annotate SystemC simulations to identify and fix performance bugs.
-
NVIDIA's Use of Catapult HLS for Building ML Inference Accelerators
This is a short introduction to NVIDIA's use of Catapult HLS for building machine learning accelerator SOCs. We will present the MatchLib modeling methodology that NVIDIA has developed and which is now supported within Catapult HLS, and we will describe the results of the fully working SOC ASIC that was almost entirely developed using HLS. -
AI/ML Accelerator Tutorial: C-level Design & Verification Using HLS
Catapult HLS (High-Level Synthesis) and C-level design and verification are reducing entire project development times by half or more in today’s ASIC and FPGA designs. It is being used to create production-quality HW Accelerators for multiple applications such as 5G and Communication, Image and Video Processing, Automotive, and AI/ML much faster than hand-coded RTL with equivalent power, performance and area.
-
Machine-Learning-Assisted Agile VLSI Design for Machine Learning
We will highlight two design automation research directions being pursued in the ASIC and VLSI Research group at NVIDIA: (1) An automated C++-to-layout VLSI flow that leverages HLS tools and open-source HLS-compatible C++ libraries for design productivity; and (2) Machine-learning assisted VLSI design techniques. We will also describe our experience using these tools as part of an agile hardware design flow to build for a deep neural network (DNN) inference accelerator testchip. -
NVIDIA: Design and Verification of a Machine Learning Accelerator SoC Using an Object-Oriented HLS-Based Design Flow
A high-productivity digital VLSI flow for designing complex SoCs is presented in this webinar. It includes High-Level Synthesis tools, an efficient implementation of Latency-Insensitive Channels, and MatchLib - an object-oriented library of synthesizable SystemC and C++ components. The flow was demonstrated on a programmable machine learning inference accelerator SoC designed in 16nm FinFET technology.
-
-
SystemC Modeling Overview
SystemC is a hardware description language (HDL) implemented as classes using the C++ language. Because SystemC enables both combinational and sequential processes to be modeled, and because it supports detailed hardware concepts such as modules and module hierarchies, ports, clocks, resets, signals, and time, it can be used to model any type of digital hardware.
SystemC is standardized as IEEE 1666, and Accellera has standardized a synthesizable subset of SystemC and is actively working on extensions.
When used with HLS, SystemC enables the following design aspects to be modeled:
- Arbitrary module hierarchies
- Designs with multiple clocks and resets, including sync and async resets.
- Resets can be dynamic, i.e. they can occur during normal operation of the design.
- Feedback paths and re-convergent paths within dataflow designs are supported.
- Non-blocking IO, arbitration, and timing dependent behaviors are supported.
- Arbitrary communication protocols and bus interfaces can be modeled.
- Direct inputs to datapath pipelines can be modeled, and they can be reliably updated as the design operates.
SystemC HLS Libraries
There are a number of libraries that are commonly used with SystemC when developing HLS models.
These include:
- ac_types for arbitrary precision integer, fixed-point and floating-point types
- ac_math for mathematical functions such as sine, cosine, tangent, square root, etc.
- ac_dsp for DSP functions such as filters and FFTs.
An important library that is often used with SystemC HLS designs is MatchLib. MatchLib is an open-source SystemC library that was originally developed by NVIDIA Research, and it enables digital hardware to be accurately and efficiently designed and verified at a high level of abstraction, leveraging commercial high level synthesis tools. MatchLib contains classes for modeling message passing interfaces within HLS models, and on top of these classes it provides parameterized building block models such as AXI bus fabric components (routers, arbiters, etc), network on chip components, banked memories, scratchpads, crossbars, etc.
Some of the key goals of MatchLib are to enable SystemC models to be directly synthesized to HW with very high quality of results, and to enable very accurate performance simulation of these models in SystemC prior to synthesis, so that the overall design and verification effort is much more efficient.
MatchLib is being actively used by hardware design teams in both industry and academia for advanced hardware design projects, and multiple tapeouts from different groups have occurred for chips that have been almost entirely designed with MatchLib.
MatchLib is being discussed in the Accellera Synthesis Working Group for possible standardization. You can download the open source MatchLib examples kit and run the examples on any Linux machine from the MatchLib ToolKit.
SystemC HLS Verification and Debug
A primary objective when utilizing High-Level Synthesis (HLS) is to identify and fix nearly all issues and bugs in the model before HLS, rather than dealing with them by debugging the post-HLS RTL. SystemC and MatchLib are tools that, when used with HLS, offer essential capabilities to achieve this goal:
- A SystemC testbench enables comprehensive testing of the SystemC Design Under Test (DUT) by applying extensive stress tests.
- For additional rigor, a SystemVerilog Universal Verification Methodology (UVM) testbench can also be used to stress test the SystemC DUT. All major EDA simulators support this mixed language capability.
- MATLAB facilitates the verification of the SystemC DUT by allowing its importation through the MATLAB MEX interface.
- Python programs can verify the SystemC DUT by importing the DUT via the Python C API, broadening the scope of verification tools.
This screenshot shows a Verilog testbench that instantiates a SystemC DUT in a mixed language simulation within Questa. MatchLib enhances the verification and debugging capabilities of the pre-HLS model with several critical features:
- Throughput-accurate modeling ensures the performance of the pre-HLS model is verified, predicting how it will perform after HLS.
- Random stall injection simplifies the process of stress testing the pre-HLS DUT by introducing potential real-world operational delays.
- Automatic generation of channel logs aids in the easy debugging of transaction streams, allowing for straightforward analysis of data flow.
- Similarly, automatic memory log generation facilitates the inspection and debugging of memory accesses.
- Automatic waveform generation provides a graphical representation of signal waveforms, making detailed analyses more accessible.
- The ability to use latency and capacity back annotation helps in accurately simulating the effects that will be introduced during the HLS process, leading to more accurate pre-HLS simulations.
These tools and features collectively enable a thorough and efficient verification process before HLS, significantly reducing the likelihood of issues persisting into the final RTL implementation.
After the HLS process is completed, the generated RTL design undergoes verification. This phase usually demands considerably less effort compared to the verification of manually written RTL. The reason for this reduced effort is that the majority of issues and bugs are addressed during the pre-HLS verification phase.
During the post-HLS verification of the RTL, several key practices are followed:
- The testbench and test scenarios employed during the pre-HLS phase are reused to test the post-HLS RTL. This ensures consistency in testing conditions and objectives.
- Standard RTL verification tools and techniques are applied to ensure the RTL design meets the required specifications and standards.
- Metrics for functional coverage and RTL code coverage are carefully monitored and achieved to ensure comprehensive testing of the design.
- If necessary, formal verification tools can be used to check RTL properties and identify unreachable code, which can then be excluded from RTL coverage metrics. This step enhances the accuracy of the verification process.
- Optionally, random stall injection can be automatically introduced to the transaction channels within the RTL Design Under Test (DUT) to rigorously stress test the design and improve coverage metrics. This technique further ensures the robustness and reliability of the RTL design.
These practices ensure that the verification of the post-HLS RTL is thorough and efficient, leveraging the groundwork laid during the pre-HLS verification phase.