Holoscan Container

Holoscan Container

Logo for Holoscan Container
Features
Description
The Holoscan container includes the Holoscan libraries, GXF extensions, headers, example source code, and sample datasets. It is the recommended way to run the Holoscan examples or build your own applications.
Publisher
NVIDIA
Latest Tag
v2.0.0-dgpu
Modified
May 23, 2024
Compressed Size
5.95 GB
Multinode Support
No
Multi-Arch Support
Yes
v2.0.0-dgpu (Latest) Security Scan Results

Linux / arm64

Sorry, your browser does not support inline SVG.

Linux / amd64

Sorry, your browser does not support inline SVG.

Overview

What is Holoscan?

NVIDIA Holoscan is the the AI sensor processing platform that combines hardware systems for low-latency sensor and network connectivity, optimized libraries for data processing and AI, and core microservices to run streaming, imaging, and other applications, from embedded to edge to cloud. It can be used to build streaming AI pipelines for a variety of domains, including Medical Devices, High Performance Computing at the Edge, Industrial Inspection and more.

What is the Holoscan container?

The Holoscan container includes the Holoscan libraries, GXF extensions, headers, example source code, and sample datasets, as well as all the dependencies that were tested with Holoscan. It is the recommended way to run the Holoscan examples, while still allowing you to create your own C++ and Python Holoscan application.

Relation to NVIDIA Clara

In previous releases, the prefix Clara was used to define Holoscan as a platform designed initially for medical devices. Starting with version 0.4.0, the Holoscan SDK is built to be domain-agnostic and can be used to build sensor AI applications in multiple domains. Domain specific content will be hosted on the HoloHub repository.

Getting Started

Visit the Holoscan User Guide to get started with the Holoscan SDK.


Using the Holoscan container

Prerequisites

Prerequisites for each supported platform are documented in the user guide.

Additionally, on x86_64, you'll need the NVIDIA Container Toolkit version 1.14.1 and Docker. These should already be installed on NVIDIA developer kits with IGX Software or JetPack.

Running the container

  1. Log in to the NGC docker registry

    docker login nvcr.io
    
  2. Press the Get Container button at the top of this webpage and choose the version you want to use:

    • select v<version>-dgpu for x86_64 systems, NVIDIA Developer Kits configured with a discrete GPU (such as IGX Orin dGPU or Clara AGX), or an SBSA system (such as GH200)
    • select v<version>-igpu for NVIDIA Developer Kits configured with an integrated GPU (such as Jetson AGX or IGX Orin iGPU)

    Set it as your NGC_CONTAINER_IMAGE_PATH in your terminal.

    # For example
    export NGC_CONTAINER_IMAGE_PATH="nvcr.io/nvidia/clara-holoscan/holoscan:v1.0.3-dgpu"
    
  3. If using a display, ensure that X11 is configured to allow commands from docker:

    xhost +local:docker
    
  4. Start the container. Here is an example with some standard flags, which are described below along with some extra flags:

    docker run -it --rm --net host \
      --runtime=nvidia \
      -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY \
      --ipc=host --cap-add=CAP_SYS_PTRACE --ulimit memlock=-1 --ulimit stack=67108864 \
      -v /var/run/docker.sock:/var/run/docker.sock \
      ${NGC_CONTAINER_IMAGE_PATH}
    
    • --runtime=nvidia is needed to leverage the NVIDIA GPUs and their capabilities. Read more here.
    • -v /tmp/.X11-unix and -e DISPLAY are needed to enable X11 display forwarding.
    • --ipc=host --cap-add=CAP_SYS_PTRACE --ulimit memlock=-1 --ulimit stack=67108864 are needed to run distributed applications with UCX. Read more here.
    • -v /var/run/docker.sock:/var/run/docker.sock enables the use of Holoscan CLI with Docker outside of Docker (DooD) for packaging and running applications inside the container.

    To expose additional hardware devices from your host to the container, add the --privileged flag to docker run (not secure), or mount their explicit device nodes by adding the flags below:

    • AJA capture card: add --device /dev/ajantv20 (and/or ajantv2<n>)
    • V4L2 video devices (HDMI IN, USB): add --device /dev/video0 (and/or video<n>).
      • If configuring a non-root user in the container, add --group-add video or ensure the user has appropriate permissions to the video device nodes (/dev/video*).
      • If using HDMI IN from a developer kit, also add --device /dev/capture-vi-channel0 to access the Tegra Video Input channels. You might need to add more nodes (with the last digit increasing) depending on the number of channels needed.
    • ConnectX RDMA: add --device /dev/infiniband/rdma_cm and --device /dev/infiniband/uverbs0 (and/or uverbs<n>).
      • This requires the MOFED drivers installed on the host.
      • Needed for RDMA (RoCE or Infiniband). Not required for simple TCP Ethernet communication through a ConnectX SmartNIC.

    On Tegra? If configuring a non-root user in the container, ensure the user has appropriate permissions to the dri device nodes (/dev/dri/*). This can be done by adding --group-add $(cat /etc/group | grep "video" | cut -d: -f3) and --group-add $(cat /etc/group | grep "render" | cut -d: -f3) (Note: simply passing --group-add render might not work if the group id differs between your host and container, even if mounting /etc/group)

Using the Holoscan SDK

C++

The Holoscan SDK is installed under /opt/nvidia/holoscan. It includes a CMake configuration file inside lib/cmake/holoscan, allowing you to import holoscan in your CMake project (link libraries + include headers):

find_package(holoscan REQUIRED CONFIG PATHS "/opt/nvidia/holoscan")
target_link_libraries(yourTarget PUBLIC holoscan::core)

Alternatives to hardcoding PATHS inside find_package in CMake are listed under the Config Mode Search Procedure documentation.

Python

For python developers, the PYTHONPATH is already set to include /opt/nvidia/holoscan/python/lib, allowing you to just call import holoscan.

Examples

Python, C++, and GXF examples are installed in /opt/nvidia/holoscan/examples alongside their source code, and run instructions (also available on the GitHub repository).

Running the examples

Example to run the Hello World example:

# Python
python3 /opt/nvidia/holoscan/examples/hello_world/python/hello_world.py

# C++
/opt/nvidia/holoscan/examples/hello_world/cpp/hello_world

Refer to the README in each example folder for specific run instructions.

Building the examples

You can rebuild the C++ and GXF examples as-is or copy them anywhere on your system to experiment with.

Example to build all the C++ and GXF examples:

export src_dir="/opt/nvidia/holoscan/examples/" # Add "<example_of_your_choice>/cpp" to build a specific example
export build_dir="/opt/nvidia/holoscan/examples/build" # Or the path of your choice
cmake -S $src_dir -B $build_dir -D Holoscan_ROOT="/opt/nvidia/holoscan" -G Ninja
cmake --build $build_dir -j

Also see the HoloHub repository for a collection of Holoscan operators and applications which you can use in your pipeline or for reference.


License

By pulling and using the container, you accept the terms and conditions of this End User License Agreement.