Optimizing Logic - 2022.1 English

Vitis High-Level Synthesis User Guide (UG1399)

Document ID: UG1399
Release Date: 2022-06-07
Version: 2022.1 English

Getting Started with Vitis HLS
Navigating Content by Design Process
Design Principles for Software Programmers
Three Paradigms for Programming FPGAs
Producer-Consumer Paradigm
Streaming Data Paradigm
Pipelining Paradigm
Combining the Three Paradigms
Conclusion - A Prescription for Performance
Introduction to Vitis HLS
Vitis HLS Memory Layout Model
Data Alignment
Data Structure Padding
Vitis HLS Alignment Rules and Semantics
Examples of Aggregation
Examples of Disaggregation
Impact of Struct Size on Pipelining
Basics of High-Level Synthesis
Scheduling and Binding Example
Extracting Control Logic and Implementing I/O Ports Example
Performance Metrics Example
Tutorials and Examples
Vitis HLS Process Overview
Enabling the Vivado IP Flow
Enabling the Vitis Kernel Flow
Default Settings of Vivado/Vitis Flows
Launching Vitis HLS
Setting Up the Environment
Overview of the Vitis HLS IDE
Customizing the Vitis HLS IDE Behavior
Creating a New Vitis HLS Project
Working with Sources
Coding C/C++ Functions
Accessing Source Files in Git Repositories
Using Libraries in Vitis HLS
Resolving Header File Problems
Resolving Comments in the Source Code
Setting Configuration Options
Specifying the Clock Frequency
Clock and Reset Ports
Using the Flow Navigator
Verifying Code with C Simulation
hls::print Function
Writing a Test Bench
Example Test Bench
Design Files and Test Bench Files
Single File Test Bench and Design
Using the Debug View Layout
Output of C Simulation
Pre-Synthesis Control Flow
Synthesizing the Code
Synthesis Summary
Output of C Synthesis
Improving Synthesis Runtime and Capacity
Analyzing the Results of Synthesis
Schedule Viewer
Function Call Graph Viewer
Dataflow Viewer
Timeline Trace Viewer
Optimizing the HLS Project
Creating Additional Solutions
Adding Pragmas and Directives
Using Directives in Scripts vs. Pragmas in Code
Applying Directives to the Proper Scope
Applying Optimization Directives to Global Variables
Applying Optimization Directives to Class Objects
Applying Optimization Directives to Templates
Using Constants with Pragmas
Failure to Satisfy Optimization Directives
C/RTL Co-Simulation in Vitis HLS
Output of C/RTL Co-Simulation
Automatically Verifying the RTL
Interface Synthesis Requirements
Verification of DATAFLOW and DEPENDENCE
Unsupported Optimizations for Co-Simulation
Simulating IP Cores
Analyzing RTL Simulations
Viewing Simulation Waveforms
Cosim Deadlock Viewer
Debugging C/RTL Co-Simulation
Setting Up the Environment
Optimization Directives
C Test Bench and C Source Code
Exporting the RTL Design
Running Implementation
Implementation Report
Output of RTL Export
Archiving the Project
Running Vitis HLS from the Command Line
Vitis HLS Hardware Design Methodology
Introduction to the Methodology Guide
Designing Efficient Kernels
Vitis HLS Coding Styles
Unsupported C/C++ Constructs
System Calls
Dynamic Memory Usage
Pointer Limitations
Recursive Functions
Standard Template Libraries
Undefined Behaviors
Functions
Inlining Functions
Impact of Coding Style
C/C++ Builtin Functions
Loops
Variable Loop Bounds
Loop Pipelining
Imperfect Nested Loops
Loop Parallelism
Loop Dependencies
Unrolling Loops in C++ Classes
Arrays
Array Accesses and Performance
FIFO Accesses
Arrays on the Interface
Array Interfaces
FIFO Interfaces
Array Initialization
Implementing ROMs
Data Types
Arbitrary Precision (AP) Data Types
Advantages of AP Data Types
Overview of Arbitrary Precision Integer Data Types
Overview of Arbitrary Precision Fixed-Point Data Types
Standard Types
Floats and Doubles
Composite Data Types
Structs
Structs on the Interface
Struct Padding and Alignment
Enumerated Types
Unions
Type Qualifiers
Volatile
Statics
Const
ROM Optimization
Global Variables
Pointers
Pointers on the Interface
Basic Pointers
Pointer Arithmetic
Multi-Access Pointers on the Interface
Understanding Volatile Data
Modeling Streaming Data Interfaces
Multi-Access Pointers and RTL Simulation
Vector Data Types
C++ Classes and Templates
Global Variables and Classes
Templates
Using Templates to Create Unique Instances
Examples of Hardware Efficient C++ Code
Typical C++ Code for a Convolution Function
Horizontal Convolution
Vertical Convolution
Border Pixels
Ensuring the Continuous Flow of Data and Data Reuse
Using HLS Streams for Streaming Data
Horizontal Convolution
Vertical Convolution
Border Pixels
Summary of C++ for Efficient Hardware
Defining Interfaces
Introduction to Interface Synthesis
Interfaces for Vitis Kernel Flow
Interfaces for Vivado IP Flow
AXI Adapter Interface Protocols
AXI4 Master Interface
Offset and Modes of Operation
Controlling the Address Offset in an AXI4 Interface
M_AXI Bundles
M_AXI Resources
Controlling AXI4 Burst Behavior
Automatic Port Width Resizing
Creating an AXI4 Interface with 32-bit Address
Customizing AXI4 Master Interfaces in IP Integrator
AXI4-Lite Interface
S_AXILITE Example
S_AXILITE Control Register Map
S_AXILITE and Port-Level Protocols
S_AXILITE Bundle Rules
S_AXILITE Offset Option
C Driver Files
C Driver Files and Float Types
Controlling Hardware
Auto-Restart Mode
Controlling Software
Control Clock and Reset in AXI4-Lite Interfaces
Customizing AXI4-Lite Slave Interfaces in IP Integrator
AXI4-Stream Interfaces
How AXI4-Stream Works
How AXI4-Stream is Implemented
Registered AXI4-Stream Interfaces
AXI4-Stream Interfaces without Side-Channels
AXI4-Stream Interfaces with Side-Channels
Coding Style for Array to Stream
Port-Level I/O Protocols
Port-Level I/O: No Protocol
Port-Level I/O: Wire Handshakes
Port-Level I/O: Memory Interface Protocol
Block-Level Control Protocols
Managing Interfaces with SSI Technology Devices
Optimization Techniques in Vitis HLS
Controlling the Reset Behavior
Initialization Behavior
Initializing and Resetting Arrays
Optimizing for Throughput
Function and Loop Pipelining
Rewinding Pipelined Loops for Performance
Flushing Pipelines
Automatic Loop Pipelining
Unrolling Loops to Improve Pipelining
Addressing Failure to Pipeline
Static Variables
Partitioning Arrays to Improve Pipelining
Automatic Array Partitioning
Managing Pipeline Dependencies
Removing False Dependencies to Improve Loop Pipelining
Scalar Dependencies
Exploiting Task Level Parallelism: Dataflow Optimization
Canonical Forms
Canonical Body
Dataflow Checking
Dataflow Optimization Limitations
Configuring Dataflow Memory Channels
Specifying Arrays as Ping-Pong Buffers or FIFOs
Specifying Compiler-Created FIFO Depth
Stable Arrays
Using ap_ctrl_none Inside the Dataflow
Improve Performance Using Stream-of-Blocks
Stream-of-Blocks Modeling Style
Resource Usage
Checking for Full and Empty Blocks
Modeling Feedback in Dataflow Regions
Limitations
Programming Model for Multi-Port Access in HBM
Optimizing for Latency
Using Latency Constraints
Merging Sequential Loops to Reduce Latency
Flattening Nested Loops to Improve Latency
Optimizing for Area
Data Types and Bit-Widths
Function Inlining
Array Reshaping
Function Instantiation
Controlling Hardware Resources
Limiting the Number of Operators
Controlling Hardware Implementation
Optimizing Logic
Inferring Shift Registers
Controlling Operator Pipelining
Optimizing Logic Expressions
Optimizing AXI System Performance
AXI Burst Transfers
Preconditions and Limitations of Burst Transfer
Options for Controlling AXI4 Burst Behavior
Examples of Recommended Coding Styles
Summary
Using Manual Burst
AXI Performance Case Study
Adding RTL Blackbox Functions
Using the RTL Blackbox Wizard
C++ Model and Header Files
RTL IP Definition
JSON File for RTL Blackbox
Vitis HLS Command Reference
vitis_hls Command
hls_init.tcl
Project Commands
add_files
close_project
close_solution
cosim_design
cosim_stall
create_clock
csim_design
csynth_design
delete_project
delete_solution
enable_beta_device
export_design
get_clock_period
get_clock_uncertainty
get_files
get_part
get_project
get_solution
get_top
help
list_part
open_project
open_solution
open_tcl_project
set_clock_uncertainty
set_part
set_top
Configuration Commands
config_array_partition
config_compile
config_dataflow
config_debug
config_export
config_interface
config_op
config_rtl
config_schedule
config_storage
config_unroll
Optimization Directives
set_directive_aggregate
set_directive_alias
set_directive_allocation
set_directive_array_partition
set_directive_array_reshape
set_directive_bind_op
set_directive_bind_storage
set_directive_dataflow
set_directive_dependence
set_directive_disaggregate
set_directive_expression_balance
set_directive_function_instantiate
set_directive_inline
set_directive_interface
set_directive_latency
set_directive_loop_flatten
set_directive_loop_merge
set_directive_loop_tripcount
set_directive_occurrence
set_directive_performance
set_directive_pipeline
set_directive_protocol
set_directive_reset
set_directive_stable
set_directive_stream
set_directive_top
set_directive_unroll
HLS Pragmas
pragma HLS aggregate
pragma HLS alias
pragma HLS allocation
pragma HLS array_partition
pragma HLS array_reshape
pragma HLS bind_op
pragma HLS bind_storage
pragma HLS dataflow
pragma HLS dependence
pragma HLS disaggregate
pragma HLS expression_balance
pragma HLS function_instantiate
pragma HLS inline
pragma HLS interface
pragma HLS latency
pragma HLS loop_flatten
pragma HLS loop_merge
pragma HLS loop_tripcount
pragma HLS occurrence
pragma HLS performance
pragma HLS pipeline
pragma HLS protocol
pragma HLS reset
pragma HLS stable
pragma HLS stream
pragma HLS top
pragma HLS unroll
Vitis HLS C Driver Reference
AXI4-Lite Slave C Driver Reference
X<DUT>_Initialize
X<DUT>_CfgInitialize
X<DUT>_LookupConfig
X<DUT>_Release
X<DUT>_Start
X<DUT>_IsDone
X<DUT>_IsIdle
X<DUT>_IsReady
X<DUT>_Continue
X<DUT>_EnableAutoRestart
X<DUT>_DisableAutoRestart
X<DUT>_Set_ARG
X<DUT>_Set_ARG_vld
X<DUT>_Set_ARG_ack
X<DUT>_Get_ARG
X<DUT>_Get_ARG_vld
X<DUT>_Get_ARG_ack
X<DUT>_Get_ARG_BaseAddress
X<DUT>_Get_ARG_HighAddress
X<DUT>_Get_ARG_TotalBytes
X<DUT>_Get_ARG_BitWidth
X<DUT>_Get_ARG_Depth
X<DUT>_Write_ARG_Words
X<DUT>_Read_ARG_Words
X<DUT>_Write_ARG_Bytes
X<DUT>_Read_ARG_Bytes
X<DUT>_InterruptGlobalEnable
X<DUT>_InterruptGlobalDisable
X<DUT>_InterruptEnable
X<DUT>_InterruptDisable
X<DUT>_InterruptClear
X<DUT>_InterruptGetEnabled
X<DUT>_InterruptGetStatus
Vitis HLS Libraries Reference
Arbitrary Precision Data Types Library
Using Arbitrary Precision Data Types
Arbitrary Integer Precision Types with C++
Arbitrary Precision Fixed-Point Data Types
Fixed-Point Identifier Summary
Example Using ap_fixed
C++ Arbitrary Precision Integer Types
C++ Arbitrary Precision Integer Types: Reference Information
C++ Arbitrary Precision Types
Compiling ap_[u]int<> Types
Declaring/Defining ap_[u] Variables
Initialization and Assignment from Constants (Literals)
Support for Console I/O (Printing)
Expressions Involving ap_[u]<> types
Class Methods and Operators
Other Class Methods, Operators, and Data Members
C++ Arbitrary Precision Fixed-Point Types
Fixed-Point Identifier Summary
C++ Arbitrary Precision Fixed-Point Types: Reference Information
C++ Arbitrary Precision Fixed-Point Types
ap_[u]fixed Representation
Quantization Modes
Overflow Modes
Compiling ap_[u]fixed<> Types
Declaring and Defining ap_[u]fixed<> Variables
Initialization and Assignment from Constants (Literals)
Support for Console I/O (Printing)
Expressions Involving ap_[u]fixed<> types
Class Methods, Operators, and Data Members
Vitis HLS Math Library
HLS Math Library Accuracy
HLS Math Library
Fixed-Point Math Functions
Verification and Math Functions
Verification Option 1: Standard Math Library and Verify Differences
Verification Option 2: HLS Math Library and Validate Differences
Verification Option 3: HLS Math Library File and Validate Differences
Common Synthesis Errors
HLS Stream Library
C Modeling and RTL Implementation
Using HLS Streams
Blocking API
Blocking Write Methods
Blocking Read Methods
Stream.full() Method
Stream.empty() Method
Deterministic Behavior
Non-Blocking API
Non-Blocking Writes
Non-Blocking Read
Controlling the RTL FIFO Depth
HLS IP Libraries
FFT IP Library
FFT Static Parameters
FFT Runtime Configuration and Status
Using the FFT Function with Array Interface
Using FFT Function with Streaming Interface
FIR Filter IP Library
FIR Static Parameters
Using the FIR Function with Array Interface
Optional FIR Runtime Configuration
Using FIR Function with Streaming Interface
DDS IP Library
DDS Static Parameters
DDS Struct Parameter Values
SRL IP Library
Mapping Directly into SRL Resources
Read from the Shifter
Read, Write, and Shift Data
Read, Write, and Enable-Shift
Vitis HLS Migration Guide
Migrating to Vitis HLS
HLS Behavioral Differences
Default Interfaces
Vitis Flow (Kernel Mode)
Vivado Flow (IP Mode)
Unconnected Ports
Global Variables on the Interface
Handling Structs
Interface Bundle Rules
S_AXI Lite
MAXI
Interface Offset
SAXI Lite
MAXI Offset
Memory Property on Interface
AXI4-Stream Interfaces with Side-Channels
Behavior Changes to Module Names and Module Prefix
Dataflow
Default User Control Settings
Unsupported Features
Assertions
Pragmas
Top-Level Function Argument
HLS Video Library
C Arbitrary Precision Types
Deprecated and Unsupported Features
Additional Resources and Legal Notices
Xilinx Resources
Documentation Navigator and Design Hubs
References
Revision History
Please Read: Important Legal Notices

Back to home page