Vitis Embedded Platforms

Introduction

The Vitis™ unified software platform provides a Platform+Kernel structure to help developers focus on the applications. The decoupling of platform and kernel helps make the platform reusable with multiple kinds of kernels and vice versa.

Xilinx provides pre-built platforms for Alveo™ and embedded evaluation boards. You are free to create your own embedded platforms or customize the Xilinx embedded platforms.

The Vitis software platform is an environment for creating embedded software and accelerated applications on heterogeneous platforms based on FPGAs, Zynq®-7000 SoCs, and Zynq® UltraScale+™ MPSoCs. This document focuses on using embedded platform for Zynq UltraScale+ MPSoC.

Platform Types

The Vitis target platforms can be customized with unique hardware and software components. There are two general types of platforms: fixed platforms and extensible platforms. Fixed platforms support embedded software development and are a direct analog to the hardware definition file that was previously used for software development with the Xilinx SDK tool. Extensible platforms support the application acceleration development flow, and includes hardware for supporting acceleration kernels, controlling AI Engine for Versal™ ACAP, and software for a target running Linux and the Xilinx Runtime (XRT) library. For more information on the XRT library, see https://github.com/Xilinx/XRT.

The following figure shows the traditional SDK flow for embedded software application development. A Xilinx Hardware Design File (HDF) is exported from the Vivado® Design Suite. It is used by SDK for board support package (BSP) generation and creating software applications that apply the BSP.

Figure 1: Pre-2019.2 SDK Flow

The following figure shows the Vitis embedded software development flow that replaces the SDK flow beginning with the 2019.2 release. The hardware specification is now contained in the Xilinx Shell Archive (XSA) and is exported from a Vivado design, but is formatted differently from HDF and uses the .xsa filename extension.

Figure 2: Vitis Embedded Software Development Flow

The Vitis core tools create a platform, BSP, and software boot components such as the FSBL and PMU firmware for the fixed-XSA, and are associated with the Vitis platform. Software applications targeting the fixed-platform can be developed with the Vitis Embedded Software Development flow. Fixed-platforms do not require Linux and the XRT library, but can target processor domains running Baremetal and RTOS operating systems as well. See the Vitis Embedded Software Development Flow Documentation in the Vitis Unified Software Platform Documentation (UG1416) for more information.

In the Vitis Application Acceleration Development flow, the Vivado Design Suite is also used to generate and write an extensible-XSA, containing additional IP blocks and metadata to support kernel connectivity. The following figure shows the acceleration software development flow.

Figure 3: Vitis Acceleration Kernel Flow

The Vitis core tool supports application development in multiple languages (OpenCL™, C, C++) but the applications must target a Vitis platform. A target platform consists of hardware and software components as shown in the following figure. The target platform view on the left side of the page is for the Vitis embedded software development flow, whereas the right side of page shows a platform that supports acceleration kernels. The differences include acceleration kernel requirements of a target with Linux + XRT, metadata, and kernel interface declarations.

Note: Custom platform generation sources are available in https://github.com/Xilinx/Vitis_Embedded_Platform_Source.
Figure 4: Vitis Target Platforms
Figure 5: Vitis Platform Project Flow

Platform Naming Convention

The platform name is used when creating acceleration applications in Vitis or targeting platforms when using the Vitis compiler (v++). Pre-built platform images also use the same file name and directory name.

Pre-built Vitis embedded platforms use the following naming convention.
<Vendor>_<Board>_<Feature>_<Supported Vitis Tool Version>_<Release
                        Version>

Where:

<Vendor>
The board vendor. For all Xilinx-created pre-built platforms, use xilinx.
<Feature>
The special function of this platform. For example:
  • base indicates that it connects all possible resources for you to use in an acceleration application.
  • DFX indicates that it supports Xilinx Dynamic Function eXchange (DFX).
<Supported Vitis Tool Version>
The specific version of the Vitis development platform that the platform is designed for. This also indicates the version of the Vivado® Design Suite tools that the pre-built platform is created by.
<Release Version>
The release version of the platform. The first version is 1.

For example, the following platform names follow the naming convention:

  • xilinx_zcu102_base_202020_1
  • xilinx_zcu104_base_202020_1
  • xilinx_zc706_base_202020_1
  • xilinx_zcu102_base_dfx_202020_1
Note: Platform source code uses a git branch for versioning. The directory name is <Board>_<Feature> (for example, zcu102_base). The platform generated from the source in https://github.com/Xilinx/Vitis_Embedded_Platform_Source has the name xilinx_zcu102_base_202020_1.

Embedded Platform Components and Architecture

A platform is the starting point of your Vitis design. Vitis applications are built on top of the platforms.

An embedded platform includes a hardware platform and a software platform.

Hardware Platform

The hardware platform is the static, unchanging portion of your hardware design. It includes the Xilinx Support Archive (XSA) file exported from the Vivado Design Suite.

The hardware platform describes platform hardware setup and the acceleration resources that can be used by acceleration applications, for example, Input and output interfaces, clocks, AXI buses, and interrupts. Vitis adds kernels and infrastructure modules to the hardware design as needed to facilitate data movement. Acceleration kernels can share data with platform IPs, but cannot change or modify them. For information about setting up the hardware platform, refer to Installing Xilinx Runtime and Platforms.

Software Platform

The software platform is the environment that runs the software to control acceleration kernels for acceleration applications. It includes the domain setup and boot components setup.

By default, all Xilinx pre-built platforms have a Linux domain that has enabled Xilinx Runtime (XRT) so that acceleration applications can run on this environment. The pre-built binaries for Linux kernel image and rootfs are located in a separate download file on the PetaLinux download page. See the "Common images for Embedded Vitis platforms" section of the Xilinx download center. Because the device tree is unique to each platform, it is provided as a component with the Linux XRT domain inside the platform.

Linux Domain Components must be provided when there is a Linux domain in the embedded platform. These components can be generated by PetaLinux, Yocto, or third-party frameworks. Because these components can be shared across all Xilinx demo boards for the given FPGA family, a common Linux component image generated by PetaLinux is provided for Zynq-7000 SoC and Zynq UltraScale+ MPSoC devices.

The following Linux images can be downloaded from the PetaLinux download page:

Root File System (RFS)
Includes binaries, libraries, and setups for a Linux file system. In the Xilinx-provided common rootfs, XRT has been installed so that acceleration application can run on this Linux environment.
Kernel Image
A compiled Linux kernel. The common kernel image provided by Xilinx includes most Xilinx peripheral drivers.
Sysroot
Used for cross compilation. It provides the libraries to be linked when compiling applications for a target system.
Note: Optionally, you can pack Linux domain components into embedded platforms. When creating a Linux application in the Vitis IDE, the Linux domain components in the platform setting will be the default and initial settings if they have been set in the platform. You can overwrite these settings with components installed elsewhere.

Xilinx pre-built embedded platforms and pre-built common Linux components are provided in separate download files. You can regenerate the common Linux components from the platform source files hosted on the Vitis Embedded Platform GitHub repository by setting the environment variable COMMON_RFS_KRNL_SYSROOT=FALSE before running make .

Installing Embedded Platforms

Pre-built Vitis embedded platforms must be downloaded from the Xilinx website:

After you download the embedded platforms, there are three ways to include them in your project:

  • Extract the pre-built platforms to /opt/xilinx/platforms.
  • Extract the pre-built platforms to any folder. Set the PLATFORM_REPO_PATHS environment variable to the folder path.
    export PLATFORM_REPO_PATHS=/path/to/platforms
  • Extract the pre-built platforms to any folder. In the Vitis IDE, select Xilinx > Add Custom Platform and select the folder path.

Common Linux components can be extracted to any folder. When you create a Linux application, you will specify the path for the components in the Vitis New Application Project wizard.