NGC | Catalog
CatalogContainersNVIDIA HPC SDK

NVIDIA HPC SDK

For copy image paths and more information, please view on a desktop device.
Logo for NVIDIA HPC SDK

Description

The NVIDIA HPC SDK is a comprehensive suite of compilers, libraries and tools essential to maximizing developer productivity and the performance and portability of HPC applications.

Publisher

NVIDIA

Latest Tag

22.9-devel-cuda_multi-ubuntu20.04

Modified

November 3, 2022

Compressed Size

8.47 GB

Multinode Support

Yes

Multi-Arch Support

Yes

22.9-devel-cuda_multi-ubuntu20.04 (Latest) Scan Results

Linux / amd64

Linux / arm64

By using this container image, you agree to the NVIDIA HPC SDK End-User License Agreement

NVIDIA HPC SDK

The NVIDIA HPC SDK is a comprehensive suite of compilers, libraries and tools essential to maximizing developer productivity and the performance and portability of HPC applications. The NVIDIA HPC SDK C, C++, and Fortran compilers support GPU acceleration of HPC modeling and simulation applications with standard C++ and Fortran, OpenACC directives, and CUDA. GPU-accelerated math libraries maximize performance on common HPC algorithms, and optimized communications libraries enable standards-based multi-GPU and scalable systems programming. Performance profiling and debugging tools simplify porting and optimization of HPC applications, and containerization tools enable easy deployment on-premises or in the cloud.

Key features of the NVIDIA HPC SDK for Linux include:

  • Support for NVIDIA Ampere Architecture GPUs with FP16, TF32 and FP64 tensor cores and MIG
  • Support for NVIDIA Volta tensor core GPUs and NVIDIA Pascal GPUs
  • Supported on CUDA 11.7, 11.6, 11.5, 11.4, 11.3, 11.2, 11.1, 11.0, and 10.2
  • Support for x86-64, OpenPOWER and Arm Server multicore CPUs
  • NVC++ ISO C++17 compiler with Parallel Algorithms acceleration on GPUs, OpenACC and OpenMP
  • NVFORTRAN ISO Fortran 2003 compiler with array intrinsics acceleration on GPUs, CUDA Fortran, OpenACC and OpenMP
  • NVC ISO C11 compiler with OpenACC and OpenMP
  • NVCC NVIDIA CUDA C++ compiler
  • cuBLAS GPU-accelerated basic linear algebra subroutine (BLAS) library
  • cuSOLVER GPU-accelerated dense and sparse direct solvers
  • cuSPARSE GPU-accelerated BLAS for sparse matrices
  • cuFFT GPU-accelerated library for Fast Fourier Transforms
  • cuTENSOR GPU-accelerated tensor linear algebra library
  • cuRAND GPU-accelerated random number generation (RNG)
  • Thrust GPU-accelerated library of C++ parallel algorithms and data structures
  • CUB cooperative threadblock primitives and utilities for CUDA kernel programming
  • libcu++ opt-in heterogeneous CUDA C++ Standard Library for NVCC
  • NCCL library for fast multi-GPU/multi-node collective communications
  • NVSHMEM library for fast GPU memory-to-memory transfers (OpenSHMEM compatible)
  • Open MPI GPU-aware message passing interface library
  • NVIDIA Nsight Systems interactive HPC applications performance profiler
  • NVIDIA Nsight Compute interactive GPU compute kernel performance profiler

System Requirements

Before running the NVIDIA HPC SDK NGC container, please ensure that your system meets the following requirements.

  • Pascal (sm60), Volta (sm70), Turing (sm75), or Ampere (sm80) NVIDIA GPU(s)
  • CUDA driver version >= 440.33 for CUDA 10.2
  • Docker 19.03 or later which includes support for the --gpus option, or Singularity version 3.4.1 or later
  • For older Docker versions, use nvidia-docker >= 2.0.3

When using the "cuda_multi" images, the NVIDIA HPC SDK will automatically choose among CUDA versions 10.2, 11.0, or 11.7 based on your installed driver. The "cuda11.7" images require a CUDA 11.2 driver or later. See the NVIDIA HPC SDK User's Guide for more information on using different CUDA Toolkit versions.

Multiarch containers for Arm (aarch64) and x86_64 are available for select tags starting with version 21.7.

Running the NVIDIA HPC SDK

Please see the NVIDIA HPC SDK User's Guide for getting started with the HPC SDK.

The HPC SDK Container Guide is a resource for using the HPC SDK with containers.

For a general guide on pulling and running containers, see Pulling A Container image and Running A Container in the NGC Container User Guide.

Examples

Several source code examples are available in the container at /opt/nvidia/hpc_sdk/Linux_x86_64/22.9/examples.

To access the OpenACC examples in an interactive session, use:

$ docker run --gpus all -it --rm nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04
$ cd /opt/nvidia/hpc_sdk/Linux_x86_64/22.9/examples/OpenACC/samples
$ make all

More detailed instructions on using the HPC SDK NGC container in Docker and Singularity can be found below.

Running with Docker

The instructions below assume Docker 19.03 or later. If using and older version of Docker with the nvidia-docker plugin, substitute docker run --gpus all below with nvidia-docker run.

Interactive shell with Docker

The following command mounts the current directory to /host_pwd and starts an interactive terminal inside the container:

$ docker run --gpus all -it --rm -v $(pwd):/host_pwd -w /host_pwd nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04

Where:

  • --gpus all: use all available GPUs
  • --rm: makes the container ephemeral (does not save changes to the image on exit)
  • -it: allocates an interactive tty shell for the container
  • -v $(pwd):/host_pwd: bind mounts the current working directory of the host into the container at /host_pwd
  • -w /host_pwd: sets the initial directory of the container to /host_pwd
  • nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04: URI of the latest HPC SDK NGC container image

To invoke NVIDIA HPC compilers during an interactive session, run make or call the compilers directly (nvfortran, nvc, nvc++) on files in the mounted directory.

For example, to run the nvfortran compiler:

$ cd /host_pwd
$ nvfortran -static-nvidia -gpu -o my_output_file my_source_file.f95

Where:

  • nvfortran: the NVIDIA Fortran compiler
  • -static-nvidia: compiles for and links to the static version of the NVIDIA runtime libraries
  • -gpu: compiles for NVIDIA GPUs. NVIDIA compilers will automatically detect GPU information and build accordingly
  • To specify compute capabilities, use -gpu=cc80 (for A100), or -gpu=cc70,cc80 (for V100 and A100)
  • -o my_output_file: names the compiled output file
  • my_source_file.f95: path to a Fortran source file

Command line execution with Docker

To use the NVIDIA HPC compilers with a Makefile in the current directory:

$ docker run --gpus all --rm -it -v $(pwd):/host_pwd -w /host_pwd nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04 make

Where:

  • --gpus all: use all available GPUs
  • --rm: makes the container ephemeral (does not save changes to the image on exit)
  • -it: allocates an interactive tty shell for the container
  • -v $(pwd):/host_pwd: bind mounts the current working directory of the host into the container at /host_pwd
  • -w /host_pwd: sets the initial directory of the container to /host_pwd
  • nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04: URI of the latest NVIDIA HPC SDK container image

It is also possible to call the NVIDIA HPC compilers directly (nvfortran, nvc, nvc++) on an appropriate source file.

For example, to use the nvfortran compiler:

$ docker run --gpus all --rm -it -v $(pwd):/host_pwd -w /host_pwd nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04 nvfortran -gpu -o my_output_file my_source_file.f95

Where:

  • --gpus all: use all available GPUs
  • --rm: makes the container ephemeral (does not save changes to the image on exit)
  • -it: allocates an interactive tty shell for the container
  • -v $(pwd):/host_pwd: bind mounts the current working directory of the host into the container at /host_pwd
  • -w /host_pwd: sets the initial directory of the container to /host_pwd
  • nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04: URI of the latest NVIDIA HPC SDK NGC container image
  • nvfortran: the NVIDIA Fortran compiler
  • -gpu: compiles for NVIDIA GPUs. NVIDIA compilers will automatically detect GPU information and build accordingly
  • To specify compute capabilities, use -gpu=cc80 (for A100), -gpu=cc70,cc80 (for V100 and A100)
  • -o my_output_file: names the compiled output file
  • my_source_file.f95: path to a Fortran source file

Runtime container images are provided to redistribute applications built with the HPC SDK as new container images. Based on the CUDA Toolkit version used to build the application, select the appropriate runtime HPC SDK container image.

Running with Singularity

The instructions below assume Singularity 3.4.1 or later.

Pull the image

Save the NVIDIA HPC SDK NGC container as a local Singularity image file:

$ singularity build nvhpc_22.9_devel.sif docker://nvcr.io/nvidia/nvhpc:22.9-devel-cuda_multi-ubuntu20.04

This command saves the container in the current directory as nvhpc_22.9_devel.sif.

Interactive shell with Singularity

To invoke an interactive shell, run /bin/bash within the container:

The following command starts an interactive terminal inside the container:

$ singularity shell --nv nvhpc_22.9_devel.sif

Where:

  • shell: specifies the mode of execution
  • --nv: exposes the host GPUs to the container
  • nvhpc_22.9_devel.sif: path to the Singularity image built above

To invoke NVIDIA HPC compilers during an interactive session, run make or call the compilers directly (nvfortran, nvc, nvc++) on files in the mounted directory.

For example, to run the nvfortran compiler:

$ nvfortran -static-nvidia -gpu -o my_output_file my_source_file.f95

Where:

  • nvfortran: the NVIDIA Fortran compiler
  • -static-nvidia: compiles for and links to the static version of the NVIDIA runtime libraries
  • -gpu: compiles for NVIDIA GPUs. NVIDIA compilers will automatically detect GPU information and build accordingly
  • To specify compute capabilities, use -gpu=cc80 (for A100), or -gpu=cc70,cc80 (for V100 and A100)
  • -o my_output_file: names the compiled output file
  • my_source_file.f95: path to a Fortran source file

Command line execution with Singularity

To use the NVIDIA HPC compilers with a Makefile in the current directory:

$ singularity exec --nv nvhpc_22.9_devel.sif make

Where:

  • exec: specifies the mode of execution
  • --nv: exposes the host GPUs to the container
  • nvhpc_22.9_devel.sif: path to the Singularity image built above

It is also possible to call the NVIDIA HPC compilers directly (nvfortran, nvc, nvc++) on an appropriate source file.

For example, to use the nvfortran compiler:

$ singularity exec --nv nvhpc_22.9_devel.sif nvfortran -gpu -o my_output_file my_source_file.f95

Where:

  • exec: specifies the mode of execution
  • --nv: exposes the host GPUs to the container
  • nvhpc_22.9_devel.sif: path to the Singularity image built above
  • nvfortran: the NVIDIA Fortran compiler
  • -gpu: compiles for NVIDIA GPUs. NVIDIA compilers will automatically detect GPU information and build accordingly
  • To specify compute capabilities, use -gpu=cc80 (for A100), or -gpu=cc70,cc80 (for V100 and A100)
  • -o my_output_file: names the compiled output file
  • my_source_file.f95: path to a Fortran source file

Runtime container images are provided to redistribute applications built with the HPC SDK as new container images. Based on the CUDA Toolkit version used to build the application, select the appropriate runtime HPC SDK container image.

Resources