One of the major differences with the Alveo V80 accelerator card is the implementation of the satellite controller. The satellite controller was previously implemented using a discrete microcontroller, on the V80 the management controller as it is named is implemented internally within the Real Time Processing Unit (RPU).
Within the AMC there are four major functions which are implemented within the RPU, these are:
Monitoring the card sensors and low-level card control features – These are provided by an in-band PCIe telemetry interface.
Remote management interface which supports server management software infrastructure like OpenBMC using SMBus.
To support application development and deployment the AMC also supports the ability to program and inspect the V80 storage memory.
Support for application runtime services e.g., clock management, using the AVED Management Interface (AMI) from the host.
The AMC is implemented in an abstracted format which leverages levels of abstraction; the lowest level of abstraction is provided by the operating system abstraction level (OSAL). This is based on a CMake build process and provides support for building the AMC on either the target RPU processor which uses Free_RTOS or to enable host testing on Linux.
In addition to the abstraction of the operating system, the AMC also leverages a Firmware Interface Abstraction Level (FAL). The FAL provides developers with an abstraction layer to any driver within the system. This enables applications to be developed which are agnostic of any platform.
Running on top of the OSAL and FAL are several applications which can implement the four major functions described above.
One of the key methods of the AMC is the use of proxy drivers, the proxy driver enables the separation of behaviour and functionality.
To get started with building the AMC, the first step is to build the XSA which we created previously here when we rebuilt the AVED Vivado design. If the project was built using the AVED scripts, you will find the project under the /AVED/hw/amd_v80_gen5x8_23.2_exdes_2/build/ directory.
To build the AMC application we need to use the scripts which are provided under the FW directory of the cloned AVED repository. Under this directory, you will see several directories including a scripts directory which contains the build scripts and of course the src directory where all of the AMC source is located. The resultant executable and build log will be located under the build directory.
Building the AMC from scratch for either target is simple, open a terminal within the AMC directory and type in the command:
./scripts/build.sh -help This will detail the modes of operation for the script and the information required for each option.
To build the RPU targeted AMC application we use the command below:
./scripts/build.sh -os freertos10_xilinx -profile v80 -xsa <path>/amd_v80.xsaThis will create the BSP and compile the AMC application for the RPU, making the executable available under the builds directory.
Should we wish to test the application on a Linux host machine we can use the command:
./scripts/build.sh -os Linux -amcAgain the resultant application will be available under the builds directory. We have now looked at the creation of the AVED Vivado design and the RPU AMC application. This provides us a solid foundation on which we can build our V80 application!
Workshops and Webinars
If you enjoyed the blog why not take a look at the free webinars, workshops and training courses we have created over the years. Highlights include
Professional PYNQ Learn how to use PYNQ in your developments
Introduction to Vivado learn how to use AMD Vivado
Ultra96, MiniZed & ZU1 three day course looking at HW, SW and PetaLinux
Arty Z7-20 Class looking at HW, SW and PetaLinux
Mastering MicroBlaze learn how to create MicroBlaze solutions
HLS Hero Workshop learn how to create High Level Synthesis based solutions
Perfecting Petalinux learn how to create and work with PetaLinux OS
Embedded System Book
Do you want to know more about designing embedded systems from scratch? Check out our book on creating embedded systems. This book will walk you through all the stages of requirements, architecture, component selection, schematics, layout, and FPGA / software design. We designed and manufactured the board at the heart of the book! The schematics and layout are available in Altium here Learn more about the board (see previous blogs on Bring up, DDR validation, USB, Sensors) and view the schematics here.
Sponsored by AMD