Benefits of High-Level Synthesis - 2024.2 English - UG1399

Vitis High-Level Synthesis User Guide (UG1399)

Document ID
UG1399
Release Date
2024-11-13
Version
2024.2 English

High-Level Synthesis (HLS) is an automated design process that takes an abstract behavioral specification of a digital system and generates a register-transfer level (RTL) structure that realizes the given behavior.

A typical flow using HLS has the following steps:

  1. Write the algorithm at a high abstraction level using C/C++ with a target architecture in mind
  2. Verify the functionality at the behavioral level
  3. Use the HLS tool to generate the RTL for a given clock speed, and design constraints
  4. Verify the functionality of the generated RTL
  5. Explore different architectures using the same input source code

HLS can enable the path of creating high-quality RTL, rather quickly compared to manually writing error-free RTL.

The designer needs to create the macro-architecture of the algorithm in C/C++ at a high level, meaning that the design intent and how this design interacts with the outside world should be carefully thought through. The HLS tool also requires design constraints like clock period, performance constraints, etc.

Micro-architecture decisions like creating the state machine, datapath, register pipelines, etc. are not needed at a high level. These details can be left to the HLS tool and optimized RTL can be generated by providing design constraints.

Using the defined macro-architecture of the C/C++ algorithm, designers can also vary constraints to generate multiple RTL solutions to explore trade-offs between performance and area. So a single algorithm can lead to multiple implementations, allowing designers to choose an implementation that best meets the needs of the overall application.

Improve Productivity

With HLS, the designer works at a high level of abstraction, meaning fewer lines of code need to be written as input to HLS. Due to less time spent on writing the C++ code and quicker turnaround, user errors may be significantly reduced, thus increasing overall design productivity. The designers can focus on creating efficient designs at a higher level of abstraction rather than worrying about mechanical RTL implementation details.

HLS not only enables high design productivity but also verification productivity. With HLS, the test bench is also generated or created at a high level, meaning the original design intent can be verified very quickly. The designer can explore quick turnarounds of verified algorithms as the flow is still within the C/C++ domain. Once the algorithm is verified in C/C++, the same test bench can be used for generated RTL by the HLS tool. Nevertheless, the generated RTL can be integrated with the existing RTL verification flow for more comprehensive verification coverage.

The design and verification benefits of using HLS are summarized here:

  • Developing and validating algorithms at the C-level for the purpose of designing at an abstract level from the hardware implementation details.
  • Using C-simulation to validate the design, and iterate more quickly than with traditional RTL design.
  • Creating multiple design solutions from the C source code and pragmas to explore the design space, and find an optimal solution.

Enable Re-Use

The designs created for High-level synthesis are generic and unaware of implementation. These sources are not tied to any technology node or any given clock period like a given RTL. With few updates of input constraints and without any source code changes, multiple architectures can be explored. A similar practice with RTL is not pragmatic. The designers create RTL for a given clock period and any change for a derivative product, however small, leads to a new, complex project. Working at a higher level with HLS, designers don't need to worry about the micro-architecture and can rely on the HLS tool to regenerate new RTL automatically.