Compiling DALI from source

Compiling DALI from source (bare metal)

Prerequisites

Required Component

Notes

Linux x64

GCC 5.3.1 or later

Boost 1.66 or later

Modules: preprocessor.

NVIDIA CUDA 10.0

nvJPEG library

This can be unofficially disabled. See below.

protobuf

Supported version: 3.11.1

CMake 3.13 or later

libjpeg-turbo 2.0.4 (2.0.3 for conda due to availability) or later

This can be unofficially disabled. See below.

libtiff 4.1.0 or later

This can be unofficially disabled. See below. Note: libtiff should be built with zlib support

FFmpeg 4.2.2 or later

We recommend using version 4.2.2 compiled following the instructions below.

libsnd 1.0.28 or later

We recommend using version 1.0.28 compiled following the instructions below.

OpenCV 4 or later

Supported version: 4.3.0

(Optional) liblmdb 0.9.x or later
One or more of the following Deep Learning frameworks:

Note

TensorFlow installation is required to build the TensorFlow plugin for DALI.

Note

Items marked “unofficial” are community contributions that are believed to work but not officially tested or maintained by NVIDIA.

Note

This software uses the FFmpeg licensed code under the LGPLv2.1. Its source can be downloaded from here.

FFmpeg was compiled using the following command line:

./configure \
--prefix=/usr/local \
--disable-static \
--disable-all \
--disable-autodetect \
--disable-iconv \
--enable-shared \
--enable-avformat \
--enable-avcodec \
--enable-avfilter \
--enable-protocol=file \
--enable-demuxer=mov,matroska,avi \
--enable-bsf=h264_mp4toannexb,hevc_mp4toannexb,mpeg4_unpack_bframes  && \
make

Note

This software uses the libsnd licensed under the LGPLv2.1. Its source can be downloaded from here.

libsnd was compiled using the following command line:

./configure && make

Build DALI

  1. Get DALI source code:

git clone --recursive https://github.com/NVIDIA/DALI
cd DALI

  1. Create a directory for CMake-generated Makefiles. This will be the directory, that DALI’s built in.

mkdir build
cd build

  1. Run CMake. For additional options you can pass to CMake, refer to Optional CMake build parameters.

cmake -D CMAKE_BUILD_TYPE=Release ..

  1. Build. You can use -j option to execute it in several threads

make -j"$(nproc)"

Install Python bindings

In order to run DALI using Python API, you need to install Python bindings

cd build
pip install dali/python

Note

Although you can create a wheel here by calling pip wheel dali/python, we don’t really recommend doing so. Such whl is not self-contained (doesn’t have all the dependencies) and it will work only on the system where you built DALI bare-metal. To build a wheel that contains the dependencies and might be therefore used on other systems, follow Compiling DALI from source (using Docker builder) - recommended.

Verify the build (optional)

Obtain test data

You can verify the build by running GTest and Nose tests. To do so, you’ll need DALI_extra repository, which contains test data. To download it follow DALI_extra README. Keep in mind, that you need git-lfs to properly clone DALI_extra repo. To install git-lfs, follow this tutorial.

Set test data path

DALI uses DALI_EXTRA_PATH environment variable to localize the test data. You can set it by invoking:

$ export DALI_EXTRA_PATH=<path_to_DALI_extra>
e.g. export DALI_EXTRA_PATH=/home/yourname/workspace/DALI_extra

Run tests

DALI tests consist of 2 parts: C++ (GTest) and Python (usually Nose, but that’s not always true). To run the tests there are convenient targets for Make, that you can run after building finished

cd <path_to_DALI>/build
make check-gtest check-python

Building DALI using Clang (experimental)

Note

This build is experimental. It is neither maintained nor tested. It is not guaranteed to work. We recommend using GCC for production builds.

cmake -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang  ..
make -j"$(nproc)"

Optional CMake build parameters

  • BUILD_PYTHON - build Python bindings (default: ON)

  • BUILD_TEST - include building test suite (default: ON)

  • BUILD_BENCHMARK - include building benchmarks (default: ON)

  • BUILD_LMDB - build with support for LMDB (default: OFF)

  • BUILD_NVTX - build with NVTX profiling enabled (default: OFF)

  • BUILD_NVJPEG - build with nvJPEG support (default: ON)

  • BUILD_LIBTIFF - build with libtiff support (default: ON)

  • BUILD_FFTS - build with ffts support (default: ON)

  • BUILD_LIBSND - build with libsnd support (default: ON)

  • BUILD_NVOF - build with NVIDIA OPTICAL FLOW SDK support (default: ON)

  • BUILD_NVDEC - build with NVIDIA NVDEC support (default: ON)

  • BUILD_NVML - build with NVIDIA Management Library (NVML) support (default: ON)

  • VERBOSE_LOGS - enables verbose loging in DALI. (default: OFF)

  • WERROR - treat all build warnings as errors (default: OFF)

  • BUILD_WITH_ASAN - build with ASAN support (default: OFF). To run issue:

  • BUILD_DALI_NODEPS - disables support for third party libraries that are normally expected to be available in the system

Warning

Enabling this option effectively results in only the most basic parts of DALI to compile (C++ core and kernels libraries). It is useful when wanting to use DALI processing primitives (kernels) directly without the need to use DALI’s executor infrastructure.

LD_LIBRARY_PATH=. ASAN_OPTIONS=symbolize=1:protect_shadow_gap=0 ASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
LD_PRELOAD= *PATH_TO_LIB_ASAN* /libasan.so. *X* *PATH_TO_BINARY*

Where *X* depends on used compiler version, for example GCC 7.x uses 4. Tested with GCC 7.4, CUDA 10.0
and libasan.4. Any earlier version may not work.

  • DALI_BUILD_FLAVOR - Allow to specify custom name sufix (i.e. ‘nightly’) for nvidia-dali whl package

  • (Unofficial) BUILD_JPEG_TURBO - build with libjpeg-turbo (default: ON)

  • (Unofficial) BUILD_LIBTIFF - build with libtiff (default: ON)

Note

DALI release packages are built with the options listed above set to ON and NVTX turned OFF. Testing is done with the same configuration. We ensure that DALI compiles with all of those options turned OFF, but there may exist cross-dependencies between some of those features.

Following CMake parameters could be helpful in setting the right paths:

  • FFMPEG_ROOT_DIR - path to installed FFmpeg

  • NVJPEG_ROOT_DIR - where nvJPEG can be found (from CUDA 10.0 it is shipped with the CUDA toolkit so this option is not needed there)

  • libjpeg-turbo options can be obtained from libjpeg CMake docs page

  • protobuf options can be obtained from protobuf CMake docs page

Cross-compiling DALI C++ API for aarch64 Linux (Docker)

Note

Support for aarch64 Linux platform is experimental. Some of the features are available only for x86-64 target and they are turned off in this build. There is no support for DALI Python library on aarch64 yet. Some Operators may not work as intended due to x86-64 specific implementations.

Setup

Download the JetPack 4.4 SDK for NVIDIA Jetson using the SDK Manager, following the instruction provided here: https://developer.nvidia.com/embedded/jetpack. Then select CUDA for the host. After download process has been completed move cuda-repo-ubuntu1804-10-2-local-10.2.89-440.40_1.0-1_amd64.deb and cuda-repo-cross-aarch64-10-2-local-10.2.89_1.0-1_all.deb from the download folder to main DALI folder (they are required for cross build).

Build the aarch64 Linux Build Container

docker build -t nvidia/dali:tools_aarch64-linux -f docker/Dockerfile.cuda_aarch64.deps .
docker build -t nvidia/dali:builder_aarch64-linux --build-arg "AARCH64_CUDA_TOOL_IMAGE_NAME=nvidia/dali:tools_aarch64-linux" -f docker/Dockerfile.build.aarch64-linux .

Compile

From the root of the DALI source tree

docker run -v $(pwd):/dali nvidia/dali:builder_aarch64-linux

The relevant artifacts will be in build/install and build/dali/python/nvidia/dali

Cross-compiling DALI C++ API for aarch64 QNX (Docker)

Note

Support for aarch64 QNX platform is experimental. Some of the features are available only for x86-64 target and they are turned off in this build. There is no support for DALI Python library on aarch64 yet. Some Operators may not work as intended due to x86-64 specific implementations.

Setup

After aquiring the QNX Toolchain, place it in a directory called qnx in the root of the DALI tree. Then using the SDK Manager for NVIDIA DRIVE, select QNX as the Target Operating System and select DRIVE OS 5.1.0.0 SDK.

In STEP 02 under Download & Install Options, select Download Now. Install Later. and agree to the Terms and Conditions. Once downloaded move the cuda-repo-cross-qnx debian package into the qnx directory you created in the DALI tree.

Build the aarch64 Build Container

docker build -t nvidia/dali:tools_aarch64-qnx -f docker/Dockerfile.cuda_qnx.deps .
docker build -t nvidia/dali:builder_aarch64-qnx --build-arg "QNX_CUDA_TOOL_IMAGE_NAME=nvidia/dali:tools_aarch64-qnx" -f docker/Dockerfile.build.aarch64-qnx .

Compile

From the root of the DALI source tree

docker run -v $(pwd):/dali nvidia/dali:builder_aarch64-qnx

The relevant Python wheel will be inside $(pwd)/wheelhouse.