From a3ff8d10640151113664bd973a2552d31e75da93 Mon Sep 17 00:00:00 2001 From: Connor Baker Date: Wed, 21 Oct 2026 20:49:37 -0700 Subject: [PATCH 1/3] cudaPackages.nvimgcodec: init at 0.9.0 Assisted-by: Claude Code (Claude Opus 5.5) --- .../cuda-modules/packages/nvimgcodec.nix | 125 ++++++++++++++++++ 1 file changed, 125 insertions(+) create mode 100644 pkgs/development/cuda-modules/packages/nvimgcodec.nix diff --git a/pkgs/development/cuda-modules/packages/nvimgcodec.nix b/pkgs/development/cuda-modules/packages/nvimgcodec.nix new file mode 100644 index 000000000000..b9516817231f --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvimgcodec.nix @@ -0,0 +1,125 @@ +{ + backendStdenv, + boost, + cmake, + cuda_cudart, + cuda_culibos ? null, + cuda_nvcc, + cudaAtLeast, + cudaNamePrefix, + fetchFromGitHub, + flags, + gitUpdater, + lib, + libjpeg_turbo, + libnvjpeg, + libnvjpeg_2k, + libnvtiff, + libtiff, + ninja, + nvtx, + opencv4WithoutCuda, + python3, + zlib, + zstd, +}: +backendStdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: Depends on the CUDA package set, so use cudaNamePrefix. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "nvimgcodec"; + version = "0.9.0"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "nvImageCodec"; + tag = "v${finalAttrs.version}"; + hash = "sha256-25IlghY8r2ZyUSwptJrwFp+8WluLdZr6P3AgR5FY3xw="; + }; + + # Use the NVTX and Boost.Preprocessor headers of Nixpkgs instead of the submodules (external/NVTX and + # external/boost/preprocessor), which aren't fetched. The DLPack submodule (external/dlpack) is used only by the Python + # bindings, which aren't built. + postPatch = '' + substituteInPlace cmake/Dependencies.cmake \ + --replace-fail \ + "\''${PROJECT_SOURCE_DIR}/external/NVTX/c/include" \ + "${lib.getInclude nvtx}/include" \ + --replace-fail \ + "\''${PROJECT_SOURCE_DIR}/external/boost/preprocessor/include" \ + "${lib.getDev boost}/include" + ''; + + nativeBuildInputs = [ + cmake + cuda_nvcc + ninja + # Generates the stubs for the CUDA driver API (loaded with dlopen) from cuda.h with libclang. + (python3.pythonOnBuildForHost.withPackages (ps: [ ps.clang ])) + ]; + + buildInputs = [ + # Replaces the Boost.Preprocessor submodule (external/boost/preprocessor) + boost + cuda_cudart + libjpeg_turbo + libnvjpeg + libnvjpeg_2k + libnvtiff + libtiff + # Replaces the NVTX submodule (external/NVTX) + nvtx + # The OpenCV extension only uses the CPU codecs (imgcodecs). + opencv4WithoutCuda + zlib + zstd + ] + # The nvJPEG and nvTIFF extensions link CUDA::culibos, a separate redistributable since CUDA 13. + ++ lib.optionals (cudaAtLeast "13.0") [ cuda_culibos ]; + + cmakeFlags = [ + (lib.cmakeFeature "CUDA_TARGET_ARCHS" flags.cmakeCudaArchitecturesString) + # The directory of cuda.h, from which the stubs for the CUDA driver API are generated, is looked for only in the + # CUDA toolkit include directories (cuda_nvcc and cccl). + (lib.cmakeFeature "CUDA_MAIN_INCLUDE_DIR" "${lib.getOutput "include" cuda_cudart}/include") + (lib.cmakeBool "BUILD_SAMPLES" false) + (lib.cmakeBool "BUILD_TEST" false) + (lib.cmakeBool "BUILD_PYTHON" false) + + # Link nvJPEG, nvJPEG2000 and nvTIFF instead of loading them with dlopen. The CUDA driver is still loaded with + # dlopen (WITH_DYNAMIC_CUDA), so the library can be loaded on machines without a GPU. + (lib.cmakeBool "WITH_DYNAMIC_NVJPEG" false) + (lib.cmakeBool "WITH_DYNAMIC_NVJPEG2K" false) + (lib.cmakeBool "WITH_DYNAMIC_NVTIFF" false) + (lib.cmakeBool "WITH_SHARED_CUDA_LIBS" true) + + # Upstream defaults to lib64/libnvimgcodec/; the extensions are looked up next to the library, in + # /extensions. + (lib.cmakeFeature "NVIMGCODEC_INSTALL_LIBDIR" "lib") + (lib.cmakeFeature "NVIMGCODEC_INSTALL_BINDIR" "bin") + (lib.cmakeFeature "NVIMGCODEC_INSTALL_EXTENSIONS_DIR" "lib/extensions") + (lib.cmakeFeature "NVIMGCODEC_INSTALL_EXTENSION_LIBDIR" "lib/extensions") + # Would install /etc/ld.so.conf.d/nvimgcodec-.conf + (lib.cmakeBool "NVIMGCODEC_INSTALL_LD_SO_CONF" false) + ]; + + passthru.updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; + + meta = { + description = "Library of GPU- and CPU-accelerated image codecs with a unified interface"; + homepage = "https://github.com/NVIDIA/nvImageCodec"; + changelog = "https://github.com/NVIDIA/nvImageCodec/releases/tag/${finalAttrs.src.tag}"; + license = lib.licenses.asl20; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + maintainers = with lib.maintainers; [ connorbaker ]; + teams = [ lib.teams.cuda ]; + }; +}) From fac8cf727174db1dc86b1c43ceb1e5bb50982090 Mon Sep 17 00:00:00 2001 From: Connor Baker Date: Wed, 21 Oct 2026 20:54:09 -0700 Subject: [PATCH 2/3] cudaPackages.dali: init at 2.4.0 Assisted-by: Claude Code (Claude Opus 5.5) --- ...link-solver-only-for-find-homography.patch | 57 ++++ .../dali/nvcomp-6-batch-staging-copies.patch | 79 ++++++ .../cuda-modules/packages/dali/nvcomp-6.patch | 227 ++++++++++++++++ .../cuda-modules/packages/dali/package.nix | 257 ++++++++++++++++++ ...on-old-thread-pool-affinity-failures.patch | 47 ++++ 5 files changed, 667 insertions(+) create mode 100644 pkgs/development/cuda-modules/packages/dali/cvcuda-link-solver-only-for-find-homography.patch create mode 100644 pkgs/development/cuda-modules/packages/dali/nvcomp-6-batch-staging-copies.patch create mode 100644 pkgs/development/cuda-modules/packages/dali/nvcomp-6.patch create mode 100644 pkgs/development/cuda-modules/packages/dali/package.nix create mode 100644 pkgs/development/cuda-modules/packages/dali/warn-on-old-thread-pool-affinity-failures.patch diff --git a/pkgs/development/cuda-modules/packages/dali/cvcuda-link-solver-only-for-find-homography.patch b/pkgs/development/cuda-modules/packages/dali/cvcuda-link-solver-only-for-find-homography.patch new file mode 100644 index 000000000000..e429671f49bc --- /dev/null +++ b/pkgs/development/cuda-modules/packages/dali/cvcuda-link-solver-only-for-find-homography.patch @@ -0,0 +1,57 @@ +From 7fa7b7bedd46a6e346d2bf1504388e7dd00138ed Mon Sep 17 00:00:00 2001 +From: Connor Baker +Date: Sun, 25 Oct 2026 18:12:47 -0700 +Subject: [PATCH] fix: link cuSOLVER and cuBLAS only when FindHomography is + built + +cvcuda_priv links CUDA::cusolver_static, CUDA::cublas_static and +CUDA::cublasLt_static unconditionally, but only OpFindHomography.cu +uses them. A build that selects a subset of the operators with +CV_CUDA_SRC_PATERN, as DALI does, still needs the static cuSOLVER and +cuBLAS libraries, and fails to configure where they aren't installed: + + CMake Error at src/cvcuda/priv/CMakeLists.txt (target_link_libraries): + Target "cvcuda_priv" links to: + + CUDA::cusolver_static + + but the target was not found. + +Link them only when OpFindHomography.cu is part of the build. A full +build links the same libraries in the same order as before. + +Co-Authored-By: Claude Opus 5.5 +--- + src/cvcuda/priv/CMakeLists.txt | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +diff --git a/third_party/cvcuda/src/cvcuda/priv/CMakeLists.txt b/third_party/cvcuda/src/cvcuda/priv/CMakeLists.txt +index deac31c..7645497 100644 +--- a/third_party/cvcuda/src/cvcuda/priv/CMakeLists.txt ++++ b/third_party/cvcuda/src/cvcuda/priv/CMakeLists.txt +@@ -95,6 +95,12 @@ add_library(cvcuda_priv STATIC + ${CV_CUDA_PRIV_FILES} + ) + ++# Only FindHomography uses cuSOLVER and cuBLAS, and CV_CUDA_SRC_PATERN can leave it out ++set(CV_CUDA_PRIV_SOLVER_LIBS) ++if ("OpFindHomography.cu" IN_LIST CV_CUDA_PRIV_FILES) ++ set(CV_CUDA_PRIV_SOLVER_LIBS CUDA::cusolver_static CUDA::cublas_static CUDA::cublasLt_static) ++endif() ++ + target_link_libraries(cvcuda_priv + PUBLIC + nvcv_types +@@ -103,8 +109,6 @@ target_link_libraries(cvcuda_priv + nvcv_util_sanitizer + cvcuda_legacy + CUDA::cudart_static +- CUDA::cusolver_static +- CUDA::cublas_static +- CUDA::cublasLt_static ++ ${CV_CUDA_PRIV_SOLVER_LIBS} + -lrt + ) +-- +2.43.0 + diff --git a/pkgs/development/cuda-modules/packages/dali/nvcomp-6-batch-staging-copies.patch b/pkgs/development/cuda-modules/packages/dali/nvcomp-6-batch-staging-copies.patch new file mode 100644 index 000000000000..6f7b49d57b97 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/dali/nvcomp-6-batch-staging-copies.patch @@ -0,0 +1,79 @@ +From 9c3b5760bfe021d0d6f974ad1559bcc13c7c463c Mon Sep 17 00:00:00 2001 +From: Janusz Lisiecki +Date: Mon, 19 Oct 2026 09:53:38 +0200 +Subject: [PATCH 2/2] Batch staging copies for nvCOMP decompression + +Signed-off-by: Janusz Lisiecki +--- + dali/operators/decoder/inflate/inflate_gpu.cc | 18 ++++++++---------- + dali/test/python/operator_1/test_inflate.py | 3 ++- + 2 files changed, 10 insertions(+), 11 deletions(-) + +diff --git a/dali/operators/decoder/inflate/inflate_gpu.cc b/dali/operators/decoder/inflate/inflate_gpu.cc +index 658f3922..b54bc0fb 100644 +--- a/dali/operators/decoder/inflate/inflate_gpu.cc ++++ b/dali/operators/decoder/inflate/inflate_gpu.cc +@@ -22,6 +22,7 @@ + #include "dali/core/common.h" + #include "dali/core/static_switch.h" + #include "dali/core/tensor_shape.h" ++#include "dali/kernels/common/scatter_gather.h" + #include "dali/kernels/kernel_manager.h" + #include "dali/operators/decoder/inflate/inflate.h" + #include "dali/operators/decoder/inflate/inflate_gpu.h" +@@ -59,18 +60,20 @@ class InflateOpGpuLZ4Impl : public InflateOpImplBase { + // aligned input and output buffers, so stage only the chunks that need it. + constexpr size_t alignment = nvcompLZ4RequiredDecompressionAlignment; + const auto &in_chunk_sizes = params_.GetInChunkSizes(); +- auto original_output_ptrs = inflated_ptrs_; ++ kernels::ScatterGatherGPU input_copies, output_copies; + for (size_t i = 0; i < total_chunks_num; i++) { + if (reinterpret_cast(input_ptrs_[i]) % alignment != 0) { + auto *aligned_input = scratchpad.AllocateGPU(in_chunk_sizes[i], alignment); +- CUDA_CALL(cudaMemcpyAsync(aligned_input, input_ptrs_[i], in_chunk_sizes[i], +- cudaMemcpyDeviceToDevice, stream)); ++ input_copies.AddCopy(aligned_input, input_ptrs_[i], in_chunk_sizes[i]); + input_ptrs_[i] = aligned_input; + } + if (reinterpret_cast(inflated_ptrs_[i]) % alignment != 0) { +- inflated_ptrs_[i] = scratchpad.AllocateGPU(inflated_sizes_[i], alignment); ++ auto *aligned_output = scratchpad.AllocateGPU(inflated_sizes_[i], alignment); ++ output_copies.AddCopy(inflated_ptrs_[i], aligned_output, inflated_sizes_[i]); ++ inflated_ptrs_[i] = aligned_output; + } + } ++ input_copies.Run(stream); + size_t *actual_out_sizes = scratchpad.AllocateGPU(total_chunks_num); + + auto [in_sizes, in, out_sizes, out] = scratchpad.ToContiguousGPU( +@@ -121,12 +124,7 @@ class InflateOpGpuLZ4Impl : public InflateOpImplBase { + // Here, we take care of the opposite case, when the allocations are bigger than really + // necessary and thus may contain some uninitialized memory. + FillTheTails(output.type(), total_chunks_num, out, actual_out_sizes, out_sizes, stream); +- for (size_t i = 0; i < total_chunks_num; i++) { +- if (inflated_ptrs_[i] != original_output_ptrs[i]) { +- CUDA_CALL(cudaMemcpyAsync(original_output_ptrs[i], inflated_ptrs_[i], inflated_sizes_[i], +- cudaMemcpyDeviceToDevice, stream)); +- } +- } ++ output_copies.Run(stream); + } + + protected: +diff --git a/dali/test/python/operator_1/test_inflate.py b/dali/test/python/operator_1/test_inflate.py +index 2cb176c0..a3e5f257 100644 +--- a/dali/test/python/operator_1/test_inflate.py ++++ b/dali/test/python/operator_1/test_inflate.py +@@ -178,7 +178,8 @@ def test_checks_sufficient_output_buffer(): + ] + ) + def test_unaligned_chunks(dtype, offset, oversized): +- sample = np.arange(15, dtype=dtype).reshape(3, 5) ++ # Enough unaligned ranges to exercise the batched copy kernel in both directions. ++ sample = np.arange(85, dtype=dtype).reshape(17, 5) + chunks = [sample_to_lz4(frame) for frame in sample] + sizes = np.array([len(chunk) for chunk in chunks], dtype=np.int32) + offsets = np.array(offset + np.cumsum([0] + list(sizes[:-1])), dtype=np.int32) +-- +2.43.0 + diff --git a/pkgs/development/cuda-modules/packages/dali/nvcomp-6.patch b/pkgs/development/cuda-modules/packages/dali/nvcomp-6.patch new file mode 100644 index 000000000000..ef53a351ec89 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/dali/nvcomp-6.patch @@ -0,0 +1,227 @@ +From ad607fa44f20392718258fc2a6a28ecf1b79590b Mon Sep 17 00:00:00 2001 +From: Janusz Lisiecki +Date: Mon, 19 Oct 2026 09:41:08 +0200 +Subject: [PATCH 1/2] Update nvCOMP to 6.0 for CUDA 12.9 and 13.4 builds + +Signed-off-by: Janusz Lisiecki +--- + cmake/Dependencies.common.cmake | 2 +- + dali/core/dynlink_nvcomp.cc | 4 +-- + dali/operators/decoder/inflate/inflate_gpu.cc | 29 +++++++++++++++-- + dali/test/python/operator_1/test_inflate.py | 32 +++++++++++++++++++ + docker/Dockerfile.cuda129.aarch64.deps | 2 +- + docker/Dockerfile.cuda129.x86_64.deps | 2 +- + docker/Dockerfile.cuda134.aarch64.deps | 2 +- + docker/Dockerfile.cuda134.x86_64.deps | 2 +- + internal_tools/stub_generator/nvcomp.json | 2 +- + 9 files changed, 66 insertions(+), 11 deletions(-) + +diff --git a/cmake/Dependencies.common.cmake b/cmake/Dependencies.common.cmake +index 80e073f9..78bfa6f7 100644 +--- a/cmake/Dependencies.common.cmake ++++ b/cmake/Dependencies.common.cmake +@@ -167,7 +167,7 @@ if(BUILD_NVCOMP) + list(APPEND DALI_LIBS ${nvcomp_LIBS}) + else() + message(STATUS "Found nvCOMP: ${nvcomp_INCLUDE_DIR}.") +- set(DALI_INSTALL_REQUIRES_NVCOMP "\'nvidia-libnvcomp-cu${CUDA_VERSION_MAJOR} == 5.3.0.16\',") ++ set(DALI_INSTALL_REQUIRES_NVCOMP "\'nvidia-libnvcomp-cu${CUDA_VERSION_MAJOR} == 6.0.0.12\',") + message(STATUS "Adding nvComp requirement as: ${DALI_INSTALL_REQUIRES_NVCOMP}") + endif() + endif() +diff --git a/dali/core/dynlink_nvcomp.cc b/dali/core/dynlink_nvcomp.cc +index ae9459d7..f64a1cfa 100644 +--- a/dali/core/dynlink_nvcomp.cc ++++ b/dali/core/dynlink_nvcomp.cc +@@ -1,4 +1,4 @@ +-// Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. ++// Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + // + // Licensed under the Apache License, Version 2.0 (the "License"); + // you may not use this file except in compliance with the License. +@@ -24,7 +24,7 @@ namespace { + typedef void* NVCOMP; + + static const char __nvCompfileLibName[] = "libnvcomp.so"; +-static const char __nvCompfileLibName1[] = "libnvcomp.so.5"; ++static const char __nvCompfileLibName1[] = "libnvcomp.so.6"; + + NVCOMP loadNvCompFileLibrary() { + NVCOMP ret = nullptr; +diff --git a/dali/operators/decoder/inflate/inflate_gpu.cc b/dali/operators/decoder/inflate/inflate_gpu.cc +index 2f0a929a..658f3922 100644 +--- a/dali/operators/decoder/inflate/inflate_gpu.cc ++++ b/dali/operators/decoder/inflate/inflate_gpu.cc +@@ -12,6 +12,7 @@ + // See the License for the specific language governing permissions and + // limitations under the License. + ++#include + #include + #include + #include +@@ -54,6 +55,22 @@ class InflateOpGpuLZ4Impl : public InflateOpImplBase { + auto stream = ws.stream(); + + kernels::DynamicScratchpad scratchpad(stream); ++ // Chunks can start at arbitrary byte offsets in DALI tensors. nvCOMP 6 requires ++ // aligned input and output buffers, so stage only the chunks that need it. ++ constexpr size_t alignment = nvcompLZ4RequiredDecompressionAlignment; ++ const auto &in_chunk_sizes = params_.GetInChunkSizes(); ++ auto original_output_ptrs = inflated_ptrs_; ++ for (size_t i = 0; i < total_chunks_num; i++) { ++ if (reinterpret_cast(input_ptrs_[i]) % alignment != 0) { ++ auto *aligned_input = scratchpad.AllocateGPU(in_chunk_sizes[i], alignment); ++ CUDA_CALL(cudaMemcpyAsync(aligned_input, input_ptrs_[i], in_chunk_sizes[i], ++ cudaMemcpyDeviceToDevice, stream)); ++ input_ptrs_[i] = aligned_input; ++ } ++ if (reinterpret_cast(inflated_ptrs_[i]) % alignment != 0) { ++ inflated_ptrs_[i] = scratchpad.AllocateGPU(inflated_sizes_[i], alignment); ++ } ++ } + size_t *actual_out_sizes = scratchpad.AllocateGPU(total_chunks_num); + + auto [in_sizes, in, out_sizes, out] = scratchpad.ToContiguousGPU( +@@ -86,14 +103,14 @@ class InflateOpGpuLZ4Impl : public InflateOpImplBase { + } + + size_t tempSize; +- CUDA_CALL(nvcompBatchedLZ4DecompressGetTempSizeAsync( ++ CUDA_CALL(nvcompBatchedLZ4DecompressGetTempSize( + total_chunks_num, + params_.GetMaxOutChunkVol() * element_type_.size(), + {}, + &tempSize, +- params_.GetMaxOutVol() * element_type_.size())); ++ params_.GetMaxOutVol() * element_type_.size(), stream)); + +- void *temp = scratchpad.AllocateGPU(tempSize); ++ void *temp = scratchpad.AllocateGPU(tempSize, alignment); + nvcompStatus_t *device_statuses = scratchpad.AllocateGPU(total_chunks_num); + CUDA_CALL(nvcompBatchedLZ4DecompressAsync(in, in_sizes, out_sizes, actual_out_sizes, + total_chunks_num, temp, tempSize, out, {}, +@@ -104,6 +121,12 @@ class InflateOpGpuLZ4Impl : public InflateOpImplBase { + // Here, we take care of the opposite case, when the allocations are bigger than really + // necessary and thus may contain some uninitialized memory. + FillTheTails(output.type(), total_chunks_num, out, actual_out_sizes, out_sizes, stream); ++ for (size_t i = 0; i < total_chunks_num; i++) { ++ if (inflated_ptrs_[i] != original_output_ptrs[i]) { ++ CUDA_CALL(cudaMemcpyAsync(original_output_ptrs[i], inflated_ptrs_[i], inflated_sizes_[i], ++ cudaMemcpyDeviceToDevice, stream)); ++ } ++ } + } + + protected: +diff --git a/dali/test/python/operator_1/test_inflate.py b/dali/test/python/operator_1/test_inflate.py +index fd34e694..2cb176c0 100644 +--- a/dali/test/python/operator_1/test_inflate.py ++++ b/dali/test/python/operator_1/test_inflate.py +@@ -167,6 +167,38 @@ def test_checks_sufficient_output_buffer(): + check_batch(inflated, [sample], batch_size=1) + + ++@has_operator("decoders.inflate") ++@restrict_platform(min_compute_cap=6.0) ++@params( ++ *[ ++ (dtype, offset, oversized) ++ for dtype in [np.uint8, np.uint16] ++ for offset in range(4) ++ for oversized in [False, True] ++ ] ++) ++def test_unaligned_chunks(dtype, offset, oversized): ++ sample = np.arange(15, dtype=dtype).reshape(3, 5) ++ chunks = [sample_to_lz4(frame) for frame in sample] ++ sizes = np.array([len(chunk) for chunk in chunks], dtype=np.int32) ++ offsets = np.array(offset + np.cumsum([0] + list(sizes[:-1])), dtype=np.int32) ++ compressed = np.concatenate([np.zeros(offset, dtype=np.uint8), *chunks]) ++ ++ @pipeline_def(batch_size=1, num_threads=4, device_id=0) ++ def pipeline(): ++ data = fn.external_source(source=lambda: compressed, batch=False) ++ return fn.decoders.inflate( ++ data.gpu(), ++ shape=[7 if oversized else 5], ++ dtype=np_type_to_dali(dtype), ++ chunk_offsets=offsets, ++ chunk_sizes=sizes, ++ ) ++ ++ (inflated,) = pipeline().run() ++ check_batch(inflated, [sample], batch_size=1, oversized_shape=oversized) ++ ++ + def _test_scalar_shape(dtype, shape, layout): + def sample_source(sample_info): + sample_size = np.prod(shape) +diff --git a/docker/Dockerfile.cuda129.aarch64.deps b/docker/Dockerfile.cuda129.aarch64.deps +index cf97e4cb..f3580637 100644 +--- a/docker/Dockerfile.cuda129.aarch64.deps ++++ b/docker/Dockerfile.cuda129.aarch64.deps +@@ -12,7 +12,7 @@ RUN curl -LO https://developer.download.nvidia.com/compute/cuda/12.9.1/local_ins + rm -f cuda_*.run; + + RUN CUFILE_VERSION=1.14.1.1-1 && \ +- NVCOMP_VERSION=5.3.0.16 && \ ++ NVCOMP_VERSION=6.0.0.12 && \ + CUDA_VERSION_MAJOR=12 && \ + CUDA_VERSION_MINOR=9 && \ + apt-get update && \ +diff --git a/docker/Dockerfile.cuda129.x86_64.deps b/docker/Dockerfile.cuda129.x86_64.deps +index 12e237d0..b962a838 100644 +--- a/docker/Dockerfile.cuda129.x86_64.deps ++++ b/docker/Dockerfile.cuda129.x86_64.deps +@@ -12,7 +12,7 @@ RUN curl -LO https://developer.download.nvidia.com/compute/cuda/12.9.1/local_ins + rm -f cuda_*.run; + + RUN CUFILE_VERSION=1.14.1.1-1 && \ +- NVCOMP_VERSION=5.3.0.16 && \ ++ NVCOMP_VERSION=6.0.0.12 && \ + CUDA_VERSION_MAJOR=12 && \ + CUDA_VERSION_MINOR=9 && \ + apt-get update && \ +diff --git a/docker/Dockerfile.cuda134.aarch64.deps b/docker/Dockerfile.cuda134.aarch64.deps +index 743bd52e..1548d3b8 100644 +--- a/docker/Dockerfile.cuda134.aarch64.deps ++++ b/docker/Dockerfile.cuda134.aarch64.deps +@@ -7,7 +7,7 @@ RUN CUDA_SUBVERSION=13.4.2-1 && \ + CUFILE_VERSION=1.19.1.55-1 && \ + CUDA_VERSION_MAJOR=13 && \ + CUDA_VERSION_MINOR=4 && \ +- NVCOMP_VERSION=5.3.0.16 && \ ++ NVCOMP_VERSION=6.0.0.12 && \ + apt-get update && \ + apt-get install wget software-properties-common -y && \ + apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/sbsa/3bf863cc.pub && \ +diff --git a/docker/Dockerfile.cuda134.x86_64.deps b/docker/Dockerfile.cuda134.x86_64.deps +index 2035d956..c61f1286 100644 +--- a/docker/Dockerfile.cuda134.x86_64.deps ++++ b/docker/Dockerfile.cuda134.x86_64.deps +@@ -7,7 +7,7 @@ RUN CUDA_SUBVERSION=13.4.2-1 && \ + CUFILE_VERSION=1.19.1.55-1 && \ + CUDA_VERSION_MAJOR=13 && \ + CUDA_VERSION_MINOR=4 && \ +- NVCOMP_VERSION=5.3.0.16 && \ ++ NVCOMP_VERSION=6.0.0.12 && \ + apt-get update && \ + apt-get install wget software-properties-common -y && \ + apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/3bf863cc.pub && \ +diff --git a/internal_tools/stub_generator/nvcomp.json b/internal_tools/stub_generator/nvcomp.json +index 899e2ed5..656bc5fd 100644 +--- a/internal_tools/stub_generator/nvcomp.json ++++ b/internal_tools/stub_generator/nvcomp.json +@@ -6,7 +6,7 @@ + "calling_conv":"", + "not_found_error":"nvcompErrorNotSupported", + "functions": { +- "nvcompBatchedLZ4DecompressGetTempSizeAsync": {}, ++ "nvcompBatchedLZ4DecompressGetTempSize": {}, + "nvcompBatchedLZ4DecompressAsync": {}, + "nvcompBatchedLZ4GetDecompressSizeAsync": {}, + "nvcompGetStatusString": { +-- +2.43.0 + diff --git a/pkgs/development/cuda-modules/packages/dali/package.nix b/pkgs/development/cuda-modules/packages/dali/package.nix new file mode 100644 index 000000000000..ead7cc3f2a1f --- /dev/null +++ b/pkgs/development/cuda-modules/packages/dali/package.nix @@ -0,0 +1,257 @@ +{ + autoAddDriverRunpath, + aws-sdk-cpp, + backendStdenv, + boost, + cfitsio, + cmake, + cuda_cudart, + cuda_nvcc, + cuda_nvml_dev, + cudaNamePrefix, + cutlass, + dlpack, + fetchFromGitHub, + fetchpatch2, + ffmpeg_8-headless, + flags, + gitUpdater, + lib, + libcufft, + libcufile, + libcurand, + libnpp, + libsndfile, + libtar, + lmdb, + ninja, + nvcomp, + nvimgcodec, + nvtx, + opencv4WithoutCuda, + pkg-config, + protobuf, + python3, + rapidjson, + # DALI only uses the S3 client. + aws-sdk-cpp-s3 ? aws-sdk-cpp.override { apis = [ "s3" ]; }, +}: +let + inherit (lib) cmakeBool cmakeFeature getLib; +in +backendStdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: Depends on the CUDA package set, so use cudaNamePrefix. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "dali"; + version = "2.4.0"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "DALI"; + tag = "v${finalAttrs.version}"; + # DALI builds CV-CUDA (a subset of its operators), FFTS (a fork) and the COCO API from the submodules. + fetchSubmodules = true; + # Fetch only those; the others are replaced by Nixpkgs packages or unused. Without a pathspec, `git submodule update + # --init` initializes (and so clones) only the submodules whose path matches a submodule.active pattern, and sets no + # submodule..active (which would outrank the patterns). The patterns are matched in every repository, nested + # ones included, so CV-CUDA's own submodules (under 3rdparty) and any submodule a later version adds at another path + # are left as empty directories. They are GIT_CONFIG_* entries, appended like nix-prefetch-git's own, because + # fetchgit's gitConfigFile would replace the user's config.gitConfigFile. + preFetch = '' + for path in third_party/{cocoapi,cvcuda,ffts}; do + i=''${GIT_CONFIG_COUNT:-0} + export GIT_CONFIG_COUNT=$((i + 1)) "GIT_CONFIG_KEY_$i=submodule.active" "GIT_CONFIG_VALUE_$i=$path" + done + ''; + hash = "sha256-NTRJFhOe5CtjOuPFDZmNuAUV9zkRG8g0aE2/2QClfaU="; + }; + + patches = [ + # Update nvCOMP to 6.0: DALI 2.4.0 loads libnvcomp.so.5 and uses the nvCOMP 5 LZ4 API, while Nixpkgs has nvCOMP 6. + # The two commits of https://github.com/NVIDIA/DALI/pull/6530, ad607fa44f20392718258fc2a6a28ecf1b79590b and + # 9c3b5760bfe021d0d6f974ad1559bcc13c7c463c, which apply to 2.4.0 as they are. The PR is open (a draft), so they are + # vendored with `git format-patch` (a rebase of the PR could let GitHub garbage-collect them). + ./nvcomp-6.patch + ./nvcomp-6-batch-staging-copies.patch + # Find the headers of the CUDA libraries DALI generates dlopen stubs from (the driver, cuFile, cuFFT, NPP and NVML) + # with find_path, instead of expecting them in CUDAToolkit_TARGET_DIR/include, which is cuda_nvcc's. + # From https://github.com/NVIDIA/DALI/pull/6550, merged after 2.4.0. + (fetchpatch2 { + name = "find-cuda-library-headers.patch"; + url = "https://github.com/NVIDIA/DALI/commit/e6dd6294ecbb6aa242da5d7864208a466d22bac2.patch?full_index=1"; + hash = "sha256-6rdej/M7LjHkXUHexRIUvYlSKq/aeQjdZXrdk3o4Mag="; + }) + # Warn instead of failing when the old thread pool (which the mixed image decoder uses) can't pin its threads to the + # GPU's CPUs, as when NVML can't read the CPU topology from /sys, which the sandbox lacks + # (https://github.com/NVIDIA/DALI/issues/6551). From https://github.com/NVIDIA/DALI/pull/6552, which is open, so it + # is vendored, without its tests: `git format-patch -1 5e1262eed055a93fa9c4eea7b3bee8178ca3abd6 -- + # dali/pipeline/util/thread_pool.cc`. + ./warn-on-old-thread-pool-affinity-failures.patch + # DALI builds only some CV-CUDA operators (CV_CUDA_SRC_PATERN), not FindHomography, the only user of cuSOLVER and + # cuBLAS; link them only when FindHomography is built, instead of requiring their static libraries + # (https://github.com/CVCUDA/CV-CUDA/issues/302). CV-CUDA doesn't accept outside contributions, so the fix is + # vendored: `git format-patch -1 --src-prefix=a/third_party/cvcuda/ --dst-prefix=b/third_party/cvcuda/` of + # https://github.com/ConnorBaker/CV-CUDA/commit/7fa7b7bedd46a6e346d2bf1504388e7dd00138ed, the backport of + # https://github.com/ConnorBaker/CV-CUDA/commit/e9ecacfcedf41b9c4518696c268e2518c3133643 to ef50300b (DALI 2.4.0's + # third_party/cvcuda). The prefixes apply it to the submodule's checkout. + ./cvcuda-link-solver-only-for-find-homography.patch + ]; + + # Use the header-only Boost.Preprocessor, RapidJSON, CUTLASS and DLPack of Nixpkgs instead of the submodules. + postPatch = + # Replaces third_party/boost/preprocessor, third_party/rapidjson and third_party/cutlass. DALI uses none of the + # CUTLASS utilities (tools/util), which Nixpkgs' CUTLASS installs only with its tools. + '' + substituteInPlace cmake/Dependencies.common.cmake \ + --replace-fail \ + "\''${PROJECT_SOURCE_DIR}/third_party/boost/preprocessor/include" \ + "${lib.getDev boost}/include" \ + --replace-fail \ + "\''${PROJECT_SOURCE_DIR}/third_party/rapidjson/include" \ + "${lib.getDev rapidjson}/include" \ + --replace-fail \ + "include_directories(SYSTEM third_party/cutlass/include)" \ + "include_directories(SYSTEM ${lib.getInclude cutlass}/include)" \ + --replace-fail \ + "include_directories(SYSTEM third_party/cutlass/tools/util/include)" \ + "" + '' + # Replaces third_party/dlpack. + + '' + substituteInPlace dali/pipeline/data/dltensor.h dali/pipeline/data/dltensor_obj.h \ + --replace-fail '"third_party/dlpack/include/dlpack/dlpack.h"' "" + '' + # Replaces third_party/boost/preprocessor as the source of the Boost.Preprocessor headers that the Python package + # ships with its own (for building plugins). + + '' + substituteInPlace dali/CMakeLists.txt \ + --replace-fail \ + 'cp -rL "''${PROJECT_SOURCE_DIR}/third_party/boost/preprocessor/include/." "''${PROJECT_BINARY_DIR}/''${DALI_INCLUDE_DIR}/"' \ + 'cp -rL --no-preserve=mode --parents boost/preprocessor boost/preprocessor.hpp "''${PROJECT_BINARY_DIR}/''${DALI_INCLUDE_DIR}/" WORKING_DIRECTORY "${lib.getDev boost}/include"' + ''; + + nativeBuildInputs = [ + autoAddDriverRunpath + cmake + cuda_nvcc + ninja + pkg-config + protobuf + # Generates the stubs for the libraries loaded with dlopen (CUDA driver, nvCOMP, cuFile) from their headers with + # libclang. + (python3.pythonOnBuildForHost.withPackages (ps: [ ps.clang ])) + ]; + + buildInputs = [ + aws-sdk-cpp-s3 + # Replaces the Boost.Preprocessor submodule (third_party/boost/preprocessor) + boost + cfitsio + cuda_cudart + (lib.getOutput "static" cuda_cudart) + cuda_nvml_dev + # Replaces the CUTLASS submodule (third_party/cutlass) + cutlass + # Replaces the DLPack submodule (third_party/dlpack) + dlpack + ffmpeg_8-headless + libcufft + libcufile + libcurand + libnpp + libsndfile + libtar + lmdb + nvcomp + nvimgcodec + nvtx + # DALI only uses OpenCV's CPU core and imgproc modules. + opencv4WithoutCuda + protobuf + # Replaces the RapidJSON submodule (third_party/rapidjson) + rapidjson + ]; + + cmakeFlags = [ + # Selects the CUDA_known_archs set and the dependency file (aarch64-linux is the Jetson cross-compilation setup). + (cmakeFeature "ARCH" backendStdenv.hostPlatform.parsed.cpu.name) + # DALI appends PTX for the last architecture. + (cmakeFeature "CUDA_TARGET_ARCHS" flags.cmakeCudaArchitecturesString) + + (cmakeBool "BUILD_PYTHON" false) + (cmakeBool "BUILD_TEST" false) + (cmakeBool "BUILD_BENCHMARK" false) + (cmakeBool "FORMAT_PYTHON_STUB_FILES" false) + + # Load the CUDA libraries (cuFFT, NPP) and nvCOMP with dlopen, like the wheels and conda-forge, instead of linking + # them statically. The CUDA driver is loaded with dlopen as well (LINK_DRIVER defaults to OFF). + (cmakeBool "WITH_DYNAMIC_CUDA_TOOLKIT" true) + # Off by default + (cmakeBool "BUILD_NVCOMP" true) + (cmakeBool "BUILD_CUFILE" true) + # nvImageCodec is loaded with dlopen by default; it can only be linked statically when DALI builds it itself (as an + # ExternalProject cloned from GitHub). + (cmakeFeature "NVIMGCODEC_DEFAULT_INSTALL_PATH" "${getLib nvimgcodec}") + # The other optional features (NVDEC, optical flow, NVML, CV-CUDA, the AWS SDK, cfitsio, libsndfile, libtar and + # LMDB) are on by default. + # Google Cloud Storage support needs google-cloud-cpp 3.0 or later, which Nixpkgs doesn't have; DALI would turn it + # off with a warning. + (cmakeBool "BUILD_GCS" false) + + # Links CV-CUDA against stubs of glibc 2.17's libdl, librt and libpthread, which are Git LFS objects (missing from + # the source), to run on distributions with an older glibc. + (cmakeBool "ENABLE_COMPAT_OLD_GLIBC" false) + # Defaults to the static library + (cmakeBool "Protobuf_USE_STATIC_LIBS" false) + ]; + + # CV-CUDA installs an /etc/ld.so.conf.d drop-in for its libraries, which DALI's libraries find through their runpath. + postInstall = '' + rm -r "$out/etc" + ''; + + # The libraries DALI loads with dlopen aren't in DT_NEEDED, so they must be added to the runpath after it is shrunk. + # The CUDA driver and its NVDEC, NVML and optical flow libraries come from autoAddDriverRunpath. + postFixup = '' + for lib in "$out"/lib/libdali*.so; do + patchelf --add-rpath "${ + lib.makeLibraryPath [ + libcufft + libcufile + libnpp + nvcomp + nvimgcodec + ] + }" "$lib" + done + ''; + + passthru.updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + # Skip the tags of the development branches (e.g. v2.4.0-dev) + ignoredVersions = "-dev$"; + }; + + meta = { + description = "GPU-accelerated library for data loading and pre-processing for deep learning"; + homepage = "https://github.com/NVIDIA/DALI"; + changelog = "https://github.com/NVIDIA/DALI/releases/tag/${finalAttrs.src.tag}"; + license = with lib.licenses; [ + asl20 + # Bundled third-party code (see Acknowledgements.txt) + bsd2 + bsd3 + mit + ]; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + maintainers = with lib.maintainers; [ connorbaker ]; + teams = [ lib.teams.cuda ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/dali/warn-on-old-thread-pool-affinity-failures.patch b/pkgs/development/cuda-modules/packages/dali/warn-on-old-thread-pool-affinity-failures.patch new file mode 100644 index 000000000000..a29d1da60c4d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/dali/warn-on-old-thread-pool-affinity-failures.patch @@ -0,0 +1,47 @@ +From 5e1262eed055a93fa9c4eea7b3bee8178ca3abd6 Mon Sep 17 00:00:00 2001 +From: Janusz Lisiecki +Date: Mon, 26 Oct 2026 08:36:47 +0100 +Subject: [PATCH] Warn on CPU affinity failures in the old thread pool + +Treat affinity setup as best effort, matching NewThreadPool. This lets +mixed image decoding continue when NVML cannot report CPU topology. + +Add regression tests for affinity failure recovery and task exception +propagation. + +Fixes #6551. + +Signed-off-by: Janusz Lisiecki +--- + dali/pipeline/util/thread_pool.cc | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/dali/pipeline/util/thread_pool.cc b/dali/pipeline/util/thread_pool.cc +index 5c1bd84..e044cca 100644 +--- a/dali/pipeline/util/thread_pool.cc ++++ b/dali/pipeline/util/thread_pool.cc +@@ -15,6 +15,7 @@ + #include + #include + #include ++#include + #include + #include "dali/pipeline/util/thread_pool.h" + #if NVML_ENABLED +@@ -153,8 +154,12 @@ void OldThreadPool::ThreadMain(int thread_id, int device_id, bool set_affinity, + nvml::SetCPUAffinity(core); + } + #endif ++ } catch (const std::exception &e) { ++ DALI_WARN("Couldn't set thread affinity in thread ", thread_id, " of thread pool \"", ++ name, "\". Exception ", typeid(e).name(), ": ", e.what()); + } catch (...) { +- tl_errors_[thread_id].push(std::current_exception()); ++ DALI_WARN("Couldn't set thread affinity in thread ", thread_id, " of thread pool \"", ++ name, "\". Unknown error."); + } + + while (running_) { +-- +2.43.0 + From 30a3a5c4180ee1f7607ce853118ff62bd449b258 Mon Sep 17 00:00:00 2001 From: Connor Baker Date: Wed, 21 Oct 2026 21:08:02 -0700 Subject: [PATCH 3/3] python3Packages.nvidia-dali: init at 2.4.0 Assisted-by: Claude Code (Claude Opus 5.5) --- .../python-modules/nvidia-dali/default.nix | 171 ++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 173 insertions(+) create mode 100644 pkgs/development/python-modules/nvidia-dali/default.nix diff --git a/pkgs/development/python-modules/nvidia-dali/default.nix b/pkgs/development/python-modules/nvidia-dali/default.nix new file mode 100644 index 000000000000..89c2d56bb88e --- /dev/null +++ b/pkgs/development/python-modules/nvidia-dali/default.nix @@ -0,0 +1,171 @@ +{ + lib, + buildPythonPackage, + cudaPackages, + python, + + # buildInputs + pybind11, + + # build-system + setuptools, + + # dependencies + astunparse, + gast, + libcst, + makefun, + numpy, + nvtx, + optree, + packaging, + six, +}: + +let + inherit (cudaPackages) dali; + inherit (lib) cmakeBool cmakeFeature; +in +buildPythonPackage (finalAttrs: { + pname = "nvidia-dali"; + inherit (dali) version src patches; + pyproject = true; + __structuredAttrs = true; + + postPatch = + # Replaces the submodules of the header-only libraries with Nixpkgs', as for the C++ libraries. + dali.postPatch + # Name the distribution nvidia-dali instead of nvidia-dali-cuda0, since Nixpkgs selects the CUDA version + # with cudaPackages, and drop the requirements on the nvImageCodec and nvCOMP wheels: DALI loads both with dlopen, + # and cudaPackages.dali has them in its runpath. + + '' + substituteInPlace dali/python/setup.py.in \ + --replace-fail \ + "name='nvidia-dali@DALI_FLAVOR_MINUS@-cuda@CUDA_VERSION_SHORT_DIGIT_ONLY@'" \ + "name='nvidia-dali'" \ + --replace-fail "@DALI_INSTALL_REQUIRES_NVIMGCODEC@" "" \ + --replace-fail "@DALI_INSTALL_REQUIRES_NVCOMP@" "" + ''; + + # The bindings are built with the configuration of the C++ libraries, which CMake checks again. + inherit (dali) nativeBuildInputs; + + buildInputs = dali.buildInputs ++ [ + dali + pybind11 + ]; + + build-system = [ setuptools ]; + + dependencies = [ + astunparse + gast + libcst + makefun + numpy + nvtx + optree + packaging + six + ]; + + # Build only the Python bindings (backend_impl and the python_function plugin), against the C++ libraries of + # cudaPackages.dali, like conda-forge does. The flags of the C++ libraries set BUILD_PYTHON=OFF; the later value wins. + cmakeFlags = dali.cmakeFlags ++ [ + (cmakeBool "BUILD_PYTHON" true) + (cmakeBool "PREBUILD_DALI_LIBS" true) + (cmakeFeature "PYTHON_VERSIONS" python.pythonVersion) + (cmakeBool "USE_PREBUILD_PYBIND11" true) + ]; + + # The Python package (with the headers for building plugins) is staged in dali/python of the build tree. + preBuild = '' + cmake --build . --target dali_python python_function_plugin copy_post_build_target install_headers + cd dali/python + ''; + + # nvidia.dali.sysconfig points plugin builds (-L, -ldali) at the package directory, where the wheels bundle the C++ + # libraries. + postInstall = '' + ln -s ${lib.getLib dali}/lib/libdali*.so "$out/${python.sitePackages}/nvidia/dali/" + ''; + + pythonImportsCheck = [ + "nvidia.dali" + # The experimental dynamic mode, the only user of nvtx + "nvidia.dali.experimental.dynamic" + ]; + + passthru = { + # Decodes JPEGs on the GPU with nvImageCodec, resizes and median-blurs them (CV-CUDA), and inflates LZ4 data with + # nvCOMP, which DALI all loads with dlopen. + gpuCheck = + ((cudaPackages.writeGpuTestPython.override { python3Packages = python.pkgs; }) + { + name = "nvidia-dali-gpu-check"; + libraries = ps: [ + ps.lz4 + ps.nvidia-dali + ]; + } + '' + import lz4.block + import numpy as np + from nvidia.dali import fn, pipeline_def, types + + images = "${finalAttrs.src}/docs/examples/data/images" + + + @pipeline_def(batch_size=4, num_threads=2, device_id=0) + def decode(): + jpegs, _ = fn.readers.file(file_root=images) + decoded = fn.decoders.image(jpegs, device="mixed", output_type=types.RGB) + resized = fn.resize(decoded, resize_x=224, resize_y=224) + return fn.experimental.median_blur(resized, window_size=3), fn.decoders.image(jpegs, device="cpu") + + + pipe = decode() + gpu, cpu = pipe.run() + for sample in gpu.as_cpu(): + assert np.array(sample).shape == (224, 224, 3), np.array(sample).shape + for sample in cpu: + assert np.array(sample).ndim == 3 + print("decoded, resized and blurred", len(gpu), "images") + + frames = np.arange(85, dtype=np.int32).reshape(17, 5) + chunks = [np.frombuffer(lz4.block.compress(f.tobytes(), store_size=False), np.uint8) for f in frames] + sizes = np.array([len(c) for c in chunks], dtype=np.int32) + # An odd offset, which nvCOMP 6 requires DALI to stage in aligned buffers + offsets = np.array(1 + np.cumsum([0, *sizes[:-1]]), dtype=np.int32) + compressed = np.concatenate([np.zeros(1, np.uint8), *chunks]) + + + @pipeline_def(batch_size=1, num_threads=2, device_id=0) + def inflate(): + data = fn.external_source(source=lambda: compressed, batch=False) + return fn.decoders.inflate( + data.gpu(), shape=[5], dtype=types.INT32, chunk_offsets=offsets, chunk_sizes=sizes + ) + + + (inflated,) = inflate().run() + np.testing.assert_array_equal(np.array(inflated.as_cpu()[0]), frames) + print("inflated", len(chunks), "LZ4 chunks") + '' + ).gpuCheck; + + # The version and source are cudaPackages.dali's: its update script, run on that attribute, updates both. + updateScript = dali.updateScript // { + attrPath = "cudaPackages.dali"; + }; + }; + + meta = { + description = "GPU-accelerated library for data loading and pre-processing for deep learning (Python API)"; + homepage = "https://github.com/NVIDIA/DALI"; + changelog = "https://github.com/NVIDIA/DALI/releases/tag/${finalAttrs.src.tag}"; + inherit (dali.meta) license platforms; + maintainers = with lib.maintainers; [ connorbaker ]; + teams = [ lib.teams.cuda ]; + }; +}) diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 031d2cbd591d..cf88cc3a471a 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -12434,6 +12434,8 @@ self: super: with self; { nvidia-cutlass-operators = callPackage ../development/python-modules/nvidia-cutlass-operators { }; + nvidia-dali = callPackage ../development/python-modules/nvidia-dali { }; + nvidia-dlprof-pytorch-nvtx = callPackage ../development/python-modules/nvidia-dlprof-pytorch-nvtx { };