Merge pull request #1541 from JOOpdenhoevel/feature/slash_support

Adding Alveo V80 support by adding Slash/V80++ as a new build target

Author: auphelia

docker/Dockerfile.finn

@@ -33,6 +33,7 @@ LABEL maintainer="Jakoba Petri-Koenig <jakoba.petri-koenig@amd.com>, Yaman Umuro
 ARG XRT_DEB_VERSION="xrt_202220.2.14.354_22.04-amd64-xrt"
 ARG SKIP_XRT
 ARG LOCAL_XRT
+ARG V80PP_DEB_PACKAGE
 
 WORKDIR /workspace
 
@@ -50,6 +51,10 @@ RUN apt-get update && \
     libsm6 \
     libxext6 \
     libxrender-dev \
+    libyaml-0-2 \
+    libjsoncpp-dev \
+    libxml2-dev \
+    libzmq3-dev \
     libpixman-1-0 \
     nano \
     zsh \
@@ -74,10 +79,16 @@ RUN apt-get update && \
     libjansson-dev \
     libgetdata-dev \
     libtinfo5 \
-    g++-10
+    g++-10 \
+    cmake
 RUN echo "StrictHostKeyChecking no" >> /etc/ssh/ssh_config
 RUN locale-gen "en_US.UTF-8"
 
+# Install v80++. If the package isn't provided, this is a no-op
+# The wildcard pattern ensures COPY doesn't fail if the file doesn't exist
+COPY v80pp.de[b] /tmp/
+RUN if [ -f /tmp/v80pp.deb ]; then apt-get install -y /tmp/v80pp.deb && rm /tmp/v80pp.deb; fi
+
 # install XRT
 RUN if [ -z "$LOCAL_XRT" ] && [ -z "$SKIP_XRT" ];then \
     wget -U 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.27 Safari/537.17' "https://www.xilinx.com/bin/public/openDownload?filename=$XRT_DEB_VERSION.deb" -O /tmp/$XRT_DEB_VERSION.deb; fi

docker/jenkins/test_bnn_hw_pytest.py

@@ -40,7 +40,7 @@ def delete_file(file_path):
 
 
 def get_platform(board_str):
-    return "alveo" if "U250" in board_str else "zynq-iodma"
+    return "vitis-xrt" if "U250" in board_str else "zynq-iodma"
 
 
 def get_full_parameterized_test_list(marker, test_dir_list, batch_size_list, platform_list):
@@ -110,7 +110,7 @@ def test_type_execute(self, test_dir, batch_size, platform):
         delete_file(output_execute_results_file)
 
         # Run test option: execute
-        bitfile = "a.xclbin" if platform == "alveo" else "resizer.bit"
+        bitfile = "a.xclbin" if platform == "vitis-xrt" else "resizer.bit"
         result = subprocess.run(
             [
                 "python",
@@ -144,7 +144,7 @@ def test_type_throughput(self, test_dir, batch_size, platform):
         delete_file(output_throughput_results_file)
 
         # Run test option: throughput
-        bitfile = "a.xclbin" if platform == "alveo" else "resizer.bit"
+        bitfile = "a.xclbin" if platform == "vitis-xrt" else "resizer.bit"
         result = subprocess.run(
             [
                 "python",

docs/finn/command_line.rst

@@ -132,16 +132,16 @@ build configuration), and are detailed below.
 
   * ``report/ooc_synth_and_timing.json`` -- resources and achievable clock frequency from out-of-context synthesis
 
-* :py:mod:`finn.builder.build_dataflow_config.DataflowOutputType.BITFILE` will run Vivado and/or Vitis to insert the FINN accelerator inside a shell, with DMA engines instantiated to move data to/from main memory:
+* :py:mod:`finn.builder.build_dataflow_config.DataflowOutputType.BITFILE` will run Vivado (for Zynq), Vitis, or Slash to insert the FINN accelerator inside a shell, with DMA engines instantiated to move data to/from main memory:
 
-  * ``bitfile/finn-accel.(bit|xclbin)`` -- generated bitfile depending on platform
+  * ``bitfile/finn-accel.(bit|xclbin|vbin)`` -- generated bitfile depending on platform
   * ``report/post_synth_resources.xml`` -- FPGA resource utilization after synthesis
   * ``report/post_route_timing.rpt`` -- post-route timing report
 
 
 * :py:mod:`finn.builder.build_dataflow_config.DataflowOutputType.PYNQ_DRIVER` will generate a PYNQ Python driver that can be used to interface the generated accelerator:
 
-  * ``driver/driver.py`` -- Python driver that can be used on PYNQ on Zynq or Alveo platforms to launch the accelerator
+  * ``driver/driver.py`` -- Python driver that can be used on PYNQ on Zynq or Vitis Alveo platforms to launch the accelerator
 
 * :py:mod:`finn.builder.build_dataflow_config.DataflowOutputType.DEPLOYMENT_PACKAGE`:
 

docs/finn/getting_started.rst

@@ -11,7 +11,7 @@ Quickstart
 2. Set up ``FINN_XILINX_PATH`` and ``FINN_XILINX_VERSION`` environment variables pointing respectively to the Xilinx tools installation directory and version (e.g. ``FINN_XILINX_PATH=/opt/Xilinx`` and ``FINN_XILINX_VERSION=2022.2``)
 3. Clone the FINN compiler from the repo: ``git clone https://github.com/Xilinx/finn/`` and go into the directory where it is cloned
 4. Execute ``./run-docker.sh quicktest`` to verify your installation.
-5. Optionally, follow the instructions on :ref:`PYNQ board first-time setup` or :ref:`Alveo first-time setup` for board setup.
+5. Optionally, follow the instructions on :ref:`PYNQ board first-time setup`, :ref:`Vitis-based Alveo first-time setup`, or :ref:`Slash-based Alveo first-time setup` for board setup.
 6. Optionally, set up a `Vivado/Vitis license`_.
 7. All done! See :ref:`Running FINN in Docker` for the various options on how to run the FINN compiler.
 
@@ -98,8 +98,9 @@ The most relevant are summarized below:
 
 * (required) ``FINN_XILINX_PATH`` points to your Xilinx tools installation on the host (e.g. ``/opt/Xilinx``)
 * (required) ``FINN_XILINX_VERSION`` sets the Xilinx tools version to be used (e.g. ``2022.2``)
-* (required for Alveo) ``PLATFORM_REPO_PATHS`` points to the Vitis platform files (DSA).
-* (required for Alveo) ``XRT_DEB_VERSION`` specifies the .deb to be installed for XRT inside the container (see default value in ``run-docker.sh``).
+* (required for Vitis) ``PLATFORM_REPO_PATHS`` points to the Vitis platform files (DSA).
+* (required for Vitis) ``XRT_DEB_VERSION`` specifies the .deb to be installed for XRT inside the container (see default value in ``run-docker.sh``).
+* (required for Slash) ``V80PP_DEB_PACKAGE`` specifies the .deb to be installed for Slash's v80++ linker.
 * (optional) ``NUM_DEFAULT_WORKERS`` (default 4) specifies the degree of parallelization for the transformations that can be run in parallel, potentially reducing build time
 * (optional) ``FINN_HOST_BUILD_DIR`` specifies which directory on the host will be used as the build directory. Defaults to ``/tmp/finn_dev_<username>``
 * (optional) ``JUPYTER_PORT`` (default 8888) changes the port for Jupyter inside Docker
@@ -125,7 +126,7 @@ Supported FPGA Hardware
 =======================
 **Vivado IPI support for any Xilinx FPGA:** FINN generates a Vivado IP Integrator (IPI) design from the neural network with AXI stream (FIFO) in-out interfaces, which can be integrated onto any Xilinx-AMD FPGA as part of a larger system. It’s up to you to take the FINN-generated accelerator (what we call “stitched IP” in the tutorials), wire it up to your FPGA design and send/receive neural network data to/from the accelerator.
 
-**Shell-integrated accelerator + driver:** For quick deployment, we target boards supported by  `PYNQ <http://www.pynq.io/>`_ . For these platforms, we can build a full bitfile including DMAs to move data into and out of the FINN-generated accelerator, as well as a Python driver to launch the accelerator. We support the Pynq-Z1, Pynq-Z2, Kria SOM, Ultra96, ZCU102 and ZCU104 boards, as well as Alveo cards.
+**Shell-integrated accelerator + driver:** For quick deployment, we target boards supported by  `PYNQ <http://www.pynq.io/>`_ . For these platforms, we can build a full bitfile including DMAs to move data into and out of the FINN-generated accelerator, as well as a Python driver to launch the accelerator. We support the Pynq-Z1, Pynq-Z2, Kria SOM, Ultra96, ZCU102 and ZCU104 boards, as well as UltraScale+-based Alveo datacenter accelerator cards.
 
 PYNQ board first-time setup
 ****************************
@@ -145,9 +146,9 @@ Continue on the host side (replace the ``<PYNQ_IP>`` and ``<PYNQ_USERNAME>`` wit
 5. Test that you can ``ssh <PYNQ_USERNAME>@<PYNQ_IP>`` without having to enter the password. Pass the ``-v`` flag to the ssh command if it doesn't work to help you debug.
 
 
-Alveo first-time setup
-**********************
-We use *host* to refer to the PC running the FINN Docker environment, which will build the accelerator+driver and package it up, and *target* to refer to the PC where the Alveo card is installed. These two can be the same PC, or connected over the network -- FINN includes some utilities to make it easier to test on remote PCs too. Prior to first usage, you need to set up both the host and the target in the following manner:
+Vitis-based Alveo first-time setup
+**********************************
+The Vitis toolchain targets UltraScale and UltraScale+-based Alveo cards, such as the U250. We use *host* to refer to the PC running the FINN Docker environment, which will build the accelerator+driver and package it up, and *target* to refer to the PC where the Alveo card is installed. These two can be the same PC, or connected over the network -- FINN includes some utilities to make it easier to test on remote PCs too. Prior to first usage, you need to set up both the host and the target in the following manner:
 
 On the target side:
 
@@ -164,8 +165,38 @@ On the host side:
 1. Install Vitis 2022.2 and set up the ``VITIS_PATH`` environment variable to point to your installation.
 2. Install Xilinx XRT. Ensure that the ``XRT_DEB_VERSION`` environment variable reflects which version of XRT you have installed.
 3. Install the Vitis platform files for Alveo and set up the ``PLATFORM_REPO_PATHS`` environment variable to point to your installation. *This must be the same path as the target's platform files (target step 2)*
-5. `Set up public key authentication <https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server>`_. Copy your private key to the ``finn/ssh_keys`` folder on the host to get password-less deployment and remote execution.
-6. Done!
+4. `Set up public key authentication <https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server>`_. Copy your private key to the ``finn/ssh_keys`` folder on the host to get password-less deployment and remote execution.
+5. Done!
+
+Slash-based Alveo first-time setup
+***********************************
+The Slash toolchain targets Versal-based Alveo cards such as the V80 using the V80++
+linker. We use *host* to refer to the PC running the FINN Docker environment, which will
+build the accelerator and package it up, and *target* to refer to the PC where the V80
+card is installed. These two can be the same PC, or connected over the network.
+
+Prior to first usage, you need to build the Slash packages from source and set up both
+the host and the target. Please refer to the `Slash GitHub repository
+<https://github.com/Xilinx/slash>`_ for instructions on how to build all Slash packages,
+including the ``v80++`` linker package.
+
+On the target side:
+
+1. Install all Slash runtime packages as described in the `Slash GitHub repository
+   <https://github.com/Xilinx/slash>`_.
+2. Done!
+
+On the host side:
+
+1. Build the ``v80++`` Debian package from the `Slash GitHub repository
+   <https://github.com/Xilinx/slash>`_ and copy it to a location accessible on the host.
+2. Set the ``V80PP_DEB_PACKAGE`` environment variable to the path of the ``v80++``
+   Debian package (e.g. ``export V80PP_DEB_PACKAGE=/path/to/v80++.deb``). The package
+   will be installed into the Docker image when ``run-docker.sh`` builds it.
+3. `Set up public key authentication <https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server>`_.
+   Copy your private key to the ``finn/ssh_keys`` folder on the host to get
+   password-less deployment and remote execution.
+4. Done!
 
 Vivado/Vitis license
 *********************
@@ -195,7 +226,7 @@ strong hardware:
 * **RAM.** Depending on your target FPGA platform, your system must have sufficient RAM to be
   able to run Vivado/Vitis synthesis for that part. See `this page <https://www.xilinx.com/products/design-tools/vivado/vivado-ml.html#memory>`_
   for more information. For targeting Zynq and Zynq UltraScale+ parts, at least 8 GB is recommended. Larger parts may require up to 16 GB.
-  For targeting Alveo parts with Vitis, at least 64 GB RAM is recommended.
+  For targeting Alveo parts with Vitis or Slash, at least 64 GB RAM is recommended.
 
 * **CPU.** FINN can parallelize HLS synthesis and several other operations for different
   layers, so using a multi-core CPU is recommended. However, this should be balanced

docs/finn/hw_build.rst

@@ -9,7 +9,7 @@ Hardware Build and Deployment
    :align: center
 
 A model where all layers have been converted to either HLS or RTL layers can be processed by
-FINN to build a bitfile and driver targeting a Zynq or Alveo system or to generate a Vivado IP Integrator (IPI)
+FINN to build a bitfile and driver targeting a Zynq or Alveo system (via Vitis or Slash) or to generate a Vivado IP Integrator (IPI)
 design with AXI stream (FIFO) in-out interfaces, which can be integrated onto any Xilinx FPGA as part of a larger system.
 
 
@@ -22,7 +22,7 @@ Internally, the hardware build consists of the following steps:
 2. DMA and DWC node insertion
 3. Partitioning for floorplanning
 4. FIFO insertion and IP generation
-5. Vivado/Vitis project generation and synthesis
+5. Project generation and synthesis (Vivado for Zynq, Vitis or Slash for Alveo)
 
 .. note::
   In previous FINN releases it was necessary to step through the individual sub-steps for hardware build manually by calling each transformation. The hardware build transformations `ZynqBuild` now execute all necessary sub-transformations. For more control over the build process, the transformations listed below can still be called individually.
@@ -59,7 +59,7 @@ This is accomplished by the :py:mod:`finn.transformation.fpgadataflow.floorplan.
 and :py:mod:`finn.transformation.fpgadataflow.create_dataflow_partition.CreateDataflowPartition`
 transformations.
 
-.. note:: For Vitis, each partition will be compiled as a separate kernel, and linked together afterwards. For Zynq, each partition will become an IP block.
+.. note:: For Vitis and Slash, each partition will be compiled as a separate kernel, and linked together afterwards. For Zynq, each partition will become an IP block.
 
 
 FIFO Insertion and IP Generation
@@ -76,12 +76,14 @@ For RTL layers calling :py:mod:`finn.transformation.fpgadataflow.prepare_ip.Prep
 
 The top-level IP blocks are generated in Vivado IPI, using the :py:mod:`finn.transformation.fpgadataflow.create_stitched_ip.CreateStitchedIP` transformation.
 
-Vivado/Vitis Project Generation and Synthesis
----------------------------------------------
+Project Generation and Synthesis
+---------------------------------
 
-The final step in the hardware build flow is to generate a Vivado (for Zynq) or Vitis (for Alveo)
-project, and run synthesis to generate a bitfile. This is done using the `MakeZYNQProject`
-transformation for Zynq, and the `VitisLink` transformation for Alveo.
+The final step in the hardware build flow is to generate a project and run synthesis to produce
+a bitfile. For Zynq this is done using the `MakeZYNQProject` transformation. For Alveo, the
+stitched IP kernels are first prepared by `PrepareForLinking` and then linked using either the
+`VitisLink` transformation (for UltraScale+-based Alveo cards) or the `SlashLink` transformation
+(for Versal-based Alveo cards such as the V80).
 
 
 Deployment

docs/finn/nw_prep.rst

@@ -10,7 +10,7 @@ Network Preparation
 
 The main principle of FINN are analysis and transformation passes. For more information about these, see :ref:`analysis_pass` and :ref:`transformation_pass` in the :ref:`concepts` documentation, or the tutorial notebooks in :ref:`tutorials`.
 
-This page describes the network preparation flow step that comes after :ref:`brevitas_export`. The main idea is to optimize the network and convert nodes to hardware layers that correspond to `finn-hlslib <https://github.com/Xilinx/finn-hlslib>`_ or `finn-rtllib <https://github.com/Xilinx/finn-rtllib>`_ implementations. This prepares the network for hardware generation with Vitis HLS and Vivado. Network preparation applies several transformations to the ONNX model, which is wrapped in a :ref:`modelwrapper`.
+This page describes the network preparation flow step that comes after :ref:`brevitas_export`. The main idea is to optimize the network and convert nodes to hardware layers that correspond to `finn-hlslib <https://github.com/Xilinx/finn-hlslib>`_ or `finn-rtllib <https://github.com/Xilinx/finn-rtllib>`_ implementations. This prepares the network for hardware generation with Vitis HLS and RTL code generation. Network preparation applies several transformations to the ONNX model, which is wrapped in a :ref:`modelwrapper`.
 
 Various transformations are involved in the network preparation. The following is a short overview of these.
 

docs/finn/source_code/finn.transformation.fpgadataflow.rst

@@ -294,10 +294,10 @@ finn.transformation.fpgadataflow.templates
   :undoc-members:
   :show-inheritance:
 
-finn.transformation.fpgadataflow.vitis\_build
+finn.transformation.fpgadataflow.alveo\_build
 -------------------------------------------------
 
-.. automodule:: finn.transformation.fpgadataflow.vitis_build
+.. automodule:: finn.transformation.fpgadataflow.alveo_build
    :members:
    :undoc-members:
    :show-inheritance:

run-docker.sh

@@ -53,7 +53,12 @@ fi
 
 if [ -z "$PLATFORM_REPO_PATHS" ];then
   recho "Please set PLATFORM_REPO_PATHS pointing to Vitis platform files (DSAs)."
-  recho "This is required to be able to use Alveo PCIe cards."
+  recho "This is required to be able to use Vitis-based Alveo PCIe cards."
+fi
+
+if [ -z "$V80PP_DEB_PACKAGE" ];then
+  recho "Please set V80PP_DEB_PACKAGE pointing to the SLASH v80++ .deb package."
+  recho "This is required to be able to use the Alveo V80 card."
 fi
 
 DOCKER_GID=$(id -g)
@@ -79,6 +84,7 @@ SCRIPTPATH=$(dirname "$SCRIPT")
 : ${FINN_SSH_KEY_DIR="$SCRIPTPATH/ssh_keys"}
 : ${PLATFORM_REPO_PATHS="/opt/xilinx/platforms"}
 : ${XRT_DEB_VERSION="xrt_202220.2.14.354_22.04-amd64-xrt"}
+: ${V80PP_DEB_PACKAGE=""}
 : ${FINN_HOST_BUILD_DIR="/tmp/$DOCKER_INST_NAME"}
 : ${FINN_DOCKER_TAG="xilinx/finn:$(OLD_PWD=$(pwd); cd $SCRIPTPATH; git describe --always --tags --dirty; cd $OLD_PWD).$XRT_DEB_VERSION"}
 : ${FINN_DOCKER_PREBUILT="0"}
@@ -167,6 +173,11 @@ if [ -d "$FINN_XRT_PATH" ];then
   export LOCAL_XRT=1
 fi
 
+# If v80++ deb package given, copy it to repo root for docker build
+if [ -n "$V80PP_DEB_PACKAGE" ] && [ -f "$V80PP_DEB_PACKAGE" ]; then
+  cp "$V80PP_DEB_PACKAGE" ./v80pp.deb
+fi
+
 if [ "$FINN_DOCKER_NO_CACHE" = "1" ]; then
   FINN_DOCKER_BUILD_EXTRA+="--no-cache "
 fi
@@ -204,11 +215,14 @@ if [ "$FINN_DOCKER_PREBUILT" = "0" ] && [ -z "$FINN_SINGULARITY" ]; then
   # Need to ensure this is done within the finn/ root folder:
   OLD_PWD=$(pwd)
   cd $SCRIPTPATH
+  # Export DOCKER_BUILDKIT to enable BuildKit features
+  export DOCKER_BUILDKIT
   docker build \
     -f docker/Dockerfile.finn \
     --build-arg XRT_DEB_VERSION=$XRT_DEB_VERSION \
     --build-arg SKIP_XRT=$FINN_SKIP_XRT_DOWNLOAD \
     --build-arg LOCAL_XRT=$LOCAL_XRT \
+    --build-arg V80PP_DEB_PACKAGE=$V80PP_DEB_PACKAGE \
     --tag=$FINN_DOCKER_TAG $FINN_DOCKER_BUILD_EXTRA \
     --build-arg GROUP_ID=$DOCKER_GID \
     --build-arg GROUPNAME=$DOCKER_GNAME \
@@ -223,6 +237,11 @@ if [ ! -z "$LOCAL_XRT" ];then
   rm $XRT_DEB_VERSION.deb
 fi
 
+# Remove local v80pp.deb file from repo
+if [ -f "./v80pp.deb" ]; then
+  rm ./v80pp.deb
+fi
+
 # Launch container with current directory mounted
 # important to pass the --init flag here for correct Vivado operation, see:
 # https://stackoverflow.com/questions/55733058/vivado-synthesis-hangs-in-docker-container-spawned-by-jenkins