Vitis Unified Software Platform Documentation: Application Acceleration Development (UG1393) - 2021.1 English

Document ID: UG1393
Release Date: 2022-03-29
Version: 2021.1 English

Getting Started with Vitis
Vitis Software Platform Release Notes
What's New
Supported Platforms
Changed Behavior
Known Issues
Installation
Installation Requirements
OpenCL Installable Client Driver Loader
Vitis Software Platform Installation
Installing the Vitis Software Platform
Installing Xilinx Runtime and Platforms
Installing Embedded Platforms
Setting Up the Environment to Run the Vitis Software Platform
Introduction to the Vitis Environment for Acceleration
Accelerated Flow Application Development Using the Vitis Software Platform
FPGA Acceleration
Execution Model
Data Center Application Acceleration Development Flow
Embedded Processor Application Acceleration Development Flow
Build Targets
Tutorials and Examples
Methodology for Accelerating Applications with the Vitis Software Platform
Introduction
Acceleration: An Industrial Analogy
Methodology Overview
Recommendations
Methodology for Architecting a Device Accelerated Application
Step 1: Establish a Baseline Application Performance and Establish Goals
Measure Running Time
Measure Throughput
Determine the Maximum Achievable Throughput
Establish Overall Acceleration Goals
Step 2: Identify Functions to Accelerate
Identify Performance Bottlenecks
Identify Acceleration Potential
Step 3: Identify Device Parallelization Needs
Estimate Hardware Throughput without Parallelization
Determine How Much Parallelism is Needed
Determine How Many Samples the Datapath Should be Processing in Parallel
Determine How Many Kernels Can and Should be Instantiated in the Device
Step 4: Identify Software Application Parallelization Needs
Minimize CPU Idle Time While the Device Kernels are Running
Keep the Device Kernels Utilized
Optimize Data Transfers to and from the Device
Conceptualize the Desired Application Timeline
Step 5: Refine Architectural Details
Finalize Kernel Boundaries
Decide Kernel Placement and Connectivity
Methodology for Developing C/C++ Kernels
About the High-Level Synthesis Compiler
Verification Considerations
Step 1: Partition the Code into a Load-Compute-Store Pattern
Create a Top-Level Function with the Desired Interface
Code the Load and Store Functions
Match Port Width to Datapath Width
Use Burst Transfers
Minimize the Number of Data Transfers from Global Memory
Code the Compute Functions
Connect the Load, Compute, and Store Functions
Step 2: Partition the Compute Blocks into Smaller Functions
Decompose to Identify Throughput Goals
Aim for Functions with a Single Loop Nest
Connect Compute Functions Using the Dataflow ‘Canonical Form’
Step 3: Identify Loops Requiring Optimization
Step 4: Improve Loop Latencies
Apply Loop Unrolling
Apply Array Partitioning
Step 5: Improve Loop Throughput
Eliminate I/O Contentions
Eliminate Loop-Carried Dependencies
Advanced Techniques
Developing Applications
Programming Model
Device Topology
Kernel Properties
SW-Controllable Kernels
Design Languages
HW Interfaces
Execution Modes
Non-Software Controlled Kernels
HW Interfaces
Clock and Reset Requirements
Host Programming
Specifying the Device ID and Loading the XCLBIN
Setting Up XRT-Managed Kernels and Kernel Arguments
Creating Multiple Compute Units
Transferring Data between Host and Kernels
Executing Kernels on the Device
Setting Up User-Managed Kernels and Argument Buffers
Enabling Auto-Restart of User-Managed Kernels
Summary
C/C++ Kernels
Process Execution Modes
Data Types
Arbitrary Precision Integer Types
Arbitrary Precision Fixed-Point Data Types
Interfaces
Memory Mapped Interfaces
Kernel Interfaces
Memory Interface Width Considerations
Burst Accesses to Global Memory
Scalar Inputs
Streaming Interfaces
Loops
Loop Pipelining
Loop Unrolling
Loop Dependencies
Nested Loops
Sequential Loops
Dataflow Optimization
Dataflow Coding Example
Canonical Forms of Dataflow Optimization
Troubleshooting Dataflow
Array Configuration
Function Inlining
Streaming Data in User-Managed Never-Ending Kernels
Kernel Coding Guidelines
Summary
RTL Kernels
Requirements of an RTL Kernel
Kernel Interface Requirements
Control Requirements for XRT-Managed Kernels
Interrupt
Creating User-Managed RTL Kernels
RTL Kernel Development Flow
Package the RTL Code as a Vitis XO
Design Recommendations for RTL Kernels
Memory Performance Optimizations for AXI4 Interface
Quality of Results Considerations
Debug and Verification Considerations
Best Practices for Acceleration with Vitis
Building and Running the Application
Setting Up the Vitis Environment
Build Targets
Software Emulation
Hardware Emulation
System Hardware Target
Building the Host Program
Compiling and Linking for x86
Compiling and Linking for Arm
Building the Device Binary
Compiling Kernels with the Vitis Compiler
Compiling Kernels with Vitis HLS
Creating Kernels in Vitis HLS
Vitis HLS Script for Creating Kernels
Linking the Kernels
Creating Multiple Instances of a Kernel
Mapping Kernel Ports to Memory
HBM Configuration and Use
Random Access and the RAMA IP
PLRAM Configuration and Use
Specifying Streaming Connections between Compute Units
Assigning Compute Units to SLRs
Managing Clock Frequencies
Identifying Platform Clocks
Managing Vivado Synthesis and Implementation Results
Using the -vivado and -advanced Options
Running Multiple Implementation Strategies for Timing Closure
Using -to_step and Launching Vivado Interactively
Controlling Report Generation
Packaging the System
Packaging for Embedded Platforms
Packaging for Data Center Platforms
Output Directories of the v++ Command
Running Emulation
Running Emulation Targets
Data Center vs. Embedded Platforms
QEMU
Running Emulation on Data Center Accelerator Cards
Running Emulation on an Embedded Processor Platform
Speed and Accuracy of Hardware Emulation
Working with Simulators in Hardware Emulation
Simulator Support
Using the Simulator Waveform Viewer
AXI Transactions Display in XSIM Waveform
Working with SystemC Models
Coding a SystemC Model
Creating the XO
Linking with the v++ Command
Using I/O Traffic Generators
Adding Traffic Generators to Your Design
AXI4-Stream I/O Model for Streaming Traffic
Writing Traffic Generators in Python
Writing Traffic Generators in C++
AXI4 Memory Map External Traffic through Python/C++
Use Cases
API/Pseudo Code
AXI4 Memory Map I/O Limitations in the Platform
XO Usage
Running Traffic Generators
Running the Application Hardware Build
Profiling, Optimizing, and Debugging the Application
Profiling the Application
Baselining Functionality and Performance
Enabling Profiling in Your Application
Continuous Trace Capture
Custom Profiling of the Host Application
Profiling of C++ Code
Profiling of C Code
Enabling Low Overhead Profiling
Guidance
Opening the Guidance Report
Interpreting Guidance Data
System Estimate Report
Opening the System Estimate Report
Interpreting the System Estimate Report
Design and Target Device Summary
Kernel Summary
Timing Information
Latency Information
Area Information
HLS Report
Generating and Opening the HLS Report
Interpreting the HLS Report
Profile Summary Report
Generating and Opening the Profile Summary Report
Interpreting the Profile Summary
Timeline Trace
Generating and Opening the Timeline Trace
Interpreting the Timeline Trace
Waveform View and Live Waveform Viewer
Generating and Opening the Waveform Reports
Interpreting Data in the Waveform Views
Optimizing the Performance
Host Optimization
Reducing Overhead of Kernel Enqueing
Optimizing Data Movement
Overlapping Data Transfers with Kernel Computation
Buffer Memory Segmentation
Compute Unit Scheduling
Multiple In-Order Command Queues
Single Out-of-Order Command Queue
Kernel Optimization
Optimizing Kernel Computation
Interface Attributes (Detailed Kernel Trace)
Using Burst Data Transfers
Using Full AXI Data Width
Optimizing Kernel to Kernel Communication
Optimizing Memory Architecture
Optimizing Computational Parallelism
Coding Data Parallelism
Loop Parallelism
Unrolling Loops
Pipelining Loops
Task Parallelism
Optimizing Device Resources
Exploring Kernel Optimizations Using Vitis HLS
Topological Optimization
Multiple Compute Units
Using Multiple DDR Banks
Assigning DDR Bank in Host Code
Assigning Global Memory for Kernel Code
Creating Multiple AXI Interfaces
Assigning AXI Interfaces to DDR Banks
Assigning AXI Interfaces to PLRAM
Kernel SLR and DDR Memory Assignments
Guidelines for Kernels that Access Multiple Memory Banks
Debugging Applications and Kernels
Debugging Flows
Debugging in Software Emulation
GDB-Based Debugging
Xilinx Runtime Library GDB Extensions
xprint Commands
xstatus Commands
GDB Kernel-Based Debugging
Command Line Debug Flow
Debugging OpenCL Kernels
Launching Host and Kernel Debug
Using printf() or cout to Debug Kernels
C/C++ Kernel
OpenCL Kernel
Debugging in Hardware Emulation
Waveform-Based Kernel Debugging
Enable Waveform Debugging with the Vitis Compiler Command
Run the Waveform-Based Kernel Debugging Flow
Debug Techniques for Hardware Emulation
Debugging During Hardware Execution
Enabling Kernels for Debugging with Chipscope
Adding Debug IP to RTL Kernels
Enabling ILA Triggers for Hardware Debug
Adding ILA Triggers Before Starting Kernels
Pausing the Host Application Using GDB
Debugging with ChipScope
Checking the FPGA Board for Hardware Debug Support
Running XVC and HW Servers
Automated Setup for Hardware Debug
Manual Setup for Hardware Debug
Starting Debug Servers on an Amazon F1 Instance
Debugging Designs Using Vivado Hardware Manager
JTAG Fallback for Private Debug Network
JTAG Fallback Steps
Utilities for Hardware Debugging
Using the Linux dmesg Utility
Using the Xilinx xbutil Utility
Techniques for Debugging Application Hangs
AXI Firewall Trips
Kernel Hangs Due to AXI Violations
Host Application Hangs When Accessing Memory
Typical Errors Leading to Application Hangs
Defensive Programming
Debugging on Embedded Processor Platforms
Emulation Debug for Embedded Processors
Hardware Debug for Embedded Processors
Example of Command Line Debugging
Vitis Environment Reference Materials
Vitis Compiler Command
Vitis Compiler General Options
--advanced Options
--clock Options
--connectivity Options
--debug Options
--hls Options
--linkhook Options
--package Options
--profile Options
--vivado Options
Vitis Compiler Configuration File
Using the Message Rule File
emconfigutil Utility
kernelinfo Utility
Kernel Definition
Arguments
Ports
launch_emulator Utility
Versal PS and PMC Arguments for QEMU
Zynq UltraScale+ MPSoC PS and PMU Arguments for QEMU
Zynq-7000 PS Arguments for QEMU
manage_ipcache Utility
package_xo Command
RTL Kernel XML File
platforminfo Utility
Basic Platform Information
Hardware Platform Information
Interface Information
Clock Information
Valid SLRs
Resource Availability
Memory Information
Feature ROM Information
Software Platform Information
Platforminfo for xilinx_zcu104_base_202010_1
xbutil Utility
xbmgmt Utility
xclbinutil Utility
xclbin Information
Hardware Platform Information
Clocks
Memory Configuration
Kernel Information
Tool Generation Information
xrt.ini File
HLS Pragmas
Using the Vitis Analyzer
Working with Reports
Configuring the Vitis Analyzer
Vitis Analyzer GUI and Window Manager
Diff Two Text Files
Diff Two Timeline Trace Reports
Cross-Probing between Reports
Platform and System Diagrams
AI Engine Graphs and Arrays
Link Summary: Multiple Strategies and Timing Reports
Setting Guidance Thresholds
Creating an Archive File
Using the Vitis IDE
Vitis Command Options
Creating a Vitis IDE Project
Launch a Vitis IDE Workspace
Create an Application Project
Managing Platforms and Repositories
Understanding the Vitis IDE
Adding Sources
Add Source Files
Create and Edit New Source Files
Working in the Project Editor View
Working in the Assistant View
Output Directories from the Vitis IDE
Building the System
Vitis IDE Guidance View
Working with Vivado Tools from the Vitis IDE
Vitis IDE Debug Flow
Using the Standalone Debug Flow
vitis -debug Command Line
Configuring the Vitis IDE
Vitis Project Settings
Vitis Build Configuration Settings
Vitis Hardware Function Settings
Vitis Binary Container Settings
Vitis Toolchain Settings
G++ Host Compiler and Linker Settings
V++ Compiler and Linker Settings
emconfigutil Settings
Vitis Run and Debug Configuration Settings
Project Export and Import
Export a Vitis Project
Import a Vitis Project
Import Projects from Git
Getting Started with Examples
Installing Examples and Libraries
Using Local Copies
RTL Kernel Wizard
Launch the RTL Kernel Wizard
Using the RTL Kernel Wizard
General Settings
Scalars
Global Memory
Streaming Interfaces
Summary
Using the RTL Kernel Project in Vivado IDE
RTL Type Kernel Project
Block Design Type Kernel Project
Simulation Test Bench
Out-of-Context Synthesis
Software Model and Host Code Example
Generate RTL Kernel
Modifying an Existing RTL Kernel Generated from the Wizard
Using Vitis Embedded Platforms
Vitis Embedded Platforms
Introduction
Platform Types
Platform Naming Convention
Embedded Platform Components and Architecture
Installing Embedded Platforms
Using Vitis Embedded Platforms
Packaging Images
Packaging Images with Ext4 rootfs in the Vitis IDE
Packaging Images with initramfs rootfs in the Vitis IDE
Writing Images to the SD Card
Configuring the PL Kernel in DFX Platforms and Non-DFX Platforms
Running an Acceleration Application on the Board
Software Package Management in PetaLinux rootfs
Creating Embedded Platforms in Vitis
Platform Creation Basics
Platform Creation Requirements
Creating an Embedded Platform
Adding Hardware Interfaces
Updating Software Components
Packaging a Vitis Acceleration Platform
Testing Your Platform
Enabling Hardware Emulation for Extensible XSA
Special Considerations for Embedded Platform Creation
Validating an Embedded Platform
Check Platform Metadata
Use the Platform with Simple Test Case
Run Baremetal Software on Fixed-Platform
Additional Information
OpenCL Programming
OpenCL Host Application
Setting Up the OpenCL Environment
Platform
Devices
Sub-Devices
Context
Command Queues
Program
Executing Commands in the FPGA
Setting Up Kernels
Setting Kernel Arguments
Buffer Allocation on the Device
Buffer Creation and Data Transfer
Letting XRT Allocate Buffers
Using Host Pointer Buffers
Allocating Page-Aligned Host Memory
Sub-Buffers
Reading a Specific Portion from the Device Buffer
Device Buffer Shared by Multiple Memory Ports or Multiple Kernels
Kernel Execution
Task Parallelism Using Different Kernels
Spatial Data Parallelism: Increase Number of Compute Units
Temporal Data Parallelism: Host-to-Kernel Dataflow
Enabling Host-to-Kernel Dataflow
Symmetrical and Asymmetrical Compute Units
Kernel Handle and Compute Units
Using Compute Unit Name to Get Handle of All Asymmetrical Compute Units
Event Synchronization
Post-Processing and FPGA Cleanup
OpenCL Kernel Development
Kernel Signature
Kernel Optimizations
Setting Data Width in OpenCL Kernels
Reducing Kernel to Kernel Communication Latency in OpenCL Kernels
OpenCL Attributes
always_inline
opencl_unroll_hint
reqd_work_group_size
vec_type_hint
work_group_size_hint
xcl_array_partition
xcl_array_reshape
xcl_dataflow
xcl_latency
xcl_loop_tripcount
xcl_max_work_group_size
xcl_pipeline_loop
xcl_pipeline_workitems
xcl_reqd_pipe_depth
xcl_zero_global_work_offset
Migrating to a New Target Platform
Design Migration
Understanding an FPGA Architecture
Understanding Target Platforms
Migrating Releases
Host Code Migration
Release Migration
Modifying Kernel Placement
Implications of a New Hardware Platform
Determining Where to Place the Kernels
Assigning Kernels to SLRs
Address Timing
Custom Constraints
Timing Closure Considerations
Legacy Reference
xbutil Utility - Legacy
clock
dmatest
dump
m2mtest
mem --read
mem --write
p2p
program
query
reset
scan (xbutil)
status
top
validate
version
xbmgmt Utility - Legacy
config
flash
partition
scan (xbmgmt)
version
Streaming Data Transfers
Streaming Data Transfers between Kernels (K2K)
Host Coding Guidelines
Streaming Kernel Coding Guidelines
Free-Running Kernel
Host Coding for Free-Running Kernels
Coding Guidelines for Free-Running Kernels
Additional Resources and Legal Notices
Xilinx Resources
Documentation Navigator and Design Hubs
Revision History
Please Read: Important Legal Notices

Back to home page