diff --git a/doc/languages-frameworks/cuda.section.md b/doc/languages-frameworks/cuda.section.md index a469cdd42188..01b70402cf48 100644 --- a/doc/languages-frameworks/cuda.section.md +++ b/doc/languages-frameworks/cuda.section.md @@ -26,23 +26,9 @@ All CUDA package sets include common CUDA packages like `libcublas`, `cudnn`, `t CUDA support is not enabled by default in Nixpkgs. To enable CUDA support, make sure Nixpkgs is imported with a configuration similar to the following: ```nix +{ pkgs }: { - allowUnfreePredicate = - let - ensureList = x: if builtins.isList x then x else [ x ]; - in - package: - builtins.all ( - license: - license.free - || builtins.elem license.shortName [ - "CUDA EULA" - "cuDNN EULA" - "cuSPARSELt EULA" - "cuTENSOR EULA" - "NVidia OptiX EULA" - ] - ) (ensureList package.meta.license); + allowUnfreePredicate = pkgs._cuda.lib.allowUnfreeCudaPredicate; cudaCapabilities = [ ]; cudaForwardCompat = true; cudaSupport = true; @@ -63,45 +49,23 @@ The `cudaForwardCompat` boolean configuration option determines whether PTX supp ### Modifying CUDA package sets {#cuda-modifying-cuda-package-sets} -CUDA package sets are created by using `callPackage` on `pkgs/top-level/cuda-packages.nix` with an explicit argument for `cudaMajorMinorVersion`, a string of the form `"."` (e.g., `"12.2"`), which informs the CUDA package set tooling which version of CUDA to use. The majority of the CUDA package set tooling is available through the top-level attribute set `_cuda`, a fixed-point defined outside the CUDA package sets. +CUDA package sets are defined in `pkgs/top-level/cuda-packages.nix`. A CUDA package set is created by `callPackage`-ing `pkgs/development/cuda-modules/default.nix` with an attribute set `manifests`, containing NVIDIA manifests for each redistributable. The manifests for supported redistributables are available through `_cuda.manifests` and live in `pkgs/development/cuda-modules/_cuda/manifests`. -::: {.caution} -The `cudaMajorMinorVersion` and `_cuda` attributes are not part of the CUDA package set fixed-point, but are instead provided by `callPackage` from the top-level in the construction of the package set. As such, they must be modified via the package set's `override` attribute. -::: +The majority of the CUDA package set tooling is available through the top-level attribute set `_cuda`, a fixed-point defined outside the CUDA package sets. As a fixed-point, `_cuda` should be modified through its `extend` attribute. ::: {.caution} As indicated by the underscore prefix, `_cuda` is an implementation detail and no guarantees are provided with respect to its stability or API. The `_cuda` attribute set is exposed only to ease creation or modification of CUDA package sets by expert, out-of-tree users. ::: +Out-of-tree modifications of packages should use `overrideAttrs` to make any necessary modifications to the package expression. + ::: {.note} -The `_cuda` attribute set fixed-point should be modified through its `extend` attribute. +The `_cuda` attribute set previously exposed `fixups`, an attribute set mapping from package name (`pname`) to a `callPackage`-compatible expression which provided to `overrideAttrs` on the result of a generic redistributable builder. This functionality has been removed in favor of including full package expressions for each redistributable package to ensure consistent attribute set membership across supported CUDA releases, platforms, and configurations. ::: -The `_cuda.fixups` attribute set is a mapping from package name (`pname`) to a `callPackage`-compatible expression which will be provided to `overrideAttrs` on the result of our generic builder. - -::: {.caution} -Fixups are chosen from `_cuda.fixups` by `pname`. As a result, packages with multiple versions (e.g., `cudnn`, `cudnn_8_9`, etc.) all share a single fixup function (i.e., `_cuda.fixups.cudnn`, which is `pkgs/development/cuda-modules/fixups/cudnn.nix`). -::: - -As an example, you can change the fixup function used for cuDNN for only the default CUDA package set with this overlay: - -```nix -final: prev: { - cudaPackages = prev.cudaPackages.override (prevArgs: { - _cuda = prevArgs._cuda.extend ( - _: prevAttrs: { - fixups = prevAttrs.fixups // { - cudnn = ; - }; - } - ); - }); -} -``` - ### Extending CUDA package sets {#cuda-extending-cuda-package-sets} -CUDA package sets are scopes and provide the usual `overrideScope` attribute for overriding package attributes (see the note about `cudaMajorMinorVersion` and `_cuda` in [Configuring CUDA package sets](#cuda-modifying-cuda-package-sets)). +CUDA package sets are scopes and provide the usual `overrideScope` attribute for overriding package attributes (see the note about `_cuda` in [Configuring CUDA package sets](#cuda-modifying-cuda-package-sets)). Inspired by `pythonPackagesExtensions`, the `_cuda.extensions` attribute is a list of extensions applied to every version of the CUDA package set, allowing modification of all versions of the CUDA package set without needing to know their names or explicitly enumerate and modify them. As an example, disabling `cuda_compat` across all CUDA package sets can be accomplished with this overlay: @@ -115,6 +79,8 @@ final: prev: { } ``` +Redistributable packages are constructed by the `buildRedist` helper; see `pkgs/development/cuda-modules/buildRedist/default.nix` for the implementation. + ### Using `cudaPackages` {#cuda-using-cudapackages} ::: {.caution} @@ -194,7 +160,7 @@ In `pkgsForCudaArch`, the `cudaForwardCompat` option is set to `false` because e ::: {.caution} Not every version of CUDA supports every architecture! -To illustrate: support for Blackwell (e.g., `sm_100`) was added in CUDA 12.8. Assume our Nixpkgs' default CUDA package set is to CUDA 12.6. Then the Nixpkgs variant available through `pkgsForCudaArch.sm_100` is useless, since packages like `pkgsForCudaArch.sm_100.opencv` and `pkgsForCudaArch.sm_100.python3Packages.torch` will try to generate code for `sm_100`, an architecture unknown to CUDA 12.6. In that case, you should use `pkgsForCudaArch.sm_100.cudaPackages_12_8.pkgs` instead (see [Using cudaPackages.pkgs](#cuda-using-cudapackages-pkgs) for more details). +To illustrate: support for Blackwell (e.g., `sm_100`) was added in CUDA 12.8. Assume our Nixpkgs' default CUDA package set is to CUDA 12.6. Then the Nixpkgs variant available through `pkgsForCudaArch.sm_100` is useless, since packages like `pkgsForCudaArch.sm_100.opencv` and `pkgsForCudaArch.sm_100.python3Packages.torch` will try to generate code for `sm_100`, an architecture unknown to CUDA 12.6. In that case, you should use `pkgsForCudaArch.sm_100.cudaPackages_12_8.pkgs` instead (see [Using `cudaPackages.pkgs`](#cuda-using-cudapackages-pkgs) for more details). ::: The `pkgsForCudaArch` attribute set makes it possible to access packages built for a specific architecture without needing to manually call `pkgs.extend` and supply a new `config`. As an example, `pkgsForCudaArch.sm_89.python3Packages.torch` provides PyTorch built for Ada Lovelace GPUs. @@ -306,82 +272,41 @@ This section of the docs is still very much in progress. Feedback is welcome in ### Package set maintenance {#cuda-package-set-maintenance} -The CUDA Toolkit is a suite of CUDA libraries and software meant to provide a development environment for CUDA-accelerated applications. Until the release of CUDA 11.4, NVIDIA had only made the CUDA Toolkit available as a multi-gigabyte runfile installer, which we provide through the [`cudaPackages.cudatoolkit`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages.cudatoolkit) attribute. From CUDA 11.4 and onwards, NVIDIA has also provided CUDA redistributables (“CUDA-redist”): individually packaged CUDA Toolkit components meant to facilitate redistribution and inclusion in downstream projects. These packages are available in the [`cudaPackages`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages) package set. +The CUDA Toolkit is a suite of CUDA libraries and software meant to provide a development environment for CUDA-accelerated applications. Until the release of CUDA 11.4, NVIDIA had only made the CUDA Toolkit available as a multi-gigabyte runfile installer. From CUDA 11.4 and onwards, NVIDIA has also provided CUDA redistributables (“CUDA-redist”): individually packaged CUDA Toolkit components meant to facilitate redistribution and inclusion in downstream projects. These packages are available in the [`cudaPackages`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages) package set. -All new projects should use the CUDA redistributables available in [`cudaPackages`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages) in place of [`cudaPackages.cudatoolkit`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages.cudatoolkit), as they are much easier to maintain and update. +While the monolithic CUDA Toolkit runfile installer is no longer provided, [`cudaPackages.cudatoolkit`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages.cudatoolkit) provides a `symlinkJoin`-ed approximation which common libraries. The use of [`cudaPackages.cudatoolkit`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages.cudatoolkit) is discouraged: all new projects should use the CUDA redistributables available in [`cudaPackages`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages) instead, as they are much easier to maintain and update. #### Updating redistributables {#cuda-updating-redistributables} -1. Go to NVIDIA's index of CUDA redistributables: -2. Make a note of the new version of CUDA available. -3. Run +Whenever a new version of a redistributable manifest is made available: - ```bash - nix run github:connorbaker/cuda-redist-find-features -- \ - download-manifests \ - --log-level DEBUG \ - --version \ - https://developer.download.nvidia.com/compute/cuda/redist \ - ./pkgs/development/cuda-modules/cuda/manifests - ``` +1. Check the corresponding README.md in `pkgs/development/cuda-modules/_cuda/manifests` for the URL to use when vendoring manifests. +2. Update the manifest version used in construction of each CUDA package set in `pkgs/top-level/cuda-packages.nix`. +3. Update package expressions in `pkgs/development/cuda-modules/packages`. - This will download a copy of the manifest for the new version of CUDA. -4. Run +Updating package expressions amounts to: - ```bash - nix run github:connorbaker/cuda-redist-find-features -- \ - process-manifests \ - --log-level DEBUG \ - --version \ - https://developer.download.nvidia.com/compute/cuda/redist \ - ./pkgs/development/cuda-modules/cuda/manifests - ``` - - This will generate a `redistrib_features_.json` file in the same directory as the manifest. -5. Update the `cudaVersionMap` attribute set in `pkgs/development/cuda-modules/cuda/extension.nix`. - -#### Updating cuTensor {#cuda-updating-cutensor} - -1. Repeat the steps present in [Updating CUDA redistributables](#cuda-updating-redistributables) with the following changes: - - Use the index of cuTensor redistributables: - - Use the newest version of cuTensor available instead of the newest version of CUDA. - - Use `pkgs/development/cuda-modules/cutensor/manifests` instead of `pkgs/development/cuda-modules/cuda/manifests`. - - Skip the step of updating `cudaVersionMap` in `pkgs/development/cuda-modules/cuda/extension.nix`. +- adding fixes conditioned on newer releases, like added or removed dependencies +- adding package expressions for new packages +- updating `passthru.brokenConditions` and `passthru.badPlatformsConditions` with various constraints, (e.g., new releases removing support for various architectures) #### Updating supported compilers and GPUs {#cuda-updating-supported-compilers-and-gpus} -1. Update `nvccCompatibilities` in `pkgs/development/cuda-modules/_cuda/data/nvcc.nix` to include the newest release of NVCC, as well as any newly supported host compilers. -2. Update `cudaCapabilityToInfo` in `pkgs/development/cuda-modules/_cuda/data/cuda.nix` to include any new GPUs supported by the new release of CUDA. - -#### Updating the CUDA Toolkit runfile installer {#cuda-updating-the-cuda-toolkit} - -::: {.warning} -While the CUDA Toolkit runfile installer is still available in Nixpkgs as the [`cudaPackages.cudatoolkit`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages.cudatoolkit) attribute, its use is not recommended, and it should be considered deprecated. Please migrate to the CUDA redistributables provided by the [`cudaPackages`](https://search.nixos.org/packages?channel=unstable&type=packages&query=cudaPackages) package set. - -To ensure packages relying on the CUDA Toolkit runfile installer continue to build, it will continue to be updated until a migration path is available. -::: - -1. Go to NVIDIA's CUDA Toolkit runfile installer download page: -2. Select the appropriate OS, architecture, distribution, and version, and installer type. - - - For example: Linux, x86_64, Ubuntu, 22.04, runfile (local) - - NOTE: Typically, we use the Ubuntu runfile. It is unclear if the runfile for other distributions will work. - -3. Take the link provided by the installer instructions on the webpage after selecting the installer type and get its hash by running: - - ```bash - nix store prefetch-file --hash-type sha256 - ``` - -4. Update `pkgs/development/cuda-modules/cudatoolkit/releases.nix` to include the release. +1. Update `nvccCompatibilities` in `pkgs/development/cuda-modules/_cuda/db/bootstrap/nvcc.nix` to include the newest release of NVCC, as well as any newly supported host compilers. +2. Update `cudaCapabilityToInfo` in `pkgs/development/cuda-modules/_cuda/db/bootstrap/cuda.nix` to include any new GPUs supported by the new release of CUDA. #### Updating the CUDA package set {#cuda-updating-the-cuda-package-set} -1. Include a new `cudaPackages__` package set in `pkgs/top-level/all-packages.nix`. +::: {.note} +Changing the default CUDA package set should occur in a separate PR, allowing time for additional testing. +::: - - NOTE: Changing the default CUDA package set should occur in a separate PR, allowing time for additional testing. +::: {.warning} +As described in [Using `cudaPackages.pkgs`](#cuda-using-cudapackages-pkgs), the current implementation fix for package set leakage involves creating a new instance for each non-default CUDA package sets. As such, We should limit the number of CUDA package sets which have `recurseForDerivations` set to true: `lib.recurseIntoAttrs` should only be applied to the default CUDA package set. +::: -2. Successfully build the closure of the new package set, updating `pkgs/development/cuda-modules/cuda/overrides.nix` as needed. Below are some common failures: +1. Include a new `cudaPackages__` package set in `pkgs/top-level/cuda-packages.nix` and inherit it in `pkgs/top-level/all-packages.nix`. +2. Successfully build the closure of the new package set, updating expressions in `pkgs/development/cuda-modules/packages` as needed. Below are some common failures: | Unable to ... | During ... | Reason | Solution | Note | | -------------- | -------------------------------- | ------------------------------------------------ | -------------------------- | ------------------------------------------------------------ | @@ -389,6 +314,13 @@ To ensure packages relying on the CUDA Toolkit runfile installer continue to bui | Find libraries | `configurePhase` | Missing dependency on a `dev` output | Add the missing dependency | The `dev` output typically contains CMake configuration files | | Find libraries | `buildPhase` or `patchelf` | Missing dependency on a `lib` or `static` output | Add the missing dependency | The `lib` or `static` output typically contains the libraries | +::: {.note} +Two utility derivations ease testing updates to the package set: + +- `cudaPackages.tests.redists-unpacked`: the `src` of each redistributable package unpacked and `symlinkJoin`-ed +- `cudaPackages.tests.redists-installed`: each output of each redistributable package `symlinkJoin`-ed +::: + Failure to run the resulting binary is typically the most challenging to diagnose, as it may involve a combination of the aforementioned issues. This type of failure typically occurs when a library attempts to load or open a library it depends on that it does not declare in its `DT_NEEDED` section. Try the following debugging steps: 1. First ensure that dependencies are patched with [`autoAddDriverRunpath`](https://search.nixos.org/packages?channel=unstable&type=packages&query=autoAddDriverRunpath). diff --git a/doc/redirects.json b/doc/redirects.json index 6334e3e669e5..4ba879f51d2b 100644 --- a/doc/redirects.json +++ b/doc/redirects.json @@ -58,9 +58,8 @@ ], "cuda-updating-redistributables": [ "index.html#cuda-updating-redistributables", - "index.html#updating-cuda-redistributables" - ], - "cuda-updating-cutensor": [ + "index.html#updating-cuda-redistributables", + "index.html#updating-the-cuda-toolkit", "index.html#cuda-updating-cutensor", "index.html#updating-cutensor" ], @@ -72,10 +71,6 @@ "index.html#cuda-updating-the-cuda-package-set", "index.html#updating-the-cuda-package-set" ], - "cuda-updating-the-cuda-toolkit": [ - "index.html#cuda-updating-the-cuda-toolkit", - "index.html#updating-the-cuda-toolkit" - ], "cuda-user-guide": [ "index.html#cuda-user-guide" ], diff --git a/pkgs/by-name/ac/actiona/package.nix b/pkgs/by-name/ac/actiona/package.nix index 0e022282ced7..b1c68d2a4c00 100644 --- a/pkgs/by-name/ac/actiona/package.nix +++ b/pkgs/by-name/ac/actiona/package.nix @@ -44,7 +44,10 @@ stdenv.mkDerivation (finalAttrs: { buildInputs = [ bluez libnotify - opencv + # NOTE: Specifically not using lib.getOutput here because it would select the out output of opencv, which changes + # semantics since make-derivation uses lib.getDev on the dependency arrays, which won't touch derivations with + # specified outputs. + (opencv.cxxdev or opencv) qt6.qtbase qt6.qtmultimedia qt6.qttools diff --git a/pkgs/by-name/bl/blender/package.nix b/pkgs/by-name/bl/blender/package.nix index dc4f903ade7f..25d6eb947682 100644 --- a/pkgs/by-name/bl/blender/package.nix +++ b/pkgs/by-name/bl/blender/package.nix @@ -434,9 +434,7 @@ stdenv'.mkDerivation (finalAttrs: { # They comment two licenses: GPLv2 and Blender License, but they # say: "We've decided to cancel the BL offering for an indefinite period." # OptiX, enabled with cudaSupport, is non-free. - license = - with lib.licenses; - [ gpl2Plus ] ++ lib.optional cudaSupport (unfree // { shortName = "NVidia OptiX EULA"; }); + license = with lib.licenses; [ gpl2Plus ] ++ lib.optional cudaSupport nvidiaCudaRedist; platforms = [ "aarch64-linux" diff --git a/pkgs/by-name/co/colmap/package.nix b/pkgs/by-name/co/colmap/package.nix index babe6beab93b..24608e78d058 100644 --- a/pkgs/by-name/co/colmap/package.nix +++ b/pkgs/by-name/co/colmap/package.nix @@ -55,7 +55,7 @@ let ] ++ lib.optionals cudaSupport [ cudatoolkit - cudaPackages.cuda_cudart.static + (lib.getOutput "static" cudaPackages.cuda_cudart) ] ++ lib.optional stdenv'.cc.isClang llvmPackages.openmp; @@ -129,7 +129,7 @@ stdenv'.mkDerivation { mainProgram = "colmap"; homepage = "https://colmap.github.io/index.html"; license = licenses.bsd3; - platforms = platforms.unix; + platforms = if cudaSupport then platforms.linux else platforms.unix; maintainers = with maintainers; [ lebastr usertam diff --git a/pkgs/by-name/dc/dcgm/package.nix b/pkgs/by-name/dc/dcgm/package.nix index a9094cd870a5..0c43d7b3bbe1 100644 --- a/pkgs/by-name/dc/dcgm/package.nix +++ b/pkgs/by-name/dc/dcgm/package.nix @@ -60,7 +60,7 @@ let in [ (lib.cmakeFeature "CUDA${version}_INCLUDE_DIR" "${headers}") - (lib.cmakeFeature "CUDA${version}_LIBS" "${cudaPackages.cuda_cudart.stubs}/lib/stubs/libcuda.so") + (lib.cmakeFeature "CUDA${version}_LIBS" "${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs/libcuda.so") (lib.cmakeFeature "CUDA${version}_STATIC_LIBS" "${lib.getLib cudaPackages.cuda_cudart}/lib/libcudart.so") (lib.cmakeFeature "CUDA${version}_STATIC_CUBLAS_LIBS" ( lib.concatStringsSep ";" [ diff --git a/pkgs/by-name/gp/gpu-burn/package.nix b/pkgs/by-name/gp/gpu-burn/package.nix index 02ef35d1ab9f..ac4b748d7b49 100644 --- a/pkgs/by-name/gp/gpu-burn/package.nix +++ b/pkgs/by-name/gp/gpu-burn/package.nix @@ -6,7 +6,6 @@ lib, }: let - inherit (lib.attrsets) getBin; inherit (lib.lists) last map optionals; inherit (lib.trivial) boolToString; inherit (config) cudaSupport; @@ -36,7 +35,11 @@ backendStdenv.mkDerivation { substituteInPlace gpu_burn-drv.cpp \ --replace-fail \ '#define COMPARE_KERNEL "compare.ptx"' \ - "#define COMPARE_KERNEL \"$out/share/compare.ptx\"" + '#define COMPARE_KERNEL "${placeholder "out"}/share/compare.ptx"' + substituteInPlace Makefile \ + --replace-fail \ + '${''''${CUDAPATH}/bin/nvcc''}' \ + '${lib.getExe cuda_nvcc}' ''; nativeBuildInputs = [ @@ -52,7 +55,8 @@ backendStdenv.mkDerivation { ]; makeFlags = [ - "CUDAPATH=${getBin cuda_nvcc}" + # NOTE: CUDAPATH assumes cuda_cudart is a single output containing all of lib, dev, and stubs. + "CUDAPATH=${cuda_cudart}" "COMPUTE=${last (map dropDots cudaCapabilities)}" "IS_JETSON=${boolToString isJetsonBuild}" ]; diff --git a/pkgs/by-name/ko/koboldcpp/package.nix b/pkgs/by-name/ko/koboldcpp/package.nix index b21669dee58b..1f4cefb71bd1 100644 --- a/pkgs/by-name/ko/koboldcpp/package.nix +++ b/pkgs/by-name/ko/koboldcpp/package.nix @@ -57,6 +57,14 @@ effectiveStdenv.mkDerivation (finalAttrs: { python3Packages.wrapPython ]; + postPatch = '' + nixLog "patching $PWD/Makefile to remove explicit linking against CUDA driver" + substituteInPlace "$PWD/Makefile" \ + --replace-fail \ + 'CUBLASLD_FLAGS = -lcuda ' \ + 'CUBLASLD_FLAGS = ' + ''; + pythonInputs = builtins.attrValues { inherit (python3Packages) tkinter customtkinter packaging; }; buildInputs = [ diff --git a/pkgs/by-name/on/onnxruntime/package.nix b/pkgs/by-name/on/onnxruntime/package.nix index dcbea042fe7d..05ecb2453419 100644 --- a/pkgs/by-name/on/onnxruntime/package.nix +++ b/pkgs/by-name/on/onnxruntime/package.nix @@ -23,7 +23,7 @@ darwinMinVersionHook, pythonSupport ? true, cudaSupport ? config.cudaSupport, - ncclSupport ? config.cudaSupport, + ncclSupport ? cudaSupport && cudaPackages.nccl.meta.available, withFullProtobuf ? false, cudaPackages ? { }, }@inputs: @@ -154,12 +154,7 @@ effectiveStdenv.mkDerivation rec { cudnn # cudnn.h cuda_cudart ] - ++ lib.optionals (cudaSupport && ncclSupport) ( - with cudaPackages; - [ - nccl - ] - ) + ++ lib.optionals ncclSupport [ nccl ] ) ++ lib.optionals effectiveStdenv.hostPlatform.isDarwin [ (darwinMinVersionHook "13.3") @@ -270,7 +265,7 @@ effectiveStdenv.mkDerivation rec { ''; passthru = { - inherit cudaSupport cudaPackages; # for the python module + inherit cudaSupport cudaPackages ncclSupport; # for the python module inherit protobuf; tests = lib.optionalAttrs pythonSupport { python = python3Packages.onnxruntime; diff --git a/pkgs/by-name/op/openmpi/package.nix b/pkgs/by-name/op/openmpi/package.nix index 2984c4c035d9..a437632e8d7a 100644 --- a/pkgs/by-name/op/openmpi/package.nix +++ b/pkgs/by-name/op/openmpi/package.nix @@ -123,8 +123,9 @@ stdenv.mkDerivation (finalAttrs: { # TODO: add UCX support, which is recommended to use with cuda for the most robust OpenMPI build # https://github.com/openucx/ucx # https://www.open-mpi.org/faq/?category=buildcuda - (lib.withFeatureAs cudaSupport "cuda" (lib.getDev cudaPackages.cuda_cudart)) - (lib.withFeatureAs cudaSupport "cuda-libdir" "${cudaPackages.cuda_cudart.stubs}/lib") + # NOTE: Open MPI requires the header files specifically, which are in the `include` output. + (lib.withFeatureAs cudaSupport "cuda" (lib.getOutput "include" cudaPackages.cuda_cudart)) + (lib.withFeatureAs cudaSupport "cuda-libdir" "${lib.getLib cudaPackages.cuda_cudart}/lib") (lib.enableFeature cudaSupport "dlopen") (lib.withFeatureAs fabricSupport "psm2" (lib.getDev libpsm2)) (lib.withFeatureAs fabricSupport "ofi" (lib.getDev libfabric)) diff --git a/pkgs/by-name/sl/slurm/package.nix b/pkgs/by-name/sl/slurm/package.nix index 1ed22d4730d0..596916865a11 100644 --- a/pkgs/by-name/sl/slurm/package.nix +++ b/pkgs/by-name/sl/slurm/package.nix @@ -34,7 +34,7 @@ # enable internal X11 support via libssh2 enableX11 ? true, enableNVML ? config.cudaSupport, - nvml, + cudaPackages, }: stdenv.mkDerivation (finalAttrs: { @@ -110,8 +110,8 @@ stdenv.mkDerivation (finalAttrs: { ++ lib.optionals enableNVML [ (runCommand "collect-nvml" { } '' mkdir $out - ln -s ${lib.getDev nvml}/include $out/include - ln -s ${lib.getLib nvml}/lib/stubs $out/lib + ln -s ${lib.getOutput "include" cudaPackages.cuda_nvml_dev}/include $out/include + ln -s ${lib.getOutput "stubs" cudaPackages.cuda_nvml_dev}/lib/stubs $out/lib '') ]; diff --git a/pkgs/by-name/uc/ucc/package.nix b/pkgs/by-name/uc/ucc/package.nix index 284fcdc68cf4..fc43ddc832d4 100644 --- a/pkgs/by-name/uc/ucc/package.nix +++ b/pkgs/by-name/uc/ucc/package.nix @@ -15,7 +15,7 @@ inputs@{ enableSse42 ? stdenv.hostPlatform.sse4_2Support, }: let - inherit (lib.attrsets) getLib; + inherit (lib.attrsets) getOutput; inherit (lib.lists) optionals; inherit (lib.strings) concatStringsSep; @@ -88,8 +88,10 @@ effectiveStdenv.mkDerivation (finalAttrs: { # referring to an array! env.LDFLAGS = toString ( optionals enableCuda [ + # Fake libcuda.so (the real one is deployed impurely) + "-L${getOutput "stubs" cuda_cudart}/lib/stubs" # Fake libnvidia-ml.so (the real one is deployed impurely) - "-L${getLib cuda_nvml_dev}/lib/stubs" + "-L${getOutput "stubs" cuda_nvml_dev}/lib/stubs" ] ); diff --git a/pkgs/by-name/uc/ucx/package.nix b/pkgs/by-name/uc/ucx/package.nix index b3a10fc8454e..aecefb06fd48 100644 --- a/pkgs/by-name/uc/ucx/package.nix +++ b/pkgs/by-name/uc/ucx/package.nix @@ -34,6 +34,13 @@ let }; in stdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + # TODO(@connorbaker): + # When strictDeps is enabled, `cuda_nvcc` is required as the argument to `--with-cuda` in `configureFlags` or else + # configurePhase fails with `checking for cuda_runtime.h... no`. + # This is odd, especially given `cuda_runtime.h` is provided by `cuda_cudart.dev`, which is already in `buildInputs`. + strictDeps = true; + pname = "ucx"; version = "1.19.0"; @@ -75,10 +82,17 @@ stdenv.mkDerivation (finalAttrs: { ] ++ lib.optionals enableRocm rocmList; - LDFLAGS = lib.optionals enableCuda [ - # Fake libnvidia-ml.so (the real one is deployed impurely) - "-L${lib.getLib cudaPackages.cuda_nvml_dev}/lib/stubs" - ]; + # NOTE: With `__structuredAttrs` enabled, `LDFLAGS` must be set under `env` so it is assured to be a string; + # otherwise, we might have forgotten to convert it to a string and Nix would make LDFLAGS a shell variable + # referring to an array! + env.LDFLAGS = toString ( + lib.optionals enableCuda [ + # Fake libcuda.so (the real one is deployed impurely) + "-L${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs" + # Fake libnvidia-ml.so (the real one is deployed impurely) + "-L${lib.getOutput "stubs" cudaPackages.cuda_nvml_dev}/lib/stubs" + ] + ); configureFlags = [ "--with-rdmacm=${lib.getDev rdma-core}" diff --git a/pkgs/by-name/xg/xgboost/package.nix b/pkgs/by-name/xg/xgboost/package.nix index fe0e48d2f95c..dade3dfebf3d 100644 --- a/pkgs/by-name/xg/xgboost/package.nix +++ b/pkgs/by-name/xg/xgboost/package.nix @@ -16,7 +16,7 @@ rPackages, }@inputs: -assert ncclSupport -> (cudaSupport && !cudaPackages.nccl.meta.unsupported); +assert ncclSupport -> (cudaSupport && cudaPackages.nccl.meta.available); # Disable regular tests when building the R package # because 1) the R package runs its own tests and # 2) the R package creates a different binary shared diff --git a/pkgs/development/cuda-modules/README.md b/pkgs/development/cuda-modules/README.md index 8d450302a45d..8b1b1856cb3f 100644 --- a/pkgs/development/cuda-modules/README.md +++ b/pkgs/development/cuda-modules/README.md @@ -10,39 +10,48 @@ package set by [cuda-packages.nix](../../top-level/cuda-packages.nix). ## Top-level directories -- `cuda`: CUDA redistributables! Provides extension to `cudaPackages` scope. -- `cudatoolkit`: monolithic CUDA Toolkit run-file installer. Provides extension - to `cudaPackages` scope. -- `cudnn`: NVIDIA cuDNN library. -- `cutensor`: NVIDIA cuTENSOR library. -- `fixups`: Each file or directory (excluding `default.nix`) should contain a - `callPackage`-able expression to be provided to the `overrideAttrs` attribute - of a package produced by the generic manifest builder. - These fixups are applied by `pname`, so packages with multiple versions - (e.g., `cudnn`, `cudnn_8_9`, etc.) all share a single fixup function - (i.e., `fixups/cudnn.nix`). -- `generic-builders`: - - Contains a builder `manifest.nix` which operates on the `Manifest` type - defined in `modules/generic/manifests`. Most packages are built using this - builder. - - Contains a builder `multiplex.nix` which leverages the Manifest builder. In - short, the Multiplex builder adds multiple versions of a single package to - single instance of the CUDA Packages package set. It is used primarily for - packages like `cudnn` and `cutensor`. -- `modules`: Nixpkgs modules to check the shape and content of CUDA - redistributable and feature manifests. These modules additionally use shims - provided by some CUDA packages to allow them to re-use the - `genericManifestBuilder`, even if they don't have manifest files of their - own. `cudnn` and `tensorrt` are examples of packages which provide such - shims. These modules are further described in the - [Modules](./modules/README.md) documentation. +- `_cuda`: Fixed-point used to configure, construct, and extend the CUDA package + set. This includes NVIDIA manifests. +- `buildRedist`: Contains the logic to build packages using NVIDIA's manifests. - `packages`: Contains packages which exist in every instance of the CUDA package set. These packages are built in a `by-name` fashion. -- `setup-hooks`: Nixpkgs setup hooks for CUDA. -- `tensorrt`: NVIDIA TensorRT library. +- `tests`: Contains tests which can be run against the CUDA package set. + +Many redistributable packages are in the `packages` directory. Their presence +ensures that, even if a CUDA package set which no longer includes a given package +is being constructed, the attribute for that package will still exist (but refer +to a broken package). This prevents missing attribute errors as the package set +evolves. ## Distinguished packages +Some packages are purposefully not in the `packages` directory. These are packages +which do not make sense for Nixpkgs, require further investigation, or are otherwise +not straightforward to include. These packages are: + +- `cuda`: + - `collectx_bringup`: missing `libssl.so.1.1` and `libcrypto.so.1.1`; not sure how + to provide them or what the package does. + - `cuda_sandbox_dev`: unclear on purpose. + - `driver_assistant`: we don't use the drivers from the CUDA releases; irrelevant. + - `mft_autocomplete`: unsure of purpose; contains FHS paths. + - `mft_oem`: unsure of purpose; contains FHS paths. + - `mft`: unsure of purpose; contains FHS paths. + - `nvidia_driver`: we don't use the drivers from the CUDA releases; irrelevant. + - `nvlsm`: contains FHS paths/NVSwitch and NVLINK software + - `libnvidia_nscq`: NVSwitch software + - `libnvsdm`: NVSwitch software +- `cublasmp`: + - `libcublasmp`: `nvshmem` isnt' packaged. +- `cudnn`: + - `cudnn_samples`: requires FreeImage, which is abandoned and not packaged. + +> [!NOTE] +> +> When packaging redistributables, prefer `autoPatchelfIgnoreMissingDeps` to providing +> paths to stubs with `extraAutoPatchelfLibs`; the stubs are meant to be used for +> projects where linking against libraries available only at runtime is unavoidable. + ### CUDA Compatibility [CUDA Compatibility](https://docs.nvidia.com/deploy/cuda-compatibility/), diff --git a/pkgs/development/cuda-modules/_cuda/db/bootstrap/cuda.nix b/pkgs/development/cuda-modules/_cuda/db/bootstrap/cuda.nix index eaee60b2434e..4157dc9ddf65 100644 --- a/pkgs/development/cuda-modules/_cuda/db/bootstrap/cuda.nix +++ b/pkgs/development/cuda-modules/_cuda/db/bootstrap/cuda.nix @@ -100,10 +100,27 @@ } ) { + # Tesla K40 + "3.5" = { + archName = "Kepler"; + minCudaMajorMinorVersion = "10.0"; + dontDefaultAfterCudaMajorMinorVersion = "11.0"; + maxCudaMajorMinorVersion = "11.8"; + }; + + # Tesla K80 + "3.7" = { + archName = "Kepler"; + minCudaMajorMinorVersion = "10.0"; + dontDefaultAfterCudaMajorMinorVersion = "11.0"; + maxCudaMajorMinorVersion = "11.8"; + }; + # Tesla/Quadro M series "5.0" = { archName = "Maxwell"; minCudaMajorMinorVersion = "10.0"; + maxCudaMajorMinorVersion = "12.9"; dontDefaultAfterCudaMajorMinorVersion = "11.0"; }; @@ -111,6 +128,7 @@ "5.2" = { archName = "Maxwell"; minCudaMajorMinorVersion = "10.0"; + maxCudaMajorMinorVersion = "12.9"; dontDefaultAfterCudaMajorMinorVersion = "11.0"; }; @@ -118,6 +136,7 @@ "6.0" = { archName = "Pascal"; minCudaMajorMinorVersion = "10.0"; + maxCudaMajorMinorVersion = "12.9"; # Removed from TensorRT 10.0, which corresponds to CUDA 12.4 release. # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1001/support-matrix/index.html dontDefaultAfterCudaMajorMinorVersion = "12.3"; @@ -128,6 +147,7 @@ "6.1" = { archName = "Pascal"; minCudaMajorMinorVersion = "10.0"; + maxCudaMajorMinorVersion = "12.9"; # Removed from TensorRT 10.0, which corresponds to CUDA 12.4 release. # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1001/support-matrix/index.html dontDefaultAfterCudaMajorMinorVersion = "12.3"; @@ -137,11 +157,22 @@ "7.0" = { archName = "Volta"; minCudaMajorMinorVersion = "10.0"; + maxCudaMajorMinorVersion = "12.9"; # Removed from TensorRT 10.5, which corresponds to CUDA 12.6 release. # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1050/support-matrix/index.html dontDefaultAfterCudaMajorMinorVersion = "12.5"; }; + # Jetson AGX Xavier, Drive AGX Pegasus, Xavier NX + "7.2" = { + archName = "Volta"; + minCudaMajorMinorVersion = "10.0"; + # Note: without `cuda_compat`, maxCudaMajorMinorVersion is 11.8 + # https://docs.nvidia.com/cuda/cuda-for-tegra-appnote/index.html#deployment-considerations-for-cuda-upgrade-package + maxCudaMajorMinorVersion = "12.2"; + isJetson = true; + }; + # GTX/RTX Turing – GTX 1660 Ti, RTX 2060, RTX 2070, RTX 2080, Titan RTX, Quadro RTX 4000, # Quadro RTX 5000, Quadro RTX 6000, Quadro RTX 8000, Quadro T1000/T2000, Tesla T4 "7.5" = { @@ -163,20 +194,30 @@ minCudaMajorMinorVersion = "11.2"; }; - # Jetson AGX Orin and Drive AGX Orin only + # Tegra T234 (Jetson Orin) "8.7" = { archName = "Ampere"; - minCudaMajorMinorVersion = "11.5"; + minCudaMajorMinorVersion = "11.4"; isJetson = true; }; + # Tegra T239 (Switch 2?) + # "8.8" = { + # archName = "Ampere"; + # minCudaMajorMinorVersion = "13.0"; + # # It's not a Jetson device, but it does use the same architecture. + # isJetson = true; + # # Should never be default. + # dontDefaultAfterCudaMajorMinorVersion = "13.0"; + # }; + # NVIDIA GeForce RTX 4090, RTX 4080, RTX 6000, Tesla L40 "8.9" = { archName = "Ada"; minCudaMajorMinorVersion = "11.8"; }; - # NVIDIA H100 (GH100) + # NVIDIA H100, H200, GH200 "9.0" = { archName = "Hopper"; minCudaMajorMinorVersion = "11.8"; @@ -187,7 +228,7 @@ minCudaMajorMinorVersion = "12.0"; }; - # NVIDIA B100 + # NVIDIA B200, GB200 "10.0" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.7"; @@ -203,26 +244,33 @@ minCudaMajorMinorVersion = "12.9"; }; - # NVIDIA Jetson Thor Blackwell + # NVIDIA Jetson Thor Blackwell, T4000, T5000 (CUDA 12.7-12.9) + # Okay, so: + # - Support for Thor was added in CUDA 12.7, which was never released but is referenced in docs + # - NVIDIA changed the compute capability from 10.0 to 11.0 in CUDA 13.0 + # - From CUDA 13.0 and on, 10.1 is no longer a valid compute capability "10.1" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.7"; + maxCudaMajorMinorVersion = "12.9"; isJetson = true; }; "10.1a" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.7"; + maxCudaMajorMinorVersion = "12.9"; isJetson = true; }; "10.1f" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.9"; + maxCudaMajorMinorVersion = "12.9"; isJetson = true; }; - # NVIDIA ??? + # NVIDIA B300 "10.3" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.9"; @@ -238,6 +286,25 @@ minCudaMajorMinorVersion = "12.9"; }; + # NVIDIA Jetson Thor Blackwell, T4000, T5000 (CUDA 13.0+) + "11.0" = { + archName = "Blackwell"; + minCudaMajorMinorVersion = "13.0"; + isJetson = true; + }; + + "11.0a" = { + archName = "Blackwell"; + minCudaMajorMinorVersion = "13.0"; + isJetson = true; + }; + + "11.0f" = { + archName = "Blackwell"; + minCudaMajorMinorVersion = "13.0"; + isJetson = true; + }; + # NVIDIA GeForce RTX 5090 (GB202) etc. "12.0" = { archName = "Blackwell"; @@ -254,7 +321,7 @@ minCudaMajorMinorVersion = "12.9"; }; - # NVIDIA ??? + # NVIDIA DGX Spark "12.1" = { archName = "Blackwell"; minCudaMajorMinorVersion = "12.9"; diff --git a/pkgs/development/cuda-modules/_cuda/db/bootstrap/nvcc.nix b/pkgs/development/cuda-modules/_cuda/db/bootstrap/nvcc.nix index 76704f9c5c65..7a1548f81645 100644 --- a/pkgs/development/cuda-modules/_cuda/db/bootstrap/nvcc.nix +++ b/pkgs/development/cuda-modules/_cuda/db/bootstrap/nvcc.nix @@ -28,7 +28,204 @@ ``` */ nvccCompatibilities = { - # Our baseline + # https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features + "11.0" = { + clang = { + maxMajorVersion = "9"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "9"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 10 and GCC 10 + # https://docs.nvidia.com/cuda/archive/11.1.1/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features + "11.1" = { + clang = { + maxMajorVersion = "10"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "10"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 11 + # https://docs.nvidia.com/cuda/archive/11.2.2/cuda-installation-guide-linux/index.html#system-requirements + "11.2" = { + clang = { + maxMajorVersion = "11"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "10"; + minMajorVersion = "6"; + }; + }; + + # No changes from 11.2 to 11.3 + "11.3" = { + clang = { + maxMajorVersion = "11"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "10"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 12 and GCC 11 + # https://docs.nvidia.com/cuda/archive/11.4.4/cuda-toolkit-release-notes/index.html#cuda-general-new-features + # NOTE: There is a bug in the version of GLIBC that GCC 11 uses which causes it to fail to compile some CUDA + # code. As such, we skip it for this release, and do the bump in 11.6 (skipping 11.5). + # https://forums.developer.nvidia.com/t/cuda-11-5-samples-throw-multiple-error-attribute-malloc-does-not-take-arguments/192750/15 + "11.4" = { + clang = { + maxMajorVersion = "12"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "10"; + minMajorVersion = "6"; + }; + }; + + # No changes from 11.4 to 11.5 + "11.5" = { + clang = { + maxMajorVersion = "12"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "10"; + minMajorVersion = "6"; + }; + }; + + # No changes from 11.5 to 11.6 + # However, as mentioned above, we add GCC 11 this release. + "11.6" = { + clang = { + maxMajorVersion = "12"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "11"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 13 + # https://docs.nvidia.com/cuda/archive/11.7.1/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features + "11.7" = { + clang = { + maxMajorVersion = "13"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "11"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 14 + # https://docs.nvidia.com/cuda/archive/11.8.0/cuda-installation-guide-linux/index.html#system-requirements + "11.8" = { + clang = { + maxMajorVersion = "14"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "11"; + minMajorVersion = "6"; + }; + }; + + # Added support for GCC 12 + # https://docs.nvidia.com/cuda/archive/12.0.1/cuda-installation-guide-linux/index.html#system-requirements + "12.0" = { + clang = { + maxMajorVersion = "14"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "12"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 15 + # https://docs.nvidia.com/cuda/archive/12.1.1/cuda-toolkit-release-notes/index.html#cuda-compilers-new-features + "12.1" = { + clang = { + maxMajorVersion = "15"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "12"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 16 + # https://docs.nvidia.com/cuda/archive/12.2.2/cuda-installation-guide-linux/index.html#host-compiler-support-policy + "12.2" = { + clang = { + maxMajorVersion = "16"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "12"; + minMajorVersion = "6"; + }; + }; + + # No changes from 12.2 to 12.3 + # https://docs.nvidia.com/cuda/archive/12.3.2/cuda-installation-guide-linux/index.html#host-compiler-support-policy + "12.3" = { + clang = { + maxMajorVersion = "16"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "12"; + minMajorVersion = "6"; + }; + }; + + # Maximum Clang version is 17 + # Minimum GCC version is still 6, but all versions prior to GCC 7.3 are deprecated. + # Maximum GCC version is 13.2 + # https://docs.nvidia.com/cuda/archive/12.4.1/cuda-installation-guide-linux/index.html#host-compiler-support-policy + "12.4" = { + clang = { + maxMajorVersion = "17"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "13"; + minMajorVersion = "6"; + }; + }; + + # No changes from 12.4 to 12.5 + # https://docs.nvidia.com/cuda/archive/12.5.1/cuda-installation-guide-linux/index.html#host-compiler-support-policy + "12.5" = { + clang = { + maxMajorVersion = "17"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "13"; + minMajorVersion = "6"; + }; + }; + + # Added support for Clang 18 # https://docs.nvidia.com/cuda/archive/12.6.0/cuda-installation-guide-linux/index.html#host-compiler-support-policy "12.6" = { clang = { @@ -55,7 +252,7 @@ }; # No changes from 12.8 to 12.9 - # https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#host-compiler-support-policy + # https://docs.nvidia.com/cuda/archive/12.9.1/cuda-installation-guide-linux/index.html#host-compiler-support-policy "12.9" = { clang = { maxMajorVersion = "19"; @@ -66,5 +263,18 @@ minMajorVersion = "6"; }; }; + + # 12.9 to 13.0 adds support for GCC 15 and Clang 20 + # https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#host-compiler-support-policy + "13.0" = { + clang = { + maxMajorVersion = "20"; + minMajorVersion = "7"; + }; + gcc = { + maxMajorVersion = "15"; + minMajorVersion = "6"; + }; + }; }; } diff --git a/pkgs/development/cuda-modules/_cuda/default.nix b/pkgs/development/cuda-modules/_cuda/default.nix index fdbac3c8fbd7..9f7fe75ecfa5 100644 --- a/pkgs/development/cuda-modules/_cuda/default.nix +++ b/pkgs/development/cuda-modules/_cuda/default.nix @@ -1,9 +1,7 @@ # The _cuda attribute set is a fixed-point which contains the static functionality required to construct CUDA package # sets. For example, `_cuda.bootstrapData` includes information about NVIDIA's redistributables (such as the names -# NVIDIA uses for different systems), `_cuda.lib` contains utility functions like `formatCapabilities` (which generate -# common arguments passed to NVCC and `cmakeFlags`), and `_cuda.fixups` contains `callPackage`-able functions which -# are provided to the corresponding package's `overrideAttrs` attribute to provide package-specific fixups -# out of scope of the generic redistributable builder. +# NVIDIA uses for different systems), and `_cuda.lib` contains utility functions like `formatCapabilities` (which generate +# common arguments passed to NVCC and `cmakeFlags`). # # Since this attribute set is used to construct the CUDA package sets, it must exist outside the fixed point of the # package sets. Make these attributes available directly in the package set construction could cause confusion if @@ -23,7 +21,7 @@ lib.fixedPoints.makeExtensible (final: { inherit lib; }; extensions = [ ]; # Extensions applied to every CUDA package set. - fixups = import ./fixups { inherit lib; }; + manifests = import ./manifests { inherit lib; }; lib = import ./lib { _cuda = final; inherit lib; diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_compat.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_compat.nix deleted file mode 100644 index 1f5736ba059a..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_compat.nix +++ /dev/null @@ -1,12 +0,0 @@ -{ flags, lib }: -prevAttrs: { - autoPatchelfIgnoreMissingDeps = prevAttrs.autoPatchelfIgnoreMissingDeps or [ ] ++ [ - "libnvrm_gpu.so" - "libnvrm_mem.so" - "libnvdla_runtime.so" - ]; - # `cuda_compat` only works on aarch64-linux, and only when building for Jetson devices. - badPlatformsConditions = prevAttrs.badPlatformsConditions or { } // { - "Trying to use cuda_compat on aarch64-linux targeting non-Jetson devices" = !flags.isJetsonBuild; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_cudart.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_cudart.nix deleted file mode 100644 index d95b014cdca6..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_cudart.nix +++ /dev/null @@ -1,37 +0,0 @@ -# TODO(@connorbaker): cuda_cudart.dev depends on crt/host_config.h, which is from -# (getDev cuda_nvcc). It would be nice to be able to encode that. -{ addDriverRunpath, lib }: -prevAttrs: { - # Remove once cuda-find-redist-features has a special case for libcuda - outputs = - prevAttrs.outputs or [ ] - ++ lib.lists.optionals (!(builtins.elem "stubs" prevAttrs.outputs)) [ "stubs" ]; - - allowFHSReferences = false; - - # The libcuda stub's pkg-config doesn't follow the general pattern: - postPatch = - prevAttrs.postPatch or "" - + '' - while IFS= read -r -d $'\0' path; do - sed -i \ - -e "s|^libdir\s*=.*/lib\$|libdir=''${!outputLib}/lib/stubs|" \ - -e "s|^Libs\s*:\(.*\)\$|Libs: \1 -Wl,-rpath,${addDriverRunpath.driverLink}/lib|" \ - "$path" - done < <(find -iname 'cuda-*.pc' -print0) - '' - # Namelink may not be enough, add a soname. - # Cf. https://gitlab.kitware.com/cmake/cmake/-/issues/25536 - + '' - if [[ -f lib/stubs/libcuda.so && ! -f lib/stubs/libcuda.so.1 ]]; then - ln -s libcuda.so lib/stubs/libcuda.so.1 - fi - ''; - - postFixup = prevAttrs.postFixup or "" + '' - mv "''${!outputDev}/share" "''${!outputDev}/lib" - moveToOutput lib/stubs "$stubs" - ln -s "$stubs"/lib/stubs/* "$stubs"/lib/ - ln -s "$stubs"/lib/stubs "''${!outputLib}/lib/stubs" - ''; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_demo_suite.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_demo_suite.nix deleted file mode 100644 index 817f9d1a0302..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_demo_suite.nix +++ /dev/null @@ -1,18 +0,0 @@ -{ - libglut, - libcufft, - libcurand, - libGLU, - libglvnd, - libgbm, -}: -prevAttrs: { - buildInputs = prevAttrs.buildInputs or [ ] ++ [ - libglut - libcufft - libcurand - libGLU - libglvnd - libgbm - ]; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_gdb.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_gdb.nix deleted file mode 100644 index e3593b0a90f0..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_gdb.nix +++ /dev/null @@ -1,35 +0,0 @@ -{ - cudaAtLeast, - gmp, - expat, - libxcrypt-legacy, - ncurses6, - python310, - python311, - python312, - stdenv, - lib, -}: -prevAttrs: { - buildInputs = - prevAttrs.buildInputs or [ ] - ++ [ - gmp - libxcrypt-legacy - ncurses6 - python310 - python311 - python312 - ] - # aarch64,sbsa needs expat - ++ lib.lists.optionals (stdenv.hostPlatform.isAarch64) [ expat ]; - - installPhase = - prevAttrs.installPhase or "" - # Python 3.8 is not in nixpkgs anymore, delete Python 3.8 cuda-gdb support - # to avoid autopatchelf failing to find libpython3.8.so. - + '' - find $bin -name '*python3.8*' -delete - find $bin -name '*python3.9*' -delete - ''; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvcc.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvcc.nix deleted file mode 100644 index f042222ab9fd..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvcc.nix +++ /dev/null @@ -1,62 +0,0 @@ -{ - lib, - backendStdenv, - setupCudaHook, -}: -prevAttrs: { - # Merge "bin" and "dev" into "out" to avoid circular references - outputs = builtins.filter ( - x: - !(builtins.elem x [ - "dev" - "bin" - ]) - ) prevAttrs.outputs or [ ]; - - # Patch the nvcc.profile. - # Syntax: - # - `=` for assignment, - # - `?=` for conditional assignment, - # - `+=` to "prepend", - # - `=+` to "append". - - # Cf. https://web.archive.org/web/20230308044351/https://arcb.csc.ncsu.edu/~mueller/cluster/nvidia/2.0/nvcc_2.0.pdf - - # We set all variables with the lowest priority (=+), but we do force - # nvcc to use the fixed backend toolchain. Cf. comments in - # backend-stdenv.nix - - postPatch = - prevAttrs.postPatch or "" - + '' - substituteInPlace bin/nvcc.profile \ - --replace-fail \ - '$(TOP)/$(_TARGET_DIR_)/include' \ - "''${!outputDev}/include" - '' - + '' - cat << EOF >> bin/nvcc.profile - - # Fix a compatible backend compiler - PATH += "${backendStdenv.cc}/bin": - - # Expose the split-out nvvm - LIBRARIES =+ "-L''${!outputBin}/nvvm/lib" - INCLUDES =+ "-I''${!outputBin}/nvvm/include" - EOF - ''; - - # Entries here will be in nativeBuildInputs when cuda_nvcc is in nativeBuildInputs. - propagatedBuildInputs = prevAttrs.propagatedBuildInputs or [ ] ++ [ setupCudaHook ]; - - postInstall = prevAttrs.postInstall or "" + '' - moveToOutput "nvvm" "''${!outputBin}" - ''; - - # The nvcc and cicc binaries contain hard-coded references to /usr - allowFHSReferences = true; - - meta = prevAttrs.meta or { } // { - mainProgram = "nvcc"; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvprof.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvprof.nix deleted file mode 100644 index 7452e41bad7b..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_nvprof.nix +++ /dev/null @@ -1 +0,0 @@ -{ cuda_cupti }: prevAttrs: { buildInputs = prevAttrs.buildInputs or [ ] ++ [ cuda_cupti ]; } diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cuda_sanitizer_api.nix b/pkgs/development/cuda-modules/_cuda/fixups/cuda_sanitizer_api.nix deleted file mode 100644 index df0019f4d827..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cuda_sanitizer_api.nix +++ /dev/null @@ -1 +0,0 @@ -_: _: { outputs = [ "out" ]; } diff --git a/pkgs/development/cuda-modules/_cuda/fixups/cudnn.nix b/pkgs/development/cuda-modules/_cuda/fixups/cudnn.nix deleted file mode 100644 index dbf36688f011..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/cudnn.nix +++ /dev/null @@ -1,75 +0,0 @@ -{ - cudaOlder, - cudaMajorMinorVersion, - fetchurl, - lib, - libcublas, - patchelf, - zlib, -}: -let - inherit (lib) - attrsets - maintainers - meta - strings - ; -in -finalAttrs: prevAttrs: { - src = fetchurl { inherit (finalAttrs.passthru.redistribRelease) hash url; }; - - # Useful for inspecting why something went wrong. - badPlatformsConditions = - let - cudaTooOld = cudaOlder finalAttrs.passthru.featureRelease.minCudaVersion; - cudaTooNew = - (finalAttrs.passthru.featureRelease.maxCudaVersion != null) - && strings.versionOlder finalAttrs.passthru.featureRelease.maxCudaVersion cudaMajorMinorVersion; - in - prevAttrs.badPlatformsConditions or { } - // { - "CUDA version is too old" = cudaTooOld; - "CUDA version is too new" = cudaTooNew; - }; - - buildInputs = prevAttrs.buildInputs or [ ] ++ [ - zlib - (attrsets.getLib libcublas) - ]; - - # Tell autoPatchelf about runtime dependencies. *_infer* libraries only - # exist in CuDNN 8. - # NOTE: Versions from CUDNN releases have four components. - postFixup = - prevAttrs.postFixup or "" - + - strings.optionalString - ( - strings.versionAtLeast finalAttrs.version "8.0.5.0" - && strings.versionOlder finalAttrs.version "9.0.0.0" - ) - '' - ${meta.getExe patchelf} $lib/lib/libcudnn.so --add-needed libcudnn_cnn_infer.so - ${meta.getExe patchelf} $lib/lib/libcudnn_ops_infer.so --add-needed libcublas.so --add-needed libcublasLt.so - ''; - - meta = prevAttrs.meta or { } // { - homepage = "https://developer.nvidia.com/cudnn"; - maintainers = - prevAttrs.meta.maintainers or [ ] - ++ (with maintainers; [ - mdaiter - samuela - connorbaker - ]); - # TODO(@connorbaker): Temporary workaround to avoid changing the derivation hash since introducing more - # brokenConditions would change the derivation as they're top-level and __structuredAttrs is set. - teams = prevAttrs.meta.teams or [ ]; - license = { - shortName = "cuDNN EULA"; - fullName = "NVIDIA cuDNN Software License Agreement (EULA)"; - url = "https://docs.nvidia.com/deeplearning/sdk/cudnn-sla/index.html#supplement"; - free = false; - }; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/default.nix b/pkgs/development/cuda-modules/_cuda/fixups/default.nix deleted file mode 100644 index 0c9874672ce4..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/default.nix +++ /dev/null @@ -1,11 +0,0 @@ -{ lib }: -lib.concatMapAttrs ( - fileName: _type: - let - # Fixup is in `./${attrName}.nix` or in `./${fileName}/default.nix`: - attrName = lib.removeSuffix ".nix" fileName; - fixup = import (./. + "/${fileName}"); - isFixup = fileName != "default.nix"; - in - lib.optionalAttrs isFixup { ${attrName} = fixup; } -) (builtins.readDir ./.) diff --git a/pkgs/development/cuda-modules/_cuda/fixups/driver_assistant.nix b/pkgs/development/cuda-modules/_cuda/fixups/driver_assistant.nix deleted file mode 100644 index e9c50b2f4eaf..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/driver_assistant.nix +++ /dev/null @@ -1,5 +0,0 @@ -_: prevAttrs: { - badPlatformsConditions = prevAttrs.badPlatformsConditions or { } // { - "Package is not supported; use drivers from linuxPackages" = true; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/fabricmanager.nix b/pkgs/development/cuda-modules/_cuda/fixups/fabricmanager.nix deleted file mode 100644 index fa2073ce002a..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/fabricmanager.nix +++ /dev/null @@ -1 +0,0 @@ -{ zlib }: prevAttrs: { buildInputs = prevAttrs.buildInputs or [ ] ++ [ zlib ]; } diff --git a/pkgs/development/cuda-modules/_cuda/fixups/imex.nix b/pkgs/development/cuda-modules/_cuda/fixups/imex.nix deleted file mode 100644 index fa2073ce002a..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/imex.nix +++ /dev/null @@ -1 +0,0 @@ -{ zlib }: prevAttrs: { buildInputs = prevAttrs.buildInputs or [ ] ++ [ zlib ]; } diff --git a/pkgs/development/cuda-modules/_cuda/fixups/libcufile.nix b/pkgs/development/cuda-modules/_cuda/fixups/libcufile.nix deleted file mode 100644 index b4fc02e89655..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/libcufile.nix +++ /dev/null @@ -1,12 +0,0 @@ -{ - libcublas, - numactl, - rdma-core, -}: -prevAttrs: { - buildInputs = prevAttrs.buildInputs or [ ] ++ [ - libcublas - numactl - rdma-core - ]; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/libcusolver.nix b/pkgs/development/cuda-modules/_cuda/fixups/libcusolver.nix deleted file mode 100644 index 699f0f708260..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/libcusolver.nix +++ /dev/null @@ -1,19 +0,0 @@ -{ - cudaAtLeast, - lib, - libcublas, - libcusparse ? null, - libnvjitlink ? null, -}: -prevAttrs: { - buildInputs = prevAttrs.buildInputs or [ ] ++ [ - libcublas - libnvjitlink - libcusparse - ]; - - brokenConditions = prevAttrs.brokenConditions or { } // { - "libnvjitlink missing (CUDA >= 12.0)" = libnvjitlink == null; - "libcusparse missing (CUDA >= 12.1)" = libcusparse == null; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/libcusparse.nix b/pkgs/development/cuda-modules/_cuda/fixups/libcusparse.nix deleted file mode 100644 index e895e568d784..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/libcusparse.nix +++ /dev/null @@ -1,12 +0,0 @@ -{ - cudaAtLeast, - lib, - libnvjitlink ? null, -}: -prevAttrs: { - buildInputs = prevAttrs.buildInputs or [ ] ++ [ libnvjitlink ]; - - brokenConditions = prevAttrs.brokenConditions or { } // { - "libnvjitlink missing (CUDA >= 12.0)" = libnvjitlink == null; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/libcusparse_lt.nix b/pkgs/development/cuda-modules/_cuda/fixups/libcusparse_lt.nix deleted file mode 100644 index 009e64555133..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/libcusparse_lt.nix +++ /dev/null @@ -1,23 +0,0 @@ -{ - cuda_cudart, - lib, - libcublas, -}: -finalAttrs: prevAttrs: { - buildInputs = - prevAttrs.buildInputs or [ ] - ++ [ (lib.getLib libcublas) ] - # For some reason, the 1.4.x release of cusparselt requires the cudart library. - ++ lib.optionals (lib.hasPrefix "1.4" finalAttrs.version) [ (lib.getLib cuda_cudart) ]; - meta = prevAttrs.meta or { } // { - description = "cuSPARSELt: A High-Performance CUDA Library for Sparse Matrix-Matrix Multiplication"; - homepage = "https://developer.nvidia.com/cusparselt-downloads"; - maintainers = prevAttrs.meta.maintainers or [ ] ++ [ lib.maintainers.sepiabrown ]; - teams = prevAttrs.meta.teams or [ ]; - license = lib.licenses.unfreeRedistributable // { - shortName = "cuSPARSELt EULA"; - fullName = "cuSPARSELt SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; - url = "https://docs.nvidia.com/cuda/cusparselt/license.html"; - }; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/libcutensor.nix b/pkgs/development/cuda-modules/_cuda/fixups/libcutensor.nix deleted file mode 100644 index 530e35af5635..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/libcutensor.nix +++ /dev/null @@ -1,23 +0,0 @@ -{ - cuda_cudart, - lib, - libcublas, -}: -finalAttrs: prevAttrs: { - buildInputs = - prevAttrs.buildInputs or [ ] - ++ [ (lib.getLib libcublas) ] - # For some reason, the 1.4.x release of cuTENSOR requires the cudart library. - ++ lib.optionals (lib.hasPrefix "1.4" finalAttrs.version) [ (lib.getLib cuda_cudart) ]; - meta = prevAttrs.meta or { } // { - description = "cuTENSOR: A High-Performance CUDA Library For Tensor Primitives"; - homepage = "https://developer.nvidia.com/cutensor"; - maintainers = prevAttrs.meta.maintainers or [ ] ++ [ lib.maintainers.obsidian-systems-maintenance ]; - teams = prevAttrs.meta.teams; - license = lib.licenses.unfreeRedistributable // { - shortName = "cuTENSOR EULA"; - fullName = "cuTENSOR SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; - url = "https://docs.nvidia.com/cuda/cutensor/license.html"; - }; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/nsight_compute.nix b/pkgs/development/cuda-modules/_cuda/fixups/nsight_compute.nix deleted file mode 100644 index bc7c5f1784db..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/nsight_compute.nix +++ /dev/null @@ -1,86 +0,0 @@ -{ - cudaAtLeast, - cudaMajorMinorVersion, - cudaOlder, - e2fsprogs, - elfutils, - flags, - gst_all_1, - lib, - libjpeg8, - qt6, - rdma-core, - stdenv, - ucx, -}: -prevAttrs: -let - qtwayland = lib.getLib qt6.qtwayland; - inherit (qt6) wrapQtAppsHook qtwebview; - archDir = - { - aarch64-linux = "linux-" + (if flags.isJetsonBuild then "v4l_l4t" else "desktop") + "-t210-a64"; - x86_64-linux = "linux-desktop-glibc_2_11_3-x64"; - } - .${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}"); -in -{ - outputs = [ "out" ]; # NOTE(@connorbaker): Force a single output so relative lookups work. - nativeBuildInputs = prevAttrs.nativeBuildInputs or [ ] ++ [ wrapQtAppsHook ]; - buildInputs = - prevAttrs.buildInputs or [ ] - ++ [ - qtwayland - qtwebview - qt6.qtwebengine - rdma-core - ] - ++ lib.optionals (cudaOlder "12.7") [ - e2fsprogs - ucx - ] - ++ lib.optionals (cudaMajorMinorVersion == "12.9") [ - elfutils - ]; - dontWrapQtApps = true; - preInstall = prevAttrs.preInstall or "" + '' - if [[ -d nsight-compute ]]; then - nixLog "Lifting components of Nsight Compute to the top level" - mv -v nsight-compute/*/* . - nixLog "Removing empty directories" - rmdir -pv nsight-compute/* - fi - - rm -rf host/${archDir}/Mesa/ - ''; - postInstall = - prevAttrs.postInstall or "" - + '' - moveToOutput 'ncu' "''${!outputBin}/bin" - moveToOutput 'ncu-ui' "''${!outputBin}/bin" - moveToOutput 'host/${archDir}' "''${!outputBin}/bin" - moveToOutput 'target/${archDir}' "''${!outputBin}/bin" - wrapQtApp "''${!outputBin}/bin/host/${archDir}/ncu-ui.bin" - '' - # NOTE(@connorbaker): No idea what this platform is or how to patchelf for it. - + lib.optionalString (flags.isJetsonBuild && cudaOlder "12.9") '' - nixLog "Removing QNX 700 target directory for Jetson builds" - rm -rfv "''${!outputBin}/target/qnx-700-t210-a64" - '' - + lib.optionalString (flags.isJetsonBuild && cudaAtLeast "12.8") '' - nixLog "Removing QNX 800 target directory for Jetson builds" - rm -rfv "''${!outputBin}/target/qnx-800-tegra-a64" - ''; - # lib needs libtiff.so.5, but nixpkgs provides libtiff.so.6 - preFixup = prevAttrs.preFixup or "" + '' - patchelf --replace-needed libtiff.so.5 libtiff.so "''${!outputBin}/bin/host/${archDir}/Plugins/imageformats/libqtiff.so" - ''; - autoPatchelfIgnoreMissingDeps = prevAttrs.autoPatchelfIgnoreMissingDeps or [ ] ++ [ - "libnvidia-ml.so.1" - ]; - # NOTE(@connorbaker): It might be a problem that when nsight_compute contains hosts and targets of different - # architectures, that we patchelf just the binaries matching the builder's platform; autoPatchelfHook prints - # messages like - # skipping [$out]/host/linux-desktop-glibc_2_11_3-x64/libQt6Core.so.6 because its architecture (x64) differs from - # target (AArch64) -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/nsight_systems.nix b/pkgs/development/cuda-modules/_cuda/fixups/nsight_systems.nix deleted file mode 100644 index 2967fa89470a..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/nsight_systems.nix +++ /dev/null @@ -1,136 +0,0 @@ -{ - boost178, - cuda_cudart, - cudaAtLeast, - e2fsprogs, - gst_all_1, - lib, - nss, - numactl, - pulseaudio, - qt6, - rdma-core, - stdenv, - ucx, - wayland, - xorg, -}: -prevAttrs: -let - qtwayland = lib.getLib qt6.qtwayland; - qtWaylandPlugins = "${qtwayland}/${qt6.qtbase.qtPluginPrefix}"; - # NOTE(@connorbaker): nsight_systems doesn't support Jetson, so no need for case splitting on aarch64-linux. - hostDir = - { - aarch64-linux = "host-linux-armv8"; - x86_64-linux = "host-linux-x64"; - } - .${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}"); - targetDir = - { - aarch64-linux = "target-linux-sbsa-armv8"; - x86_64-linux = "target-linux-x64"; - } - .${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}"); -in -{ - outputs = [ "out" ]; # NOTE(@connorbaker): Force a single output so relative lookups work. - - # An ad hoc replacement for - # https://github.com/ConnorBaker/cuda-redist-find-features/issues/11 - env = prevAttrs.env or { } // { - rmPatterns = - prevAttrs.env.rmPatterns or "" - + toString [ - "${hostDir}/lib{arrow,jpeg}*" - "${hostDir}/lib{ssl,ssh,crypto}*" - "${hostDir}/libboost*" - "${hostDir}/libexec" - "${hostDir}/libstdc*" - "${hostDir}/python/bin/python" - "${hostDir}/Mesa" - ]; - }; - - # NOTE(@connorbaker): nsight-exporter and nsight-sys are deprecated scripts wrapping nsys, it's fine to remove them. - prePatch = prevAttrs.prePatch or "" + '' - if [[ -d bin ]]; then - nixLog "Removing bin wrapper scripts" - for knownWrapper in bin/{nsys{,-ui},nsight-{exporter,sys}}; do - [[ -e $knownWrapper ]] && rm -v "$knownWrapper" - done - unset -v knownWrapper - - nixLog "Removing empty bin directory" - rmdir -v bin - fi - - if [[ -d nsight-systems ]]; then - nixLog "Lifting components of Nsight System to the top level" - mv -v nsight-systems/*/* . - nixLog "Removing empty nsight-systems directory" - rmdir -pv nsight-systems/* - fi - ''; - - postPatch = prevAttrs.postPatch or "" + '' - for path in $rmPatterns; do - rm -r "$path" - done - patchShebangs nsight-systems - ''; - - nativeBuildInputs = prevAttrs.nativeBuildInputs or [ ] ++ [ qt6.wrapQtAppsHook ]; - - dontWrapQtApps = true; - - buildInputs = - prevAttrs.buildInputs or [ ] - ++ [ - qt6.qtdeclarative - qt6.qtsvg - qt6.qtimageformats - qt6.qtpositioning - qt6.qtscxml - qt6.qttools - qt6.qtwebengine - qt6.qtwayland - boost178 - cuda_cudart.stubs - e2fsprogs - gst_all_1.gst-plugins-base - gst_all_1.gstreamer - nss - numactl - pulseaudio - qt6.qtbase - qtWaylandPlugins - rdma-core - ucx - wayland - xorg.libXcursor - xorg.libXdamage - xorg.libXrandr - xorg.libXtst - ] - # NOTE(@connorbaker): Seems to be required only for aarch64-linux. - ++ lib.optionals stdenv.hostPlatform.isAarch64 [ - gst_all_1.gst-plugins-bad - ]; - - postInstall = prevAttrs.postInstall or "" + '' - moveToOutput '${hostDir}' "''${!outputBin}" - moveToOutput '${targetDir}' "''${!outputBin}" - moveToOutput 'bin' "''${!outputBin}" - wrapQtApp "''${!outputBin}/${hostDir}/nsys-ui.bin" - ''; - - # lib needs libtiff.so.5, but nixpkgs provides libtiff.so.6 - preFixup = prevAttrs.preFixup or "" + '' - patchelf --replace-needed libtiff.so.5 libtiff.so "''${!outputBin}/${hostDir}/Plugins/imageformats/libqtiff.so" - ''; - - autoPatchelfIgnoreMissingDeps = prevAttrs.autoPatchelfIgnoreMissingDeps or [ ] ++ [ - "libnvidia-ml.so.1" - ]; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/nvidia_driver.nix b/pkgs/development/cuda-modules/_cuda/fixups/nvidia_driver.nix deleted file mode 100644 index e9c50b2f4eaf..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/nvidia_driver.nix +++ /dev/null @@ -1,5 +0,0 @@ -_: prevAttrs: { - badPlatformsConditions = prevAttrs.badPlatformsConditions or { } // { - "Package is not supported; use drivers from linuxPackages" = true; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/fixups/tensorrt.nix b/pkgs/development/cuda-modules/_cuda/fixups/tensorrt.nix deleted file mode 100644 index 49d1018ab305..000000000000 --- a/pkgs/development/cuda-modules/_cuda/fixups/tensorrt.nix +++ /dev/null @@ -1,127 +0,0 @@ -{ - _cuda, - cudaOlder, - cudaPackages, - cudaMajorMinorVersion, - lib, - patchelf, - requireFile, - stdenv, -}: -let - inherit (lib) - attrsets - maintainers - meta - strings - versions - ; - inherit (stdenv) hostPlatform; - # targetArch :: String - targetArch = attrsets.attrByPath [ hostPlatform.system ] "unsupported" { - x86_64-linux = "x86_64-linux-gnu"; - aarch64-linux = "aarch64-linux-gnu"; - }; -in -finalAttrs: prevAttrs: { - # Useful for inspecting why something went wrong. - brokenConditions = - let - cudaTooOld = cudaOlder finalAttrs.passthru.featureRelease.minCudaVersion; - cudaTooNew = - (finalAttrs.passthru.featureRelease.maxCudaVersion != null) - && strings.versionOlder finalAttrs.passthru.featureRelease.maxCudaVersion cudaMajorMinorVersion; - cudnnVersionIsSpecified = finalAttrs.passthru.featureRelease.cudnnVersion != null; - cudnnVersionSpecified = versions.majorMinor finalAttrs.passthru.featureRelease.cudnnVersion; - cudnnVersionProvided = versions.majorMinor finalAttrs.passthru.cudnn.version; - cudnnTooOld = - cudnnVersionIsSpecified && (strings.versionOlder cudnnVersionProvided cudnnVersionSpecified); - cudnnTooNew = - cudnnVersionIsSpecified && (strings.versionOlder cudnnVersionSpecified cudnnVersionProvided); - in - prevAttrs.brokenConditions or { } - // { - "CUDA version is too old" = cudaTooOld; - "CUDA version is too new" = cudaTooNew; - "CUDNN version is too old" = cudnnTooOld; - "CUDNN version is too new" = cudnnTooNew; - }; - - src = requireFile { - name = finalAttrs.passthru.redistribRelease.filename; - inherit (finalAttrs.passthru.redistribRelease) hash; - message = '' - To use the TensorRT derivation, you must join the NVIDIA Developer Program and - download the ${finalAttrs.version} TAR package for CUDA ${cudaMajorMinorVersion} from - ${finalAttrs.meta.homepage}. - - Once you have downloaded the file, add it to the store with the following - command, and try building this derivation again. - - $ nix-store --add-fixed sha256 ${finalAttrs.passthru.redistribRelease.filename} - ''; - }; - - # We need to look inside the extracted output to get the files we need. - sourceRoot = "TensorRT-${finalAttrs.version}"; - - buildInputs = prevAttrs.buildInputs or [ ] ++ [ (finalAttrs.passthru.cudnn.lib or null) ]; - - preInstall = - prevAttrs.preInstall or "" - + strings.optionalString (targetArch != "unsupported") '' - # Replace symlinks to bin and lib with the actual directories from targets. - for dir in bin lib; do - rm "$dir" - mv "targets/${targetArch}/$dir" "$dir" - done - - # Remove broken symlinks - for dir in include samples; do - rm "targets/${targetArch}/$dir" || : - done - ''; - - # Tell autoPatchelf about runtime dependencies. - postFixup = - let - versionTriple = "${versions.majorMinor finalAttrs.version}.${versions.patch finalAttrs.version}"; - in - prevAttrs.postFixup or "" - + '' - ${meta.getExe' patchelf "patchelf"} --add-needed libnvinfer.so \ - "$lib/lib/libnvinfer.so.${versionTriple}" \ - "$lib/lib/libnvinfer_plugin.so.${versionTriple}" \ - "$lib/lib/libnvinfer_builder_resource.so.${versionTriple}" - ''; - - passthru = prevAttrs.passthru or { } // { - # The CUDNN used with TensorRT. - # If null, the default cudnn derivation will be used. - # If a version is specified, the cudnn derivation with that version will be used, - # unless it is not available, in which case the default cudnn derivation will be used. - cudnn = - let - desiredName = _cuda.lib.mkVersionedName "cudnn" ( - lib.versions.majorMinor finalAttrs.passthru.featureRelease.cudnnVersion - ); - in - if finalAttrs.passthru.featureRelease.cudnnVersion == null || (cudaPackages ? desiredName) then - cudaPackages.cudnn - else - cudaPackages.${desiredName}; - }; - - meta = prevAttrs.meta or { } // { - badPlatforms = - prevAttrs.meta.badPlatforms or [ ] - ++ lib.optionals (targetArch == "unsupported") [ hostPlatform.system ]; - homepage = "https://developer.nvidia.com/tensorrt"; - teams = prevAttrs.meta.teams or [ ]; - - # Building TensorRT on Hydra is impossible because of the non-redistributable - # license and because the source needs to be manually downloaded from the - # NVIDIA Developer Program (see requireFile above). - hydraPlatforms = lib.platforms.none; - }; -} diff --git a/pkgs/development/cuda-modules/_cuda/lib/cuda.nix b/pkgs/development/cuda-modules/_cuda/lib/cuda.nix index 16f99e57709a..09cf9c588f4a 100644 --- a/pkgs/development/cuda-modules/_cuda/lib/cuda.nix +++ b/pkgs/development/cuda-modules/_cuda/lib/cuda.nix @@ -1,4 +1,4 @@ -{ lib }: +{ _cuda, lib }: { /** Returns whether a capability should be built by default for a particular CUDA version. @@ -114,16 +114,14 @@ ``` */ allowUnfreeCudaPredicate = - package: - lib.all ( - license: - license.free - || lib.elem license.shortName [ - "CUDA EULA" - "cuDNN EULA" - "cuSPARSELt EULA" - "cuTENSOR EULA" - "NVidia OptiX EULA" + let + cudaLicenseNames = [ + lib.licenses.nvidiaCuda.shortName ] - ) (lib.toList package.meta.license); + ++ lib.map (license: license.shortName) (lib.attrValues _cuda.lib.licenses); + in + package: + lib.all (license: license.free || lib.elem (license.shortName or null) cudaLicenseNames) ( + lib.toList package.meta.license + ); } diff --git a/pkgs/development/cuda-modules/_cuda/lib/default.nix b/pkgs/development/cuda-modules/_cuda/lib/default.nix index b2fe9838de61..376abcd27f7b 100644 --- a/pkgs/development/cuda-modules/_cuda/lib/default.nix +++ b/pkgs/development/cuda-modules/_cuda/lib/default.nix @@ -11,13 +11,16 @@ ; # See ./cuda.nix for documentation. - inherit (import ./cuda.nix { inherit lib; }) + inherit (import ./cuda.nix { inherit _cuda lib; }) _cudaCapabilityIsDefault _cudaCapabilityIsSupported _mkCudaVariant allowUnfreeCudaPredicate ; + # See ./licenses.nix for documentation. + licenses = import ./licenses.nix; + # See ./meta.nix for documentation. inherit (import ./meta.nix { inherit _cuda lib; }) _mkMetaBadPlatforms @@ -30,6 +33,7 @@ getNixSystems getRedistSystem mkRedistUrl + selectManifests ; # See ./strings.nix for documentation. diff --git a/pkgs/development/cuda-modules/_cuda/lib/licenses.nix b/pkgs/development/cuda-modules/_cuda/lib/licenses.nix new file mode 100644 index 000000000000..68b5ec7cc32a --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/lib/licenses.nix @@ -0,0 +1,55 @@ +{ + cudnn = { + shortName = "cuDNN EULA"; + fullName = "cuDNN SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; + url = "https://docs.nvidia.com/deeplearning/cudnn/backend/latest/reference/eula.html"; + free = false; + redistributable = false; + }; + + cusparse_lt = { + shortName = "cuSPARSELt EULA"; + fullName = "cuSPARSELt SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; + url = "https://docs.nvidia.com/cuda/cusparselt/license.html"; + free = false; + redistributable = false; + }; + + cutensor = { + shortName = "cuTENSOR EULA"; + fullName = "cuTENSOR SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; + url = "https://docs.nvidia.com/cuda/cutensor/latest/license.html"; + free = false; + redistributable = false; + }; + + tensorrt = { + shortName = "TensorRT EULA"; + fullName = "TensorRT SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS"; + url = "https://docs.nvidia.com/deeplearning/tensorrt/latest/reference/sla.html"; + free = false; + redistributable = false; + }; + + math_sdk_sla = { + shortName = "NVIDIA Math SDK SLA"; + fullName = "LICENSE AGREEMENT FOR NVIDIA MATH LIBRARIES SOFTWARE DEVELOPMENT KITS"; + url = "https://developer.download.nvidia.com/compute/mathdx/License.txt"; + free = false; + redistributable = false; + }; + + # "license": "CUDA Toolkit", + # "license": "NVIDIA Driver", + # "license": "NVIDIA Proprietary", + # "license": "NVIDIA", + # "license": "NVIDIA SLA", + # "license": "cuDSS library", + # "license": "cuQuantum", + # "license": "libcusolvermp library", + # "license": "NPP PLUS library", + # "license": "nvCOMP library", + # "license": "nvJPEG 2K", + # "license": "NVPL", + # "license": "nvTIFF", +} diff --git a/pkgs/development/cuda-modules/_cuda/lib/meta.nix b/pkgs/development/cuda-modules/_cuda/lib/meta.nix index 72f71973b0cd..7adc36474935 100644 --- a/pkgs/development/cuda-modules/_cuda/lib/meta.nix +++ b/pkgs/development/cuda-modules/_cuda/lib/meta.nix @@ -2,7 +2,7 @@ { /** Returns a list of bad platforms for a given package if assertsions in `finalAttrs.passthru.platformAssertions` - fail, optionally logging evaluation warnings for each reason. + fail, optionally logging evaluation warnings with `builtins.traceVerbose` for each reason. NOTE: No guarantees are made about this function's stability. You may use it at your own risk. @@ -12,31 +12,39 @@ # Type ``` - _mkMetaBadPlatforms :: (warn :: Bool) -> (finalAttrs :: AttrSet) -> List String + _mkMetaBadPlatforms :: (finalAttrs :: AttrSet) -> List String ``` + + # Inputs + + `finalAttrs` + + : The final attributes of the package */ _mkMetaBadPlatforms = - warn: finalAttrs: + finalAttrs: let failedAssertionsString = _cuda.lib._mkFailedAssertionsString finalAttrs.passthru.platformAssertions; hasFailedAssertions = failedAssertionsString != ""; finalStdenv = finalAttrs.finalPackage.stdenv; - in - lib.warnIf (warn && hasFailedAssertions) - "Package ${finalAttrs.finalPackage.name} is unsupported on this platform due to the following failed assertions:${failedAssertionsString}" - ( - lib.optionals hasFailedAssertions ( - lib.unique [ - finalStdenv.buildPlatform.system - finalStdenv.hostPlatform.system - finalStdenv.targetPlatform.system - ] - ) + badPlatforms = lib.optionals hasFailedAssertions ( + lib.unique [ + finalStdenv.buildPlatform.system + finalStdenv.hostPlatform.system + finalStdenv.targetPlatform.system + ] ); + handle = + if hasFailedAssertions then + builtins.traceVerbose "Package ${finalAttrs.finalPackage.name} is unsupported on this platform due to the following failed assertions:${failedAssertionsString}" + else + lib.id; + in + handle badPlatforms; /** Returns a boolean indicating whether the package is broken as a result of `finalAttrs.passthru.brokenAssertions`, - optionally logging evaluation warnings for each reason. + optionally logging evaluation warnings with `builtins.traceVerbose` for each reason. NOTE: No guarantees are made about this function's stability. You may use it at your own risk. @@ -46,26 +54,25 @@ # Type ``` - _mkMetaBroken :: (warn :: Bool) -> (finalAttrs :: AttrSet) -> Bool + _mkMetaBroken :: (finalAttrs :: AttrSet) -> Bool ``` # Inputs - `warn` - - : A boolean indicating whether to log warnings - `finalAttrs` : The final attributes of the package */ _mkMetaBroken = - warn: finalAttrs: + finalAttrs: let failedAssertionsString = _cuda.lib._mkFailedAssertionsString finalAttrs.passthru.brokenAssertions; hasFailedAssertions = failedAssertionsString != ""; + handle = + if hasFailedAssertions then + builtins.traceVerbose "Package ${finalAttrs.finalPackage.name} is marked as broken due to the following failed assertions:${failedAssertionsString}" + else + lib.id; in - lib.warnIf (warn && hasFailedAssertions) - "Package ${finalAttrs.finalPackage.name} is marked as broken due to the following failed assertions:${failedAssertionsString}" - hasFailedAssertions; + handle hasFailedAssertions; } diff --git a/pkgs/development/cuda-modules/_cuda/lib/redist.nix b/pkgs/development/cuda-modules/_cuda/lib/redist.nix index a7053dc582c4..3138097c1694 100644 --- a/pkgs/development/cuda-modules/_cuda/lib/redist.nix +++ b/pkgs/development/cuda-modules/_cuda/lib/redist.nix @@ -111,26 +111,39 @@ /** Maps a Nix system to a NVIDIA redistributable system. - NOTE: We swap out the default `linux-sbsa` redist (for server-grade ARM chips) with the `linux-aarch64` redist - (which is for Jetson devices) if we're building any Jetson devices. Since both are based on aarch64, we can only - have one or the other, otherwise there's an ambiguity as to which should be used. + NOTE: Certain Nix systems can map to multiple NVIDIA redistributable systems. In particular, ARM systems can map to + either `linux-sbsa` (for server-grade ARM chips) or `linux-aarch64` (for Jetson devices). Complicating matters + further, as of CUDA 13.0, Jetson Thor devices use `linux-sbsa` instead of `linux-aarch64`. (It is unknown whether + NVIDIA plans to make the Orin series use `linux-sbsa` as well for the CUDA 13.0 release.) NOTE: This function *will* be called by unsupported systems because `cudaPackages` is evaluated on all systems. As such, we need to handle unsupported systems gracefully. + NOTE: This function does not check whether the provided CUDA capabilities are valid for the given CUDA version. + The heavy validation work to ensure consistency of CUDA capabilities is performed by backendStdenv. + # Type ``` - getRedistSystem :: (hasJetsonCudaCapability :: Bool) -> (nixSystem :: String) -> String + getRedistSystem :: + { cudaCapabilities :: List String + , cudaMajorMinorVersion :: String + , system :: String + } + -> String ``` # Inputs - `hasJetsonCudaCapability` + `cudaCapabilities` - : If configured for a Jetson device + : The list of CUDA capabilities to build GPU code for - `nixSystem` + `cudaMajorMinorVersion` + + : The major and minor version of CUDA (e.g. "12.6") + + `system` : The Nix system @@ -140,22 +153,53 @@ ## `cudaLib.getRedistSystem` usage examples ```nix - getRedistSystem true "aarch64-linux" + getRedistSystem { + cudaCapabilities = [ "8.7" ]; + cudaMajorMinorVersion = "12.6"; + system = "aarch64-linux"; + } => "linux-aarch64" ``` ```nix - getRedistSystem false "aarch64-linux" + getRedistSystem { + cudaCapabilities = [ "11.0" ]; + cudaMajorMinorVersion = "13.0"; + system = "aarch64-linux"; + } + => "linux-sbsa" + ``` + + ```nix + getRedistSystem { + cudaCapabilities = [ "8.0" "8.9" ]; + cudaMajorMinorVersion = "12.6"; + system = "aarch64-linux"; + } => "linux-sbsa" ``` ::: */ getRedistSystem = - hasJetsonCudaCapability: nixSystem: - if nixSystem == "x86_64-linux" then + { + cudaCapabilities, + cudaMajorMinorVersion, + system, + }: + if system == "x86_64-linux" then "linux-x86_64" - else if nixSystem == "aarch64-linux" then - if hasJetsonCudaCapability then "linux-aarch64" else "linux-sbsa" + else if system == "aarch64-linux" then + # If all the Jetson devices are at least 10.1 (Thor, CUDA 12.9; CUDA 13.0 and later use 11.0 for Thor), then + # we've got SBSA. + if + lib.all ( + cap: _cuda.db.cudaCapabilityToInfo.${cap}.isJetson -> lib.versionAtLeast cap "10.1" + ) cudaCapabilities + then + "linux-sbsa" + # Otherwise we've got some Jetson devices older than Thor and need to use linux-aarch64. + else + "linux-aarch64" else "unsupported"; @@ -193,4 +237,34 @@ ) ++ [ relativePath ] ); + + /** + Function which accepts an attribute set mapping redistributable name to version and retrieves the corresponding + collection of manifests from `_cuda.manifests`. Additionally, the version provided is used to populate the + `release_label` field in the corresponding manifest if it is missing. + + It is an error to provide a redistributable name and version for which there is no corresponding manifest. + + # Type + + ``` + selectManifests :: (versions :: AttrSet RedistName Version) -> AttrSet RedistName Manifest + ``` + + # Inputs + + `versions` + + : An attribute set mapping redistributable name to manifest version + */ + selectManifests = lib.mapAttrs ( + name: version: + let + manifest = _cuda.manifests.${name}.${version}; + in + manifest + // { + release_label = manifest.release_label or version; + } + ); } diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/README.md new file mode 100644 index 000000000000..de9d7fcd41c2 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/README.md @@ -0,0 +1,5 @@ +# cublasmp + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/redistrib_0.6.0.json b/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/redistrib_0.6.0.json new file mode 100644 index 000000000000..f3c90fe91791 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cublasmp/redistrib_0.6.0.json @@ -0,0 +1,43 @@ +{ + "release_date": "2025-09-09", + "release_label": "0.6.0", + "release_product": "cublasmp", + "libcublasmp": { + "name": "NVIDIA cuBLASMp library", + "license": "cuBLASMp library", + "license_path": "libcublasmp/LICENSE.txt", + "version": "0.6.0.84", + "linux-x86_64": { + "cuda12": { + "relative_path": "libcublasmp/linux-x86_64/libcublasmp-linux-x86_64-0.6.0.84_cuda12-archive.tar.xz", + "sha256": "214a439031cc53be7d02961651e5e6ee520d80ab09b772d5a470e678477a6c57", + "md5": "2a6a91fd58b90a16a1c2b3c3e4d2bdce", + "size": "4324732" + }, + "cuda13": { + "relative_path": "libcublasmp/linux-x86_64/libcublasmp-linux-x86_64-0.6.0.84_cuda13-archive.tar.xz", + "sha256": "f3892486ac72649ab5e140fd1466421e5638ce23a56a5360a42f32450fcfbf83", + "md5": "b3f96dce5e52f432a36e0a6a006f6b27", + "size": "4815848" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "libcublasmp/linux-sbsa/libcublasmp-linux-sbsa-0.6.0.84_cuda12-archive.tar.xz", + "sha256": "6af07f02ed01eee761509ad5c733a7196520f09ce036d5d047f38a1768287080", + "md5": "f6efeba7b2e1ae8b164a69f208c5a53b", + "size": "4273376" + }, + "cuda13": { + "relative_path": "libcublasmp/linux-sbsa/libcublasmp-linux-sbsa-0.6.0.84_cuda13-archive.tar.xz", + "sha256": "9c3ea75c2a2705cb415d37316a6f540dbeb021ac3dc7bf0404dac314eb098aa0", + "md5": "35bac35e00eb29a86e54bb4fb703d258", + "size": "4751836" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cuda/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cuda/README.md new file mode 100644 index 000000000000..3a5eb56b6f9f --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cuda/README.md @@ -0,0 +1,5 @@ +# cuda + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/cuda/manifests/redistrib_12.6.3.json b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.6.3.json similarity index 100% rename from pkgs/development/cuda-modules/cuda/manifests/redistrib_12.6.3.json rename to pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.6.3.json diff --git a/pkgs/development/cuda-modules/cuda/manifests/redistrib_12.8.1.json b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.8.1.json similarity index 100% rename from pkgs/development/cuda-modules/cuda/manifests/redistrib_12.8.1.json rename to pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.8.1.json diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.9.1.json b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.9.1.json new file mode 100644 index 000000000000..835340899e33 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_12.9.1.json @@ -0,0 +1,1151 @@ +{ + "release_date": "2025-06-05", + "release_label": "12.9.1", + "release_product": "cuda", + "collectx_bringup": { + "name": "UFM telemetry CollectX Bringup", + "license": "NVIDIA Proprietary", + "license_path": "collectx_bringup/LICENSE.txt", + "version": "1.19.13", + "linux-x86_64": { + "relative_path": "collectx_bringup/linux-x86_64/collectx_bringup-linux-x86_64-1.19.13-archive.tar.xz", + "sha256": "4965fe096fca645a6d4565fd4d12366ae0ec31ec54ca20274910f34eea74b41a", + "md5": "d48b8c177f312c8774c54988594f725c", + "size": "125307508" + }, + "linux-sbsa": { + "relative_path": "collectx_bringup/linux-sbsa/collectx_bringup-linux-sbsa-1.19.13-archive.tar.xz", + "sha256": "5d716fbb80ef7b9ac89f9e3fa8b900a29d4e6c0be487420dc4ee7a05340b57a9", + "md5": "dc2c0bfedf790ba7dc21f684510e592e", + "size": "120696772" + } + }, + "cuda_cccl": { + "name": "CXX Core Compute Libraries", + "license": "CUDA Toolkit", + "license_path": "cuda_cccl/LICENSE.txt", + "version": "12.9.27", + "linux-x86_64": { + "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.9.27-archive.tar.xz", + "sha256": "8b1a5095669e94f2f9afd7715533314d418179e9452be61e2fde4c82a3e542aa", + "md5": "59e3cb66aeb96423dcca73218c85bc02", + "size": "997888" + }, + "linux-sbsa": { + "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.9.27-archive.tar.xz", + "sha256": "8c3da24801b500f1d9217d191bb4b63e5d2096c8e7d0b7695e876853180ba82f", + "md5": "b39d03cfac57a3b2ded8e9b0a6b0e782", + "size": "997840" + }, + "windows-x86_64": { + "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.9.27-archive.zip", + "sha256": "17aaa7c6b8f94a417d8f3261780b7e34b9cbdfab7513bce86768623b06aa28b5", + "md5": "afdfa89a35951f67b5bd70c513f5ef09", + "size": "3127658" + }, + "linux-aarch64": { + "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-12.9.27-archive.tar.xz", + "sha256": "8c87c2db67130108861609eacd40d30ee109656a7765e5172eab71dd6da4c453", + "md5": "25b1a257ed35393052577bd9ee432d3f", + "size": "998228" + } + }, + "cuda_compat": { + "name": "CUDA compat L4T", + "license": "CUDA Toolkit", + "license_path": "cuda_compat/LICENSE.txt", + "version": "12.9.40580548", + "linux-aarch64": { + "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-12.9.40580548-archive.tar.xz", + "sha256": "c03fe18b9d23881f068ac97b45001a47778f83d2361728427a3f92b551b1c898", + "md5": "3ca26403b8b36c5cc18104ee174ec874", + "size": "37422044" + } + }, + "cuda_cudart": { + "name": "CUDA Runtime (cudart)", + "license": "CUDA Toolkit", + "license_path": "cuda_cudart/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "1f6ad42d4f530b24bfa35894ccf6b7209d2354f59101fd62ec4a6192a184ce99", + "md5": "6153e2b6a43389e5be3d68b04c6488f5", + "size": "1514676" + }, + "linux-sbsa": { + "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "8b422a3b2cb8452cb678181b0bf9d7aa7342df168b5319c5488ae3b8514101fc", + "md5": "c4b3e0d206f5dc3aceaddb78a32424d3", + "size": "1521596" + }, + "windows-x86_64": { + "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.9.79-archive.zip", + "sha256": "179e9c43b0735ffe67207b3da556eb5a0c50f3047961882b7657d3b822d34ef8", + "md5": "22e500ce68dc9e099ec18f57e1309808", + "size": "3521238" + }, + "linux-aarch64": { + "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "f893e2c72be81b0d0e3bc33827c785a96db15fd5aafdc51cc187f3df6fdbb657", + "md5": "8970e9d40a7edada8cd9270906b1daa3", + "size": "1223440" + } + }, + "cuda_cuobjdump": { + "name": "cuobjdump", + "license": "CUDA Toolkit", + "license_path": "cuda_cuobjdump/LICENSE.txt", + "version": "12.9.82", + "linux-x86_64": { + "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.9.82-archive.tar.xz", + "sha256": "ee0de40e8c18068bfcc53e73510e7e7a1a80555205347940df67fa525d24452f", + "md5": "fb4ceb446f3ca58c4ca5381a2c0eee06", + "size": "214896" + }, + "linux-sbsa": { + "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.9.82-archive.tar.xz", + "sha256": "2d39ae9309f81a7980df296a93c0e49215c6fb22d316fd9daae211d29a731d27", + "md5": "9ec739cea851b184b55017d0a6185304", + "size": "208936" + }, + "windows-x86_64": { + "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.9.82-archive.zip", + "sha256": "1eda43a76a2eac25fce5bdb4b68673b5bda737d54cca5513148c36362ab7c811", + "md5": "0a1c8b1f69537bc605c0d5fc28110258", + "size": "6219088" + }, + "linux-aarch64": { + "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-12.9.82-archive.tar.xz", + "sha256": "91a9ae2935b411d136c2c61ccbbc0df3a83f17cce122d12d262be202217163ee", + "md5": "ec5905b13be30f8f39e18d1f41dbcf18", + "size": "197604" + } + }, + "cuda_cupti": { + "name": "CUPTI", + "license": "CUDA Toolkit", + "license_path": "cuda_cupti/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "f779a24e8f0177b4ce45cbf118cb470139fb5107858df96689d0a0aa01f0fba1", + "md5": "5fe49729261d1f899bd0948026b755ae", + "size": "16799436" + }, + "linux-sbsa": { + "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "84f8657375c23a425b2d107c3cde1ce75777bff9798b744b78e146fdc02d2de0", + "md5": "ff4c04b183cc173aa2937a21a3569b5b", + "size": "12805704" + }, + "windows-x86_64": { + "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.9.79-archive.zip", + "sha256": "c96018456dc4db6af6d69d6db0170a2ccc656ddde8c8ce6ee05682c2c5569daa", + "md5": "1cecfef05160d4e6b0f2549534fe7973", + "size": "13359912" + }, + "linux-aarch64": { + "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "74a884691b2c7e5c8db8bd2a38143fc82f7502f0dd484051809df7953f7ae719", + "md5": "7f92adb9aed6fdb047ebe3c7617c7179", + "size": "4781260" + } + }, + "cuda_cuxxfilt": { + "name": "CUDA cuxxfilt (demangler)", + "license": "CUDA Toolkit", + "license_path": "cuda_cuxxfilt/LICENSE.txt", + "version": "12.9.82", + "linux-x86_64": { + "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.9.82-archive.tar.xz", + "sha256": "833d7e56351d032717f217212577d369d230e284b2ded4bf151403cc11213add", + "md5": "a7f4a446e4fb00657f5bd7eb1dd814a7", + "size": "188692" + }, + "linux-sbsa": { + "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.9.82-archive.tar.xz", + "sha256": "2175ef96b523eb8fea5d6ccfd21b70d6afaee623d00dbab70f11e8aa892c2828", + "md5": "fde8b2db7d7e4afb08e7c703fa735440", + "size": "177440" + }, + "windows-x86_64": { + "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.9.82-archive.zip", + "sha256": "ec5911d680394d90968c480c7359e7f5a4025b9c4806dad673d489e57585afd3", + "md5": "537cd82a0945fe20275d4791e353c3f5", + "size": "178570" + }, + "linux-aarch64": { + "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-12.9.82-archive.tar.xz", + "sha256": "37acae6576874c3781e844ea268a9fe076d13aaab3acda6f65bbe885a3726a3c", + "md5": "c8e23bff8cc13fb58a57c90d69e7b374", + "size": "170436" + } + }, + "cuda_demo_suite": { + "name": "CUDA Demo Suite", + "license": "CUDA Toolkit", + "license_path": "cuda_demo_suite/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "92e0b324bf02d9705b8dd5bf1d36149c06512c720ceda7cc7d791fc3ecf64f0e", + "md5": "5030cddcab7101704bb8a9b53c6137ad", + "size": "4036604" + }, + "windows-x86_64": { + "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.9.79-archive.zip", + "sha256": "adffd0b0f7cca262025f171dcaa73f62af020de5d9a0d6e0fbe7dbd827dd77a8", + "md5": "9a8c3bbd696392e768ae3278e269cbd9", + "size": "5164004" + } + }, + "cuda_documentation": { + "name": "CUDA Documentation", + "license": "CUDA Toolkit", + "license_path": "cuda_documentation/LICENSE.txt", + "version": "12.9.88", + "linux-x86_64": { + "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.9.88-archive.tar.xz", + "sha256": "d6e44c454654016a3650f3101688231ba111cd00647b726b34d18ff0bd721933", + "md5": "17436d82e589824bbf3f4ff669201d81", + "size": "67920" + }, + "linux-sbsa": { + "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.9.88-archive.tar.xz", + "sha256": "e1c47f32279a827baf8b4339c1737d7bd8e54c73388835e5fae3e2db83db2479", + "md5": "995f5692be016e44821fb85ebc3a62d9", + "size": "67924" + }, + "windows-x86_64": { + "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.9.88-archive.zip", + "sha256": "660f2f71b94c13a021850a8bb6227dfb4eb9a8dd8e0f6bc9feb0b993dea180fd", + "md5": "3d21d1b9056629557bb2745f962af636", + "size": "107626" + }, + "linux-aarch64": { + "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-12.9.88-archive.tar.xz", + "sha256": "830476a755f9a8c9780a6876d0ed562c073f29968c3e0e91962d0fd14b3f3618", + "md5": "098d318ebb7700a6513e57e41edf20c8", + "size": "67948" + } + }, + "cuda_gdb": { + "name": "CUDA GDB", + "license": "CUDA Toolkit", + "license_path": "cuda_gdb/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "3dbb657683cd4f2989c30bdad31b3f4493795a9acc8a2214f48df3cfca7c37c0", + "md5": "1405f9cf4a5d2c03785a69aefa05de16", + "size": "67691620" + }, + "linux-sbsa": { + "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "251b9bd86ffcce0cdc4a5480ef3d8d609ca3a276cbbb5c793ca9978721d31faf", + "md5": "b76ab824a5b651ecec31978e6e2f41bf", + "size": "45695592" + }, + "linux-aarch64": { + "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "5473c27f1ec03fe064a09399e52b251e6ca5d3b9a67f21c1a26a02a26102f165", + "md5": "95325479bec751d72d4f063d8d244049", + "size": "45662012" + } + }, + "cuda_nsight": { + "name": "Nsight Eclipse Edition Plugin", + "license": "CUDA Toolkit", + "license_path": "cuda_nsight/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "5c3994440ce7aa6ac5ab120e45f25f5f5eaa631af0f793fab860a5edbc499518", + "md5": "3bce6195222da1c1d549fbd2d83422e8", + "size": "118693300" + } + }, + "cuda_nvcc": { + "name": "CUDA NVCC", + "license": "CUDA Toolkit", + "license_path": "cuda_nvcc/LICENSE.txt", + "version": "12.9.86", + "linux-x86_64": { + "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.9.86-archive.tar.xz", + "sha256": "7a1a5b652e5ef85c82b721d10672fc9a2dbaab44e9bd3c65a69517bf53998c35", + "md5": "ac1871c955070267e117bd985f6dbb36", + "size": "81100244" + }, + "linux-sbsa": { + "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.9.86-archive.tar.xz", + "sha256": "0aa1fce92dbae76c059c27eefb9d0ffb58e1291151e44ff7c7f1fc2dd9376c0d", + "md5": "1322a14e4d6482f69d4b8a14a7d5f4c5", + "size": "73407012" + }, + "windows-x86_64": { + "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.9.86-archive.zip", + "sha256": "227b109663b5e57d2718bcabb24a4ba0d9d4e52d958e327dc476f7c28691be85", + "md5": "ff9b2942aaa3a1dfb487da6767bc689f", + "size": "126917884" + }, + "linux-aarch64": { + "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-12.9.86-archive.tar.xz", + "sha256": "2432ef8a7c12d0a9ce3332a8af42b123c07f256390b3390802b1b2c6254c6c74", + "md5": "f846e79e53be949484a4968880eb9dd9", + "size": "77162776" + } + }, + "cuda_nvdisasm": { + "name": "CUDA nvdisasm", + "license": "CUDA Toolkit", + "license_path": "cuda_nvdisasm/LICENSE.txt", + "version": "12.9.88", + "linux-x86_64": { + "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.9.88-archive.tar.xz", + "sha256": "49296dd550e05434185a8588ec639f1325b2de413e2321ddd7e56c5182a476ff", + "md5": "87ec016e430618bf724a3e8332bfcca6", + "size": "5483340" + }, + "linux-sbsa": { + "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.9.88-archive.tar.xz", + "sha256": "28b2597f0901cfafcd050cba0877c1eb5edcd7ebd8164aea356cec832e636ee3", + "md5": "0d6f0b8883e55ca07d64cbb746b80e8c", + "size": "5408212" + }, + "windows-x86_64": { + "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.9.88-archive.zip", + "sha256": "955ba1f52f7115031f10408ce3cec4c745df41dba8fdf6024c3983d899e9fbbc", + "md5": "43cd76e59014be18d96ce03e2ed09d6b", + "size": "5791897" + }, + "linux-aarch64": { + "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-12.9.88-archive.tar.xz", + "sha256": "99bf70149423c42c8dc2649f76f8983101dcf9879d355cfb2582b2adbed84614", + "md5": "cb9f7798d824ef1696fdde67f9506aa4", + "size": "5416148" + } + }, + "cuda_nvml_dev": { + "name": "CUDA NVML Headers", + "license": "CUDA Toolkit", + "license_path": "cuda_nvml_dev/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "1ad0866dbfff6a9e2661f5348e4ca4c2a4e40882b90014ab127f2734856ecccb", + "md5": "7e615aa7b4525d3cc1b28379abcf6ce5", + "size": "129244" + }, + "linux-sbsa": { + "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "e97e668ead7ebc1fb7e93ffe303019660d0119c4e4d0e8ef26ce012bbbea9b34", + "md5": "d48bcaa83a7299b836d381b32e94a99d", + "size": "130480" + }, + "windows-x86_64": { + "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.9.79-archive.zip", + "sha256": "1894b70c5487a739c740929263fa3fbca80e53790647abc02b74eac024b97be8", + "md5": "213d773bb297b15e9f697ec8f1363bd9", + "size": "144955" + }, + "linux-aarch64": { + "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "531ac94b8b83209657cd14b28d23660df252393fb34c24f5d8919c56c977477e", + "md5": "3fe82d3f6042a22ac3d119192577db79", + "size": "130544" + } + }, + "cuda_nvprof": { + "name": "CUDA nvprof", + "license": "CUDA Toolkit", + "license_path": "cuda_nvprof/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "8d8d1a9004710bad8d7a653769f088064b0285a06a80b46c4da7598115a0c6a2", + "md5": "df8f768c6c21b06cb048b9a4b0ac39e7", + "size": "2402440" + }, + "windows-x86_64": { + "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.9.79-archive.zip", + "sha256": "81aefd12ab0a24f88feee10303b814fcf21887b3947d5e73523ed14338ef4e2b", + "md5": "69ada7050609c5860a2396a6354665e0", + "size": "1705346" + } + }, + "cuda_nvprune": { + "name": "CUDA nvprune", + "license": "CUDA Toolkit", + "license_path": "cuda_nvprune/LICENSE.txt", + "version": "12.9.82", + "linux-x86_64": { + "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.9.82-archive.tar.xz", + "sha256": "a06f0e2959a4dd3dbb62a984dbe77b813397022596f5c62d74ddd83b238571f2", + "md5": "db647ad5946c1e4cb0289c16e5ec92d8", + "size": "59372" + }, + "linux-sbsa": { + "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.9.82-archive.tar.xz", + "sha256": "15e1d6527bf04c162950251940b10b8b8254f68028e2ffc0bfb7ed84bb2e1382", + "md5": "3d51536a3582379389d821afa05becfd", + "size": "51052" + }, + "windows-x86_64": { + "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.9.82-archive.zip", + "sha256": "be23018507f015ca948c503a43a3c48449c0dc1ceaab1e721caf01f024727312", + "md5": "f5c1eaa20c7c8c67a564f04cec87fca2", + "size": "142316" + }, + "linux-aarch64": { + "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-12.9.82-archive.tar.xz", + "sha256": "69fa4cf2cede678825e0c8032ccd629e17de1b9d8667b05b6702d873fd2fb926", + "md5": "00c370560287a3dcdeedb32fe13e7e0e", + "size": "52876" + } + }, + "cuda_nvrtc": { + "name": "CUDA NVRTC", + "license": "CUDA Toolkit", + "license_path": "cuda_nvrtc/LICENSE.txt", + "version": "12.9.86", + "linux-x86_64": { + "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.9.86-archive.tar.xz", + "sha256": "82913658363892dbc0f2638b070476234476e06e084fed60db861cb7e161a6af", + "md5": "8ed74b72c44ee50759f820dee875589c", + "size": "114231976" + }, + "linux-sbsa": { + "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.9.86-archive.tar.xz", + "sha256": "fb2d50c791465f333fc2236d2419170cf7a7886f48dd9b967a10f8233c686029", + "md5": "483dc56df046c9c03eb17cd637bb8fc9", + "size": "53265740" + }, + "windows-x86_64": { + "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.9.86-archive.zip", + "sha256": "1aa0644fa53c8ca34cdc73db17bcc73530557bdd3f582c7bfdbd7916c8b48f65", + "md5": "76317f5006ce9de6720cea0b3bdc7db6", + "size": "314608748" + }, + "linux-aarch64": { + "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-12.9.86-archive.tar.xz", + "sha256": "785b0952c0f77dd0feb9a674f3fcca3fcf05541bbe27f70a5926da9f85339152", + "md5": "b49aeba8583248a4cd628154361d313d", + "size": "57633224" + } + }, + "cuda_nvtx": { + "name": "CUDA NVTX", + "license": "CUDA Toolkit", + "license_path": "cuda_nvtx/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "819bc39192955e6ba2067de39b85f30e157de462945e54b12bfdeda429d793fb", + "md5": "3a56b3c5c1e20d99cff4c354e57ea30f", + "size": "64496" + }, + "linux-sbsa": { + "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "dae359c2c51f83a5cd402468f481a82aeb6d32d79dc707d3625607e83cf97ceb", + "md5": "d783ac2926973ad682c69270d047c3f3", + "size": "64856" + }, + "windows-x86_64": { + "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.9.79-archive.zip", + "sha256": "b9d506ce9ba056bf171b60e9dada06fb3d8bed5453a6399d0541960bf9b81659", + "md5": "907cfcf3f3b637912ded30349ecfd515", + "size": "87029" + }, + "linux-aarch64": { + "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "f1a4366e45dbfd0a4e6210a5a4b9b51501aaebb6b58845d3f1b271ec3d7f3e15", + "md5": "6b40a46f73f46a7d8bac37b212989007", + "size": "65396" + } + }, + "cuda_nvvp": { + "name": "CUDA NVVP", + "license": "CUDA Toolkit", + "license_path": "cuda_nvvp/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "6cdf9196373a848856c1afc6f1df1023649fb5fe77b896967ecc0b014b200003", + "md5": "0ded9b80cf8fc2c2233b28d582f2334e", + "size": "117732648" + }, + "windows-x86_64": { + "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.9.79-archive.zip", + "sha256": "a7e1ac0de34c69afc288283ea75314b67f109b08d046c3622405dff8f66b0720", + "md5": "dd673788d3fae14c38af5c1506fae11d", + "size": "120342251" + } + }, + "cuda_opencl": { + "name": "CUDA OpenCL", + "license": "CUDA Toolkit", + "license_path": "cuda_opencl/LICENSE.txt", + "version": "12.9.19", + "linux-x86_64": { + "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.9.19-archive.tar.xz", + "sha256": "1bddacc2f0de77901faad5fecfad8fef8136ea8dd708e02177d10eef97d85b78", + "md5": "d0a85b602afc8957374d3f536dfd0306", + "size": "94140" + }, + "windows-x86_64": { + "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.9.19-archive.zip", + "sha256": "7c78e05697a3f74510c4154b175ce4597ed0719c7793236ca7f3989eccae0ff6", + "md5": "e2dec7d45f8d87045c4a37bb882e9cf4", + "size": "139663" + } + }, + "cuda_profiler_api": { + "name": "CUDA Profiler API", + "license": "CUDA Toolkit", + "license_path": "cuda_profiler_api/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "8c50636bfb97e9420905aa795b9fa6e3ad0b30ec6a6c8b0b8db519beb9241ce6", + "md5": "483998e0e5b012d976bf62ada20bd4fa", + "size": "16316" + }, + "linux-sbsa": { + "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "e07f47ef3aeb3a3ca995e9070d77d98ad79460216bf2075c9f9018962ae1d03b", + "md5": "55345cd640f299f8da43ef946dd8aa89", + "size": "16316" + }, + "windows-x86_64": { + "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.9.79-archive.zip", + "sha256": "b05519f8ce4f02167bfc859358f62eb771d89ac2af3a6952a82317f2af4bc5bd", + "md5": "f5da20e1160f547602ec1c558dd0bc64", + "size": "20352" + }, + "linux-aarch64": { + "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "e26d82b4ce994dc445dc0191b1a5fe68dacc7290bfb9c2133b4979fe90e05433", + "md5": "738fe1e26407ab88e0fd3209b4da1cfa", + "size": "16308" + } + }, + "cuda_sandbox_dev": { + "name": "CUDA nvsandboxutils Headers", + "license": "CUDA Toolkit", + "license_path": "cuda_sandbox_dev/LICENSE.txt", + "version": "12.9.19", + "linux-x86_64": { + "relative_path": "cuda_sandbox_dev/linux-x86_64/cuda_sandbox_dev-linux-x86_64-12.9.19-archive.tar.xz", + "sha256": "058c9616f9bb4e57c58996a053cf9a87f655c139dc2fa11af7bed74432bd8153", + "md5": "ce4326bc03b26b88a552db8b163d7f5f", + "size": "29172" + } + }, + "cuda_sanitizer_api": { + "name": "CUDA Compute Sanitizer API", + "license": "CUDA Toolkit", + "license_path": "cuda_sanitizer_api/LICENSE.txt", + "version": "12.9.79", + "linux-x86_64": { + "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.9.79-archive.tar.xz", + "sha256": "e23aad21132ff58b92a22aad372a7048793400b79c625665d325d4ecec6979bf", + "md5": "9d138eb96c11e1b9293408e5b7a97114", + "size": "9758036" + }, + "linux-sbsa": { + "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.9.79-archive.tar.xz", + "sha256": "281538927b6818d4687fad102c0603ab7b389513c9c129f3e0de8c61ac7f474d", + "md5": "3192ef7e50255f80430471ae6add0ebf", + "size": "7753752" + }, + "windows-x86_64": { + "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.9.79-archive.zip", + "sha256": "b1f366312cb52164dfe7b78463ab085b742f052e74b89e9da08561a8ca8b06e9", + "md5": "1821743a8a46f3e4bab0fe96dac813f8", + "size": "10103190" + }, + "linux-aarch64": { + "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-12.9.79-archive.tar.xz", + "sha256": "2baaba3ff47eceb529ddcc866fc7e647fd02427ef3dbb8bec06689f919c14c69", + "md5": "e48b00b6ed2124ac4a3a0b20201ba4dd", + "size": "4808620" + } + }, + "driver_assistant": { + "name": "NVIDIA Driver Assistant", + "license": "MIT", + "license_path": "driver_assistant/LICENSE.txt", + "version": "0.21.57.08", + "linux-all": { + "relative_path": "driver_assistant/source/driver_assistant-0.21.57.08-archive.tar.xz", + "sha256": "4904c08e1de1aa790d200f36528aaa672ab6b3c6620bbfe5e221312b9ef1120a", + "md5": "ebb37f4ad248ddba8071c570f5267da3", + "size": "38644" + } + }, + "fabricmanager": { + "name": "NVIDIA Fabric Manager", + "license": "NVIDIA Driver", + "license_path": "fabricmanager/LICENSE.txt", + "version": "575.57.08", + "linux-x86_64": { + "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-575.57.08-archive.tar.xz", + "sha256": "2e7dc4db6788e618af345fb50dee63115b5116ccb57d6d27d93c1ff5e2c3a8cf", + "md5": "39f4aa35a3f7cda55297bb73c91a5481", + "size": "8077772" + }, + "linux-sbsa": { + "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-575.57.08-archive.tar.xz", + "sha256": "239a7f8406987fb6d44cd4f7f6ba6e843b3f3acb7b1732e6ab5c0d370690ee85", + "md5": "4d288febfed83ff3d532ebbc692f65ec", + "size": "7336832" + } + }, + "imex": { + "name": "Nvidia-Imex", + "license": "NVIDIA Proprietary", + "license_path": "imex/LICENSE.txt", + "version": "575.57.08", + "linux-x86_64": { + "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-575.57.08-archive.tar.xz", + "sha256": "5dfe195429b0967788b7e9b4bab85d4936220d6d2f6cf394a61bd3439b437506", + "md5": "909fd5da3b23f54e39484efd187f4c3e", + "size": "7718644" + }, + "linux-sbsa": { + "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-575.57.08-archive.tar.xz", + "sha256": "36d1a49fb52294ef5352eeea457d131f3d14320fca0a56633d7798ab32eead18", + "md5": "bd3d1ce8d91e1fd7d26191c05292698e", + "size": "7149236" + } + }, + "libcublas": { + "name": "CUDA cuBLAS", + "license": "CUDA Toolkit", + "license_path": "libcublas/LICENSE.txt", + "version": "12.9.1.4", + "linux-x86_64": { + "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.9.1.4-archive.tar.xz", + "sha256": "546addc4a9d82b8f23aa9ba9274b6bc0429a63008a31c759884ac24880796057", + "md5": "9b07f0c3d94534e56e003c6016b9771c", + "size": "933611504" + }, + "linux-sbsa": { + "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.9.1.4-archive.tar.xz", + "sha256": "e99b074e6f66034e563508118804599d7579f73afc8424c55ad5fd8d12e085a5", + "md5": "4c7cdc43283c0ba62e665b02e9ec7540", + "size": "932528492" + }, + "windows-x86_64": { + "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.9.1.4-archive.zip", + "sha256": "d534d98b0b453a98914dbf3adf47d7e84b55037abf02f87466439e1dcef581ed", + "md5": "3f092963b0767968fe6f02febc1b0cbf", + "size": "549755186" + }, + "linux-aarch64": { + "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-12.9.1.4-archive.tar.xz", + "sha256": "f75938d72153902cf08d1666311f35851e7eb6a16af743b2346bc68d7ba6b341", + "md5": "15f6396431885647e961af811a90cc06", + "size": "493899648" + } + }, + "libcudla": { + "name": "cuDLA", + "license": "CUDA Toolkit", + "license_path": "libcudla/LICENSE.txt", + "version": "12.9.19", + "linux-aarch64": { + "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-12.9.19-archive.tar.xz", + "sha256": "ef7c1a05d9927c53aa089ec2217a1e999ffac0e776145d798bf784279fc79d40", + "md5": "dd1fc18bd0fe3ed38b87a453d31575a0", + "size": "38548" + } + }, + "libcufft": { + "name": "CUDA cuFFT", + "license": "CUDA Toolkit", + "license_path": "libcufft/LICENSE.txt", + "version": "11.4.1.4", + "linux-x86_64": { + "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.4.1.4-archive.tar.xz", + "sha256": "b0e65af59b0c2f6c8ed9f5552a9b375890855b7926ae2c0404d15dcf2565bda4", + "md5": "3ffadd77d5b084470aa8d9215d760e76", + "size": "470942192" + }, + "linux-sbsa": { + "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.4.1.4-archive.tar.xz", + "sha256": "b87637db96e485f4793d7ca8bd2cf07250eca5c86f6c56744a36683418359c03", + "md5": "4a0906639fd293f529b8f949bc3ad9eb", + "size": "471560648" + }, + "windows-x86_64": { + "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.4.1.4-archive.zip", + "sha256": "f26f80bb9abff3269c548e1559e8c2b4ba58ccb8acc6095bbc6404fc962d4b80", + "md5": "504ad2e94fd0d923b8a7082659813431", + "size": "198361265" + }, + "linux-aarch64": { + "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-11.4.1.4-archive.tar.xz", + "sha256": "5d992b98f0d3d294e339ed2f65a477a587803c1567598a120349fae52596bf20", + "md5": "1f10a57d45e9078e940340cdeff26478", + "size": "471529132" + } + }, + "libcufile": { + "name": "CUDA cuFile", + "license": "CUDA Toolkit", + "license_path": "libcufile/LICENSE.txt", + "version": "1.14.1.1", + "linux-x86_64": { + "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.14.1.1-archive.tar.xz", + "sha256": "7ba9834b8dc2f8cdb1710a49f3de3f627bbcd4cc1f8a754019c66c8c80fdaee7", + "md5": "e59833cbd8e423948fa5814a276315e3", + "size": "42129088" + }, + "linux-sbsa": { + "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.14.1.1-archive.tar.xz", + "sha256": "6b1d2a771bd822fdd06a6286eb59acba179b13fe063ae5b0de8fc0f4991a39d8", + "md5": "5a8499cdc22754fe5c9335065d708ea4", + "size": "41676328" + }, + "linux-aarch64": { + "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.14.1.1-archive.tar.xz", + "sha256": "196b61a1bf02b85e76c21bdfe414a3f4db4380df41d9212c9eb6d0aa92eee1ce", + "md5": "c7e269a01ecd2dc427941c5bc775c2ef", + "size": "41655988" + } + }, + "libcurand": { + "name": "CUDA cuRAND", + "license": "CUDA Toolkit", + "license_path": "libcurand/LICENSE.txt", + "version": "10.3.10.19", + "linux-x86_64": { + "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.10.19-archive.tar.xz", + "sha256": "48281b4caadb1cf790d44ac76b23c77d06f474c0b1799814f314aafec9258ad6", + "md5": "e2fd0b8dd197f3bccc0ee19e5640fc93", + "size": "89582256" + }, + "linux-sbsa": { + "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.10.19-archive.tar.xz", + "sha256": "078afec842c99b3a953d62cc76bd74afa2d883dc436e6d642e6440bb1e85eb8e", + "md5": "fae5b6ce60678f452a2c760e8bf27563", + "size": "89544732" + }, + "windows-x86_64": { + "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.10.19-archive.zip", + "sha256": "d0411f0b8c07e90d0fb6e01bfa7a54c9cb80f2ddf67e4ded2d96a50e19aadad6", + "md5": "6ccce2f4f1f6d9592c908fa1cb91536d", + "size": "67904600" + }, + "linux-aarch64": { + "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.10.19-archive.tar.xz", + "sha256": "e5087640b5c9cd8bc173efb6a21f8388b24da59511cc3d57e60afc5e05d14b50", + "md5": "71ed8ff7a7e539c0be8ca4b699f2f3e1", + "size": "79761424" + } + }, + "libcusolver": { + "name": "CUDA cuSOLVER", + "license": "CUDA Toolkit", + "license_path": "libcusolver/LICENSE.txt", + "version": "11.7.5.82", + "linux-x86_64": { + "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.7.5.82-archive.tar.xz", + "sha256": "3d3b96f3087dbc43893a28691b172f31725b316d524f5a3c1e6837257c898d06", + "md5": "efcc5d100623563d1a56dff59b45b65d", + "size": "324393196" + }, + "linux-sbsa": { + "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.7.5.82-archive.tar.xz", + "sha256": "db463593ffcbc78f542a7f1ef808da43bf742acae654d970d99a47289c2a83e5", + "md5": "63113f462dc11289f996eec8bab1db74", + "size": "323573816" + }, + "windows-x86_64": { + "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.7.5.82-archive.zip", + "sha256": "e991d64a0bbe3e0bb69ce2adce000244288002b0341894729666d66adb9b4f25", + "md5": "e2d79987f6e38f63cc64816f393a8e51", + "size": "322216184" + }, + "linux-aarch64": { + "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.7.5.82-archive.tar.xz", + "sha256": "45e2fefeee5797c0492d8a9ee26c3dbb7af0cdcefe6f1cd25bd586daa633d9a0", + "md5": "e311d62bfc65c6afc29152f6e923f78c", + "size": "113258352" + } + }, + "libcusparse": { + "name": "CUDA cuSPARSE", + "license": "CUDA Toolkit", + "license_path": "libcusparse/LICENSE.txt", + "version": "12.5.10.65", + "linux-x86_64": { + "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.5.10.65-archive.tar.xz", + "sha256": "a83415dcd3e1183afe363d4740f9f0309cfe560c6c08016c2a61468304f4b848", + "md5": "c7ed952d12dec0f50a4386e5d09203f6", + "size": "398914580" + }, + "linux-sbsa": { + "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.5.10.65-archive.tar.xz", + "sha256": "8d1c8a57ba3eaecc3f7c11e29fed275a2f3dca5cea51dd2a24d07ab5d9998583", + "md5": "2d48c3aecca07be0a458a977350ce175", + "size": "398606816" + }, + "windows-x86_64": { + "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.5.10.65-archive.zip", + "sha256": "abb4bfc01198f82fbc956773ccb98c578c03027b6ad425e829355be0c0a11a4a", + "md5": "33ce31c3d880596c31304c965dbfcdce", + "size": "358114928" + }, + "linux-aarch64": { + "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-12.5.10.65-archive.tar.xz", + "sha256": "b294b6cd0acf5e68078d2fe4d41d95a4073fed780805adca7774bce7cbbe5b65", + "md5": "ce4d363d3affd40fe751f065ec2bd4cf", + "size": "131075108" + } + }, + "libnpp": { + "name": "CUDA NPP", + "license": "CUDA Toolkit", + "license_path": "libnpp/LICENSE.txt", + "version": "12.4.1.87", + "linux-x86_64": { + "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.4.1.87-archive.tar.xz", + "sha256": "49351448d896854284ec708c14506eaaceb92aa01fbe35c91d5c52ad482e17ae", + "md5": "03de546e34ad54d0119594bc237c5e87", + "size": "331733872" + }, + "linux-sbsa": { + "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.4.1.87-archive.tar.xz", + "sha256": "992d461905366cec4243b26ce7bfe997c0c0eabf53a001333025930a1a0c7237", + "md5": "8de3be3d9043a07011b0de46c49ea668", + "size": "330804724" + }, + "windows-x86_64": { + "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.4.1.87-archive.zip", + "sha256": "cfcfbf59e4e5ce71113c058bd4eba3dd56e4db080932146d4047c0d44b4a558e", + "md5": "7549e1191510ae5ca9291e5f13c70296", + "size": "274109870" + }, + "linux-aarch64": { + "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-12.4.1.87-archive.tar.xz", + "sha256": "50c9f80592eaf4f246c82475143768b848333d9f540782257d42023f5fe68fdf", + "md5": "869efb32d5ab9468fda4cb94848cf90f", + "size": "104647240" + } + }, + "libnvfatbin": { + "name": "NVIDIA compiler library for fatbin interaction", + "license": "CUDA Toolkit", + "license_path": "libnvfatbin/LICENSE.txt", + "version": "12.9.82", + "linux-x86_64": { + "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-12.9.82-archive.tar.xz", + "sha256": "315be969a303437329bf72d7141babed024fc54f90a10aa748b03be8f826d57b", + "md5": "d5e2dc19c01ab62dbf437a1ef80847b1", + "size": "930820" + }, + "linux-sbsa": { + "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-12.9.82-archive.tar.xz", + "sha256": "87bf71288ea7390d039b246fa794cad2ddd3b164ce9566f8542bb15039432cdb", + "md5": "91902ce86f6f55a4ecc948f95bf1c032", + "size": "836312" + }, + "windows-x86_64": { + "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-12.9.82-archive.zip", + "sha256": "86563b25096bbc21d74b1c043701ec8596499f76b40e32f9ec9179fc10404d00", + "md5": "c0963a07d7f2cbffd34b0b1ec6cae5c0", + "size": "2217262" + }, + "linux-aarch64": { + "relative_path": "libnvfatbin/linux-aarch64/libnvfatbin-linux-aarch64-12.9.82-archive.tar.xz", + "sha256": "248e77ede9afbd6060cda7de0475d222731ac021e22e696ce75ed72b426dfca9", + "md5": "814b2ff13e944a07669580eb85c0e653", + "size": "808780" + } + }, + "libnvidia_nscq": { + "name": "NVIDIA NSCQ API", + "license": "NVIDIA Driver", + "license_path": "libnvidia_nscq/LICENSE.txt", + "version": "575.57.08", + "linux-x86_64": { + "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-575.57.08-archive.tar.xz", + "sha256": "7c54e959ee50212be8595e01ee76581c1f3a13c19b2279424b55a8d26385c41a", + "md5": "b86a87c4f9fd58a79ced07cf82cec271", + "size": "455504" + }, + "linux-sbsa": { + "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-575.57.08-archive.tar.xz", + "sha256": "931004b8b2062249016a9bded2499f70331d27b265226ed879428b8bd7e4bb20", + "md5": "790ca3dd29b03a71f32ad1dd05611a9e", + "size": "446980" + } + }, + "libnvjitlink": { + "name": "NVIDIA compiler library for JIT LTO functionality", + "license": "CUDA Toolkit", + "license_path": "libnvjitlink/LICENSE.txt", + "version": "12.9.86", + "linux-x86_64": { + "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.9.86-archive.tar.xz", + "sha256": "392cac3144b52ba14900bc7259ea6405ae6da88a8c704eab9bbbcc9ba4824b07", + "md5": "9156156146001536d1c8346783991d1b", + "size": "54021940" + }, + "linux-sbsa": { + "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.9.86-archive.tar.xz", + "sha256": "9c9227c1e9122fd8448cafced3b32bc69f40d3c041d25034ea23611a1262852f", + "md5": "7fdf2864352ac613415327ebde38598b", + "size": "50981988" + }, + "windows-x86_64": { + "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.9.86-archive.zip", + "sha256": "ee7175da9628d47ccc92dce6d28d57ca77633e79079a2aee90e2a645edcd1384", + "md5": "4cdb56f88316a5ade3edf69a1e7192e8", + "size": "265666466" + }, + "linux-aarch64": { + "relative_path": "libnvjitlink/linux-aarch64/libnvjitlink-linux-aarch64-12.9.86-archive.tar.xz", + "sha256": "a24842165d98660d4ba9fd753395f7c9834445552110fabce4baa4c211fd2c52", + "md5": "548a35d56f08d07b1dc294a3c8172f71", + "size": "54783780" + } + }, + "libnvjpeg": { + "name": "CUDA nvJPEG", + "license": "CUDA Toolkit", + "license_path": "libnvjpeg/LICENSE.txt", + "version": "12.4.0.76", + "linux-x86_64": { + "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.4.0.76-archive.tar.xz", + "sha256": "ddd8245b2803f5b55211261d7e5d7abf803c05f3b032238d0feaa6e09ea9401d", + "md5": "b9f7806fb279c9cdd0b4a40e4171b87b", + "size": "6378624" + }, + "linux-sbsa": { + "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.4.0.76-archive.tar.xz", + "sha256": "405b5627ffd772d2837ae4ece123fdee841c34894dba2180a1c8e1b84c0f2665", + "md5": "bad1da3ec8865dbd3955a757bb6b7ba0", + "size": "6179324" + }, + "windows-x86_64": { + "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.4.0.76-archive.zip", + "sha256": "b253241fc88bf30947b8ee068101aca8930960f113d8ee4a9583de021a79ffa1", + "md5": "d19d13f9bd3dbc9c9361a3c1fee99dd5", + "size": "4667529" + }, + "linux-aarch64": { + "relative_path": "libnvjpeg/linux-aarch64/libnvjpeg-linux-aarch64-12.4.0.76-archive.tar.xz", + "sha256": "a9841bff40e577bec81352054e05c5d98720ae8e2ccfc4863eaac9dd35444c27", + "md5": "0a7197330938f8b5363d38bdde63562c", + "size": "1821640" + } + }, + "libnvsdm": { + "name": "LIBNVSDM", + "license": "NVIDIA", + "license_path": "libnvsdm/LICENSE.txt", + "version": "575.57.08", + "linux-x86_64": { + "relative_path": "libnvsdm/linux-x86_64/libnvsdm-linux-x86_64-575.57.08-archive.tar.xz", + "sha256": "7a6ee934d5c328f9c05e967b63053c211f80485e0443ac119d887612a510ad53", + "md5": "788f7c59de54096d84dc7f645964ad2a", + "size": "500100" + } + }, + "mft": { + "name": "NVLink 5 MFT", + "license": "NVIDIA Proprietary", + "license_path": "mft/LICENSE.txt", + "version": "4.30.1.510", + "linux-x86_64": { + "relative_path": "mft/linux-x86_64/mft-linux-x86_64-4.30.1.510-archive.tar.xz", + "sha256": "512714ab076d90d88550e60f5da65181363336cee94c67bff8821face8ef10b4", + "md5": "30698cf8741826df5ca3d4d3bb3a982c", + "size": "45536612" + }, + "linux-sbsa": { + "relative_path": "mft/linux-sbsa/mft-linux-sbsa-4.30.1.510-archive.tar.xz", + "sha256": "95c05e1bc03ff81dffa58bfff26a1dd59c6300d6d5922662ae59c7af5788a310", + "md5": "78ef93686e91302f7b751fed8f83d9be", + "size": "44222004" + } + }, + "mft_autocomplete": { + "name": "NVLink 5 MFT AUTOCOMPLETE", + "license": "NVIDIA Proprietary", + "license_path": "mft_autocomplete/LICENSE.txt", + "version": "4.30.1.510", + "linux-x86_64": { + "relative_path": "mft_autocomplete/linux-x86_64/mft_autocomplete-linux-x86_64-4.30.1.510-archive.tar.xz", + "sha256": "dc9069baa888c7ca0c3e55a3043d27b0100c29c81e6ed3346907dd49dabb1325", + "md5": "b65cb40bacfe276b3444920e8eef1f2f", + "size": "11884" + }, + "linux-sbsa": { + "relative_path": "mft_autocomplete/linux-sbsa/mft_autocomplete-linux-sbsa-4.30.1.510-archive.tar.xz", + "sha256": "64647ce2a4de62e535ea7060d20d58c2613937071008c2a93894e1995facce2b", + "md5": "bf034fbf9f887d62434f83dc9727db80", + "size": "11880" + } + }, + "mft_oem": { + "name": "NVLink 5 MFT OEM", + "license": "NVIDIA Proprietary", + "license_path": "mft_oem/LICENSE.txt", + "version": "4.30.1.510", + "linux-x86_64": { + "relative_path": "mft_oem/linux-x86_64/mft_oem-linux-x86_64-4.30.1.510-archive.tar.xz", + "sha256": "7a4729f8b91ba5c179820583189a4c95ffa9669312a28fe7ac03feebb726bbc3", + "md5": "7329d76d0e5b976f88ef1f2484d962de", + "size": "4708108" + }, + "linux-sbsa": { + "relative_path": "mft_oem/linux-sbsa/mft_oem-linux-sbsa-4.30.1.510-archive.tar.xz", + "sha256": "b71bb03130b6dd3388a3e909cdf91cc9bca8b8098a8b80b5f376f5726e5b5e1c", + "md5": "e55a4d898553c2cf92be57724a8204e1", + "size": "4429188" + } + }, + "nsight_compute": { + "name": "Nsight Compute", + "license": "NVIDIA SLA", + "license_path": "nsight_compute/LICENSE.txt", + "version": "2025.2.1.3", + "linux-x86_64": { + "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2025.2.1.3-archive.tar.xz", + "sha256": "02ab8867197aaf6a6ae3171293d70b6a9ddb20296be94ff4287741338cc2e1df", + "md5": "e81faf319af6b21f241bae535d3d1907", + "size": "300347320" + }, + "linux-sbsa": { + "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2025.2.1.3-archive.tar.xz", + "sha256": "0e336a5139f76778b8ad70fdb49fb43817ec1bb3ee6e7425d59d99d8c455d976", + "md5": "18334b109fe6f10fdba2c2681726ba96", + "size": "107009604" + }, + "windows-x86_64": { + "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2025.2.1.3-archive.zip", + "sha256": "e9d558654c98d83049969d133b98922b53ab8f4e3ba9e0a37bdb5e2ff300b7de", + "md5": "7cb9cff3e0718212866c7fbb4365dee5", + "size": "341265370" + }, + "linux-aarch64": { + "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2025.2.1.3-archive.tar.xz", + "sha256": "51c7762110c34728acd37878d4340f13612401fa622be0031b1a9e2ce112cfb2", + "md5": "355babae2f49f3f2c7ec1cf1c0b07966", + "size": "221171904" + } + }, + "nsight_systems": { + "name": "Nsight Systems", + "license": "NVIDIA SLA", + "license_path": "nsight_systems/LICENSE.txt", + "version": "2025.1.3.140", + "linux-x86_64": { + "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2025.1.3.140-archive.tar.xz", + "sha256": "dded4227619340307be0ba5bc4e23bcbc966e2df3763170ebb20410c2b54754e", + "md5": "0b16c35f6e63a4fc33d14795e65bcd61", + "size": "1075732108" + }, + "linux-sbsa": { + "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2025.1.3.140-archive.tar.xz", + "sha256": "479c46de1c459f7c760ef1ea5e5bbe61bfe7f4ba525ce4778d5ba25d874b8e1f", + "md5": "6d70406b53a94eba94d7c3552b938fe6", + "size": "980282844" + }, + "windows-x86_64": { + "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2025.1.3.140-archive.zip", + "sha256": "8d61f266a8a1bc1ababd44de3ee38f7b85c8cdfcdaebace14c8f065d7624d0b3", + "md5": "b741046881531cbf6e3ccedb0b403432", + "size": "403084779" + } + }, + "nsight_vse": { + "name": "Nsight Visual Studio Edition (VSE)", + "license": "NVIDIA SLA", + "license_path": "nsight_vse/LICENSE.txt", + "version": "2025.2.1.25125", + "windows-x86_64": { + "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2025.2.1.25125-archive.zip", + "sha256": "3f2b6ca8705929c97e0f931f0559921b110b9337cf11af5e017d0c95b5b31feb", + "md5": "7e74f479c09aece6e5b46c97d0d4cc86", + "size": "136237151" + } + }, + "nvidia_driver": { + "name": "NVIDIA Linux Driver", + "license": "NVIDIA Driver", + "license_path": "nvidia_driver/LICENSE.txt", + "version": "575.57.08", + "linux-x86_64": { + "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-575.57.08-archive.tar.xz", + "sha256": "27ddfabde120a107527cbf88a6c96d1f81ee5c977462ce1a793051a3e678f552", + "md5": "9007dddd1e2d48f897958b676fbe30ff", + "size": "471616744" + }, + "linux-sbsa": { + "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-575.57.08-archive.tar.xz", + "sha256": "4a7d1accb257f2539ff7dabb02319339fc3a8db622073e5dde33a5446910346a", + "md5": "3c2b686f392789d8f3a1db1ae2ad62be", + "size": "349127420" + } + }, + "nvidia_fs": { + "name": "NVIDIA filesystem", + "license": "CUDA Toolkit", + "license_path": "nvidia_fs/LICENSE.txt", + "version": "2.25.7", + "linux-x86_64": { + "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.25.7-archive.tar.xz", + "sha256": "6e11ec0b885177ab21f4b864ff7417ea3cc1b0994f1c318767984557cd5b29d1", + "md5": "60d2fa54d55b739302e3db38a8a389c9", + "size": "60280" + }, + "linux-sbsa": { + "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.25.7-archive.tar.xz", + "sha256": "62baf0beac2d446c0ff033fb3780cf348ab9c090d7903c210106dc98bb29d7eb", + "md5": "3859bed4b5e330cde0e2316f9cdcdaeb", + "size": "60296" + }, + "linux-aarch64": { + "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.25.7-archive.tar.xz", + "sha256": "b8c67e28e9e23453183fb7d12ed9fed449427b2c11a21b1de4e7046a57d8d366", + "md5": "5128c63c80c1089340b65807445d921a", + "size": "60272" + } + }, + "nvlsm": { + "name": "NVLSM SM component", + "license": "NVIDIA Proprietary", + "license_path": "nvlsm/LICENSE.txt", + "version": "2025.03.1", + "linux-x86_64": { + "relative_path": "nvlsm/linux-x86_64/nvlsm-linux-x86_64-2025.03.1-archive.tar.xz", + "sha256": "b034dad10a3154359e244b85206cd73f0fbce8e1cdf76058417b7b562c337388", + "md5": "6e09669fe8e4fb26e5334a1c4aa9dabb", + "size": "6890300" + }, + "linux-sbsa": { + "relative_path": "nvlsm/linux-sbsa/nvlsm-linux-sbsa-2025.03.1-archive.tar.xz", + "sha256": "e260285ec01c6beb562a14625e9564b96374bb824ec62cc9866066a48710fa54", + "md5": "bc90989f567c27d8b39e607f719acba8", + "size": "6175832" + } + }, + "visual_studio_integration": { + "name": "CUDA Visual Studio Integration", + "license": "CUDA Toolkit", + "license_path": "visual_studio_integration/LICENSE.txt", + "version": "12.9.79", + "windows-x86_64": { + "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.9.79-archive.zip", + "sha256": "d5b6514866395f52f04107da1aa523954f8dc76daf18a9f8699c3d564f294449", + "md5": "680fbdf0f345619c1fa3de5f1fc79090", + "size": "864204" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_13.0.2.json b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_13.0.2.json new file mode 100644 index 000000000000..d4caeeddd7e4 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cuda/redistrib_13.0.2.json @@ -0,0 +1,1031 @@ +{ + "release_date": "2025-10-09", + "release_label": "13.0.2", + "release_product": "cuda", + "collectx_bringup": { + "name": "UFM telemetry CollectX Bringup", + "license": "NVIDIA Proprietary", + "license_path": "collectx_bringup/LICENSE.txt", + "version": "1.22.1", + "linux-x86_64": { + "relative_path": "collectx_bringup/linux-x86_64/collectx_bringup-linux-x86_64-1.22.1-archive.tar.xz", + "sha256": "ba1676715cc32ddf9695e1e59fe283c0489a9a18f6a0bfdd1b0104631766a1ca", + "md5": "e480e74d2ca1ec226c1f15f47d0fac30", + "size": "142950700" + }, + "linux-sbsa": { + "relative_path": "collectx_bringup/linux-sbsa/collectx_bringup-linux-sbsa-1.22.1-archive.tar.xz", + "sha256": "8f7dd62d0adf8dfd0543aa82c1859f161fea23e8d5bb5b4b2bcc698508329a22", + "md5": "5e44cf49922aec1937414c0f54b2e491", + "size": "125513356" + } + }, + "cuda_cccl": { + "name": "CXX Core Compute Libraries", + "license": "CUDA Toolkit", + "license_path": "cuda_cccl/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "ed845eae8c1767706b6ee91e40c608a03f6f633551a849b63f7346d32d73ee60", + "md5": "c0dd26e0c41dc35bd73435a4799c7508", + "size": "991284" + }, + "linux-sbsa": { + "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "eca22ded176804a78afcba3fe1909e7d473366ee1cb9f3784080df23bc8e74d5", + "md5": "e50b07ae0a9920ce07a107a5c7030157", + "size": "990368" + }, + "windows-x86_64": { + "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-13.0.85-archive.zip", + "sha256": "f4f5187f7976d8057d76e1e04e72c8b7d0a2a22793107a671ad709b1d8d3408d", + "md5": "8dba9713ce4b4e6f0c58a92a8a1379db", + "size": "3119228" + } + }, + "cuda_crt": { + "name": "CUDA CRT", + "license": "CUDA Toolkit", + "license_path": "cuda_crt/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "cuda_crt/linux-x86_64/cuda_crt-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "5a3279a049ffc1cdb951c44cb95206acfdde9e9ae5e87825fc18d7e4a6878bb0", + "md5": "f90b38d702a29668d97e8f94a399ea31", + "size": "79800" + }, + "linux-sbsa": { + "relative_path": "cuda_crt/linux-sbsa/cuda_crt-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "c03b92941ba7bf58a4992231ceb572477784ef450ce678f6545bed02392cae50", + "md5": "3db54b1fb543f00c1cca085569bffd9e", + "size": "79916" + }, + "windows-x86_64": { + "relative_path": "cuda_crt/windows-x86_64/cuda_crt-windows-x86_64-13.0.88-archive.zip", + "sha256": "ff413c89dbd96ed3b3dcfac923437de78acea32fb90309277197c8a127588112", + "md5": "29b09d1ab8f3b5550a8e8da587b105f1", + "size": "140187" + } + }, + "cuda_ctadvisor": { + "name": "ctadvisor", + "license": "CUDA Toolkit", + "license_path": "cuda_ctadvisor/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_ctadvisor/linux-x86_64/cuda_ctadvisor-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "9c82af2dbd2d0db7c8108bc9f150ddb02f36d2b66a5edc552ffb94ab41fda065", + "md5": "86766786f7e67b75320f7b79c1cdb8f9", + "size": "617204" + }, + "linux-sbsa": { + "relative_path": "cuda_ctadvisor/linux-sbsa/cuda_ctadvisor-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "7a2b60e949fcce748318bda190ff4c54d6d4b9753a1be44bbeed254b6880b91a", + "md5": "03361a3736df8719d2294649419d637f", + "size": "529764" + }, + "windows-x86_64": { + "relative_path": "cuda_ctadvisor/windows-x86_64/cuda_ctadvisor-windows-x86_64-13.0.85-archive.zip", + "sha256": "beeab2bf9575ff04f9a9d1c94b743f29ed817a12b294b8928db84fb26f5ef056", + "md5": "72a0e640cabd8baa6455117d375dbb4d", + "size": "861030" + } + }, + "cuda_cudart": { + "name": "CUDA Runtime (cudart)", + "license": "CUDA Toolkit", + "license_path": "cuda_cudart/LICENSE.txt", + "version": "13.0.96", + "linux-x86_64": { + "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-13.0.96-archive.tar.xz", + "sha256": "25b8071951baba827be1580b841d363464f6ee6c39f48d33a81646f90cc95ed1", + "md5": "26ebf8fd2c0fe1f303d5d27c49624d5e", + "size": "1487960" + }, + "linux-sbsa": { + "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-13.0.96-archive.tar.xz", + "sha256": "e2c78564330a09d890f98a066a2082a32c78256ffcc6bccca1696bd2abbaf445", + "md5": "ff3140b2fb00f583295484fe36f77995", + "size": "1489276" + }, + "windows-x86_64": { + "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-13.0.96-archive.zip", + "sha256": "a2ed875f9997aa24904fb70cc9db3acd9308433cde99bc8e63ec1271c9da31b4", + "md5": "dc22a52b5b75c198a12ce8c4d885e2e5", + "size": "2873447" + } + }, + "cuda_culibos": { + "name": "CUDA MATH Library (cuda culibos)", + "license": "CUDA Toolkit", + "license_path": "cuda_culibos/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_culibos/linux-x86_64/cuda_culibos-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "98fca11f9ab89be61385a67eee686c1ebf76fad9c7269d0cf9090edfcdb8a8ac", + "md5": "4b61b30864c47e1292f6d132653140d1", + "size": "21412" + }, + "linux-sbsa": { + "relative_path": "cuda_culibos/linux-sbsa/cuda_culibos-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "ab5ecee37c8adc7efbc2a88ab091de9d978924c4d7f66c3e0c42f23983a1beb3", + "md5": "86aa2f9aca3cddc7c61d6029ce22a5d3", + "size": "21444" + } + }, + "cuda_cuobjdump": { + "name": "cuobjdump", + "license": "CUDA Toolkit", + "license_path": "cuda_cuobjdump/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "bd624dcb2089842add8f293efab1d21aa076c98b36d8dcb64347fe08fb03315d", + "md5": "1f6f98ec1dcf7f0b1b50ca88f2c4cd7b", + "size": "242604" + }, + "linux-sbsa": { + "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "cd0304f70ff905421da2ca0fe53cfc384baa48d6ff6b34f92a80cf723064e827", + "md5": "eb64d979ba5c6e75e14bac6ec4c58e08", + "size": "232276" + }, + "windows-x86_64": { + "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-13.0.85-archive.zip", + "sha256": "cddbc524dc229c708cc989e4ff2d636ba342c695e0f60c1026a1b5f76de4b77b", + "md5": "f4738a4ff851ffed9d83e03ad98e4c13", + "size": "6272066" + } + }, + "cuda_cupti": { + "name": "CUPTI", + "license": "CUDA Toolkit", + "license_path": "cuda_cupti/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "92fb7e0430521517174c4c171173b888aaa8d78d8762e59752dea2ed14a0ad7d", + "md5": "da5bac6241e10114d6dd941c25b0e1b0", + "size": "16253056" + }, + "linux-sbsa": { + "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "f6f34d534cce56f91b1496abf51be3b1559ba879985d34eb89c808004b77513a", + "md5": "bafe0e433c575ab69369919a04ab923d", + "size": "12542416" + }, + "windows-x86_64": { + "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-13.0.85-archive.zip", + "sha256": "e739e96415e1fb9a650eaac826f7cd24701e18ae2f7c26b78f3fabaf64c8e39b", + "md5": "d4affebe5c588520fb13a4ba04a9da22", + "size": "13282089" + } + }, + "cuda_cuxxfilt": { + "name": "CUDA cuxxfilt (demangler)", + "license": "CUDA Toolkit", + "license_path": "cuda_cuxxfilt/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "ae1acfe8dca8453e0b243ecde8a45e88a9584bf050b307b96ec9dc286fd8e714", + "md5": "8f6fa1787171abc922814d6b4c6824c1", + "size": "189496" + }, + "linux-sbsa": { + "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "8f0dd0433d2fa4591f7dbdf8169ec4b355fe567657dd28bc8ac2e8ec41fda4f9", + "md5": "bdadf71bdfc2a4418e1cc25828a69c0b", + "size": "177300" + }, + "windows-x86_64": { + "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-13.0.85-archive.zip", + "sha256": "f885168de4d35ee4c8ea3d37068bc476726310334dcbcc74e2c1b76b3d088ece", + "md5": "293ca297f3263c0cbd3487ad5d5a4749", + "size": "186499" + } + }, + "cuda_documentation": { + "name": "CUDA Documentation", + "license": "CUDA Toolkit", + "license_path": "cuda_documentation/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "05df885f5b825e51a69da1318ca6713112ec09baf4d3c6262663111255504eae", + "md5": "6467a953e2492ddb3d812b5e8768bb9a", + "size": "67948" + }, + "linux-sbsa": { + "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "f6bdca23da438ce1ce11f557e7a9571e1a81aa49a56d3b9eaaee2419111dae13", + "md5": "8f6f5d7fe9a964bce7560ee6a55d08ec", + "size": "68052" + }, + "windows-x86_64": { + "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-13.0.85-archive.zip", + "sha256": "4879ab75b0fefc591ec0752d80c846b9a191fe6e9528380cc2f105210403e9c2", + "md5": "8c1f9a2a0bb9cfb51cc1660da920cc96", + "size": "107985" + } + }, + "cuda_gdb": { + "name": "CUDA GDB", + "license": "CUDA Toolkit", + "license_path": "cuda_gdb/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "a6bf87dac5edb64eee36425f6f8a91676966c456c49a213da5b3158581a4432f", + "md5": "24267797e580285a899686e6909cb425", + "size": "68531784" + }, + "linux-sbsa": { + "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "48bfce61e6f86661ec12bb65dd97e1607799406de5ceafccba2212962568d40e", + "md5": "b50bc5c7d85c3bb669b0f4b907eaaa6d", + "size": "66117920" + } + }, + "cuda_nsight": { + "name": "Nsight Eclipse Edition Plugin", + "license": "CUDA Toolkit", + "license_path": "cuda_nsight/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "26bace58e46a4aa038ac531d6ef3a3abd12f43da65ba24c29b894e08ca64f5e9", + "md5": "937fcefb4d045d1c986bc459b1df078e", + "size": "118691392" + } + }, + "cuda_nvcc": { + "name": "CUDA NVCC", + "license": "CUDA Toolkit", + "license_path": "cuda_nvcc/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "48e35be3cfbf4b4fbc16828eaec8a7048ee789403049dc409f7b643d6259cf7a", + "md5": "e3e925c644055b9306aec9c9b84d1975", + "size": "26657716" + }, + "linux-sbsa": { + "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "01b01e10aa2662ad1b3aeab3317151d7d6d4a650eeade55ded504f6b7fced18e", + "md5": "4defe04ac10e7231bfa63cbd72dd8e21", + "size": "22383012" + }, + "windows-x86_64": { + "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-13.0.88-archive.zip", + "sha256": "61760e24a44937c6c29a20ddea69067b4d3860ccd6a9a0564573f840d96e6c5f", + "md5": "00f382c4efc8602a6fce54fd61da0c23", + "size": "29142142" + } + }, + "cuda_nvdisasm": { + "name": "CUDA nvdisasm", + "license": "CUDA Toolkit", + "license_path": "cuda_nvdisasm/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "0541e0230f724a43d67288ef882c63351d0c302bf567591b7620d40f93c2c93c", + "md5": "c087569ce5afb128f99fadf280c98815", + "size": "4129456" + }, + "linux-sbsa": { + "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "77e2ef1494270839829d5608352ba67a278e80fdaf4e3cc3c8ac9cb73e1c463c", + "md5": "004432bcd5466fdc6a4bcb8ce67c14cc", + "size": "4057500" + }, + "windows-x86_64": { + "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-13.0.85-archive.zip", + "sha256": "c15885ed180cc6439b92a59fede41082434fdd9baac7280d5f0570f1d0786b04", + "md5": "00cd56f73b5de05c94c7858cb1219c79", + "size": "4450492" + } + }, + "cuda_nvml_dev": { + "name": "CUDA NVML Headers", + "license": "CUDA Toolkit", + "license_path": "cuda_nvml_dev/LICENSE.txt", + "version": "13.0.87", + "linux-x86_64": { + "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-13.0.87-archive.tar.xz", + "sha256": "92d441fa7ae41bba92e06c928cacdb32f4703763512f68d10c9c230f09ffe6d8", + "md5": "f293cd0388e3d57f4e216a7843f0af3a", + "size": "140148" + }, + "linux-sbsa": { + "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-13.0.87-archive.tar.xz", + "sha256": "71740823e837c2a1a6e314f0fe801f8fa6aef1055220e9a504f6f4c67e21d72b", + "md5": "d8455698e595b0a78bec35ee84065c90", + "size": "142288" + }, + "windows-x86_64": { + "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-13.0.87-archive.zip", + "sha256": "b19b2b5fd534f37c3f0aab49d25ebb28496963aef3e819466bcf0fa20607b0cd", + "md5": "6f820eb0f0de554e48e6dd627acd0845", + "size": "162340" + } + }, + "cuda_nvprune": { + "name": "CUDA nvprune", + "license": "CUDA Toolkit", + "license_path": "cuda_nvprune/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "b182d8b0398ba9ff8ee75fc2ffef3ff1e2069e6bec6938bcf02a6c9e69d40456", + "md5": "ae2e691465a09e92768b3aada7092f38", + "size": "59948" + }, + "linux-sbsa": { + "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "956e1f1b282522ff40b331e5cea83b5d7a87bd97cd9c2bea3454bb0c6adf5414", + "md5": "b9529445dd0d916e71e9e4af96ba63ec", + "size": "51700" + }, + "windows-x86_64": { + "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-13.0.85-archive.zip", + "sha256": "b52ca2d51d0e41c317f68f38ce88f4ae7184443eac04203e7a80fd054f2028ec", + "md5": "fef61c48fdef576c2f44d26da5168bd3", + "size": "150099" + } + }, + "cuda_nvrtc": { + "name": "CUDA NVRTC", + "license": "CUDA Toolkit", + "license_path": "cuda_nvrtc/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "00038aac08e1dba6f1933237dbfb217ac6452ae24fab970edcac808f103ca64b", + "md5": "62a842b5c00b0d44a5a03a18fad07945", + "size": "116779532" + }, + "linux-sbsa": { + "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "decf9977ab114ff195c8cdfce6fbc94aea4a62efdae628092cbb9fd1c31cda1a", + "md5": "1fdf86efd1ad72fe618404d4cd1947c6", + "size": "52411212" + }, + "windows-x86_64": { + "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-13.0.88-archive.zip", + "sha256": "8c50a52467826167e0dbe99936140c52d62272bfc5849fe2d6587d050c8c5d29", + "md5": "584ae7baced761d594e2e53eb30f1411", + "size": "318076161" + } + }, + "cuda_nvtx": { + "name": "CUDA NVTX", + "license": "CUDA Toolkit", + "license_path": "cuda_nvtx/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "ed150e6fb1b50663ff068cccee3c5e2ca581c3b939b321656afbc9193671137d", + "md5": "56273621b95441995c72c199cfd5226b", + "size": "94140" + }, + "linux-sbsa": { + "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "6f50a3729091aa5a0ae61cda979ea020e09aeb7c07cec0c8962949599d2b72c6", + "md5": "1a2ed71befd31ee92a91b12ee257c406", + "size": "94612" + }, + "windows-x86_64": { + "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-13.0.85-archive.zip", + "sha256": "184f578d7bcce2012edf266c51dfa7834ded41464f62459f4ebcb2398cddc665", + "md5": "9b01b0d114755775d98626f6dd176137", + "size": "147156" + } + }, + "cuda_opencl": { + "name": "CUDA OpenCL", + "license": "CUDA Toolkit", + "license_path": "cuda_opencl/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "f48040e3054d561484e4ba136650cec68eeebaf4ff4d70d1d704dcdc5f38cf90", + "md5": "36009e7503e87c28dc66f8840287eb0d", + "size": "95092" + }, + "windows-x86_64": { + "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-13.0.85-archive.zip", + "sha256": "ef7b189fba61e0fd13e5f50b940fc0e22f9d211481d1c7061b9d586641929f3b", + "md5": "ac85141514a2f42eb30f0f6550b5b9bf", + "size": "140926" + } + }, + "cuda_profiler_api": { + "name": "CUDA Profiler API", + "license": "CUDA Toolkit", + "license_path": "cuda_profiler_api/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "dc233d88a5cafa095b197e6246b4c468a4581c128da8f951d67e063cdd6bca4c", + "md5": "643aa0f86952f61a183c7342ef877632", + "size": "17044" + }, + "linux-sbsa": { + "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "58c304116de3d184cebcc7d04934bff9d99d2276ff28c46372664bc3fcc32976", + "md5": "75920888da1f2ab140a90f490195a636", + "size": "17048" + }, + "windows-x86_64": { + "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-13.0.85-archive.zip", + "sha256": "38c6c854f325b64e7ca0a8b14e1996dedb5abbb38f3580e5c7744b688abdc56e", + "md5": "61c405a619241f213110f0a5ea7fe559", + "size": "21185" + } + }, + "cuda_sandbox_dev": { + "name": "CUDA nvsandboxutils Headers", + "license": "CUDA Toolkit", + "license_path": "cuda_sandbox_dev/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_sandbox_dev/linux-x86_64/cuda_sandbox_dev-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "642d3dccf9c59d3238659687cdb968f85f643b089c946e35ce278ae59288d73e", + "md5": "6ea5dd26e7ea3c047ebb6c8de171ab2c", + "size": "30208" + }, + "linux-sbsa": { + "relative_path": "cuda_sandbox_dev/linux-sbsa/cuda_sandbox_dev-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "d3aaa63a9fbbee1eb656b10390dd2f0d86c9e9329b578e27c11bbe4fea3cdab6", + "md5": "483d362d27d9b828f10b16ee32f2e90d", + "size": "30792" + } + }, + "cuda_sanitizer_api": { + "name": "CUDA Compute Sanitizer API", + "license": "CUDA Toolkit", + "license_path": "cuda_sanitizer_api/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "8eeba425f66fdd17e78d0dff49baa8b3e4599fc0579984eab7ad9c486a95ebf2", + "md5": "47623b2482a3c6e09710d63b44d97b90", + "size": "11399964" + }, + "linux-sbsa": { + "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "68cc7d0144cdf746d4e76565dca86002979ecab5c5674be01bb3fbd3628531e5", + "md5": "02b4d469d5099b8853a2669f338e155d", + "size": "8547700" + }, + "windows-x86_64": { + "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-13.0.85-archive.zip", + "sha256": "dcca7ce173165d75eb7f5df76672ec598b11f12e583356eaf80b16f6d43ace9f", + "md5": "07ac1cb30f5ea1810092ea08bd4d0fbb", + "size": "10867115" + } + }, + "driver_assistant": { + "name": "NVIDIA Driver Assistant", + "license": "MIT", + "license_path": "driver_assistant/LICENSE.txt", + "version": "0.22.95.05", + "linux-all": { + "relative_path": "driver_assistant/source/driver_assistant-0.22.95.05-archive.tar.xz", + "sha256": "1f4d19c468988dc0f23ca7c1844d6434dfc9a6f0c4eaca43a7a63ab9a51c8552", + "md5": "bce1617e3337e8bbab4a51937e0ff544", + "size": "38944" + } + }, + "fabricmanager": { + "name": "NVIDIA Fabric Manager", + "license": "NVIDIA Driver", + "license_path": "fabricmanager/LICENSE.txt", + "version": "580.95.05", + "linux-x86_64": { + "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-580.95.05-archive.tar.xz", + "sha256": "f0220bfb67d04b4107acf00cc95abe5a9268fd8f8b5bae26971f4df232e4369c", + "md5": "a6568aa288cb4784b85ba6826463f918", + "size": "8249864" + }, + "linux-sbsa": { + "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-580.95.05-archive.tar.xz", + "sha256": "ea91191e91b306da1ee2932da399fab8fe46395ec6820f638432b0176fc7a28e", + "md5": "3acd0c87be46dfcc6a45704aa34f0f03", + "size": "7501248" + } + }, + "imex": { + "name": "Nvidia-Imex", + "license": "NVIDIA Proprietary", + "license_path": "imex/LICENSE.txt", + "version": "580.95.05", + "linux-x86_64": { + "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-580.95.05-archive.tar.xz", + "sha256": "8f8c2fe1571ffbc9d7810289b8fb323340083a896d51daffeebee94d5a60b37e", + "md5": "0557449a6dadc51171bc54323a1b64c9", + "size": "7772976" + }, + "linux-sbsa": { + "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-580.95.05-archive.tar.xz", + "sha256": "3d0179eeed5899b32bb893ec3466c9e3ae347bf7947e35313224480eb966ed92", + "md5": "c7e9affa44fbb1d94d7888808b706eed", + "size": "7212868" + } + }, + "libcublas": { + "name": "CUDA cuBLAS", + "license": "CUDA Toolkit", + "license_path": "libcublas/LICENSE.txt", + "version": "13.1.0.3", + "linux-x86_64": { + "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-13.1.0.3-archive.tar.xz", + "sha256": "88bc951efd906032a371153ca61975e0d9c4761e4012169169a6b3a47931606e", + "md5": "980968a3f2a7fc483be4a07dd56e09ad", + "size": "838952932" + }, + "linux-sbsa": { + "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-13.1.0.3-archive.tar.xz", + "sha256": "18832d4798b0a4fc75fa90d58c1780203713ca2e35751a2492262e58f2620c50", + "md5": "5773abd5980d9a7af9c0732700287156", + "size": "1084803912" + }, + "windows-x86_64": { + "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-13.1.0.3-archive.zip", + "sha256": "4ac4847bbe4f7709b244956fcfc32197a2954ee70b155cb67eebd9ee26f7e339", + "md5": "1d3169b46c18bbb58df11c1227931a54", + "size": "403672823" + } + }, + "libcufft": { + "name": "CUDA cuFFT", + "license": "CUDA Toolkit", + "license_path": "libcufft/LICENSE.txt", + "version": "12.0.0.61", + "linux-x86_64": { + "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-12.0.0.61-archive.tar.xz", + "sha256": "5cdef1238c270f8f148da18587fdba8b9478c596e40f5490bba2b15c94915dd9", + "md5": "aec4ffbf2d55707649295e0372ee3d36", + "size": "354634628" + }, + "linux-sbsa": { + "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-12.0.0.61-archive.tar.xz", + "sha256": "5361f3b22a50923204e07f7ff601150dc67aab6b0fff26c47bd3ac0a50c921a0", + "md5": "d4a1bd6640e13b13bc919ba6d5128290", + "size": "354230580" + }, + "windows-x86_64": { + "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-12.0.0.61-archive.zip", + "sha256": "4f2695ea50f895618316ee32636f5d0e5e0bc330e74b3e0876bff002af9e1eb3", + "md5": "3d031b8a3629ea62add09f974d608f3f", + "size": "212026245" + } + }, + "libcufile": { + "name": "CUDA cuFile", + "license": "CUDA Toolkit", + "license_path": "libcufile/LICENSE.txt", + "version": "1.15.1.6", + "linux-x86_64": { + "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.15.1.6-archive.tar.xz", + "sha256": "2c1f544ab1b0e215590d943cbd1b0a192a066e9b7592e605c2e28b22e886688f", + "md5": "c745668d5bebe08c01473d48bf398833", + "size": "42256540" + }, + "linux-sbsa": { + "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.15.1.6-archive.tar.xz", + "sha256": "e41292a40bb89bb6f64e19972d3d9a209eddcbb96299a777b2edfa6b7d5b8777", + "md5": "91e1dc883031e2b90351634ad4768e4d", + "size": "42514828" + } + }, + "libcurand": { + "name": "CUDA cuRAND", + "license": "CUDA Toolkit", + "license_path": "libcurand/LICENSE.txt", + "version": "10.4.0.35", + "linux-x86_64": { + "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.4.0.35-archive.tar.xz", + "sha256": "ee0dbf473998050bda876cb945634bec87d44b90b05a5550e9c2499ab7c1a5c3", + "md5": "e236c0f2483e83d614b563a9dc136ba3", + "size": "86175028" + }, + "linux-sbsa": { + "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.4.0.35-archive.tar.xz", + "sha256": "12a0afe1ee73e806924fc6c9bdd33a47a970d31967a634ec9ab2f0662a502ed2", + "md5": "1aa3ad816d7bd327c2561712426c471a", + "size": "87176908" + }, + "windows-x86_64": { + "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.4.0.35-archive.zip", + "sha256": "c4db1ed0595fcdba3c4da0f5605ca4c3f4340b6be833d94765994e239c775a32", + "md5": "b204f174a5bf30a728a4f6f68356ad8c", + "size": "54762976" + } + }, + "libcusolver": { + "name": "CUDA cuSOLVER", + "license": "CUDA Toolkit", + "license_path": "libcusolver/LICENSE.txt", + "version": "12.0.4.66", + "linux-x86_64": { + "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-12.0.4.66-archive.tar.xz", + "sha256": "1cd13dcb58c5e4bb0ce47ea8876aba21091c1e67165c616144b2dd6331d252ec", + "md5": "0dd4b521ddaa0a475a528ef61bd91f7c", + "size": "265714920" + }, + "linux-sbsa": { + "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-12.0.4.66-archive.tar.xz", + "sha256": "882c480bedd5ec6e416fe0a9edb7bfdd78f6ffa885310870e4a04d8fce8e655d", + "md5": "c43e9ec46e165d5af53df9353eee9512", + "size": "291337460" + }, + "windows-x86_64": { + "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-12.0.4.66-archive.zip", + "sha256": "8fe0aa8b2f8709402a8a7494037cdb648f0be7da1ed14e511cefea88a532ef8b", + "md5": "ab03f6e62dadab74f4a475068615b935", + "size": "193265103" + } + }, + "libcusparse": { + "name": "CUDA cuSPARSE", + "license": "CUDA Toolkit", + "license_path": "libcusparse/LICENSE.txt", + "version": "12.6.3.3", + "linux-x86_64": { + "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.6.3.3-archive.tar.xz", + "sha256": "b9de356c3478329e2589d91284f2a685a36f041060f3cb897441ab46a480a30a", + "md5": "4c101a89f3b6185ac36e1e98e2d45f15", + "size": "278384532" + }, + "linux-sbsa": { + "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.6.3.3-archive.tar.xz", + "sha256": "50c9fb74e8468af559150f3f072cc2793a5ff70792fa79962146096385cf7346", + "md5": "fed1a66a5af73ab124faf01e886c4470", + "size": "308854880" + }, + "windows-x86_64": { + "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.6.3.3-archive.zip", + "sha256": "21f70385aae76de5c24c6baab4df4337d0bc9e1ce69e9ebad228d87d686a28e6", + "md5": "4980a04d3a1a810fe86e76693dc9624e", + "size": "143747284" + } + }, + "libnpp": { + "name": "CUDA NPP", + "license": "CUDA Toolkit", + "license_path": "libnpp/LICENSE.txt", + "version": "13.0.1.2", + "linux-x86_64": { + "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-13.0.1.2-archive.tar.xz", + "sha256": "b99e7e145283667728e5fd1bf99c79ed9825c164d3c4a40f6dc549cb0b0e1333", + "md5": "27a886d47c737964fa4a628997efad31", + "size": "240938928" + }, + "linux-sbsa": { + "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-13.0.1.2-archive.tar.xz", + "sha256": "6d06bd527b3cb17e354a3d25f9334ff9f972f6af7dc1fe0a7e0f5b87ba6e618a", + "md5": "d5e81e33a02980c1320f45c482b34f39", + "size": "267380224" + }, + "windows-x86_64": { + "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-13.0.1.2-archive.zip", + "sha256": "cec65b472cdbd97c557cc45cabc5998288b48c166b9e05d95b8ee3e44083906b", + "md5": "b4eeff86fa222309f114eced88ee3bd5", + "size": "129562453" + } + }, + "libnvfatbin": { + "name": "NVIDIA compiler library for fatbin interaction", + "license": "CUDA Toolkit", + "license_path": "libnvfatbin/LICENSE.txt", + "version": "13.0.85", + "linux-x86_64": { + "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-13.0.85-archive.tar.xz", + "sha256": "2f23e25c90517aefd0417304a6b428760373bac78a57d0137645b1bd326f754d", + "md5": "298af14438a14e755d2c9deb90ea2604", + "size": "940220" + }, + "linux-sbsa": { + "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-13.0.85-archive.tar.xz", + "sha256": "2599efa23bd85d29526bc579ee86c810705bfbfbefd033e4df85b13a2e8e661f", + "md5": "9208373e18a48e5ae61d161a07b3ffcc", + "size": "848440" + }, + "windows-x86_64": { + "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-13.0.85-archive.zip", + "sha256": "ba40fc248c8cf1e709004adeb8c92ac1343048b23a56961e93d282eaed9b3566", + "md5": "7200ba0c4a4c786fd671acfe85fd425d", + "size": "2242775" + } + }, + "libnvidia_nscq": { + "name": "NVIDIA NSCQ API", + "license": "NVIDIA Driver", + "license_path": "libnvidia_nscq/LICENSE.txt", + "version": "580.95.05", + "linux-x86_64": { + "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-580.95.05-archive.tar.xz", + "sha256": "c2285c12f10ec2afc0ad2949f7fcc282b6fd37f32165c1df241451ccabb1067a", + "md5": "6bc20061ebdae98fadd7a76110b44430", + "size": "380464" + }, + "linux-sbsa": { + "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-580.95.05-archive.tar.xz", + "sha256": "67cba21aad38e48247e88f480ed67a3096f7173abc190a3f3fbcb312f9649ac6", + "md5": "e368f46e7ea592090d3efe425ffc5bbe", + "size": "351076" + } + }, + "libnvjitlink": { + "name": "NVIDIA compiler library for JIT LTO functionality", + "license": "CUDA Toolkit", + "license_path": "libnvjitlink/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "25f9763fd60122a4f728eec22ac4e64e46ea8679e140234f15eaec008e6c41a8", + "md5": "ad488d8956b7e93e6386ede30a3f2e6d", + "size": "55521316" + }, + "linux-sbsa": { + "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "b7c25896af24ea88309301c8325449cd3d4907b3f1db4060f43a8ca8f4738cdc", + "md5": "3febdc80a7af025dc93a2091bb97648e", + "size": "49924684" + }, + "windows-x86_64": { + "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-13.0.88-archive.zip", + "sha256": "4b2cff3cfcec50cab2193f11cee023589b1b3b15388ab38780ea08b7ebbf15e3", + "md5": "e4b5c1e668ce33e44b643e14342504e8", + "size": "269633168" + } + }, + "libnvjpeg": { + "name": "CUDA nvJPEG", + "license": "CUDA Toolkit", + "license_path": "libnvjpeg/LICENSE.txt", + "version": "13.0.1.86", + "linux-x86_64": { + "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-13.0.1.86-archive.tar.xz", + "sha256": "ebef16a52d31d2de0e888f0fd9c788bfe99be988ebad4927754e5ccdfdae6360", + "md5": "23291f980056e22961a2ab83e6a1c52c", + "size": "3618252" + }, + "linux-sbsa": { + "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-13.0.1.86-archive.tar.xz", + "sha256": "6132e76ec6064881592b38ef5b2a135237005d8533660ee8f525b120a178d1f4", + "md5": "b2c038c246ca28a1446eaf235769ea62", + "size": "3460824" + }, + "windows-x86_64": { + "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-13.0.1.86-archive.zip", + "sha256": "b8d64f9fb90632e33685529e2b8baee245ca3dcaecab4b8998815ae0f44c5171", + "md5": "8c0faada587f472d75ae4e22ced3f6c1", + "size": "3144778" + } + }, + "libnvptxcompiler": { + "name": "CUDA libnvptxcompiler", + "license": "CUDA Toolkit", + "license_path": "libnvptxcompiler/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "libnvptxcompiler/linux-x86_64/libnvptxcompiler-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "3d2a51c6816278b90167550a7e0e9adfff9c8c919d87ef980565c0eb7fc23830", + "md5": "c2877d647902ab01f88b922306189a8c", + "size": "13779680" + }, + "linux-sbsa": { + "relative_path": "libnvptxcompiler/linux-sbsa/libnvptxcompiler-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "fa47b2045245c5e86d41f9f13d571514f12a9f84eaaf0680087813fd71c3c0bd", + "md5": "5a4d6a737853f25547a2a47287572c08", + "size": "12913976" + }, + "windows-x86_64": { + "relative_path": "libnvptxcompiler/windows-x86_64/libnvptxcompiler-windows-x86_64-13.0.88-archive.zip", + "sha256": "863efcf751575f17111b99d0e553de954d3e8c9a91315505605601b0cc33fe4d", + "md5": "b920f1abf2214e335d6ff22d8188cbeb", + "size": "46889642" + } + }, + "libnvsdm": { + "name": "LIBNVSDM", + "license": "NVIDIA", + "license_path": "libnvsdm/LICENSE.txt", + "version": "580.95.05", + "linux-x86_64": { + "relative_path": "libnvsdm/linux-x86_64/libnvsdm-linux-x86_64-580.95.05-archive.tar.xz", + "sha256": "61731fb08bcc5cc143e8514d5ec4f24d42ef9f2563d0ba1ea78bac9eabee8075", + "md5": "a46f9176919e90badd89240de658ec7c", + "size": "499756" + } + }, + "libnvvm": { + "name": "CUDA NVVM", + "license": "CUDA Toolkit", + "license_path": "libnvvm/LICENSE.txt", + "version": "13.0.88", + "linux-x86_64": { + "relative_path": "libnvvm/linux-x86_64/libnvvm-linux-x86_64-13.0.88-archive.tar.xz", + "sha256": "17ef1665b63670887eeba7d908da5669fa8c66bb73b5b4c1367f49929c086353", + "md5": "816927093ffbdc10fddd751f045396b1", + "size": "43645408" + }, + "linux-sbsa": { + "relative_path": "libnvvm/linux-sbsa/libnvvm-linux-sbsa-13.0.88-archive.tar.xz", + "sha256": "f94feb1a0da0c55ceb5c7f039c1f0ffad5d162e0fedfb565efb87771187ddcfd", + "md5": "b9730ee7e25db76caa843c858af31d98", + "size": "38570872" + }, + "windows-x86_64": { + "relative_path": "libnvvm/windows-x86_64/libnvvm-windows-x86_64-13.0.88-archive.zip", + "sha256": "6dda4a82d22a2c173a65c66b4b4c933e3424a56ce845e2864bdca9cc66e6c524", + "md5": "779d2fb0a5235cc7763c06686def0226", + "size": "52909116" + } + }, + "mft": { + "name": "NVLink 5 MFT", + "license": "NVIDIA Proprietary", + "license_path": "mft/LICENSE.txt", + "version": "4.33.0.3004", + "linux-x86_64": { + "relative_path": "mft/linux-x86_64/mft-linux-x86_64-4.33.0.3004-archive.tar.xz", + "sha256": "d8b885df13e32730275436d56cd48a3c4a755b2591ff4e3e6836c7a9f9433af1", + "md5": "0ee5b7ee7e9e3d982d39c65117891db9", + "size": "50206528" + }, + "linux-sbsa": { + "relative_path": "mft/linux-sbsa/mft-linux-sbsa-4.33.0.3004-archive.tar.xz", + "sha256": "26aa6ecb6827d88003b50c7d649962b78eb58cba190fdb1f4836b9a3bc75b22e", + "md5": "93f81aed65d166b5cb4b2c1193778f3d", + "size": "46314988" + } + }, + "mft_autocomplete": { + "name": "NVLink 5 MFT AUTOCOMPLETE", + "license": "NVIDIA Proprietary", + "license_path": "mft_autocomplete/LICENSE.txt", + "version": "4.33.0.3004", + "linux-x86_64": { + "relative_path": "mft_autocomplete/linux-x86_64/mft_autocomplete-linux-x86_64-4.33.0.3004-archive.tar.xz", + "sha256": "8d16437d55f15ab5c6da9fa26aec6806eb7f6e9606006a7f09593344c848acdb", + "md5": "00c429dd417652d24a93f7e66fbab865", + "size": "12240" + }, + "linux-sbsa": { + "relative_path": "mft_autocomplete/linux-sbsa/mft_autocomplete-linux-sbsa-4.33.0.3004-archive.tar.xz", + "sha256": "b4d492b889d76ea156b97739da4661dfd36c2053a0090065317701c323b51859", + "md5": "1a7327e04ae79247054cc551d8f0b263", + "size": "12176" + } + }, + "mft_oem": { + "name": "NVLink 5 MFT OEM", + "license": "NVIDIA Proprietary", + "license_path": "mft_oem/LICENSE.txt", + "version": "4.33.0.3004", + "linux-x86_64": { + "relative_path": "mft_oem/linux-x86_64/mft_oem-linux-x86_64-4.33.0.3004-archive.tar.xz", + "sha256": "0f703047ad69e46c6e3f021fc1ae5e086530a52311da08b3a49451db7f1332e7", + "md5": "42498e50e4bdedbb3a99ba434a3ee6a5", + "size": "3674360" + }, + "linux-sbsa": { + "relative_path": "mft_oem/linux-sbsa/mft_oem-linux-sbsa-4.33.0.3004-archive.tar.xz", + "sha256": "fb755738e56a883d68bb408f28e293df00d1e66e1554e48f339f0f0cf0b7be04", + "md5": "fe00dfbbac0c16f74e0d8f21a759d522", + "size": "3276404" + } + }, + "nsight_compute": { + "name": "Nsight Compute", + "license": "NVIDIA SLA", + "license_path": "nsight_compute/LICENSE.txt", + "version": "2025.3.1.4", + "linux-x86_64": { + "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2025.3.1.4-archive.tar.xz", + "sha256": "d3c0a0402511034c58227b817cbfed599765f32dc662cdcda58922247b52dd7a", + "md5": "05222d0ca8b526f7f94d95e60dbb0459", + "size": "322049776" + }, + "linux-sbsa": { + "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2025.3.1.4-archive.tar.xz", + "sha256": "562acdb72942ba3250fbda1d0a5b45d9d8bebf7295049846d16ffbdb457f9d28", + "md5": "e061682e32865f54d6499c402cb1f340", + "size": "141672040" + }, + "windows-x86_64": { + "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2025.3.1.4-archive.zip", + "sha256": "0ad1c310f38cdfc17e85f6efa2da60e7628bd2db81eba8ec487ab6d49c1bcdef", + "md5": "a78ed24bbe8554a6ff7ebfff6c516185", + "size": "371135506" + } + }, + "nsight_systems": { + "name": "Nsight Systems", + "license": "NVIDIA SLA", + "license_path": "nsight_systems/LICENSE.txt", + "version": "2025.3.2.474", + "linux-x86_64": { + "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2025.3.2.474-archive.tar.xz", + "sha256": "fa4e9908e9a593383ac7f669472dd52e712cbc426f69b349ada363e80cdebbd5", + "md5": "e0dbd1d1d1d7ab7387eb2cf2c7b6cabc", + "size": "1131797276" + }, + "linux-sbsa": { + "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2025.3.2.474-archive.tar.xz", + "sha256": "547bc5c72df6adc325a761201f4d7e20a2c80c94adf1169f6d365c6995594b4f", + "md5": "5a6bdffed12380675d576ca20d81a1b4", + "size": "1025797284" + }, + "windows-x86_64": { + "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2025.3.2.474-archive.zip", + "sha256": "7b55f8fedbcf797817e5062fbdec55f8b90c26c62c0451adc68cf2f30000752a", + "md5": "f1f3f495e27127f32a8e6d8486df0385", + "size": "446766583" + } + }, + "nsight_vse": { + "name": "Nsight Visual Studio Edition (VSE)", + "license": "NVIDIA SLA", + "license_path": "nsight_vse/LICENSE.txt", + "version": "2025.3.1.25227", + "windows-x86_64": { + "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2025.3.1.25227-archive.zip", + "sha256": "bc92e5c1bb1a45f60d4e8382169990094b1f8531f37cafb180690d5bb14e2fce", + "md5": "00022c2eafadf7bc024625629f896b74", + "size": "200540705" + } + }, + "nvidia_driver": { + "name": "NVIDIA Linux Driver", + "license": "NVIDIA Driver", + "license_path": "nvidia_driver/LICENSE.txt", + "version": "580.95.05", + "linux-x86_64": { + "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-580.95.05-archive.tar.xz", + "sha256": "3528df4fb0c7a1665ae2af5d26effeb67f76fc86742ffc1defd7714408405d4d", + "md5": "414882bb4f82d3f30f56e22bcb162a67", + "size": "492741996" + }, + "linux-sbsa": { + "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-580.95.05-archive.tar.xz", + "sha256": "95b52919632928d7a245e5696b71cd68285e6bffd1f22cdcd4f9686d5d5b0b09", + "md5": "119f7e0375f09e0a9c1ec4befca800f0", + "size": "367188496" + } + }, + "nvidia_fs": { + "name": "NVIDIA filesystem", + "license": "CUDA Toolkit", + "license_path": "nvidia_fs/LICENSE.txt", + "version": "2.26.6", + "linux-x86_64": { + "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.26.6-archive.tar.xz", + "sha256": "39ff513827f39c26140303c2b1eb28cb46e2afb6f6676881dfcd6e7b0248bcee", + "md5": "9cdd880eb9678967d8e0712f708eeca5", + "size": "60292" + }, + "linux-sbsa": { + "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.26.6-archive.tar.xz", + "sha256": "de648016c4123afe65684448ee0e8719cf9d4f934bb63a82239411f6c7fd1fc1", + "md5": "51c58f7b414b3461f0bdc71316dc2f50", + "size": "60308" + } + }, + "nvlsm": { + "name": "NVLSM SM component", + "license": "NVIDIA Proprietary", + "license_path": "nvlsm/LICENSE.txt", + "version": "2025.06.6", + "linux-x86_64": { + "relative_path": "nvlsm/linux-x86_64/nvlsm-linux-x86_64-2025.06.6-archive.tar.xz", + "sha256": "bd77ad2504966450aab15041223eea34538a57e870b7d447c097ec721efba792", + "md5": "798accd845365da78e2ce99b0aac22ce", + "size": "7005320" + }, + "linux-sbsa": { + "relative_path": "nvlsm/linux-sbsa/nvlsm-linux-sbsa-2025.06.6-archive.tar.xz", + "sha256": "1f24d590129e4951d57b1ba75f321bc7ec66b487249ac53b771f0d3a5c5ff371", + "md5": "953f75c92485fd63057ec365511f27da", + "size": "9365804" + } + }, + "visual_studio_integration": { + "name": "CUDA Visual Studio Integration", + "license": "CUDA Toolkit", + "license_path": "visual_studio_integration/LICENSE.txt", + "version": "13.0.85", + "windows-x86_64": { + "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-13.0.85-archive.zip", + "sha256": "babb8113ae3845fff6cac0fd8a14838d384d61960bcc60289b72129e8db08bd9", + "md5": "9577f804ebffb01e9876a7d7b33cba1f", + "size": "887859" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudnn/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/README.md new file mode 100644 index 000000000000..ca6a04ea7074 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/README.md @@ -0,0 +1,8 @@ +# cudnn + +Link: + +Requirements: + +8.9.7 is the latest release from the 8.x series and supports everything but Jetson. +8.9.5 is the latest release from the 8.x series that supports Jetson. diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.5.json b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.5.json new file mode 100644 index 000000000000..6d1962435bfa --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.5.json @@ -0,0 +1,139 @@ +{ + "release_date": "2024-03-15", + "release_label": "8.9.5", + "release_product": "cudnn", + "cudnn": { + "name": "NVIDIA CUDA Deep Neural Network library", + "license": "cudnn", + "license_path": "cudnn/LICENSE.txt", + "version": "8.9.5.30", + "cuda_variant": [ + "11", + "12" + ], + "linux-x86_64": { + "cuda11": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "bbe10e3c08cd7e4aea1012213781e4fe270e1c908263444f567cafefb2cc6525", + "md5": "300aaaa05ca6d12b3ac058fd0bd70c6b", + "size": "857471712" + }, + "cuda12": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "2a2eb89a2ab51071151c6082f1e816c702167a711a9372f9f73a7b5c4b06e01a", + "md5": "afb13f2d7377f4a16b54a6acc373bbd9", + "size": "861488496" + } + }, + "linux-ppc64le": { + "cuda11": { + "relative_path": "cudnn/linux-ppc64le/cudnn-linux-ppc64le-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "d678f8b2903b95de7eeaef38890c5674705864ea049b2b63e90565f2c0ea682f", + "md5": "daed75ed0c9f4dcc5b9521d2a833be3d", + "size": "860245008" + }, + "cuda12": { + "relative_path": "cudnn/linux-ppc64le/cudnn-linux-ppc64le-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "38388ec3c99c6646aaf5c707985cd35e25c67f653d780c4081c2df5557ab665f", + "md5": "8893605a415202937ad9f2587e7a16ce", + "size": "862346664" + } + }, + "linux-sbsa": { + "cuda11": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "50e3d38cb70a53bb059da0aefc60e1460729c6988e2697200c43b80d218e556c", + "md5": "3479f3fdbda83cd6df104851dc1f940a", + "size": "857816268" + }, + "cuda12": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "107d3dbec6345e1a3879a151cf3cbf6a2d96162c7b8eeb2ff85b84a67e79e2d1", + "md5": "90715ef0e48f6f153587ee59df7c1a87", + "size": "859978180" + } + }, + "windows-x86_64": { + "cuda11": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-8.9.5.30_cuda11-archive.zip", + "sha256": "e42aaa92203cc101a1619656ae50852a0d818a06ca99684c5f51ba95bd7a7cf9", + "md5": "d2f4fbc710da61253570306ed2e63ac4", + "size": "701179425" + }, + "cuda12": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-8.9.5.30_cuda12-archive.zip", + "sha256": "be76d407ce0e609f94688aa45bfd5648fd21a4d9f84a588fad10aa4802ca1301", + "md5": "54146d8da6df9da3ef125171da959dcf", + "size": "705347747" + } + }, + "linux-aarch64": { + "cuda12": { + "relative_path": "cudnn/linux-aarch64/cudnn-linux-aarch64-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "0491f7b02f55c22077eb678bf314c1f917524bd507cf5b658239bf98a47233a1", + "md5": "fffd4a177c3e2ebaaceb83131d69e4e3", + "size": "891432124" + } + } + }, + "cudnn_samples": { + "name": "NVIDIA cuDNN samples", + "license": "cudnn", + "license_path": "cudnn_samples/LICENSE.txt", + "version": "8.9.5.30", + "cuda_variant": [ + "11", + "12" + ], + "linux-x86_64": { + "cuda11": { + "relative_path": "cudnn_samples/linux-x86_64/cudnn_samples-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "9c0d951788461f6e9e000209cf4b100839effd1fd300371dfa6929552c8b1d4e", + "md5": "dcbdaaa0171aa6b8331fcd6218558953", + "size": "1665468" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-x86_64/cudnn_samples-linux-x86_64-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "441d262d82888c6ca5a02c8ad0f07c3a876be7b473bc2ec2638d86ea2e80a884", + "md5": "a2ca6bf77b610024aff5c1a7ee53ea01", + "size": "1664272" + } + }, + "linux-ppc64le": { + "cuda11": { + "relative_path": "cudnn_samples/linux-ppc64le/cudnn_samples-linux-ppc64le-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "ded84be373031ff843c0b7118e9fdb48b06ec763eae3c76cb9c57e121b47c228", + "md5": "d4d76362cf7ba0a0711088c38a3e17a7", + "size": "1666372" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-ppc64le/cudnn_samples-linux-ppc64le-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "275d6a6671c210d4c4a92240de24cba0c5ca17e9007f91656b18bbff81621f81", + "md5": "b13c3befd24473ad536ef6ea3f4dc939", + "size": "1666788" + } + }, + "linux-sbsa": { + "cuda11": { + "relative_path": "cudnn_samples/linux-sbsa/cudnn_samples-linux-sbsa-8.9.5.30_cuda11-archive.tar.xz", + "sha256": "fa2150dff6f574fb2927bfd2d10b5c2e2e90603f59d3d3371eaa41f2e9528c74", + "md5": "80783b38089b6573943959e873693f0a", + "size": "1665660" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-sbsa/cudnn_samples-linux-sbsa-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "af98dec9cf613cb7f67e27f5a5da24fc183996fc25a875aa0a7dc2914c986fe3", + "md5": "5f5b67f5d2862190ae9440ca7041b7a5", + "size": "1668336" + } + }, + "linux-aarch64": { + "cuda12": { + "relative_path": "cudnn_samples/linux-aarch64/cudnn_samples-linux-aarch64-8.9.5.30_cuda12-archive.tar.xz", + "sha256": "044c0d4436e1ecff6785a8bacf45cf2b5d504eb1c04bb9617aed86bfea77e45f", + "md5": "ad2c201cf63561b5f0ddf505706eed97", + "size": "1663868" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.7.json b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.7.json new file mode 100644 index 000000000000..b5940fd5275c --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_8.9.7.json @@ -0,0 +1,123 @@ +{ + "release_date": "2024-03-15", + "release_label": "8.9.7", + "release_product": "cudnn", + "cudnn": { + "name": "NVIDIA CUDA Deep Neural Network library", + "license": "cudnn", + "license_path": "cudnn/LICENSE.txt", + "version": "8.9.7.29", + "cuda_variant": [ + "11", + "12" + ], + "linux-x86_64": { + "cuda11": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "a3e2509028cecda0117ce5a0f42106346e82e86d390f4bb9475afc976c77402e", + "md5": "9ee28df53dc5f83d97f5406f880d3953", + "size": "860967256" + }, + "cuda12": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "475333625c7e42a7af3ca0b2f7506a106e30c93b1aa0081cd9c13efb6e21e3bb", + "md5": "046e32d5ab0fdc56878e9b33f3a6883d", + "size": "864984964" + } + }, + "linux-ppc64le": { + "cuda11": { + "relative_path": "cudnn/linux-ppc64le/cudnn-linux-ppc64le-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "f23fd7d59f9d4f743fa926f317dab0d37f6ea21edb2726ceb607bea45b0f9f36", + "md5": "44d8f80a90b6ba44379727a49a75b1fc", + "size": "863759764" + }, + "cuda12": { + "relative_path": "cudnn/linux-ppc64le/cudnn-linux-ppc64le-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "8574d291b299f9cc0134304473c9933bd098cc717e8d0876f4aba9f9eebe1b76", + "md5": "7acbeb71d48373ea343c13028172c783", + "size": "865846096" + } + }, + "linux-sbsa": { + "cuda11": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "91c37cfb458f541419e98510f13aaf5975c0232c613e18b776385490074eea17", + "md5": "b4ae46fb80f2f8ef283d038585bbb122", + "size": "861355724" + }, + "cuda12": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "e98b7c80010785e5d5ca01ee4ce9b5b0c8c73587ea6f8648be34d3f8d1d47bd1", + "md5": "52a436f378d20b8e1e1a8a173a8bdeda", + "size": "863497272" + } + }, + "windows-x86_64": { + "cuda11": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-8.9.7.29_cuda11-archive.zip", + "sha256": "5e45478efe71a96329e6c0d2a3a2f79c747c15b2a51fead4b84c89b02cbf1671", + "md5": "7dddb764c0a608ac23e72761be4c92c0", + "size": "704240064" + }, + "cuda12": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-8.9.7.29_cuda12-archive.zip", + "sha256": "94fc17af8e83a26cc5d231ed23981b28c29c3fc2e87b1844ea3f46486f481df5", + "md5": "30f8a180be36451511306f7837270214", + "size": "708408517" + } + } + }, + "cudnn_samples": { + "name": "NVIDIA cuDNN samples", + "license": "cudnn", + "license_path": "cudnn_samples/LICENSE.txt", + "version": "8.9.7.29", + "cuda_variant": [ + "11", + "12" + ], + "linux-x86_64": { + "cuda11": { + "relative_path": "cudnn_samples/linux-x86_64/cudnn_samples-linux-x86_64-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "8b17f56e9d654d9af3d7711645811fb6f240f53bc2d62c00c063a6d452d80091", + "md5": "b5410e97c73ea206b3d8939ce6ff8832", + "size": "1664448" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-x86_64/cudnn_samples-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "d3a9a4f3f74b04c393bb9152fe3a53ac1514da679ca57858d69f64243debb905", + "md5": "348306c65eb4c865fba72332fa7a5f33", + "size": "1665932" + } + }, + "linux-ppc64le": { + "cuda11": { + "relative_path": "cudnn_samples/linux-ppc64le/cudnn_samples-linux-ppc64le-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "29a18538f13a63ee54cd795c78f64a1ca45df2de0b140cf095281a16d1d4d4e3", + "md5": "9f398a26a5c7913faf58e8ee3bd9c6ff", + "size": "1665244" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-ppc64le/cudnn_samples-linux-ppc64le-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "80664b7a6abed08633e0dc238f47f26aaaa0add5571bf6f4f4e475686a702c8d", + "md5": "6aa5e8e801b5f730a103aaf52c66485e", + "size": "1668400" + } + }, + "linux-sbsa": { + "cuda11": { + "relative_path": "cudnn_samples/linux-sbsa/cudnn_samples-linux-sbsa-8.9.7.29_cuda11-archive.tar.xz", + "sha256": "dd7b618f4af89fff9cdad9cd87dbc4380c7f6120460c174bd10fef6342099915", + "md5": "841a6dde4037a39f7ddd0fb92f245c9d", + "size": "1666176" + }, + "cuda12": { + "relative_path": "cudnn_samples/linux-sbsa/cudnn_samples-linux-sbsa-8.9.7.29_cuda12-archive.tar.xz", + "sha256": "4d84211d62e636ad3728674e55e9ce91e29c78d071fcb78453f8a71902758836", + "md5": "0e80992ee19918efd714199f41cbe24b", + "size": "1664288" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_9.13.0.json b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_9.13.0.json new file mode 100644 index 000000000000..15367f5a3fa6 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudnn/redistrib_9.13.0.json @@ -0,0 +1,121 @@ +{ + "release_date": "2025-09-04", + "release_label": "9.13.0", + "release_product": "cudnn", + "cudnn": { + "name": "NVIDIA CUDA Deep Neural Network library", + "license": "cudnn", + "license_path": "cudnn/LICENSE.txt", + "version": "9.13.0.50", + "linux-x86_64": { + "cuda12": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-9.13.0.50_cuda12-archive.tar.xz", + "sha256": "28c5c59316464434eb7bafe75fc36285160c28d559a50056ded13394955d1f7d", + "md5": "55633b6a710506c4e4d704aef42a5fdd", + "size": "873944756" + }, + "cuda13": { + "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-9.13.0.50_cuda13-archive.tar.xz", + "sha256": "02f47d9456773c80d97ed245efd9eb22bb985dcfdb74559213536035291e7a01", + "md5": "ff33c2783f44d10874f93d32d13764ab", + "size": "641302680" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-9.13.0.50_cuda12-archive.tar.xz", + "sha256": "28f3f86aa102870c5d6804bca1bb1a0dcc1df69d0235c0a4120ae0aa6d14ffc7", + "md5": "9bd5d15c46ccc94e7191e47446f22e62", + "size": "873177712" + }, + "cuda13": { + "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-9.13.0.50_cuda13-archive.tar.xz", + "sha256": "78931057322ab87b72b0a988462568412edfed5bdef1eaf717961351b53cb3d0", + "md5": "aadbfef24b136ce2385170c19213c4fa", + "size": "766735516" + } + }, + "windows-x86_64": { + "cuda12": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-9.13.0.50_cuda12-archive.zip", + "sha256": "827e294e13e352586a5bcf5b2188025fe5cba590df69b8010e97dd30b9a0266f", + "md5": "e08c945fd8f570e6779ce9cb216bcf20", + "size": "621840857" + }, + "cuda13": { + "relative_path": "cudnn/windows-x86_64/cudnn-windows-x86_64-9.13.0.50_cuda13-archive.zip", + "sha256": "6314aa4ca21e727bc012fecf2bf7192276ac7b648e1f709f52947496d70808dd", + "md5": "d5fa2f7d1596bc6bbabb6888f9139fd4", + "size": "337906764" + } + }, + "linux-aarch64": { + "cuda12": { + "relative_path": "cudnn/linux-aarch64/cudnn-linux-aarch64-9.13.0.50_cuda12-archive.tar.xz", + "sha256": "c4b47fe8b1f936aa5cbc312f2d0707990fe5f55693fb5640c7141d301aa7db4c", + "md5": "4a00c0ae53ad6fdb761d7ab56993863c", + "size": "940699120" + }, + "cuda13": { + "relative_path": "cudnn/linux-aarch64/cudnn-linux-aarch64-9.13.0.50_cuda13-archive.tar.xz", + "sha256": "f18ee7d3fd7b1d136602eb2f5d5d59abe5445db384ad308d22fbeeee11ef151e", + "md5": "365f06153492370374e5e7b20d4646eb", + "size": "690215112" + } + } + }, + "cudnn_jit": { + "name": "NVIDIA CUDA Deep Neural Network Graph JIT library", + "license": "cudnn", + "license_path": "cudnn_jit/LICENSE.txt", + "version": "9.13.0.50", + "linux-x86_64": { + "cuda12": { + "relative_path": "cudnn_jit/linux-x86_64/cudnn_jit-linux-x86_64-9.13.0.50_cuda12-archive.tar.xz", + "sha256": "eb22533f125e4315de501112e2d0f0c001ba50b8f872f2bf7a12d545f609cb59", + "md5": "07023563efe85b7aab07b2982e541872", + "size": "13417344" + }, + "cuda13": { + "relative_path": "cudnn_jit/linux-x86_64/cudnn_jit-linux-x86_64-9.13.0.50_cuda13-archive.tar.xz", + "sha256": "cd76ea09574f3a1c07728c15fc794dbeed181b57b25e02768c5918b0353e658d", + "md5": "e9cc3e0e19d4c88158ef48193905b94b", + "size": "12722420" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "cudnn_jit/linux-sbsa/cudnn_jit-linux-sbsa-9.13.0.50_cuda12-archive.tar.xz", + "sha256": "f8c91dca056c0128f0ed15296de4b9fcf1cd503241cec02f6e4b3e2965e1be9e", + "md5": "adf011a7b7bcbd0c9be0abd546a49e22", + "size": "13047884" + }, + "cuda13": { + "relative_path": "cudnn_jit/linux-sbsa/cudnn_jit-linux-sbsa-9.13.0.50_cuda13-archive.tar.xz", + "sha256": "d5ce2fb281457eddf6319e517a797d009a4f5db55a565a753f0ba53e541163b2", + "md5": "d61024f0d19e5bcdad3e969c79f21d62", + "size": "12812136" + } + } + }, + "cudnn_samples": { + "name": "NVIDIA cuDNN samples", + "license": "cudnn", + "license_path": "cudnn_samples/LICENSE.txt", + "version": "9.13.0.50", + "source": { + "relative_path": "cudnn_samples/source/cudnn_samples-source-9.13.0.50-archive.tar.xz", + "sha256": "34dd694b6a1de34fca31a89b0b41f1f5edbf2dddb5822dda193332be6a2f508d", + "md5": "2750b23e2e468d8f5ff0b429d1e60d32", + "size": "1666920" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudss/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cudss/README.md new file mode 100644 index 000000000000..95d44eaba298 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudss/README.md @@ -0,0 +1,5 @@ +# cudss + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cudss/redistrib_0.6.0.json b/pkgs/development/cuda-modules/_cuda/manifests/cudss/redistrib_0.6.0.json new file mode 100644 index 000000000000..778d938e3db7 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cudss/redistrib_0.6.0.json @@ -0,0 +1,46 @@ +{ + "release_date": "2025-06-16", + "release_label": "0.6.0", + "release_product": "cudss", + "libcudss": { + "name": "NVIDIA cuDSS library", + "license": "cuDSS library", + "license_path": "libcudss/LICENSE.txt", + "version": "0.6.0.5", + "linux-x86_64": { + "cuda12": { + "relative_path": "libcudss/linux-x86_64/libcudss-linux-x86_64-0.6.0.5_cuda12-archive.tar.xz", + "sha256": "159ce1d4e3e4bba13b0bd15cf943e44b869c53b7a94f9bac980768c927f02e75", + "md5": "4ac17f5b35a4ecc550c4d7c479a5c5b5", + "size": "68957176" + } + }, + "cuda_variant": [ + "12" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "libcudss/linux-sbsa/libcudss-linux-sbsa-0.6.0.5_cuda12-archive.tar.xz", + "sha256": "b56cd0841c543bb81b2665063967f56cf3a3a22a445ddf1642c7f765f2059b42", + "md5": "490582492aceea286eb6d961d1a55beb", + "size": "68786208" + } + }, + "windows-x86_64": { + "cuda12": { + "relative_path": "libcudss/windows-x86_64/libcudss-windows-x86_64-0.6.0.5_cuda12-archive.zip", + "sha256": "45319317d9f67fecc9af7e5cf162cb46111f5d35b06871c147fa8f030d7cecc5", + "md5": "c1036a4cbadc7b201e08acaac13fcac6", + "size": "50807624" + } + }, + "linux-aarch64": { + "cuda12": { + "relative_path": "libcudss/linux-aarch64/libcudss-linux-aarch64-0.6.0.5_cuda12-archive.tar.xz", + "sha256": "e6f5d5122d735f9dbfd42c9eaba067a557a5613ee4a6001806935de11aff4b09", + "md5": "34fd4b0843da02ebaa76f5711e1b63de", + "size": "32347256" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/README.md new file mode 100644 index 000000000000..e9601dcb9d9c --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/README.md @@ -0,0 +1,5 @@ +# cuquantum + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/redistrib_25.09.0.json b/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/redistrib_25.09.0.json new file mode 100644 index 000000000000..a66a8c10a557 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cuquantum/redistrib_25.09.0.json @@ -0,0 +1,43 @@ +{ + "release_date": "2025-09-08", + "release_label": "25.09.0", + "release_product": "cuquantum", + "cuquantum": { + "name": "NVIDIA cuQuantum", + "license": "cuQuantum", + "license_path": "cuquantum/LICENSE.txt", + "version": "25.09.0.7", + "linux-x86_64": { + "cuda12": { + "relative_path": "cuquantum/linux-x86_64/cuquantum-linux-x86_64-25.09.0.7_cuda12-archive.tar.xz", + "sha256": "fec8fcceeb9b62f2dff37834a9cd44c6ab05486dec0ebc5ae3452dd8d6390ea0", + "md5": "b57e63b14a2a83115fc11ebb0fa93f61", + "size": "115548260" + }, + "cuda13": { + "relative_path": "cuquantum/linux-x86_64/cuquantum-linux-x86_64-25.09.0.7_cuda13-archive.tar.xz", + "sha256": "3f1e706c0ee582341ec4f103d37c92d90ef16d1cfac42f502c44b2feb6861dd9", + "md5": "9e11c71d25231c962b8df11adb4e570b", + "size": "119378588" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "cuquantum/linux-sbsa/cuquantum-linux-sbsa-25.09.0.7_cuda12-archive.tar.xz", + "sha256": "b63237e122a32f2576118297c291597815c9c3573daf5c9b4592ada7af13fc17", + "md5": "5b7d6dcf44d2e80eb155a22574b71b3a", + "size": "115171716" + }, + "cuda13": { + "relative_path": "cuquantum/linux-sbsa/cuquantum-linux-sbsa-25.09.0.7_cuda13-archive.tar.xz", + "sha256": "629d3e6749ac49e96de4469477d3b0172581896c7273890bc355420b344fac87", + "md5": "624ddcbf89311a43f2d7fb6671e37c6b", + "size": "119179132" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/README.md new file mode 100644 index 000000000000..a142f245fe06 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/README.md @@ -0,0 +1,5 @@ +# cusolvermp + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/redistrib_0.7.0.json b/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/redistrib_0.7.0.json new file mode 100644 index 000000000000..8181beabbec6 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cusolvermp/redistrib_0.7.0.json @@ -0,0 +1,43 @@ +{ + "release_date": "2025-08-12", + "release_label": "0.7.0", + "release_product": "cusolvermp", + "libcusolvermp": { + "name": "NVIDIA libcusolvermp library", + "license": "libcusolvermp library", + "license_path": "libcusolvermp/LICENSE.txt", + "version": "0.7.0.833", + "linux-x86_64": { + "cuda12": { + "relative_path": "libcusolvermp/linux-x86_64/libcusolvermp-linux-x86_64-0.7.0.833_cuda12-archive.tar.xz", + "sha256": "5383f35eefd45cc0a5cbd173a4a353941f02b912eb2f8d3a85c30345054df5e9", + "md5": "f9cf72595e8ff6d72a68b4a23ccc9973", + "size": "9293812" + }, + "cuda13": { + "relative_path": "libcusolvermp/linux-x86_64/libcusolvermp-linux-x86_64-0.7.0.833_cuda13-archive.tar.xz", + "sha256": "4a4bf2d08dad3a276b33f9356f8cd8b5b2a70201257a277c83bb3cfdb7a7107a", + "md5": "a95c2c6a6f8d9c07ee99ca1545a71967", + "size": "8014464" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "libcusolvermp/linux-sbsa/libcusolvermp-linux-sbsa-0.7.0.833_cuda12-archive.tar.xz", + "sha256": "a0012c5be7ac742a26cf8894bed3c703edea84eddf0d5dca42d35582622ffb9b", + "md5": "626c1e35145fa495a7708c5fff007866", + "size": "9214676" + }, + "cuda13": { + "relative_path": "libcusolvermp/linux-sbsa/libcusolvermp-linux-sbsa-0.7.0.833_cuda13-archive.tar.xz", + "sha256": "51b80fc5cdeb197b3e9b1de393a8413943ccb2d0e7509c6a183816be83123260", + "md5": "6338b4e581a076214581ec650f9eb92e", + "size": "7605548" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/README.md new file mode 100644 index 000000000000..80252fca2261 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/README.md @@ -0,0 +1,7 @@ +# cusparselt + +Link: + +Requirements: + +NOTE: 0.7.1 only supports CUDA 12.8 and later. diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.6.3.json b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.6.3.json new file mode 100644 index 000000000000..d2d8279c9d75 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.6.3.json @@ -0,0 +1,35 @@ +{ + "release_date": "2024-10-15", + "release_label": "0.6.3", + "release_product": "cusparselt", + "libcusparse_lt": { + "name": "NVIDIA cuSPARSELt", + "license": "cuSPARSELt", + "license_path": "libcusparse_lt/LICENSE.txt", + "version": "0.6.3.2", + "linux-x86_64": { + "relative_path": "libcusparse_lt/linux-x86_64/libcusparse_lt-linux-x86_64-0.6.3.2-archive.tar.xz", + "sha256": "a2f856e78943f5c538bdef1c9edc64a5ed30bf8bb7d5fcb615c684ffe776cc31", + "md5": "d074824e3dc6c382160873a8ef49c098", + "size": "110698912" + }, + "linux-sbsa": { + "relative_path": "libcusparse_lt/linux-sbsa/libcusparse_lt-linux-sbsa-0.6.3.2-archive.tar.xz", + "sha256": "3e420ddbff4eb9ac603f57c7aa8b3d5271112816e244eb55ef9f30c4eb6a04b7", + "md5": "dd6b0dd464bb8596950ab761890e1ae1", + "size": "109919332" + }, + "windows-x86_64": { + "relative_path": "libcusparse_lt/windows-x86_64/libcusparse_lt-windows-x86_64-0.6.3.2-archive.zip", + "sha256": "6d276e33a399008c22ffefd707eefe2f57ff2ff8f1dc1929d9e3e75d3c83562d", + "md5": "95de6b57ceceb199f9b86bfbe5d2d394", + "size": "328143559" + }, + "linux-aarch64": { + "relative_path": "libcusparse_lt/linux-aarch64/libcusparse_lt-linux-aarch64-0.6.3.2-archive.tar.xz", + "sha256": "91501d0c05d1ff0dd67399ecd7c1bf76a620e842dce54ae4c8a1f07cec0673e5", + "md5": "7f00c8663678a97948bbd2e98b65a9fa", + "size": "19000276" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.8.1.json b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.8.1.json new file mode 100644 index 000000000000..c0e38e6acec8 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cusparselt/redistrib_0.8.1.json @@ -0,0 +1,71 @@ +{ + "release_date": "2025-09-04", + "release_label": "0.8.1", + "release_product": "cusparselt", + "libcusparse_lt": { + "name": "NVIDIA cuSPARSELt", + "license": "cuSPARSELt", + "license_path": "libcusparse_lt/LICENSE.txt", + "version": "0.8.1.1", + "linux-x86_64": { + "cuda12": { + "relative_path": "libcusparse_lt/linux-x86_64/libcusparse_lt-linux-x86_64-0.8.1.1_cuda12-archive.tar.xz", + "sha256": "b34272e683e9f798435af05dc124657d1444cd0e13802c3d2f3152e31cd898a3", + "md5": "8e6d6454a2ac514c592f18fe7e77f84c", + "size": "311599728" + }, + "cuda13": { + "relative_path": "libcusparse_lt/linux-x86_64/libcusparse_lt-linux-x86_64-0.8.1.1_cuda13-archive.tar.xz", + "sha256": "82dd3e5ebc199a27011f58857a80cd825e77bba634ab2286ba3d4e13115db89a", + "md5": "90e40a8bffe304d14578eb8f2173dee1", + "size": "317355908" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "libcusparse_lt/linux-sbsa/libcusparse_lt-linux-sbsa-0.8.1.1_cuda12-archive.tar.xz", + "sha256": "e87c2e1a8615aa588864915a05c42309869c96d4046b07a50a7a729af2c1ff22", + "md5": "504742ec72d48e75954d1a31e30aebcb", + "size": "310432728" + }, + "cuda13": { + "relative_path": "libcusparse_lt/linux-sbsa/libcusparse_lt-linux-sbsa-0.8.1.1_cuda13-archive.tar.xz", + "sha256": "d3ce9fb25961540291c6dc6c7292a1ea7cb886590bf896fdc2564cb2a261a3de", + "md5": "032ce0fc1decdca18652ce3fcf05b14e", + "size": "425143780" + } + }, + "windows-x86_64": { + "cuda12": { + "relative_path": "libcusparse_lt/windows-x86_64/libcusparse_lt-windows-x86_64-0.8.1.1_cuda12-archive.zip", + "sha256": "1a1a4be5c2da47e242d3fbab35b66077916aeb2b8175bc6a0a6691e11972951c", + "md5": "78f5c274b42ff56b1b74427d89372a14", + "size": "223735080" + }, + "cuda13": { + "relative_path": "libcusparse_lt/windows-x86_64/libcusparse_lt-windows-x86_64-0.8.1.1_cuda13-archive.zip", + "sha256": "d83c3a9c34df98aa999e6a64278a36eb837b411af593d41fe74746a2915e379d", + "md5": "ece8942a85c1706547da6c11ed4e48b2", + "size": "156765306" + } + }, + "linux-aarch64": { + "cuda12": { + "relative_path": "libcusparse_lt/linux-aarch64/libcusparse_lt-linux-aarch64-0.8.1.1_cuda12-archive.tar.xz", + "sha256": "5426a897c73a9b98a83c4e132d15abc63dc4a00f7e38266e7b82c42cd58a01e1", + "md5": "fffc61b32112a6c09046bfb3300c840f", + "size": "127531168" + }, + "cuda13": { + "relative_path": "libcusparse_lt/linux-aarch64/libcusparse_lt-linux-aarch64-0.8.1.1_cuda13-archive.tar.xz", + "sha256": "0fcf5808f66c71f755b4a73af2e955292e4334fec6a851eea1ac2e20878602b7", + "md5": "eb6eb4a96f82ff42e0be38f8486fb5d7", + "size": "124707896" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cutensor/README.md b/pkgs/development/cuda-modules/_cuda/manifests/cutensor/README.md new file mode 100644 index 000000000000..5df404c3f6f9 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cutensor/README.md @@ -0,0 +1,5 @@ +# cutensor + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/cutensor/redistrib_2.3.1.json b/pkgs/development/cuda-modules/_cuda/manifests/cutensor/redistrib_2.3.1.json new file mode 100644 index 000000000000..2a00c57e23b0 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/cutensor/redistrib_2.3.1.json @@ -0,0 +1,57 @@ +{ + "release_date": "2025-09-04", + "release_label": "2.3.1", + "release_product": "cutensor", + "libcutensor": { + "name": "NVIDIA cuTENSOR", + "license": "cuTensor", + "license_path": "libcutensor/LICENSE.txt", + "version": "2.3.1.0", + "linux-x86_64": { + "cuda12": { + "relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-2.3.1.0_cuda12-archive.tar.xz", + "sha256": "b1d7ad37b24cd66a446ae76ac33bd5125aa58007a604cb64fc9c014a8d685940", + "md5": "061f0d50d4642431d284bdd8ad9c45a4", + "size": "428900080" + }, + "cuda13": { + "relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-2.3.1.0_cuda13-archive.tar.xz", + "sha256": "9cb1125f7de01ca319b5c72edeb7169b679b72beacc90354fb18a14056e24372", + "md5": "e94ea98ca6e88961a39d52da1c9470c7", + "size": "386539432" + } + }, + "cuda_variant": [ + "12", + "13" + ], + "linux-sbsa": { + "cuda12": { + "relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-2.3.1.0_cuda12-archive.tar.xz", + "sha256": "f3763cdc7b03ca08e348efb6faa35d461537390ce7d059e279e415b33dad8291", + "md5": "048b99ec5a968df2dd2a3f6bd26d6f63", + "size": "427395404" + }, + "cuda13": { + "relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-2.3.1.0_cuda13-archive.tar.xz", + "sha256": "2e4c24bd1621dac7497ca9edf90bfc5dbdcc38490dafd35821066f96f2934aef", + "md5": "05e13cda907130e2f77cf86bba05fa11", + "size": "385157096" + } + }, + "windows-x86_64": { + "cuda12": { + "relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-2.3.1.0_cuda12-archive.zip", + "sha256": "8df4c1b856c40e72f41d5b92efee5729bf11f00a0e1e3afd546b0d35a360a6cb", + "md5": "3aae5e991b780b9c484a4f77883c84f8", + "size": "218109706" + }, + "cuda13": { + "relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-2.3.1.0_cuda13-archive.zip", + "sha256": "8f933694164e310183fffa9cf27d4db43b6edb0fff53b5aa0ab23e705807ac12", + "md5": "d4a958abf9ba2f10234364a37302e1ee", + "size": "150006958" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/default.nix b/pkgs/development/cuda-modules/_cuda/manifests/default.nix new file mode 100644 index 000000000000..8f33ebbfb413 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/default.nix @@ -0,0 +1,19 @@ +{ lib }: +lib.mapAttrs ( + redistName: _type: + let + redistManifestDir = ./. + "/${redistName}"; + in + lib.concatMapAttrs ( + fileName: _type: + let + # Manifests all end in .json and are named "redistrib_.json". + version = lib.removePrefix "redistrib_" (lib.removeSuffix ".json" fileName); + in + # NOTE: We do not require that all files have this pattern, as manifest directories may contain documentation + # and utility functions we should ignore. + lib.optionalAttrs (version != fileName) { + "${version}" = lib.importJSON (redistManifestDir + "/${fileName}"); + } + ) (builtins.readDir redistManifestDir) +) (builtins.removeAttrs (builtins.readDir ./.) [ "default.nix" ]) diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nppplus/README.md b/pkgs/development/cuda-modules/_cuda/manifests/nppplus/README.md new file mode 100644 index 000000000000..15ca836ce534 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nppplus/README.md @@ -0,0 +1,5 @@ +# nppplus + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nppplus/redistrib_0.10.0.json b/pkgs/development/cuda-modules/_cuda/manifests/nppplus/redistrib_0.10.0.json new file mode 100644 index 000000000000..84c8b1a0d70d --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nppplus/redistrib_0.10.0.json @@ -0,0 +1,71 @@ +{ + "release_date": "2025-04-18", + "release_label": "0.10.0", + "release_product": "nppplus", + "libnpp_plus": { + "name": "NVIDIA NPP PLUS library", + "license": "NPP PLUS library", + "license_path": "libnpp_plus/LICENSE.txt", + "version": "0.10.0.0", + "linux-x86_64": { + "cuda11": { + "relative_path": "libnpp_plus/linux-x86_64/libnpp_plus-linux-x86_64-0.10.0.0_cuda11-archive.tar.xz", + "sha256": "dfd0995068504ab9cd14767036680222f73d01a0e38ab9a53f9968d53f9745f7", + "md5": "210b430b3b047956a43564f6102664a1", + "size": "365025464" + }, + "cuda12": { + "relative_path": "libnpp_plus/linux-x86_64/libnpp_plus-linux-x86_64-0.10.0.0_cuda12-archive.tar.xz", + "sha256": "0a2f1138b941160863eb1ec75a9f5072b330b234c287504bc5ca06130c5342b9", + "md5": "71c7a351c31df634bb9c504ff8d3f9c1", + "size": "365024708" + } + }, + "cuda_variant": [ + "11", + "12" + ], + "linux-sbsa": { + "cuda11": { + "relative_path": "libnpp_plus/linux-sbsa/libnpp_plus-linux-sbsa-0.10.0.0_cuda11-archive.tar.xz", + "sha256": "108a3126d07c7e4ce5ad0c85a9076bed6c2abeeec66b4c23a35d30d45ecf9110", + "md5": "461dbe9d9dbdf1ed68b688634a3aaafa", + "size": "363897792" + }, + "cuda12": { + "relative_path": "libnpp_plus/linux-sbsa/libnpp_plus-linux-sbsa-0.10.0.0_cuda12-archive.tar.xz", + "sha256": "7aab2e7cab1fade883463bdb85a240f66d956395e3a90ca78b5bf413fa9a2fd9", + "md5": "f0b042171c6c0290a9afaf1a5766994b", + "size": "363891396" + } + }, + "windows-x86_64": { + "cuda11": { + "relative_path": "libnpp_plus/windows-x86_64/libnpp_plus-windows-x86_64-0.10.0.0_cuda11-archive.zip", + "sha256": "333b9181526d8421b3445bc1c2b50ea8a0a8dd06412bf1c5dce3ed760659ec73", + "md5": "13d9f5a50932e3c457fec8f38e0b914b", + "size": "310918881" + }, + "cuda12": { + "relative_path": "libnpp_plus/windows-x86_64/libnpp_plus-windows-x86_64-0.10.0.0_cuda12-archive.zip", + "sha256": "55f352478ce111187e2a1a2944f95eff009e156fc16793786f36ed6ed6e334d6", + "md5": "5142a28d82bc8470d7a7eea698b10f56", + "size": "310918881" + } + }, + "linux-aarch64": { + "cuda11": { + "relative_path": "libnpp_plus/linux-aarch64/libnpp_plus-linux-aarch64-0.10.0.0_cuda11-archive.tar.xz", + "sha256": "fa09d1306eadd304913fa7e9904790e00c8acb05bdddd9832b2681d591449ecf", + "md5": "0263b51a2cf5ca3b23464dfe5a688044", + "size": "114297704" + }, + "cuda12": { + "relative_path": "libnpp_plus/linux-aarch64/libnpp_plus-linux-aarch64-0.10.0.0_cuda12-archive.tar.xz", + "sha256": "570c4e0c871f9dd0a3e5959c1d144a53b232e8308b7d7f4d496df705f9aa2269", + "md5": "44b1e1f7d5671aa08276bcabbe1cc458", + "size": "114297660" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/README.md b/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/README.md new file mode 100644 index 000000000000..51bf4844fe93 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/README.md @@ -0,0 +1,5 @@ +# nvcomp + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/redistrib_5.0.0.6.json b/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/redistrib_5.0.0.6.json new file mode 100644 index 000000000000..d5976c02450a --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvcomp/redistrib_5.0.0.6.json @@ -0,0 +1,76 @@ +{ + "release_date": "2025-08-04", + "release_label": "5.0.0.6", + "release_product": "nvcomp", + "nvcomp": { + "name": "NVIDIA nvCOMP library", + "license": "nvCOMP library", + "license_path": "nvcomp/LICENSE.txt", + "version": "5.0.0.6", + "linux-x86_64": { + "cuda11": { + "relative_path": "nvcomp/linux-x86_64/nvcomp-linux-x86_64-5.0.0.6_cuda11-archive.tar.xz", + "sha256": "64f5f7cc622f36006c503ee5a3f9d730b5c6cc49e4fab0fc0507c1272d5efa7b", + "md5": "e7fcc75a1ed5c056211948c896dccf62", + "size": "21128508" + }, + "cuda12": { + "relative_path": "nvcomp/linux-x86_64/nvcomp-linux-x86_64-5.0.0.6_cuda12-archive.tar.xz", + "sha256": "40ac1d5f8c0a2719f11b21a4d31b6050343607dffd1401d1fe9a154800b56e46", + "md5": "58436c6eb41b7a317ddf9131bfe7f92b", + "size": "40211608" + }, + "cuda13": { + "relative_path": "nvcomp/linux-x86_64/nvcomp-linux-x86_64-5.0.0.6_cuda13-archive.tar.xz", + "sha256": "4166e7c3825fa90139d50042154438ba06ea493985aeb7968fc1ad0d5fa5a22a", + "md5": "abb06ec210645ce491d66fdf26f89a35", + "size": "37072544" + } + }, + "cuda_variant": [ + "11", + "12", + "13" + ], + "linux-sbsa": { + "cuda11": { + "relative_path": "nvcomp/linux-sbsa/nvcomp-linux-sbsa-5.0.0.6_cuda11-archive.tar.xz", + "sha256": "e98a20570e56ad94709c5014960c9f1fa9b4b5a7eb132dede85dd8ffd6c5f3f8", + "md5": "d80c48f270668e50e61e718b13643080", + "size": "21312128" + }, + "cuda12": { + "relative_path": "nvcomp/linux-sbsa/nvcomp-linux-sbsa-5.0.0.6_cuda12-archive.tar.xz", + "sha256": "e57e658e35f6b266399ca2286e9439e5e9c9f3db907a718c55a07e6338b1c5bf", + "md5": "a32f79f2cef263a7b304d681a3076af5", + "size": "40157632" + }, + "cuda13": { + "relative_path": "nvcomp/linux-sbsa/nvcomp-linux-sbsa-5.0.0.6_cuda13-archive.tar.xz", + "sha256": "26f6189f302affba7a3df726164a809aa7a5118560283627bbaa9aaa860cbc96", + "md5": "57c04016e2506a63947e5ccedb3a0be3", + "size": "37327100" + } + }, + "windows-x86_64": { + "cuda11": { + "relative_path": "nvcomp/windows-x86_64/nvcomp-windows-x86_64-5.0.0.6_cuda11-archive.zip", + "sha256": "5c2e1ee55398f47d28806eb7c53aca33b9e22d6d5b3acec86bbc4253c7e6d1d3", + "md5": "40e5c7250ad930aeb1e34d5e01f3ada1", + "size": "38916070" + }, + "cuda12": { + "relative_path": "nvcomp/windows-x86_64/nvcomp-windows-x86_64-5.0.0.6_cuda12-archive.zip", + "sha256": "d851077cf6ebaea21a548c4e55db45f0dd45271e35e7cffda7dd9917603ab8d4", + "md5": "da94be1539cf0f709bf9cd2b6881ebd1", + "size": "61092352" + }, + "cuda13": { + "relative_path": "nvcomp/windows-x86_64/nvcomp-windows-x86_64-5.0.0.6_cuda13-archive.zip", + "sha256": "d7d1397a438f6d16dbe9989a72ffcf9e7935f17c836316dd98403929c09c585a", + "md5": "b3195c7bbe9775a9ddcaea1c1f43664e", + "size": "43017930" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/README.md b/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/README.md new file mode 100644 index 000000000000..5e5a9300ff9a --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/README.md @@ -0,0 +1,5 @@ +# nvjpeg2000 + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/redistrib_0.9.0.json b/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/redistrib_0.9.0.json new file mode 100644 index 000000000000..a611460cba67 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvjpeg2000/redistrib_0.9.0.json @@ -0,0 +1,35 @@ +{ + "release_date": "2025-08-05", + "release_label": "0.9.0", + "release_product": "nvjpeg2000", + "libnvjpeg_2k": { + "name": "NVIDIA nvJPEG 2000", + "license": "nvJPEG 2K", + "license_path": "libnvjpeg_2k/LICENSE.txt", + "version": "0.9.0.43", + "linux-x86_64": { + "relative_path": "libnvjpeg_2k/linux-x86_64/libnvjpeg_2k-linux-x86_64-0.9.0.43-archive.tar.xz", + "sha256": "1d26f62a7141e81c604342a610deb8ad8d10e1c08cb59598881dc201e59f21a3", + "md5": "88e231d23f60bfc0effc871ccf465b3a", + "size": "15407304" + }, + "linux-sbsa": { + "relative_path": "libnvjpeg_2k/linux-sbsa/libnvjpeg_2k-linux-sbsa-0.9.0.43-archive.tar.xz", + "sha256": "03e37b8e0f2d67a1ee376e6ac54fa9d62284bbdbf9edf90ea7d0a05b4c45bce1", + "md5": "1b6b06ec71a67e1a70b15e379cd8c9ca", + "size": "15432332" + }, + "windows-x86_64": { + "relative_path": "libnvjpeg_2k/windows-x86_64/libnvjpeg_2k-windows-x86_64-0.9.0.43-archive.zip", + "sha256": "272d409945cd1c00beaa7f5d4c8197139aa32394358ea76d83f2cd2b51faf0c7", + "md5": "6828d19ce79b943705e22d5cd4dbe6c4", + "size": "14206962" + }, + "linux-aarch64": { + "relative_path": "libnvjpeg_2k/linux-aarch64/libnvjpeg_2k-linux-aarch64-0.9.0.43-archive.tar.xz", + "sha256": "b2285c1da026bd189e837800da2a26cb75ce45ccb23ea7e6ee65114b3dcee66c", + "md5": "608ef4eb15da8fda26b5b649c340855d", + "size": "5384888" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvpl/README.md b/pkgs/development/cuda-modules/_cuda/manifests/nvpl/README.md new file mode 100644 index 000000000000..1a338d1c2461 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvpl/README.md @@ -0,0 +1,5 @@ +# nvpl + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvpl/redistrib_25.5.json b/pkgs/development/cuda-modules/_cuda/manifests/nvpl/redistrib_25.5.json new file mode 100644 index 000000000000..d7739f946a1c --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvpl/redistrib_25.5.json @@ -0,0 +1,101 @@ +{ + "release_date": "2025-05-28", + "release_label": "25.5", + "release_product": "nvpl", + "nvpl_blas": { + "name": "NVPL BLAS", + "license": "NVPL", + "license_path": "nvpl_blas/LICENSE.txt", + "version": "0.4.1.1", + "linux-sbsa": { + "relative_path": "nvpl_blas/linux-sbsa/nvpl_blas-linux-sbsa-0.4.1.1-archive.tar.xz", + "sha256": "57704e2e211999c899bca26346b946b881b609554914245131b390410f7b93e8", + "md5": "9e2a95925dcb4bbe0ac337550f317272", + "size": "773716" + } + }, + "nvpl_common": { + "name": "NVPL Common", + "license": "NVPL", + "license_path": "nvpl_common/LICENSE.txt", + "version": "0.3.3", + "linux-sbsa": { + "relative_path": "nvpl_common/linux-sbsa/nvpl_common-linux-sbsa-0.3.3-archive.tar.xz", + "sha256": "fe87ccd63817427c6c9b9e292447a4e8f256b9c9157065fba1a338719fa433c8", + "md5": "9ae9f3253461a0565bc3c01a07c50fe3", + "size": "9444" + } + }, + "nvpl_fft": { + "name": "NVPL FFT", + "license": "NVPL", + "license_path": "nvpl_fft/LICENSE.txt", + "version": "0.4.2.1", + "linux-sbsa": { + "relative_path": "nvpl_fft/linux-sbsa/nvpl_fft-linux-sbsa-0.4.2.1-archive.tar.xz", + "sha256": "ebb9d98abc23ddee5c492e0bbf2c534570a38d7df1863a0630da2c6d7f5cca3d", + "md5": "211ec34eef6b023f7af8e1fc40ae4ad1", + "size": "24974464" + } + }, + "nvpl_lapack": { + "name": "NVPL LAPACK", + "license": "NVPL", + "license_path": "nvpl_lapack/LICENSE.txt", + "version": "0.3.1.1", + "linux-sbsa": { + "relative_path": "nvpl_lapack/linux-sbsa/nvpl_lapack-linux-sbsa-0.3.1.1-archive.tar.xz", + "sha256": "f5b916aa36a8549946fc2262acebb082fe8c463bd1523a3c0cc2c93527231653", + "md5": "ec0616b0be4616ac7050807a872343a2", + "size": "4781368" + } + }, + "nvpl_rand": { + "name": "NVPL RAND", + "license": "NVPL", + "license_path": "nvpl_rand/LICENSE.txt", + "version": "0.5.2", + "linux-sbsa": { + "relative_path": "nvpl_rand/linux-sbsa/nvpl_rand-linux-sbsa-0.5.2-archive.tar.xz", + "sha256": "1eb5c2a5e98390b2bc76c3218837916df64d33cce220169811e14ecead36933f", + "md5": "fe72dcf4600cbd85f7249e95ebbcd363", + "size": "34025772" + } + }, + "nvpl_scalapack": { + "name": "NVPL SCALAPACK", + "license": "NVPL", + "license_path": "nvpl_scalapack/LICENSE.txt", + "version": "0.2.2", + "linux-sbsa": { + "relative_path": "nvpl_scalapack/linux-sbsa/nvpl_scalapack-linux-sbsa-0.2.2-archive.tar.xz", + "sha256": "20cf6c54a0352f2fb0060e6f5ef6b892c5d07a242f8aab31cd9bbceb58a7bd11", + "md5": "8e3e728e8587cc4698beb2ab7ce162d6", + "size": "4647440" + } + }, + "nvpl_sparse": { + "name": "NVPL SPARSE", + "license": "NVPL", + "license_path": "nvpl_sparse/LICENSE.txt", + "version": "0.4.1", + "linux-sbsa": { + "relative_path": "nvpl_sparse/linux-sbsa/nvpl_sparse-linux-sbsa-0.4.1-archive.tar.xz", + "sha256": "fda868fe6619e94463a93efed1958e67588c607c170a4c658103a24295855e19", + "md5": "851080b3e56db9bf6fa37cea198bcb33", + "size": "556932" + } + }, + "nvpl_tensor": { + "name": "NVPL TENSOR", + "license": "NVPL", + "license_path": "nvpl_tensor/LICENSE.txt", + "version": "0.3.1", + "linux-sbsa": { + "relative_path": "nvpl_tensor/linux-sbsa/nvpl_tensor-linux-sbsa-0.3.1-archive.tar.xz", + "sha256": "12e9293609b3726cf9e92c648f117412a98a5e54700c877518ec2991e51ab50f", + "md5": "613b9a05d867667deae31bfea26688e8", + "size": "2338804" + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/README.md b/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/README.md new file mode 100644 index 000000000000..cda290cb2c4d --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/README.md @@ -0,0 +1,5 @@ +# nvtiff + +Link: + +Requirements: diff --git a/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/redistrib_0.5.1.json b/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/redistrib_0.5.1.json new file mode 100644 index 000000000000..03e84ce292d4 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/nvtiff/redistrib_0.5.1.json @@ -0,0 +1,96 @@ +{ + "release_date": "2025-08-05", + "release_label": "0.5.1", + "release_product": "nvtiff", + "libnvtiff": { + "name": "NVIDIA nvTIFF", + "license": "nvTIFF", + "license_path": "libnvtiff/LICENSE.txt", + "version": "0.5.1.75", + "linux-x86_64": { + "cuda11": { + "relative_path": "libnvtiff/linux-x86_64/libnvtiff-linux-x86_64-0.5.1.75_cuda11-archive.tar.xz", + "sha256": "5adabfe9c4eac59916bfc464b7325866da99752ade30bbc3ddd3cd9c852f69e7", + "md5": "93e04a669a8dd4ff696950bac5e77e7d", + "size": "1332668" + }, + "cuda12": { + "relative_path": "libnvtiff/linux-x86_64/libnvtiff-linux-x86_64-0.5.1.75_cuda12-archive.tar.xz", + "sha256": "1f97778f92c938f5174fda74a913370d4ff200d77809570cecdafcd8aaff84b6", + "md5": "1c8508be2791abbd5d78f059bbc3a2be", + "size": "1922764" + }, + "cuda13": { + "relative_path": "libnvtiff/linux-x86_64/libnvtiff-linux-x86_64-0.5.1.75_cuda13-archive.tar.xz", + "sha256": "5d63be4128daf28676ae01a81d2e69f828d2e7eda332c039079ff57b42915d20", + "md5": "0aa016e6e9d70866dae1367ee5d8731a", + "size": "1498124" + } + }, + "cuda_variant": [ + "11", + "12", + "13" + ], + "linux-sbsa": { + "cuda11": { + "relative_path": "libnvtiff/linux-sbsa/libnvtiff-linux-sbsa-0.5.1.75_cuda11-archive.tar.xz", + "sha256": "9274e74f58c2d85d13089ba3be3e3464c2cb34d2332c9f7a96ec42765bf2b034", + "md5": "e174a596cf84862ca903f79a2db356c2", + "size": "1236416" + }, + "cuda12": { + "relative_path": "libnvtiff/linux-sbsa/libnvtiff-linux-sbsa-0.5.1.75_cuda12-archive.tar.xz", + "sha256": "d20309617df0bca6b373dfa33bac99703993a0e3759af70d2691d3b829df4d33", + "md5": "1a25761b4bfeb2ff7016114701d132b6", + "size": "1829060" + }, + "cuda13": { + "relative_path": "libnvtiff/linux-sbsa/libnvtiff-linux-sbsa-0.5.1.75_cuda13-archive.tar.xz", + "sha256": "415c507443c026db501bd58d49428d6378f7d5e02e371f8f05d9cbe421565a90", + "md5": "6fb9797d1cef94e17c0ed8c82e9b8bc8", + "size": "1559296" + } + }, + "windows-x86_64": { + "cuda11": { + "relative_path": "libnvtiff/windows-x86_64/libnvtiff-windows-x86_64-0.5.1.75_cuda11-archive.zip", + "sha256": "c140fb7c0cb40c8796cdc7f3cf604a7fbb85e5b6e0e3315d9c269cfa19caa46a", + "md5": "1747419ee8df0434010a89014757065d", + "size": "1157130" + }, + "cuda12": { + "relative_path": "libnvtiff/windows-x86_64/libnvtiff-windows-x86_64-0.5.1.75_cuda12-archive.zip", + "sha256": "a3db5d37c61845d97aa5f1c1a93f9885239741c169a4c577f1f93293dd139a0d", + "md5": "861f76739d7632b9ccf60f9bde2c2b36", + "size": "1805927" + }, + "cuda13": { + "relative_path": "libnvtiff/windows-x86_64/libnvtiff-windows-x86_64-0.5.1.75_cuda13-archive.zip", + "sha256": "0e75603c23eed4df4d04d8ddd08bc106df9a4423596f32d238fbf7bb623280b1", + "md5": "83c07811a9ebcc9aaa3e8d296f018f4a", + "size": "1178242" + } + }, + "linux-aarch64": { + "cuda11": { + "relative_path": "libnvtiff/linux-aarch64/libnvtiff-linux-aarch64-0.5.1.75_cuda11-archive.tar.xz", + "sha256": "ef8f2f8472959be63e895997c0b13892db4e3c6bf3d06a4752c8e9292531c55a", + "md5": "ee0034f50b9c348ce64c7358ebc16ea5", + "size": "979744" + }, + "cuda12": { + "relative_path": "libnvtiff/linux-aarch64/libnvtiff-linux-aarch64-0.5.1.75_cuda12-archive.tar.xz", + "sha256": "7d37821154aca7846695ccf12369eeb8c0f263d58b6dfb43e23bd12f4c114ef0", + "md5": "0491eaec9a956a42a4450b546cc113d4", + "size": "1279516" + }, + "cuda13": { + "relative_path": "libnvtiff/linux-aarch64/libnvtiff-linux-aarch64-0.5.1.75_cuda13-archive.tar.xz", + "sha256": "8d1b07af6d8b68776d6a6533b4c33134af01d5cb6a0d9c5bcc7a866559de600a", + "md5": "94e8fbcbeca5b26e177b3c9c71f18214", + "size": "1104224" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/README.md b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/README.md new file mode 100644 index 000000000000..4710f1ff0a39 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/README.md @@ -0,0 +1,30 @@ +# tensorrt + +Requirements: + +These redistributable manifests are made by hand to allow TensorRT to be packaged with the same functionality the other NVIDIA redistributable libraries are packaged with. + +Only available from 10.0.0 and onwards, which is when NVIDIA stopped putting them behind a login wall. + +You can find them at: . + +Construct entries using the provider `helper.bash` script. + +As an example: + +```console +$ ./tensorrt/helper.bash 12.5 10.2.0.19 windows-x86_64 +main: storePath: /nix/store/l2hq83ihj3bcm4z836cz2dw3ilkhwrpy-TensorRT-10.2.0.19.Windows.win10.cuda-12.5.zip +{ + "windows-x86_64": { + "cuda12": { + "md5": "70282ec501c9e395a3ffdd0d2baf9d95", + "relative_path": "tensorrt/10.2.0/zip/TensorRT-10.2.0.19.Windows.win10.cuda-12.5.zip", + "sha256": "4a9c6e279fd36559551a6d88e37d835db5ebdc950246160257b0b538960e57fa", + "size": "1281366141" + } + } +} +``` + +I set the `release_date` to the date of the corresponding release on their GitHub: . diff --git a/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/helper.bash b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/helper.bash new file mode 100755 index 000000000000..b6ee9355e976 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/helper.bash @@ -0,0 +1,131 @@ +#!/usr/bin/env nix-shell +#! nix-shell -i bash -p nix jq + +# shellcheck shell=bash + +set -euo pipefail + +mkRedistUrlRelativePath() { + local -r cudaMajorMinorVersion=${1:?} + local -r tensorrtMajorMinorPatchBuildVersion=${2:?} + local -r redistSystem=${3:?} + + local -r tensorrtMajorMinorPatchVersion="$(echo "$tensorrtMajorMinorPatchBuildVersion" | cut -d. -f1-3)" + local -r tensorrtMinorVersion="$(echo "$tensorrtMajorMinorPatchVersion" | cut -d. -f2)" + + local archiveDir="" + local archiveExtension="" + local osName="" + local platformName="" + case "$redistSystem" in + linux-aarch64) archiveDir="tars" && archiveExtension="tar.gz" && osName="l4t" && platformName="aarch64-gnu" ;; + linux-sbsa) + archiveDir="tars" && archiveExtension="tar.gz" && platformName="aarch64-gnu" + # 10.0-10.3 use Ubuntu 22.40 + # 10.4-10.6 use Ubuntu 24.04 + # 10.7+ use Linux + case "$tensorrtMinorVersion" in + 0 | 1 | 2 | 3) osName="Ubuntu-22.04" ;; + 4 | 5 | 6) osName="Ubuntu-24.04" ;; + *) osName="Linux" ;; + esac + ;; + linux-x86_64) archiveDir="tars" && archiveExtension="tar.gz" && osName="Linux" && platformName="x86_64-gnu" ;; + windows-x86_64) + archiveExtension="zip" && platformName="win10" + # Windows info is different for 10.0.* + case "$tensorrtMinorVersion" in + 0) archiveDir="zips" && osName="Windows10" ;; + *) archiveDir="zip" && osName="Windows" ;; + esac + ;; + *) + echo "mkRedistUrlRelativePath: Unsupported redistSystem: $redistSystem" >&2 + exit 1 + ;; + esac + + local -r relativePath="tensorrt/$tensorrtMajorMinorPatchVersion/$archiveDir/TensorRT-${tensorrtMajorMinorPatchBuildVersion}.${osName}.${platformName}.cuda-${cudaMajorMinorVersion}.${archiveExtension}" + echo "$relativePath" +} + +getNixStorePath() { + local -r relativePath=${1:?} + local -r jsonBlob="$(nix store prefetch-file --json "https://developer.nvidia.com/downloads/compute/machine-learning/$relativePath")" + if [[ -z $jsonBlob ]]; then + echo "getNixStorePath: Failed to fetch jsonBlob for relativePath: $relativePath" >&2 + exit 1 + fi + local -r storePath="$(echo "$jsonBlob" | jq -cr '.storePath')" + echo "$storePath" +} + +printOutput() { + local -r cudaMajorMinorVersion=${1:?} + local -r redistSystem=${2:?} + local -r md5Hash=${3:?} + local -r relativePath=${4:?} + local -r sha256Hash=${5:?} + local -r size=${6:?} + + local -r cudaVariant="cuda$(echo "$cudaMajorMinorVersion" | cut -d. -f1)" + + # Echo everything to stdout using JQ to format the output as JSON + jq \ + --raw-output \ + --sort-keys \ + --null-input \ + --arg redistSystem "$redistSystem" \ + --arg cudaVariant "$cudaVariant" \ + --arg md5Hash "$md5Hash" \ + --arg relativePath "$relativePath" \ + --arg sha256Hash "$sha256Hash" \ + --arg size "$size" \ + '{ + $redistSystem: { + $cudaVariant: { + md5: $md5Hash, + relative_path: $relativePath, + sha256: $sha256Hash, + size: $size + } + } + }' +} + +main() { + local -r cudaMajorMinorVersion=${1:?} + if [[ ! $cudaMajorMinorVersion =~ ^[0-9]+\.[0-9]+$ ]]; then + echo "main: Invalid cudaMajorMinorVersion: $cudaMajorMinorVersion" >&2 + exit 1 + fi + + local -r tensorrtMajorMinorPatchBuildVersion=${2:?} + if [[ ! $tensorrtMajorMinorPatchBuildVersion =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then + echo "main: Invalid tensorrtMajorMinorPatchBuildVersion: $tensorrtMajorMinorPatchBuildVersion" >&2 + exit 1 + fi + + local -r redistSystem=${3:?} + case "$redistSystem" in + linux-aarch64) ;; + linux-sbsa) ;; + linux-x86_64) ;; + windows-x86_64) ;; + *) + echo "main: Unsupported redistSystem: $redistSystem" >&2 + exit 1 + ;; + esac + + local -r relativePath="$(mkRedistUrlRelativePath "$cudaMajorMinorVersion" "$tensorrtMajorMinorPatchBuildVersion" "$redistSystem")" + local -r storePath="$(getNixStorePath "$relativePath")" + echo "main: storePath: $storePath" >&2 + local -r md5Hash="$(nix hash file --type md5 --base16 "$storePath")" + local -r sha256Hash="$(nix hash file --type sha256 --base16 "$storePath")" + local -r size="$(du -b "$storePath" | cut -f1)" + + printOutput "$cudaMajorMinorVersion" "$redistSystem" "$md5Hash" "$relativePath" "$sha256Hash" "$size" +} + +main "$@" diff --git a/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.7.0.json b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.7.0.json new file mode 100644 index 000000000000..58c70ca39332 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.7.0.json @@ -0,0 +1,37 @@ +{ + "release_date": "2024-12-02", + "release_label": "10.7.0", + "release_product": "tensorrt", + "tensorrt": { + "name": "NVIDIA TensorRT", + "license": "TensorRT", + "version": "10.7.0.23", + "cuda_variant": [ + "12" + ], + "linux-aarch64": { + "cuda12": { + "md5": "ec486c783455bf31a2561f2b7874585e", + "relative_path": "tensorrt/10.7.0/tars/TensorRT-10.7.0.23.l4t.aarch64-gnu.cuda-12.6.tar.gz", + "sha256": "b3028a82818a9daf6296f43d0cdecfa51eaea4552ffb6fe6fad5e6e1aea44da6", + "size": "655777784" + } + }, + "linux-sbsa": { + "cuda12": { + "md5": "5b49557b4dc47641242a2bfb29e1cff1", + "relative_path": "tensorrt/10.7.0/tars/TensorRT-10.7.0.23.Linux.aarch64-gnu.cuda-12.6.tar.gz", + "sha256": "6b304cf014f2977e845bd44fdb343f0e7af2d9cded997bc9cfea3949d9e84dcb", + "size": "2469927296" + } + }, + "linux-x86_64": { + "cuda12": { + "md5": "925c98fbe9abe82058814159727732a2", + "relative_path": "tensorrt/10.7.0/tars/TensorRT-10.7.0.23.Linux.x86_64-gnu.cuda-12.6.tar.gz", + "sha256": "d7f16520457caaf97ad8a7e94d802f89d77aedf9f361a255f2c216e2a3a40a11", + "size": "4446480887" + } + } + } +} diff --git a/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.9.0.json b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.9.0.json new file mode 100644 index 000000000000..083119406e07 --- /dev/null +++ b/pkgs/development/cuda-modules/_cuda/manifests/tensorrt/redistrib_10.9.0.json @@ -0,0 +1,29 @@ +{ + "release_date": "2025-03-11", + "release_label": "10.9.0", + "release_product": "tensorrt", + "tensorrt": { + "name": "NVIDIA TensorRT", + "license": "TensorRT", + "version": "10.9.0.34", + "cuda_variant": [ + "12" + ], + "linux-sbsa": { + "cuda12": { + "md5": "e56a9f9d7327c65d9b95996d3008ed44", + "relative_path": "tensorrt/10.9.0/tars/TensorRT-10.9.0.34.Linux.aarch64-gnu.cuda-12.8.tar.gz", + "sha256": "b81ec2a067f67f082c13caec2dcef54385b42a9de6a4ecae6f318aa2d41964f2", + "size": "4123115318" + } + }, + "linux-x86_64": { + "cuda12": { + "md5": "ee49e3e6e00b21274907956216b6769f", + "relative_path": "tensorrt/10.9.0/tars/TensorRT-10.9.0.34.Linux.x86_64-gnu.cuda-12.8.tar.gz", + "sha256": "33be0e61e3bf177bbbcabb4892bf013f0c8ac71d2be73f2803848a382cb14272", + "size": "6917032417" + } + } + } +} diff --git a/pkgs/development/cuda-modules/aliases.nix b/pkgs/development/cuda-modules/aliases.nix index 9f73d75d8d2d..73c0f6ed83a1 100644 --- a/pkgs/development/cuda-modules/aliases.nix +++ b/pkgs/development/cuda-modules/aliases.nix @@ -9,20 +9,4 @@ in final: _: builtins.mapAttrs mkRenamed { # A comment to prevent empty { } from collapsing into a single line - - cudaFlags = { - path = "cudaPackages.flags"; - package = final.flags; - }; - - cudaVersion = { - path = "cudaPackages.cudaMajorMinorVersion"; - package = final.cudaMajorMinorVersion; - }; - - cudatoolkit-legacy-runfile = { - path = "cudaPackages.cudatoolkit"; - package = final.cudatoolkit; - }; - } diff --git a/pkgs/development/cuda-modules/buildRedist/buildRedistHook.bash b/pkgs/development/cuda-modules/buildRedist/buildRedistHook.bash new file mode 100644 index 000000000000..6ca8f3d19dcc --- /dev/null +++ b/pkgs/development/cuda-modules/buildRedist/buildRedistHook.bash @@ -0,0 +1,174 @@ +# shellcheck shell=bash + +if [[ -n ${strictDeps:-} && ${hostOffset:-0} -ne -1 ]]; then + nixLog "skipping sourcing buildRedistHook.bash (hostOffset=${hostOffset:-0}) (targetOffset=${targetOffset:-0})" + return 0 +fi +nixLog "sourcing buildRedistHook.bash (hostOffset=${hostOffset:-0}) (targetOffset=${targetOffset:-0})" + +buildRedistHookRegistration() { + postUnpackHooks+=(unpackCudaLibSubdir) + nixLog "added unpackCudaLibSubdir to postUnpackHooks" + + postUnpackHooks+=(unpackCudaPkgConfigDirs) + nixLog "added unpackCudaPkgConfigDirs to postUnpackHooks" + + prePatchHooks+=(patchCudaPkgConfig) + nixLog "added patchCudaPkgConfig to prePatchHooks" + + if [[ -z ${allowFHSReferences-} ]]; then + postInstallCheckHooks+=(checkCudaFhsRefs) + nixLog "added checkCudaFhsRefs to postInstallCheckHooks" + fi + + postInstallCheckHooks+=(checkCudaNonEmptyOutputs) + nixLog "added checkCudaNonEmptyOutputs to postInstallCheckHooks" + + preFixupHooks+=(fixupPropagatedBuildOutputsForMultipleOutputs) + nixLog "added fixupPropagatedBuildOutputsForMultipleOutputs to preFixupHooks" + + postFixupHooks+=(fixupCudaPropagatedBuildOutputsToOut) + nixLog "added fixupCudaPropagatedBuildOutputsToOut to postFixupHooks" +} + +buildRedistHookRegistration + +unpackCudaLibSubdir() { + local -r cudaLibDir="${NIX_BUILD_TOP:?}/${sourceRoot:?}/lib" + local -r versionedCudaLibDir="$cudaLibDir/${cudaMajorVersion:?}" + + if [[ ! -d $versionedCudaLibDir ]]; then + return 0 + fi + + nixLog "found versioned CUDA lib dir: $versionedCudaLibDir" + + mv \ + --verbose \ + --no-clobber \ + "$versionedCudaLibDir" \ + "${cudaLibDir}-new" + rm --verbose --recursive "$cudaLibDir" || { + nixErrorLog "could not delete $cudaLibDir: $(ls -laR "$cudaLibDir")" + exit 1 + } + mv \ + --verbose \ + --no-clobber \ + "${cudaLibDir}-new" \ + "$cudaLibDir" + + return 0 +} + +# Pkg-config's setup hook expects configuration files in $out/share/pkgconfig +unpackCudaPkgConfigDirs() { + local path + local -r pkgConfigDir="${NIX_BUILD_TOP:?}/${sourceRoot:?}/share/pkgconfig" + + for path in "${NIX_BUILD_TOP:?}/${sourceRoot:?}"/{pkg-config,pkgconfig}; do + [[ -d $path ]] || continue + mkdir -p "$pkgConfigDir" + mv \ + --verbose \ + --no-clobber \ + --target-directory "$pkgConfigDir" \ + "$path"/* + rm --recursive --dir "$path" || { + nixErrorLog "$path contains non-empty directories: $(ls -laR "$path")" + exit 1 + } + done + + return 0 +} + +patchCudaPkgConfig() { + local pc + + for pc in "${NIX_BUILD_TOP:?}/${sourceRoot:?}"/share/pkgconfig/*.pc; do + nixLog "patching $pc" + sed -i \ + -e "s|^cudaroot\s*=.*\$|cudaroot=${!outputDev:?}|" \ + -e "s|^libdir\s*=.*/lib\$|libdir=${!outputLib:?}/lib|" \ + -e "s|^includedir\s*=.*/include\$|includedir=${!outputInclude:?}/include|" \ + "$pc" + done + + for pc in "${NIX_BUILD_TOP:?}/${sourceRoot:?}"/share/pkgconfig/*-"${cudaMajorMinorVersion:?}.pc"; do + nixLog "creating unversioned symlink for $pc" + ln -s "$(basename "$pc")" "${pc%-"${cudaMajorMinorVersion:?}".pc}".pc + done + + return 0 +} + +checkCudaFhsRefs() { + nixLog "checking for FHS references..." + local -a outputPaths=() + local firstMatches + + mapfile -t outputPaths < <(for o in $(getAllOutputNames); do echo "${!o}"; done) + firstMatches="$(grep --max-count=5 --recursive --exclude=LICENSE /usr/ "${outputPaths[@]}")" || true + if [[ -n $firstMatches ]]; then + nixErrorLog "detected references to /usr: $firstMatches" + exit 1 + fi + + return 0 +} + +checkCudaNonEmptyOutputs() { + local output + local dirs + local -a failingOutputs=() + + for output in $(getAllOutputNames); do + [[ ${!output:?} == "out" || ${!output:?} == "${!outputDev:?}" ]] && continue + dirs="$(find "${!output:?}" -mindepth 1 -maxdepth 1)" || true + if [[ -z $dirs || $dirs == "${!output:?}/nix-support" ]]; then + failingOutputs+=("$output") + fi + done + + if ((${#failingOutputs[@]})); then + nixErrorLog "detected empty (excluding nix-support) outputs: ${failingOutputs[*]}" + nixErrorLog "this typically indicates a failure in packaging or moveToOutput ordering" + exit 1 + fi + + return 0 +} + +# TODO(@connorbaker): https://github.com/NixOS/nixpkgs/issues/323126. +# _multioutPropagateDev() currently expects a space-separated string rather than an array. +# NOTE: Because _multioutPropagateDev is a postFixup hook, we correct it in preFixup. +fixupPropagatedBuildOutputsForMultipleOutputs() { + nixLog "converting propagatedBuildOutputs to a space-separated string" + # shellcheck disable=SC2124 + export propagatedBuildOutputs="${propagatedBuildOutputs[@]}" + return 0 +} + +# The multiple outputs setup hook only propagates build outputs to dev. +# We want to propagate them to out as well, in case the user interpolates +# the package into a string -- in such a case, the dev output is not selected +# and no propagation occurs. +# NOTE: This must run in postFixup because fixupPhase nukes the propagated dependency files. +fixupCudaPropagatedBuildOutputsToOut() { + local output + + # The `out` output should largely be empty save for nix-support/propagated-build-inputs. + # In effect, this allows us to make `out` depend on all the other components. + # NOTE: It may have been deleted if it was empty, which is why we must recreate it. + mkdir -p "${out:?}/nix-support" + + # NOTE: We must use printWords to ensure the output is a single line. + for output in $propagatedBuildOutputs; do + # Propagate the other components to the out output + nixLog "adding ${!output:?} to propagatedBuildInputs of ${out:?}" + printWords "${!output:?}" >>"${out:?}/nix-support/propagated-build-inputs" + done + + return 0 +} diff --git a/pkgs/development/cuda-modules/buildRedist/default.nix b/pkgs/development/cuda-modules/buildRedist/default.nix new file mode 100644 index 000000000000..0317d85c9b22 --- /dev/null +++ b/pkgs/development/cuda-modules/buildRedist/default.nix @@ -0,0 +1,480 @@ +# NOTE: buildRedist should never take manifests or fixups as callPackage-provided arguments, +# since we want to provide the flexibility to call it directly with a different fixup or manifest. +{ + _cuda, + autoAddCudaCompatRunpath, + autoAddDriverRunpath, + autoPatchelfHook, + backendStdenv, + config, + cudaMajorMinorVersion, + cudaMajorVersion, + cudaNamePrefix, + fetchurl, + lib, + manifests, + markForCudatoolkitRootHook, + setupCudaHook, + srcOnly, + stdenv, + stdenvNoCC, +}: +let + inherit (backendStdenv) hostRedistSystem; + inherit (_cuda.lib) getNixSystems _mkCudaVariant mkRedistUrl; + inherit (lib.attrsets) + foldlAttrs + hasAttr + isAttrs + attrNames + optionalAttrs + ; + inherit (lib.customisation) extendMkDerivation; + inherit (lib.lists) + naturalSort + concatMap + unique + ; + inherit (lib.trivial) mapNullable pipe; + inherit (_cuda.lib) _mkMetaBadPlatforms _mkMetaBroken _redistSystemIsSupported; + inherit (lib) + licenses + sourceTypes + teams + ; + inherit (lib.asserts) assertMsg; + inherit (lib.lists) + elem + findFirst + findFirstIndex + foldl' + intersectLists + map + subtractLists + tail + ; + inherit (lib.strings) + concatMapStringsSep + toUpper + stringLength + substring + ; + inherit (lib.trivial) flip; + + mkOutputNameVar = + output: + assert assertMsg (output != "") "mkOutputNameVar: output name variable must not be empty"; + "output" + toUpper (substring 0 1 output) + substring 1 (stringLength output - 1) output; + + getSupportedReleases = + let + desiredCudaVariant = _mkCudaVariant cudaMajorVersion; + in + release: + # Always show preference to the "source", then "linux-all" redistSystem if they are available, as they are + # the most general. + if release ? source then + { + inherit (release) source; + } + else if release ? linux-all then + { + inherit (release) linux-all; + } + else + let + hasCudaVariants = release ? cuda_variant; + in + foldlAttrs ( + acc: name: value: + acc + # If the value is an attribute, and when hasCudaVariants is true it has the relevant CUDA variant, + # then add it to the set. + // optionalAttrs (isAttrs value && (hasCudaVariants -> hasAttr desiredCudaVariant value)) { + ${name} = value.${desiredCudaVariant} or value; + } + ) { } release; + + getPreferredRelease = + supportedReleases: + supportedReleases.source or supportedReleases.linux-all or supportedReleases.${hostRedistSystem} + or null; +in +extendMkDerivation { + constructDrv = backendStdenv.mkDerivation; + # These attributes are moved to passthru to avoid changing derivation hashes. + excludeDrvArgNames = [ + # Core + "redistName" + "release" + + # Misc + "brokenAssertions" + "platformAssertions" + "expectedOutputs" + "outputToPatterns" + "outputNameVarFallbacks" + ]; + extendDrvArgs = + finalAttrs: + { + # Core + redistName, + pname, + release ? manifests.${finalAttrs.passthru.redistName}.${finalAttrs.pname} or null, + + # Outputs + outputs ? [ "out" ], + propagatedBuildOutputs ? [ ], + + # Inputs + nativeBuildInputs ? [ ], + propagatedBuildInputs ? [ ], + buildInputs ? [ ], + + # Checking + doInstallCheck ? true, + allowFHSReferences ? false, + + # Fixups + appendRunpaths ? [ ], + + # Extra + passthru ? { }, + meta ? { }, + + # Misc + brokenAssertions ? [ ], + platformAssertions ? [ ], + + # Order is important here so we use a list. + expectedOutputs ? [ + "out" + "doc" + "samples" + "python" + "bin" + "dev" + "include" + "lib" + "static" + "stubs" + ], + + # Traversed in the order of the outputs speficied in outputs; + # entries are skipped if they don't exist in outputs. + # NOTE: The nil LSP gets angry if we do not parenthesize the default attrset. + outputToPatterns ? { + bin = [ "bin" ]; + dev = [ + "**/*.pc" + "**/*.cmake" + ]; + include = [ "include" ]; + lib = [ + "lib" + "lib64" + ]; + static = [ "**/*.a" ]; + samples = [ "samples" ]; + python = [ "**/*.whl" ]; + stubs = [ + "stubs" + "lib/stubs" + ]; + }, + + # Defines a list of fallbacks for each potential output. + # The last fallback is the out output. + # Taken and modified from: + # https://github.com/NixOS/nixpkgs/blob/fe5e11faed6241aacf7220436088789287507494/pkgs/build-support/setup-hooks/multiple-outputs.sh#L45-L62 + outputNameVarFallbacks ? { + outputBin = [ "bin" ]; + outputDev = [ "dev" ]; + outputDoc = [ "doc" ]; + outputInclude = [ + "include" + "dev" + ]; + outputLib = [ "lib" ]; + outputOut = [ "out" ]; + outputPython = [ "python" ]; + outputSamples = [ "samples" ]; + outputStatic = [ "static" ]; + outputStubs = [ "stubs" ]; + }, + ... + }: + { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: `release` may be null if a redistributable isn't available. + version = finalAttrs.passthru.release.version or "0-unsupported"; + + # Name should be prefixed by cudaNamePrefix to create more descriptive path names. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + + # We should only have the output `out` when `src` is null. + # lists.intersectLists iterates over the second list, checking if the elements are in the first list. + # As such, the order of the output is dictated by the order of the second list. + outputs = + if finalAttrs.src == null then + [ "out" ] + else + intersectLists outputs finalAttrs.passthru.expectedOutputs; + + # NOTE: Because the `dev` output is special in Nixpkgs -- make-derivation.nix uses it as the default if + # it is present -- we must ensure that it brings in the expected dependencies. For us, this means that `dev` + # should include `bin`, `include`, and `lib` -- `static` is notably absent because it is quite large. + # We do not include `stubs`, as a number of packages contain stubs for libraries they already ship with! + # Only a few, like cuda_cudart, actually provide stubs for libraries we're missing. + # As such, these packages should override propagatedBuildOutputs to add `stubs`. + propagatedBuildOutputs = + intersectLists [ + "bin" + "include" + "lib" + ] finalAttrs.outputs + ++ propagatedBuildOutputs; + + # src :: null | Derivation + src = mapNullable ( + { relative_path, sha256, ... }: + srcOnly { + __structuredAttrs = true; + strictDeps = true; + stdenv = stdenvNoCC; + inherit (finalAttrs) pname version; + src = fetchurl { + url = mkRedistUrl finalAttrs.passthru.redistName relative_path; + inherit sha256; + }; + } + ) (getPreferredRelease finalAttrs.passthru.supportedReleases); + + # Required for the hook. + inherit cudaMajorMinorVersion cudaMajorVersion; + + # We do need some other phases, like configurePhase, so the multiple-output setup hook works. + dontBuild = true; + + nativeBuildInputs = [ + ./buildRedistHook.bash + autoPatchelfHook + # This hook will make sure libcuda can be found + # in typically /lib/opengl-driver by adding that + # directory to the rpath of all ELF binaries. + # Check e.g. with `patchelf --print-rpath path/to/my/binary + autoAddDriverRunpath + markForCudatoolkitRootHook + ] + # autoAddCudaCompatRunpath depends on cuda_compat and would cause + # infinite recursion if applied to `cuda_compat` itself (beside the fact + # that it doesn't make sense in the first place) + ++ lib.optionals (finalAttrs.pname != "cuda_compat" && autoAddCudaCompatRunpath.enableHook) [ + # autoAddCudaCompatRunpath must appear AFTER autoAddDriverRunpath. + # See its documentation in ./setup-hooks/extension.nix. + autoAddCudaCompatRunpath + ] + ++ nativeBuildInputs; + + propagatedBuildInputs = [ setupCudaHook ] ++ propagatedBuildInputs; + + buildInputs = [ + # autoPatchelfHook will search for a libstdc++ and we're giving it + # one that is compatible with the rest of nixpkgs, even when + # nvcc forces us to use an older gcc + # NB: We don't actually know if this is the right thing to do + # NOTE: Not all packages actually need this, but it's easier to just add it than create overrides for nearly all + # of them. + (lib.getLib stdenv.cc.cc) + ] + ++ buildInputs; + + # Picked up by autoPatchelf + # Needed e.g. for libnvrtc to locate (dlopen) libnvrtc-builtins + appendRunpaths = [ "$ORIGIN" ] ++ appendRunpaths; + + # NOTE: We don't need to check for dev or doc, because those outputs are handled by + # the multiple-outputs setup hook. + # NOTE: moveToOutput operates on all outputs: + # https://github.com/NixOS/nixpkgs/blob/2920b6fc16a9ed5d51429e94238b28306ceda79e/pkgs/build-support/setup-hooks/multiple-outputs.sh#L105-L107 + # NOTE: installPhase is not moved into the builder hook because we do a lot of Nix templating. + installPhase = + let + mkMoveToOutputCommand = + output: + let + template = pattern: '' + moveToOutput "${pattern}" "${"$" + output}" + ''; + patterns = finalAttrs.passthru.outputToPatterns.${output} or [ ]; + in + concatMapStringsSep "\n" template patterns; + in + # Pre-install hook + '' + runHook preInstall + '' + # Create the primary output, out, and move the other outputs into it. + + '' + mkdir -p "$out" + nixLog "moving tree to output out" + mv * "$out" + '' + # Move the outputs into their respective outputs. + + '' + ${concatMapStringsSep "\n" mkMoveToOutputCommand (tail finalAttrs.outputs)} + '' + # Post-install hook + + '' + runHook postInstall + ''; + + inherit doInstallCheck; + inherit allowFHSReferences; + + passthru = passthru // { + inherit redistName release; + + supportedReleases = + passthru.supportedReleases + # NOTE: `release` may be null, so we must use `lib.defaultTo` + or (getSupportedReleases (lib.defaultTo { } finalAttrs.passthru.release)); + + supportedNixSystems = + passthru.supportedNixSystems or (pipe finalAttrs.passthru.supportedReleases [ + attrNames + (concatMap getNixSystems) + naturalSort + unique + ]); + + supportedRedistSystems = + passthru.supportedRedistSystems or (naturalSort (attrNames finalAttrs.passthru.supportedReleases)); + + # NOTE: Downstream may expand this to include other outputs, but they must remember to set the appropriate + # outputNameVarFallbacks! + inherit expectedOutputs; + + # Traversed in the order of the outputs speficied in outputs; + # entries are skipped if they don't exist in outputs. + inherit outputToPatterns; + + # Defines a list of fallbacks for each potential output. + # The last fallback is the out output. + # Taken and modified from: + # https://github.com/NixOS/nixpkgs/blob/fe5e11faed6241aacf7220436088789287507494/pkgs/build-support/setup-hooks/multiple-outputs.sh#L45-L62 + inherit outputNameVarFallbacks; + + # brokenAssertions :: [Attrs] + # Used by mkMetaBroken to set `meta.broken`. + # Example: Broken on a specific version of CUDA or when a dependency has a specific version. + # NOTE: Do not use this when a broken assertion means evaluation will fail! For example, if + # a package is missing and is required for the build -- that should go in platformAssertions, + # because attempts to access attributes on the package will cause evaluation errors. + brokenAssertions = [ + { + message = "CUDA support is enabled by config.cudaSupport"; + assertion = config.cudaSupport; + } + { + message = "lib output precedes static output"; + assertion = + let + libIndex = findFirstIndex (x: x == "lib") null finalAttrs.outputs; + staticIndex = findFirstIndex (x: x == "static") null finalAttrs.outputs; + in + libIndex == null || staticIndex == null || libIndex < staticIndex; + } + { + # NOTE: We cannot (easily) check that all expected outputs have a corresponding outputNameVar attribute in + # finalAttrs because of the presence of attributes which use the "output" prefix but are not outputNameVars + # (e.g., outputChecks and outputName). + message = "outputNameVarFallbacks is a super set of expectedOutputs"; + assertion = + subtractLists (map mkOutputNameVar finalAttrs.passthru.expectedOutputs) ( + attrNames finalAttrs.passthru.outputNameVarFallbacks + ) == [ ]; + } + { + message = "outputToPatterns is a super set of expectedOutputs"; + assertion = + subtractLists finalAttrs.passthru.expectedOutputs (attrNames finalAttrs.passthru.outputToPatterns) + == [ ]; + } + { + message = "propagatedBuildOutputs is a subset of outputs"; + assertion = subtractLists finalAttrs.outputs finalAttrs.propagatedBuildOutputs == [ ]; + } + ] + ++ brokenAssertions; + + # platformAssertions :: [Attrs] + # Used by mkMetaBadPlatforms to set `meta.badPlatforms`. + # Example: Broken on a specific system when some condition is met, like targeting Jetson or + # a required package missing. + # NOTE: Use this when a failed assertion means evaluation can fail! + platformAssertions = + let + isSupportedRedistSystem = _redistSystemIsSupported hostRedistSystem finalAttrs.passthru.supportedRedistSystems; + in + [ + { + message = "src is null if and only if hostRedistSystem is unsupported"; + assertion = (finalAttrs.src == null) == !isSupportedRedistSystem; + } + { + message = "hostRedistSystem (${hostRedistSystem}) is supported (${builtins.toJSON finalAttrs.passthru.supportedRedistSystems})"; + assertion = isSupportedRedistSystem; + } + ] + ++ platformAssertions; + }; + + meta = meta // { + longDescription = meta.longDescription or "" + '' + By downloading and using this package you accept the terms and conditions of the associated license(s). + ''; + sourceProvenance = meta.sourceProvenance or [ sourceTypes.binaryNativeCode ]; + platforms = finalAttrs.passthru.supportedNixSystems; + broken = _mkMetaBroken finalAttrs; + badPlatforms = _mkMetaBadPlatforms finalAttrs; + downloadPage = + meta.downloadPage + or "https://developer.download.nvidia.com/compute/${finalAttrs.passthru.redistName}/redist/${finalAttrs.pname}"; + # NOTE: + # Every redistributable should set its own license; since that's a lot of manual work, we default to + # nvidiaCudaRedist if the redistributable is from the CUDA redistributables and nvidiaCuda otherwise. + # Despite calling them "redistributable" and the download URL containing "redist", a number of these + # packages are not licensed such that redistribution is allowed. + license = + if meta ? license then + lib.toList meta.license + else if finalAttrs.passthru.redistName == "cuda" then + [ licenses.nvidiaCudaRedist ] + else + [ licenses.nvidiaCuda ]; + teams = meta.teams or [ ] ++ [ teams.cuda ]; + }; + } + # Setup the outputNameVar variables to gracefully handle missing outputs. + # NOTE: We cannot use expectedOutputs from finalAttrs.passthru because we will infinitely recurse: presence of + # attributes in finalAttrs cannot depend on finalAttrs. + // foldl' ( + acc: output: + let + outputNameVar = mkOutputNameVar output; + in + acc + // { + ${outputNameVar} = + findFirst (flip elem finalAttrs.outputs) "out" + finalAttrs.passthru.outputNameVarFallbacks.${outputNameVar}; + } + ) { } expectedOutputs; + + # Don't inherit any of stdenv.mkDerivation's arguments. + inheritFunctionArgs = false; +} diff --git a/pkgs/development/cuda-modules/cuda-library-samples/extension.nix b/pkgs/development/cuda-modules/cuda-library-samples/extension.nix deleted file mode 100644 index 1184547c7f93..000000000000 --- a/pkgs/development/cuda-modules/cuda-library-samples/extension.nix +++ /dev/null @@ -1,16 +0,0 @@ -{ lib, stdenv }: -let - inherit (stdenv) hostPlatform; - - # Samples are built around the CUDA Toolkit, which is not available for - # aarch64. Check for both CUDA version and platform. - platformIsSupported = hostPlatform.isx86_64 && hostPlatform.isLinux; - - # Build our extension - extension = - final: _: - lib.attrsets.optionalAttrs platformIsSupported { - cuda-library-samples = final.callPackage ./generic.nix { }; - }; -in -extension diff --git a/pkgs/development/cuda-modules/cuda/extension.nix b/pkgs/development/cuda-modules/cuda/extension.nix deleted file mode 100644 index 706631c06285..000000000000 --- a/pkgs/development/cuda-modules/cuda/extension.nix +++ /dev/null @@ -1,70 +0,0 @@ -{ cudaMajorMinorVersion, lib }: -let - inherit (lib) attrsets modules trivial; - redistName = "cuda"; - - # Manifest files for CUDA redistributables (aka redist). These can be found at - # https://developer.download.nvidia.com/compute/cuda/redist/ - # Maps a cuda version to the specific version of the manifest. - cudaVersionMap = { - "12.6" = "12.6.3"; - "12.8" = "12.8.1"; - "12.9" = "12.9.1"; - }; - - # Check if the current CUDA version is supported. - cudaVersionMappingExists = builtins.hasAttr cudaMajorMinorVersion cudaVersionMap; - - # fullCudaVersion : String - fullCudaVersion = cudaVersionMap.${cudaMajorMinorVersion}; - - evaluatedModules = modules.evalModules { - modules = [ - ../modules - # We need to nest the manifests in a config.cuda.manifests attribute so the - # module system can evaluate them. - { - cuda.manifests = { - redistrib = trivial.importJSON (./manifests + "/redistrib_${fullCudaVersion}.json"); - feature = trivial.importJSON (./manifests + "/feature_${fullCudaVersion}.json"); - }; - } - ]; - }; - - # Generally we prefer to do things involving getting attribute names with feature_manifest instead - # of redistrib_manifest because the feature manifest will have *only* the redist system - # names as the keys, whereas the redistrib manifest will also have things like version, name, license, - # and license_path. - featureManifest = evaluatedModules.config.cuda.manifests.feature; - redistribManifest = evaluatedModules.config.cuda.manifests.redistrib; - - # Builder function which builds a single redist package for a given platform. - # buildRedistPackage : callPackage -> PackageName -> Derivation - buildRedistPackage = - callPackage: pname: - callPackage ../generic-builders/manifest.nix { - inherit pname redistName; - # We pass the whole release to the builder because it has logic to handle - # the case we're trying to build on an unsupported platform. - redistribRelease = redistribManifest.${pname}; - featureRelease = featureManifest.${pname}; - }; - - # Build all the redist packages given final and prev. - redistPackages = - final: _prev: - # Wrap the whole thing in an optionalAttrs so we can return an empty set if the CUDA version - # is not supported. - # NOTE: We cannot include the call to optionalAttrs *in* the pipe as we would strictly evaluate the - # attrNames before we check if the CUDA version is supported. - attrsets.optionalAttrs cudaVersionMappingExists ( - trivial.pipe featureManifest [ - # Get all the package names - builtins.attrNames - # Build the redist packages - (trivial.flip attrsets.genAttrs (buildRedistPackage final.callPackage)) - ] - ); -in -redistPackages diff --git a/pkgs/development/cuda-modules/cuda/manifests/feature_12.6.3.json b/pkgs/development/cuda-modules/cuda/manifests/feature_12.6.3.json deleted file mode 100644 index 7ee3951de1d6..000000000000 --- a/pkgs/development/cuda-modules/cuda/manifests/feature_12.6.3.json +++ /dev/null @@ -1,1386 +0,0 @@ -{ - "cuda_cccl": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_compat": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cudart": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cuobjdump": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cupti": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": true, - "static": false - } - } - }, - "cuda_cuxxfilt": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_demo_suite": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_documentation": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_gdb": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nsight": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvcc": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvdisasm": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvml_dev": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprof": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprune": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvrtc": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvtx": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvvp": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_opencl": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_profiler_api": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_sanitizer_api": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "fabricmanager": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "imex": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcublas": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcudla": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libcufft": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcufile": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - } - }, - "libcurand": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusolver": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusparse": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnpp": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvfatbin": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvidia_nscq": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libnvjitlink": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvjpeg": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvsdm": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "nsight_compute": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_systems": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_vse": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nvidia_driver": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "nvidia_fs": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "visual_studio_integration": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cuda/manifests/feature_12.8.1.json b/pkgs/development/cuda-modules/cuda/manifests/feature_12.8.1.json deleted file mode 100644 index 20aa77b1ba1e..000000000000 --- a/pkgs/development/cuda-modules/cuda/manifests/feature_12.8.1.json +++ /dev/null @@ -1,1410 +0,0 @@ -{ - "cuda_cccl": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_compat": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cudart": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cuobjdump": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cupti": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": true, - "static": false - } - } - }, - "cuda_cuxxfilt": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_demo_suite": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_documentation": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_gdb": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nsight": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvcc": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvdisasm": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvml_dev": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprof": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprune": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvrtc": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvtx": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvvp": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_opencl": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_profiler_api": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_sandbox_dev": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_sanitizer_api": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "driver_assistant": { - "linux-all": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "fabricmanager": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "imex": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcublas": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcudla": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libcufft": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcufile": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - } - }, - "libcurand": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusolver": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusparse": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnpp": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvfatbin": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvidia_nscq": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libnvjitlink": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvjpeg": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvsdm": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "nsight_compute": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_systems": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_vse": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nvidia_driver": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "nvidia_fs": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "visual_studio_integration": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cuda/manifests/feature_12.9.1.json b/pkgs/development/cuda-modules/cuda/manifests/feature_12.9.1.json deleted file mode 100644 index 00e11ae31f94..000000000000 --- a/pkgs/development/cuda-modules/cuda/manifests/feature_12.9.1.json +++ /dev/null @@ -1,1520 +0,0 @@ -{ - "collectx_bringup": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cccl": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_compat": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cudart": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cuobjdump": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_cupti": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": true, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": true, - "static": false - } - } - }, - "cuda_cuxxfilt": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_demo_suite": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_documentation": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_gdb": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nsight": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvcc": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvdisasm": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvml_dev": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprof": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvprune": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvrtc": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvtx": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_nvvp": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_opencl": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_profiler_api": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "cuda_sandbox_dev": { - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": true - } - } - }, - "cuda_sanitizer_api": { - "linux-aarch64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "driver_assistant": { - "linux-all": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "fabricmanager": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "imex": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcublas": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcudla": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libcufft": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcufile": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - } - }, - "libcurand": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusolver": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libcusparse": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnpp": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvfatbin": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvidia_nscq": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "libnvjitlink": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvjpeg": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "libnvsdm": { - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "mft": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "mft_autocomplete": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "mft_oem": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_compute": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_systems": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nsight_vse": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nvidia_driver": { - "linux-sbsa": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": true, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "nvidia_fs": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - }, - "nvlsm": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": true, - "sample": false, - "static": false - } - } - }, - "visual_studio_integration": { - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": false, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cuda/manifests/redistrib_12.9.1.json b/pkgs/development/cuda-modules/cuda/manifests/redistrib_12.9.1.json deleted file mode 100644 index 2ead9b4f283f..000000000000 --- a/pkgs/development/cuda-modules/cuda/manifests/redistrib_12.9.1.json +++ /dev/null @@ -1,1151 +0,0 @@ -{ - "release_date": "2025-06-05", - "release_label": "12.9.1", - "release_product": "cuda", - "collectx_bringup": { - "name": "UFM telemetry CollectX Bringup", - "license": "NVIDIA Proprietary", - "license_path": "collectx_bringup/LICENSE.txt", - "version": "1.19.13", - "linux-x86_64": { - "relative_path": "collectx_bringup/linux-x86_64/collectx_bringup-linux-x86_64-1.19.13-archive.tar.xz", - "sha256": "4965fe096fca645a6d4565fd4d12366ae0ec31ec54ca20274910f34eea74b41a", - "md5": "d48b8c177f312c8774c54988594f725c", - "size": "125307508" - }, - "linux-sbsa": { - "relative_path": "collectx_bringup/linux-sbsa/collectx_bringup-linux-sbsa-1.19.13-archive.tar.xz", - "sha256": "5d716fbb80ef7b9ac89f9e3fa8b900a29d4e6c0be487420dc4ee7a05340b57a9", - "md5": "dc2c0bfedf790ba7dc21f684510e592e", - "size": "120696772" - } - }, - "cuda_cccl": { - "name": "CXX Core Compute Libraries", - "license": "CUDA Toolkit", - "license_path": "cuda_cccl/LICENSE.txt", - "version": "12.9.27", - "linux-x86_64": { - "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.9.27-archive.tar.xz", - "sha256": "8b1a5095669e94f2f9afd7715533314d418179e9452be61e2fde4c82a3e542aa", - "md5": "59e3cb66aeb96423dcca73218c85bc02", - "size": "997888" - }, - "linux-sbsa": { - "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.9.27-archive.tar.xz", - "sha256": "8c3da24801b500f1d9217d191bb4b63e5d2096c8e7d0b7695e876853180ba82f", - "md5": "b39d03cfac57a3b2ded8e9b0a6b0e782", - "size": "997840" - }, - "windows-x86_64": { - "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.9.27-archive.zip", - "sha256": "17aaa7c6b8f94a417d8f3261780b7e34b9cbdfab7513bce86768623b06aa28b5", - "md5": "afdfa89a35951f67b5bd70c513f5ef09", - "size": "3127658" - }, - "linux-aarch64": { - "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-12.9.27-archive.tar.xz", - "sha256": "8c87c2db67130108861609eacd40d30ee109656a7765e5172eab71dd6da4c453", - "md5": "25b1a257ed35393052577bd9ee432d3f", - "size": "998228" - } - }, - "cuda_compat": { - "name": "CUDA compat L4T", - "license": "CUDA Toolkit", - "license_path": "cuda_compat/LICENSE.txt", - "version": "12.9.40580548", - "linux-aarch64": { - "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-12.9.40580548-archive.tar.xz", - "sha256": "c03fe18b9d23881f068ac97b45001a47778f83d2361728427a3f92b551b1c898", - "md5": "3ca26403b8b36c5cc18104ee174ec874", - "size": "37422044" - } - }, - "cuda_cudart": { - "name": "CUDA Runtime (cudart)", - "license": "CUDA Toolkit", - "license_path": "cuda_cudart/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "1f6ad42d4f530b24bfa35894ccf6b7209d2354f59101fd62ec4a6192a184ce99", - "md5": "6153e2b6a43389e5be3d68b04c6488f5", - "size": "1514676" - }, - "linux-sbsa": { - "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "8b422a3b2cb8452cb678181b0bf9d7aa7342df168b5319c5488ae3b8514101fc", - "md5": "c4b3e0d206f5dc3aceaddb78a32424d3", - "size": "1521596" - }, - "windows-x86_64": { - "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.9.79-archive.zip", - "sha256": "179e9c43b0735ffe67207b3da556eb5a0c50f3047961882b7657d3b822d34ef8", - "md5": "22e500ce68dc9e099ec18f57e1309808", - "size": "3521238" - }, - "linux-aarch64": { - "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "f893e2c72be81b0d0e3bc33827c785a96db15fd5aafdc51cc187f3df6fdbb657", - "md5": "8970e9d40a7edada8cd9270906b1daa3", - "size": "1223440" - } - }, - "cuda_cuobjdump": { - "name": "cuobjdump", - "license": "CUDA Toolkit", - "license_path": "cuda_cuobjdump/LICENSE.txt", - "version": "12.9.82", - "linux-x86_64": { - "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.9.82-archive.tar.xz", - "sha256": "ee0de40e8c18068bfcc53e73510e7e7a1a80555205347940df67fa525d24452f", - "md5": "fb4ceb446f3ca58c4ca5381a2c0eee06", - "size": "214896" - }, - "linux-sbsa": { - "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.9.82-archive.tar.xz", - "sha256": "2d39ae9309f81a7980df296a93c0e49215c6fb22d316fd9daae211d29a731d27", - "md5": "9ec739cea851b184b55017d0a6185304", - "size": "208936" - }, - "windows-x86_64": { - "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.9.82-archive.zip", - "sha256": "1eda43a76a2eac25fce5bdb4b68673b5bda737d54cca5513148c36362ab7c811", - "md5": "0a1c8b1f69537bc605c0d5fc28110258", - "size": "6219088" - }, - "linux-aarch64": { - "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-12.9.82-archive.tar.xz", - "sha256": "91a9ae2935b411d136c2c61ccbbc0df3a83f17cce122d12d262be202217163ee", - "md5": "ec5905b13be30f8f39e18d1f41dbcf18", - "size": "197604" - } - }, - "cuda_cupti": { - "name": "CUPTI", - "license": "CUDA Toolkit", - "license_path": "cuda_cupti/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "f779a24e8f0177b4ce45cbf118cb470139fb5107858df96689d0a0aa01f0fba1", - "md5": "5fe49729261d1f899bd0948026b755ae", - "size": "16799436" - }, - "linux-sbsa": { - "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "84f8657375c23a425b2d107c3cde1ce75777bff9798b744b78e146fdc02d2de0", - "md5": "ff4c04b183cc173aa2937a21a3569b5b", - "size": "12805704" - }, - "windows-x86_64": { - "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.9.79-archive.zip", - "sha256": "c96018456dc4db6af6d69d6db0170a2ccc656ddde8c8ce6ee05682c2c5569daa", - "md5": "1cecfef05160d4e6b0f2549534fe7973", - "size": "13359912" - }, - "linux-aarch64": { - "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "74a884691b2c7e5c8db8bd2a38143fc82f7502f0dd484051809df7953f7ae719", - "md5": "7f92adb9aed6fdb047ebe3c7617c7179", - "size": "4781260" - } - }, - "cuda_cuxxfilt": { - "name": "CUDA cuxxfilt (demangler)", - "license": "CUDA Toolkit", - "license_path": "cuda_cuxxfilt/LICENSE.txt", - "version": "12.9.82", - "linux-x86_64": { - "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.9.82-archive.tar.xz", - "sha256": "833d7e56351d032717f217212577d369d230e284b2ded4bf151403cc11213add", - "md5": "a7f4a446e4fb00657f5bd7eb1dd814a7", - "size": "188692" - }, - "linux-sbsa": { - "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.9.82-archive.tar.xz", - "sha256": "2175ef96b523eb8fea5d6ccfd21b70d6afaee623d00dbab70f11e8aa892c2828", - "md5": "fde8b2db7d7e4afb08e7c703fa735440", - "size": "177440" - }, - "windows-x86_64": { - "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.9.82-archive.zip", - "sha256": "ec5911d680394d90968c480c7359e7f5a4025b9c4806dad673d489e57585afd3", - "md5": "537cd82a0945fe20275d4791e353c3f5", - "size": "178570" - }, - "linux-aarch64": { - "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-12.9.82-archive.tar.xz", - "sha256": "37acae6576874c3781e844ea268a9fe076d13aaab3acda6f65bbe885a3726a3c", - "md5": "c8e23bff8cc13fb58a57c90d69e7b374", - "size": "170436" - } - }, - "cuda_demo_suite": { - "name": "CUDA Demo Suite", - "license": "CUDA Toolkit", - "license_path": "cuda_demo_suite/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "92e0b324bf02d9705b8dd5bf1d36149c06512c720ceda7cc7d791fc3ecf64f0e", - "md5": "5030cddcab7101704bb8a9b53c6137ad", - "size": "4036604" - }, - "windows-x86_64": { - "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.9.79-archive.zip", - "sha256": "adffd0b0f7cca262025f171dcaa73f62af020de5d9a0d6e0fbe7dbd827dd77a8", - "md5": "9a8c3bbd696392e768ae3278e269cbd9", - "size": "5164004" - } - }, - "cuda_documentation": { - "name": "CUDA Documentation", - "license": "CUDA Toolkit", - "license_path": "cuda_documentation/LICENSE.txt", - "version": "12.9.88", - "linux-x86_64": { - "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.9.88-archive.tar.xz", - "sha256": "d6e44c454654016a3650f3101688231ba111cd00647b726b34d18ff0bd721933", - "md5": "17436d82e589824bbf3f4ff669201d81", - "size": "67920" - }, - "linux-sbsa": { - "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.9.88-archive.tar.xz", - "sha256": "e1c47f32279a827baf8b4339c1737d7bd8e54c73388835e5fae3e2db83db2479", - "md5": "995f5692be016e44821fb85ebc3a62d9", - "size": "67924" - }, - "windows-x86_64": { - "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.9.88-archive.zip", - "sha256": "660f2f71b94c13a021850a8bb6227dfb4eb9a8dd8e0f6bc9feb0b993dea180fd", - "md5": "3d21d1b9056629557bb2745f962af636", - "size": "107626" - }, - "linux-aarch64": { - "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-12.9.88-archive.tar.xz", - "sha256": "830476a755f9a8c9780a6876d0ed562c073f29968c3e0e91962d0fd14b3f3618", - "md5": "098d318ebb7700a6513e57e41edf20c8", - "size": "67948" - } - }, - "cuda_gdb": { - "name": "CUDA GDB", - "license": "CUDA Toolkit", - "license_path": "cuda_gdb/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "3dbb657683cd4f2989c30bdad31b3f4493795a9acc8a2214f48df3cfca7c37c0", - "md5": "1405f9cf4a5d2c03785a69aefa05de16", - "size": "67691620" - }, - "linux-sbsa": { - "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "251b9bd86ffcce0cdc4a5480ef3d8d609ca3a276cbbb5c793ca9978721d31faf", - "md5": "b76ab824a5b651ecec31978e6e2f41bf", - "size": "45695592" - }, - "linux-aarch64": { - "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "5473c27f1ec03fe064a09399e52b251e6ca5d3b9a67f21c1a26a02a26102f165", - "md5": "95325479bec751d72d4f063d8d244049", - "size": "45662012" - } - }, - "cuda_nsight": { - "name": "Nsight Eclipse Edition Plugin", - "license": "CUDA Toolkit", - "license_path": "cuda_nsight/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "5c3994440ce7aa6ac5ab120e45f25f5f5eaa631af0f793fab860a5edbc499518", - "md5": "3bce6195222da1c1d549fbd2d83422e8", - "size": "118693300" - } - }, - "cuda_nvcc": { - "name": "CUDA NVCC", - "license": "CUDA Toolkit", - "license_path": "cuda_nvcc/LICENSE.txt", - "version": "12.9.86", - "linux-x86_64": { - "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.9.86-archive.tar.xz", - "sha256": "7a1a5b652e5ef85c82b721d10672fc9a2dbaab44e9bd3c65a69517bf53998c35", - "md5": "ac1871c955070267e117bd985f6dbb36", - "size": "81100244" - }, - "linux-sbsa": { - "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.9.86-archive.tar.xz", - "sha256": "0aa1fce92dbae76c059c27eefb9d0ffb58e1291151e44ff7c7f1fc2dd9376c0d", - "md5": "1322a14e4d6482f69d4b8a14a7d5f4c5", - "size": "73407012" - }, - "windows-x86_64": { - "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.9.86-archive.zip", - "sha256": "227b109663b5e57d2718bcabb24a4ba0d9d4e52d958e327dc476f7c28691be85", - "md5": "ff9b2942aaa3a1dfb487da6767bc689f", - "size": "126917884" - }, - "linux-aarch64": { - "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-12.9.86-archive.tar.xz", - "sha256": "2432ef8a7c12d0a9ce3332a8af42b123c07f256390b3390802b1b2c6254c6c74", - "md5": "f846e79e53be949484a4968880eb9dd9", - "size": "77162776" - } - }, - "cuda_nvdisasm": { - "name": "CUDA nvdisasm", - "license": "CUDA Toolkit", - "license_path": "cuda_nvdisasm/LICENSE.txt", - "version": "12.9.88", - "linux-x86_64": { - "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.9.88-archive.tar.xz", - "sha256": "49296dd550e05434185a8588ec639f1325b2de413e2321ddd7e56c5182a476ff", - "md5": "87ec016e430618bf724a3e8332bfcca6", - "size": "5483340" - }, - "linux-sbsa": { - "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.9.88-archive.tar.xz", - "sha256": "28b2597f0901cfafcd050cba0877c1eb5edcd7ebd8164aea356cec832e636ee3", - "md5": "0d6f0b8883e55ca07d64cbb746b80e8c", - "size": "5408212" - }, - "windows-x86_64": { - "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.9.88-archive.zip", - "sha256": "955ba1f52f7115031f10408ce3cec4c745df41dba8fdf6024c3983d899e9fbbc", - "md5": "43cd76e59014be18d96ce03e2ed09d6b", - "size": "5791897" - }, - "linux-aarch64": { - "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-12.9.88-archive.tar.xz", - "sha256": "99bf70149423c42c8dc2649f76f8983101dcf9879d355cfb2582b2adbed84614", - "md5": "cb9f7798d824ef1696fdde67f9506aa4", - "size": "5416148" - } - }, - "cuda_nvml_dev": { - "name": "CUDA NVML Headers", - "license": "CUDA Toolkit", - "license_path": "cuda_nvml_dev/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "1ad0866dbfff6a9e2661f5348e4ca4c2a4e40882b90014ab127f2734856ecccb", - "md5": "7e615aa7b4525d3cc1b28379abcf6ce5", - "size": "129244" - }, - "linux-sbsa": { - "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "e97e668ead7ebc1fb7e93ffe303019660d0119c4e4d0e8ef26ce012bbbea9b34", - "md5": "d48bcaa83a7299b836d381b32e94a99d", - "size": "130480" - }, - "windows-x86_64": { - "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.9.79-archive.zip", - "sha256": "1894b70c5487a739c740929263fa3fbca80e53790647abc02b74eac024b97be8", - "md5": "213d773bb297b15e9f697ec8f1363bd9", - "size": "144955" - }, - "linux-aarch64": { - "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "531ac94b8b83209657cd14b28d23660df252393fb34c24f5d8919c56c977477e", - "md5": "3fe82d3f6042a22ac3d119192577db79", - "size": "130544" - } - }, - "cuda_nvprof": { - "name": "CUDA nvprof", - "license": "CUDA Toolkit", - "license_path": "cuda_nvprof/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "8d8d1a9004710bad8d7a653769f088064b0285a06a80b46c4da7598115a0c6a2", - "md5": "df8f768c6c21b06cb048b9a4b0ac39e7", - "size": "2402440" - }, - "windows-x86_64": { - "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.9.79-archive.zip", - "sha256": "81aefd12ab0a24f88feee10303b814fcf21887b3947d5e73523ed14338ef4e2b", - "md5": "69ada7050609c5860a2396a6354665e0", - "size": "1705346" - } - }, - "cuda_nvprune": { - "name": "CUDA nvprune", - "license": "CUDA Toolkit", - "license_path": "cuda_nvprune/LICENSE.txt", - "version": "12.9.82", - "linux-x86_64": { - "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.9.82-archive.tar.xz", - "sha256": "a06f0e2959a4dd3dbb62a984dbe77b813397022596f5c62d74ddd83b238571f2", - "md5": "db647ad5946c1e4cb0289c16e5ec92d8", - "size": "59372" - }, - "linux-sbsa": { - "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.9.82-archive.tar.xz", - "sha256": "15e1d6527bf04c162950251940b10b8b8254f68028e2ffc0bfb7ed84bb2e1382", - "md5": "3d51536a3582379389d821afa05becfd", - "size": "51052" - }, - "windows-x86_64": { - "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.9.82-archive.zip", - "sha256": "be23018507f015ca948c503a43a3c48449c0dc1ceaab1e721caf01f024727312", - "md5": "f5c1eaa20c7c8c67a564f04cec87fca2", - "size": "142316" - }, - "linux-aarch64": { - "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-12.9.82-archive.tar.xz", - "sha256": "69fa4cf2cede678825e0c8032ccd629e17de1b9d8667b05b6702d873fd2fb926", - "md5": "00c370560287a3dcdeedb32fe13e7e0e", - "size": "52876" - } - }, - "cuda_nvrtc": { - "name": "CUDA NVRTC", - "license": "CUDA Toolkit", - "license_path": "cuda_nvrtc/LICENSE.txt", - "version": "12.9.86", - "linux-x86_64": { - "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.9.86-archive.tar.xz", - "sha256": "82913658363892dbc0f2638b070476234476e06e084fed60db861cb7e161a6af", - "md5": "8ed74b72c44ee50759f820dee875589c", - "size": "114231976" - }, - "linux-sbsa": { - "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.9.86-archive.tar.xz", - "sha256": "fb2d50c791465f333fc2236d2419170cf7a7886f48dd9b967a10f8233c686029", - "md5": "483dc56df046c9c03eb17cd637bb8fc9", - "size": "53265740" - }, - "windows-x86_64": { - "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.9.86-archive.zip", - "sha256": "1aa0644fa53c8ca34cdc73db17bcc73530557bdd3f582c7bfdbd7916c8b48f65", - "md5": "76317f5006ce9de6720cea0b3bdc7db6", - "size": "314608748" - }, - "linux-aarch64": { - "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-12.9.86-archive.tar.xz", - "sha256": "785b0952c0f77dd0feb9a674f3fcca3fcf05541bbe27f70a5926da9f85339152", - "md5": "b49aeba8583248a4cd628154361d313d", - "size": "57633224" - } - }, - "cuda_nvtx": { - "name": "CUDA NVTX", - "license": "CUDA Toolkit", - "license_path": "cuda_nvtx/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "819bc39192955e6ba2067de39b85f30e157de462945e54b12bfdeda429d793fb", - "md5": "3a56b3c5c1e20d99cff4c354e57ea30f", - "size": "64496" - }, - "linux-sbsa": { - "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "dae359c2c51f83a5cd402468f481a82aeb6d32d79dc707d3625607e83cf97ceb", - "md5": "d783ac2926973ad682c69270d047c3f3", - "size": "64856" - }, - "windows-x86_64": { - "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.9.79-archive.zip", - "sha256": "b9d506ce9ba056bf171b60e9dada06fb3d8bed5453a6399d0541960bf9b81659", - "md5": "907cfcf3f3b637912ded30349ecfd515", - "size": "87029" - }, - "linux-aarch64": { - "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "f1a4366e45dbfd0a4e6210a5a4b9b51501aaebb6b58845d3f1b271ec3d7f3e15", - "md5": "6b40a46f73f46a7d8bac37b212989007", - "size": "65396" - } - }, - "cuda_nvvp": { - "name": "CUDA NVVP", - "license": "CUDA Toolkit", - "license_path": "cuda_nvvp/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "6cdf9196373a848856c1afc6f1df1023649fb5fe77b896967ecc0b014b200003", - "md5": "0ded9b80cf8fc2c2233b28d582f2334e", - "size": "117732648" - }, - "windows-x86_64": { - "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.9.79-archive.zip", - "sha256": "a7e1ac0de34c69afc288283ea75314b67f109b08d046c3622405dff8f66b0720", - "md5": "dd673788d3fae14c38af5c1506fae11d", - "size": "120342251" - } - }, - "cuda_opencl": { - "name": "CUDA OpenCL", - "license": "CUDA Toolkit", - "license_path": "cuda_opencl/LICENSE.txt", - "version": "12.9.19", - "linux-x86_64": { - "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.9.19-archive.tar.xz", - "sha256": "1bddacc2f0de77901faad5fecfad8fef8136ea8dd708e02177d10eef97d85b78", - "md5": "d0a85b602afc8957374d3f536dfd0306", - "size": "94140" - }, - "windows-x86_64": { - "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.9.19-archive.zip", - "sha256": "7c78e05697a3f74510c4154b175ce4597ed0719c7793236ca7f3989eccae0ff6", - "md5": "e2dec7d45f8d87045c4a37bb882e9cf4", - "size": "139663" - } - }, - "cuda_profiler_api": { - "name": "CUDA Profiler API", - "license": "CUDA Toolkit", - "license_path": "cuda_profiler_api/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "8c50636bfb97e9420905aa795b9fa6e3ad0b30ec6a6c8b0b8db519beb9241ce6", - "md5": "483998e0e5b012d976bf62ada20bd4fa", - "size": "16316" - }, - "linux-sbsa": { - "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "e07f47ef3aeb3a3ca995e9070d77d98ad79460216bf2075c9f9018962ae1d03b", - "md5": "55345cd640f299f8da43ef946dd8aa89", - "size": "16316" - }, - "windows-x86_64": { - "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.9.79-archive.zip", - "sha256": "b05519f8ce4f02167bfc859358f62eb771d89ac2af3a6952a82317f2af4bc5bd", - "md5": "f5da20e1160f547602ec1c558dd0bc64", - "size": "20352" - }, - "linux-aarch64": { - "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "e26d82b4ce994dc445dc0191b1a5fe68dacc7290bfb9c2133b4979fe90e05433", - "md5": "738fe1e26407ab88e0fd3209b4da1cfa", - "size": "16308" - } - }, - "cuda_sandbox_dev": { - "name": "CUDA nvsandboxutils Headers", - "license": "CUDA Toolkit", - "license_path": "cuda_sandbox_dev/LICENSE.txt", - "version": "12.9.19", - "linux-x86_64": { - "relative_path": "cuda_sandbox_dev/linux-x86_64/cuda_sandbox_dev-linux-x86_64-12.9.19-archive.tar.xz", - "sha256": "058c9616f9bb4e57c58996a053cf9a87f655c139dc2fa11af7bed74432bd8153", - "md5": "ce4326bc03b26b88a552db8b163d7f5f", - "size": "29172" - } - }, - "cuda_sanitizer_api": { - "name": "CUDA Compute Sanitizer API", - "license": "CUDA Toolkit", - "license_path": "cuda_sanitizer_api/LICENSE.txt", - "version": "12.9.79", - "linux-x86_64": { - "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.9.79-archive.tar.xz", - "sha256": "e23aad21132ff58b92a22aad372a7048793400b79c625665d325d4ecec6979bf", - "md5": "9d138eb96c11e1b9293408e5b7a97114", - "size": "9758036" - }, - "linux-sbsa": { - "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.9.79-archive.tar.xz", - "sha256": "281538927b6818d4687fad102c0603ab7b389513c9c129f3e0de8c61ac7f474d", - "md5": "3192ef7e50255f80430471ae6add0ebf", - "size": "7753752" - }, - "windows-x86_64": { - "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.9.79-archive.zip", - "sha256": "b1f366312cb52164dfe7b78463ab085b742f052e74b89e9da08561a8ca8b06e9", - "md5": "1821743a8a46f3e4bab0fe96dac813f8", - "size": "10103190" - }, - "linux-aarch64": { - "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-12.9.79-archive.tar.xz", - "sha256": "2baaba3ff47eceb529ddcc866fc7e647fd02427ef3dbb8bec06689f919c14c69", - "md5": "e48b00b6ed2124ac4a3a0b20201ba4dd", - "size": "4808620" - } - }, - "driver_assistant": { - "name": "NVIDIA Driver Assistant", - "license": "MIT", - "license_path": "driver_assistant/LICENSE.txt", - "version": "0.21.57.08", - "linux-all": { - "relative_path": "driver_assistant/source/driver_assistant-0.21.57.08-archive.tar.xz", - "sha256": "4904c08e1de1aa790d200f36528aaa672ab6b3c6620bbfe5e221312b9ef1120a", - "md5": "ebb37f4ad248ddba8071c570f5267da3", - "size": "38644" - } - }, - "fabricmanager": { - "name": "NVIDIA Fabric Manager", - "license": "NVIDIA Driver", - "license_path": "fabricmanager/LICENSE.txt", - "version": "575.57.08", - "linux-x86_64": { - "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-575.57.08-archive.tar.xz", - "sha256": "2e7dc4db6788e618af345fb50dee63115b5116ccb57d6d27d93c1ff5e2c3a8cf", - "md5": "39f4aa35a3f7cda55297bb73c91a5481", - "size": "8077772" - }, - "linux-sbsa": { - "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-575.57.08-archive.tar.xz", - "sha256": "239a7f8406987fb6d44cd4f7f6ba6e843b3f3acb7b1732e6ab5c0d370690ee85", - "md5": "4d288febfed83ff3d532ebbc692f65ec", - "size": "7336832" - } - }, - "imex": { - "name": "Nvidia-Imex", - "license": "NVIDIA Proprietary", - "license_path": "imex/LICENSE.txt", - "version": "575.57.08", - "linux-x86_64": { - "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-575.57.08-archive.tar.xz", - "sha256": "5dfe195429b0967788b7e9b4bab85d4936220d6d2f6cf394a61bd3439b437506", - "md5": "909fd5da3b23f54e39484efd187f4c3e", - "size": "7718644" - }, - "linux-sbsa": { - "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-575.57.08-archive.tar.xz", - "sha256": "36d1a49fb52294ef5352eeea457d131f3d14320fca0a56633d7798ab32eead18", - "md5": "bd3d1ce8d91e1fd7d26191c05292698e", - "size": "7149236" - } - }, - "libcublas": { - "name": "CUDA cuBLAS", - "license": "CUDA Toolkit", - "license_path": "libcublas/LICENSE.txt", - "version": "12.9.1.4", - "linux-x86_64": { - "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.9.1.4-archive.tar.xz", - "sha256": "546addc4a9d82b8f23aa9ba9274b6bc0429a63008a31c759884ac24880796057", - "md5": "9b07f0c3d94534e56e003c6016b9771c", - "size": "933611504" - }, - "linux-sbsa": { - "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.9.1.4-archive.tar.xz", - "sha256": "e99b074e6f66034e563508118804599d7579f73afc8424c55ad5fd8d12e085a5", - "md5": "4c7cdc43283c0ba62e665b02e9ec7540", - "size": "932528492" - }, - "windows-x86_64": { - "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.9.1.4-archive.zip", - "sha256": "d534d98b0b453a98914dbf3adf47d7e84b55037abf02f87466439e1dcef581ed", - "md5": "3f092963b0767968fe6f02febc1b0cbf", - "size": "549755186" - }, - "linux-aarch64": { - "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-12.9.1.4-archive.tar.xz", - "sha256": "f75938d72153902cf08d1666311f35851e7eb6a16af743b2346bc68d7ba6b341", - "md5": "15f6396431885647e961af811a90cc06", - "size": "493899648" - } - }, - "libcudla": { - "name": "cuDLA", - "license": "CUDA Toolkit", - "license_path": "libcudla/LICENSE.txt", - "version": "12.9.19", - "linux-aarch64": { - "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-12.9.19-archive.tar.xz", - "sha256": "ef7c1a05d9927c53aa089ec2217a1e999ffac0e776145d798bf784279fc79d40", - "md5": "dd1fc18bd0fe3ed38b87a453d31575a0", - "size": "38548" - } - }, - "libcufft": { - "name": "CUDA cuFFT", - "license": "CUDA Toolkit", - "license_path": "libcufft/LICENSE.txt", - "version": "11.4.1.4", - "linux-x86_64": { - "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.4.1.4-archive.tar.xz", - "sha256": "b0e65af59b0c2f6c8ed9f5552a9b375890855b7926ae2c0404d15dcf2565bda4", - "md5": "3ffadd77d5b084470aa8d9215d760e76", - "size": "470942192" - }, - "linux-sbsa": { - "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.4.1.4-archive.tar.xz", - "sha256": "b87637db96e485f4793d7ca8bd2cf07250eca5c86f6c56744a36683418359c03", - "md5": "4a0906639fd293f529b8f949bc3ad9eb", - "size": "471560648" - }, - "windows-x86_64": { - "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.4.1.4-archive.zip", - "sha256": "f26f80bb9abff3269c548e1559e8c2b4ba58ccb8acc6095bbc6404fc962d4b80", - "md5": "504ad2e94fd0d923b8a7082659813431", - "size": "198361265" - }, - "linux-aarch64": { - "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-11.4.1.4-archive.tar.xz", - "sha256": "5d992b98f0d3d294e339ed2f65a477a587803c1567598a120349fae52596bf20", - "md5": "1f10a57d45e9078e940340cdeff26478", - "size": "471529132" - } - }, - "libcufile": { - "name": "CUDA cuFile", - "license": "CUDA Toolkit", - "license_path": "libcufile/LICENSE.txt", - "version": "1.14.1.1", - "linux-x86_64": { - "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.14.1.1-archive.tar.xz", - "sha256": "7ba9834b8dc2f8cdb1710a49f3de3f627bbcd4cc1f8a754019c66c8c80fdaee7", - "md5": "e59833cbd8e423948fa5814a276315e3", - "size": "42129088" - }, - "linux-sbsa": { - "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.14.1.1-archive.tar.xz", - "sha256": "6b1d2a771bd822fdd06a6286eb59acba179b13fe063ae5b0de8fc0f4991a39d8", - "md5": "5a8499cdc22754fe5c9335065d708ea4", - "size": "41676328" - }, - "linux-aarch64": { - "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.14.1.1-archive.tar.xz", - "sha256": "196b61a1bf02b85e76c21bdfe414a3f4db4380df41d9212c9eb6d0aa92eee1ce", - "md5": "c7e269a01ecd2dc427941c5bc775c2ef", - "size": "41655988" - } - }, - "libcurand": { - "name": "CUDA cuRAND", - "license": "CUDA Toolkit", - "license_path": "libcurand/LICENSE.txt", - "version": "10.3.10.19", - "linux-x86_64": { - "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.10.19-archive.tar.xz", - "sha256": "48281b4caadb1cf790d44ac76b23c77d06f474c0b1799814f314aafec9258ad6", - "md5": "e2fd0b8dd197f3bccc0ee19e5640fc93", - "size": "89582256" - }, - "linux-sbsa": { - "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.10.19-archive.tar.xz", - "sha256": "078afec842c99b3a953d62cc76bd74afa2d883dc436e6d642e6440bb1e85eb8e", - "md5": "fae5b6ce60678f452a2c760e8bf27563", - "size": "89544732" - }, - "windows-x86_64": { - "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.10.19-archive.zip", - "sha256": "d0411f0b8c07e90d0fb6e01bfa7a54c9cb80f2ddf67e4ded2d96a50e19aadad6", - "md5": "6ccce2f4f1f6d9592c908fa1cb91536d", - "size": "67904600" - }, - "linux-aarch64": { - "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.10.19-archive.tar.xz", - "sha256": "e5087640b5c9cd8bc173efb6a21f8388b24da59511cc3d57e60afc5e05d14b50", - "md5": "71ed8ff7a7e539c0be8ca4b699f2f3e1", - "size": "79761424" - } - }, - "libcusolver": { - "name": "CUDA cuSOLVER", - "license": "CUDA Toolkit", - "license_path": "libcusolver/LICENSE.txt", - "version": "11.7.5.82", - "linux-x86_64": { - "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.7.5.82-archive.tar.xz", - "sha256": "3d3b96f3087dbc43893a28691b172f31725b316d524f5a3c1e6837257c898d06", - "md5": "efcc5d100623563d1a56dff59b45b65d", - "size": "324393196" - }, - "linux-sbsa": { - "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.7.5.82-archive.tar.xz", - "sha256": "db463593ffcbc78f542a7f1ef808da43bf742acae654d970d99a47289c2a83e5", - "md5": "63113f462dc11289f996eec8bab1db74", - "size": "323573816" - }, - "windows-x86_64": { - "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.7.5.82-archive.zip", - "sha256": "e991d64a0bbe3e0bb69ce2adce000244288002b0341894729666d66adb9b4f25", - "md5": "e2d79987f6e38f63cc64816f393a8e51", - "size": "322216184" - }, - "linux-aarch64": { - "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.7.5.82-archive.tar.xz", - "sha256": "45e2fefeee5797c0492d8a9ee26c3dbb7af0cdcefe6f1cd25bd586daa633d9a0", - "md5": "e311d62bfc65c6afc29152f6e923f78c", - "size": "113258352" - } - }, - "libcusparse": { - "name": "CUDA cuSPARSE", - "license": "CUDA Toolkit", - "license_path": "libcusparse/LICENSE.txt", - "version": "12.5.10.65", - "linux-x86_64": { - "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.5.10.65-archive.tar.xz", - "sha256": "a83415dcd3e1183afe363d4740f9f0309cfe560c6c08016c2a61468304f4b848", - "md5": "c7ed952d12dec0f50a4386e5d09203f6", - "size": "398914580" - }, - "linux-sbsa": { - "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.5.10.65-archive.tar.xz", - "sha256": "8d1c8a57ba3eaecc3f7c11e29fed275a2f3dca5cea51dd2a24d07ab5d9998583", - "md5": "2d48c3aecca07be0a458a977350ce175", - "size": "398606816" - }, - "windows-x86_64": { - "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.5.10.65-archive.zip", - "sha256": "abb4bfc01198f82fbc956773ccb98c578c03027b6ad425e829355be0c0a11a4a", - "md5": "33ce31c3d880596c31304c965dbfcdce", - "size": "358114928" - }, - "linux-aarch64": { - "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-12.5.10.65-archive.tar.xz", - "sha256": "b294b6cd0acf5e68078d2fe4d41d95a4073fed780805adca7774bce7cbbe5b65", - "md5": "ce4d363d3affd40fe751f065ec2bd4cf", - "size": "131075108" - } - }, - "libnpp": { - "name": "CUDA NPP", - "license": "CUDA Toolkit", - "license_path": "libnpp/LICENSE.txt", - "version": "12.4.1.87", - "linux-x86_64": { - "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.4.1.87-archive.tar.xz", - "sha256": "49351448d896854284ec708c14506eaaceb92aa01fbe35c91d5c52ad482e17ae", - "md5": "03de546e34ad54d0119594bc237c5e87", - "size": "331733872" - }, - "linux-sbsa": { - "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.4.1.87-archive.tar.xz", - "sha256": "992d461905366cec4243b26ce7bfe997c0c0eabf53a001333025930a1a0c7237", - "md5": "8de3be3d9043a07011b0de46c49ea668", - "size": "330804724" - }, - "windows-x86_64": { - "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.4.1.87-archive.zip", - "sha256": "cfcfbf59e4e5ce71113c058bd4eba3dd56e4db080932146d4047c0d44b4a558e", - "md5": "7549e1191510ae5ca9291e5f13c70296", - "size": "274109870" - }, - "linux-aarch64": { - "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-12.4.1.87-archive.tar.xz", - "sha256": "50c9f80592eaf4f246c82475143768b848333d9f540782257d42023f5fe68fdf", - "md5": "869efb32d5ab9468fda4cb94848cf90f", - "size": "104647240" - } - }, - "libnvfatbin": { - "name": "NVIDIA compiler library for fatbin interaction", - "license": "CUDA Toolkit", - "license_path": "libnvfatbin/LICENSE.txt", - "version": "12.9.82", - "linux-x86_64": { - "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-12.9.82-archive.tar.xz", - "sha256": "315be969a303437329bf72d7141babed024fc54f90a10aa748b03be8f826d57b", - "md5": "d5e2dc19c01ab62dbf437a1ef80847b1", - "size": "930820" - }, - "linux-sbsa": { - "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-12.9.82-archive.tar.xz", - "sha256": "87bf71288ea7390d039b246fa794cad2ddd3b164ce9566f8542bb15039432cdb", - "md5": "91902ce86f6f55a4ecc948f95bf1c032", - "size": "836312" - }, - "windows-x86_64": { - "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-12.9.82-archive.zip", - "sha256": "86563b25096bbc21d74b1c043701ec8596499f76b40e32f9ec9179fc10404d00", - "md5": "c0963a07d7f2cbffd34b0b1ec6cae5c0", - "size": "2217262" - }, - "linux-aarch64": { - "relative_path": "libnvfatbin/linux-aarch64/libnvfatbin-linux-aarch64-12.9.82-archive.tar.xz", - "sha256": "248e77ede9afbd6060cda7de0475d222731ac021e22e696ce75ed72b426dfca9", - "md5": "814b2ff13e944a07669580eb85c0e653", - "size": "808780" - } - }, - "libnvidia_nscq": { - "name": "NVIDIA NSCQ API", - "license": "NVIDIA Driver", - "license_path": "libnvidia_nscq/LICENSE.txt", - "version": "575.57.08", - "linux-x86_64": { - "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-575.57.08-archive.tar.xz", - "sha256": "7c54e959ee50212be8595e01ee76581c1f3a13c19b2279424b55a8d26385c41a", - "md5": "b86a87c4f9fd58a79ced07cf82cec271", - "size": "455504" - }, - "linux-sbsa": { - "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-575.57.08-archive.tar.xz", - "sha256": "931004b8b2062249016a9bded2499f70331d27b265226ed879428b8bd7e4bb20", - "md5": "790ca3dd29b03a71f32ad1dd05611a9e", - "size": "446980" - } - }, - "libnvjitlink": { - "name": "NVIDIA compiler library for JIT LTO functionality", - "license": "CUDA Toolkit", - "license_path": "libnvjitlink/LICENSE.txt", - "version": "12.9.86", - "linux-x86_64": { - "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.9.86-archive.tar.xz", - "sha256": "392cac3144b52ba14900bc7259ea6405ae6da88a8c704eab9bbbcc9ba4824b07", - "md5": "9156156146001536d1c8346783991d1b", - "size": "54021940" - }, - "linux-sbsa": { - "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.9.86-archive.tar.xz", - "sha256": "9c9227c1e9122fd8448cafced3b32bc69f40d3c041d25034ea23611a1262852f", - "md5": "7fdf2864352ac613415327ebde38598b", - "size": "50981988" - }, - "windows-x86_64": { - "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.9.86-archive.zip", - "sha256": "ee7175da9628d47ccc92dce6d28d57ca77633e79079a2aee90e2a645edcd1384", - "md5": "4cdb56f88316a5ade3edf69a1e7192e8", - "size": "265666466" - }, - "linux-aarch64": { - "relative_path": "libnvjitlink/linux-aarch64/libnvjitlink-linux-aarch64-12.9.86-archive.tar.xz", - "sha256": "a24842165d98660d4ba9fd753395f7c9834445552110fabce4baa4c211fd2c52", - "md5": "548a35d56f08d07b1dc294a3c8172f71", - "size": "54783780" - } - }, - "libnvjpeg": { - "name": "CUDA nvJPEG", - "license": "CUDA Toolkit", - "license_path": "libnvjpeg/LICENSE.txt", - "version": "12.4.0.76", - "linux-x86_64": { - "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.4.0.76-archive.tar.xz", - "sha256": "ddd8245b2803f5b55211261d7e5d7abf803c05f3b032238d0feaa6e09ea9401d", - "md5": "b9f7806fb279c9cdd0b4a40e4171b87b", - "size": "6378624" - }, - "linux-sbsa": { - "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.4.0.76-archive.tar.xz", - "sha256": "405b5627ffd772d2837ae4ece123fdee841c34894dba2180a1c8e1b84c0f2665", - "md5": "bad1da3ec8865dbd3955a757bb6b7ba0", - "size": "6179324" - }, - "windows-x86_64": { - "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.4.0.76-archive.zip", - "sha256": "b253241fc88bf30947b8ee068101aca8930960f113d8ee4a9583de021a79ffa1", - "md5": "d19d13f9bd3dbc9c9361a3c1fee99dd5", - "size": "4667529" - }, - "linux-aarch64": { - "relative_path": "libnvjpeg/linux-aarch64/libnvjpeg-linux-aarch64-12.4.0.76-archive.tar.xz", - "sha256": "a9841bff40e577bec81352054e05c5d98720ae8e2ccfc4863eaac9dd35444c27", - "md5": "0a7197330938f8b5363d38bdde63562c", - "size": "1821640" - } - }, - "libnvsdm": { - "name": "LIBNVSDM", - "license": "NVIDIA", - "license_path": "libnvsdm/LICENSE.txt", - "version": "575.57.08", - "linux-x86_64": { - "relative_path": "libnvsdm/linux-x86_64/libnvsdm-linux-x86_64-575.57.08-archive.tar.xz", - "sha256": "7a6ee934d5c328f9c05e967b63053c211f80485e0443ac119d887612a510ad53", - "md5": "788f7c59de54096d84dc7f645964ad2a", - "size": "500100" - } - }, - "mft": { - "name": "NVLink 5 MFT", - "license": "NVIDIA Proprietary", - "license_path": "mft/LICENSE.txt", - "version": "4.30.1.510", - "linux-x86_64": { - "relative_path": "mft/linux-x86_64/mft-linux-x86_64-4.30.1.510-archive.tar.xz", - "sha256": "512714ab076d90d88550e60f5da65181363336cee94c67bff8821face8ef10b4", - "md5": "30698cf8741826df5ca3d4d3bb3a982c", - "size": "45536612" - }, - "linux-sbsa": { - "relative_path": "mft/linux-sbsa/mft-linux-sbsa-4.30.1.510-archive.tar.xz", - "sha256": "95c05e1bc03ff81dffa58bfff26a1dd59c6300d6d5922662ae59c7af5788a310", - "md5": "78ef93686e91302f7b751fed8f83d9be", - "size": "44222004" - } - }, - "mft_autocomplete": { - "name": "NVLink 5 MFT AUTOCOMPLETE", - "license": "NVIDIA Proprietary", - "license_path": "mft_autocomplete/LICENSE.txt", - "version": "4.30.1.510", - "linux-x86_64": { - "relative_path": "mft_autocomplete/linux-x86_64/mft_autocomplete-linux-x86_64-4.30.1.510-archive.tar.xz", - "sha256": "dc9069baa888c7ca0c3e55a3043d27b0100c29c81e6ed3346907dd49dabb1325", - "md5": "b65cb40bacfe276b3444920e8eef1f2f", - "size": "11884" - }, - "linux-sbsa": { - "relative_path": "mft_autocomplete/linux-sbsa/mft_autocomplete-linux-sbsa-4.30.1.510-archive.tar.xz", - "sha256": "64647ce2a4de62e535ea7060d20d58c2613937071008c2a93894e1995facce2b", - "md5": "bf034fbf9f887d62434f83dc9727db80", - "size": "11880" - } - }, - "mft_oem": { - "name": "NVLink 5 MFT OEM", - "license": "NVIDIA Proprietary", - "license_path": "mft_oem/LICENSE.txt", - "version": "4.30.1.510", - "linux-x86_64": { - "relative_path": "mft_oem/linux-x86_64/mft_oem-linux-x86_64-4.30.1.510-archive.tar.xz", - "sha256": "7a4729f8b91ba5c179820583189a4c95ffa9669312a28fe7ac03feebb726bbc3", - "md5": "7329d76d0e5b976f88ef1f2484d962de", - "size": "4708108" - }, - "linux-sbsa": { - "relative_path": "mft_oem/linux-sbsa/mft_oem-linux-sbsa-4.30.1.510-archive.tar.xz", - "sha256": "b71bb03130b6dd3388a3e909cdf91cc9bca8b8098a8b80b5f376f5726e5b5e1c", - "md5": "e55a4d898553c2cf92be57724a8204e1", - "size": "4429188" - } - }, - "nsight_compute": { - "name": "Nsight Compute", - "license": "NVIDIA SLA", - "license_path": "nsight_compute/LICENSE.txt", - "version": "2025.2.1.3", - "linux-x86_64": { - "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2025.2.1.3-archive.tar.xz", - "sha256": "02ab8867197aaf6a6ae3171293d70b6a9ddb20296be94ff4287741338cc2e1df", - "md5": "e81faf319af6b21f241bae535d3d1907", - "size": "300347320" - }, - "linux-sbsa": { - "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2025.2.1.3-archive.tar.xz", - "sha256": "0e336a5139f76778b8ad70fdb49fb43817ec1bb3ee6e7425d59d99d8c455d976", - "md5": "18334b109fe6f10fdba2c2681726ba96", - "size": "107009604" - }, - "windows-x86_64": { - "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2025.2.1.3-archive.zip", - "sha256": "e9d558654c98d83049969d133b98922b53ab8f4e3ba9e0a37bdb5e2ff300b7de", - "md5": "7cb9cff3e0718212866c7fbb4365dee5", - "size": "341265370" - }, - "linux-aarch64": { - "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2025.2.1.3-archive.tar.xz", - "sha256": "51c7762110c34728acd37878d4340f13612401fa622be0031b1a9e2ce112cfb2", - "md5": "355babae2f49f3f2c7ec1cf1c0b07966", - "size": "221171904" - } - }, - "nsight_systems": { - "name": "Nsight Systems", - "license": "NVIDIA SLA", - "license_path": "nsight_systems/LICENSE.txt", - "version": "2025.1.3.140", - "linux-x86_64": { - "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2025.1.3.140-archive.tar.xz", - "sha256": "dded4227619340307be0ba5bc4e23bcbc966e2df3763170ebb20410c2b54754e", - "md5": "0b16c35f6e63a4fc33d14795e65bcd61", - "size": "1075732108" - }, - "linux-sbsa": { - "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2025.1.3.140-archive.tar.xz", - "sha256": "479c46de1c459f7c760ef1ea5e5bbe61bfe7f4ba525ce4778d5ba25d874b8e1f", - "md5": "6d70406b53a94eba94d7c3552b938fe6", - "size": "980282844" - }, - "windows-x86_64": { - "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2025.1.3.140-archive.zip", - "sha256": "8d61f266a8a1bc1ababd44de3ee38f7b85c8cdfcdaebace14c8f065d7624d0b3", - "md5": "b741046881531cbf6e3ccedb0b403432", - "size": "403084779" - } - }, - "nsight_vse": { - "name": "Nsight Visual Studio Edition (VSE)", - "license": "NVIDIA SLA", - "license_path": "nsight_vse/LICENSE.txt", - "version": "2025.2.1.25125", - "windows-x86_64": { - "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2025.2.1.25125-archive.zip", - "sha256": "3f2b6ca8705929c97e0f931f0559921b110b9337cf11af5e017d0c95b5b31feb", - "md5": "7e74f479c09aece6e5b46c97d0d4cc86", - "size": "136237151" - } - }, - "nvidia_driver": { - "name": "NVIDIA Linux Driver", - "license": "NVIDIA Driver", - "license_path": "nvidia_driver/LICENSE.txt", - "version": "575.57.08", - "linux-x86_64": { - "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-575.57.08-archive.tar.xz", - "sha256": "27ddfabde120a107527cbf88a6c96d1f81ee5c977462ce1a793051a3e678f552", - "md5": "9007dddd1e2d48f897958b676fbe30ff", - "size": "471616744" - }, - "linux-sbsa": { - "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-575.57.08-archive.tar.xz", - "sha256": "4a7d1accb257f2539ff7dabb02319339fc3a8db622073e5dde33a5446910346a", - "md5": "3c2b686f392789d8f3a1db1ae2ad62be", - "size": "349127420" - } - }, - "nvidia_fs": { - "name": "NVIDIA filesystem", - "license": "CUDA Toolkit", - "license_path": "nvidia_fs/LICENSE.txt", - "version": "2.25.7", - "linux-x86_64": { - "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.25.7-archive.tar.xz", - "sha256": "6e11ec0b885177ab21f4b864ff7417ea3cc1b0994f1c318767984557cd5b29d1", - "md5": "60d2fa54d55b739302e3db38a8a389c9", - "size": "60280" - }, - "linux-sbsa": { - "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.25.7-archive.tar.xz", - "sha256": "62baf0beac2d446c0ff033fb3780cf348ab9c090d7903c210106dc98bb29d7eb", - "md5": "3859bed4b5e330cde0e2316f9cdcdaeb", - "size": "60296" - }, - "linux-aarch64": { - "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.25.7-archive.tar.xz", - "sha256": "b8c67e28e9e23453183fb7d12ed9fed449427b2c11a21b1de4e7046a57d8d366", - "md5": "5128c63c80c1089340b65807445d921a", - "size": "60272" - } - }, - "nvlsm": { - "name": "NVLSM SM component", - "license": "NVIDIA Proprietary", - "license_path": "nvlsm/LICENSE.txt", - "version": "2025.03.1", - "linux-x86_64": { - "relative_path": "nvlsm/linux-x86_64/nvlsm-linux-x86_64-2025.03.1-archive.tar.xz", - "sha256": "b034dad10a3154359e244b85206cd73f0fbce8e1cdf76058417b7b562c337388", - "md5": "6e09669fe8e4fb26e5334a1c4aa9dabb", - "size": "6890300" - }, - "linux-sbsa": { - "relative_path": "nvlsm/linux-sbsa/nvlsm-linux-sbsa-2025.03.1-archive.tar.xz", - "sha256": "e260285ec01c6beb562a14625e9564b96374bb824ec62cc9866066a48710fa54", - "md5": "bc90989f567c27d8b39e607f719acba8", - "size": "6175832" - } - }, - "visual_studio_integration": { - "name": "CUDA Visual Studio Integration", - "license": "CUDA Toolkit", - "license_path": "visual_studio_integration/LICENSE.txt", - "version": "12.9.79", - "windows-x86_64": { - "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.9.79-archive.zip", - "sha256": "d5b6514866395f52f04107da1aa523954f8dc76daf18a9f8699c3d564f294449", - "md5": "680fbdf0f345619c1fa3de5f1fc79090", - "size": "864204" - } - } -} diff --git a/pkgs/development/cuda-modules/cudnn/releases.nix b/pkgs/development/cuda-modules/cudnn/releases.nix deleted file mode 100644 index d8c4d70ddd09..000000000000 --- a/pkgs/development/cuda-modules/cudnn/releases.nix +++ /dev/null @@ -1,112 +0,0 @@ -# NOTE: Check the following URLs for support matrices: -# v8 -> https://docs.nvidia.com/deeplearning/cudnn/archives/index.html -# v9 -> https://docs.nvidia.com/deeplearning/cudnn/frontend/latest/reference/support-matrix.html -# Version policy is to keep the latest minor release for each major release. -# https://developer.download.nvidia.com/compute/cudnn/redist/ -{ - cudnn.releases = { - # jetson - linux-aarch64 = [ - { - version = "8.9.5.30"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-aarch64/cudnn-linux-aarch64-8.9.5.30_cuda12-archive.tar.xz"; - hash = "sha256-BJH3sC9VwiB362eL8xTB+RdSS9UHz1tlgjm/mKRyM6E="; - } - { - version = "9.7.1.26"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-aarch64/cudnn-linux-aarch64-9.7.1.26_cuda12-archive.tar.xz"; - hash = "sha256-jDPWAXKOiJYpblPwg5FUSh7F0Dgg59LLnd+pX9y7r1w="; - } - { - version = "9.8.0.87"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-aarch64/cudnn-linux-aarch64-9.8.0.87_cuda12-archive.tar.xz"; - hash = "sha256-8D7OP/B9FxnwYhiXOoeXzsG+OHzDF7qrW7EY3JiBmec="; - } - ]; - # powerpc - linux-ppc64le = [ ]; - # server-grade arm - linux-sbsa = [ - { - version = "8.9.7.29"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.7.29_cuda12-archive.tar.xz"; - hash = "sha256-6Yt8gAEHheXVygHuTOm1sMjHNYfqb4ZIvjTT+NHUe9E="; - } - { - version = "9.3.0.75"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.6"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-9.3.0.75_cuda12-archive.tar.xz"; - hash = "sha256-Eibdm5iciYY4VSlj0ACjz7uKCgy5uvjLCear137X1jk="; - } - { - version = "9.7.1.26"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-9.7.1.26_cuda12-archive.tar.xz"; - hash = "sha256-koJFUKlesnWwbJCZhBDhLOBRQOBQjwkFZExlTJ7Xp2Q="; - } - { - version = "9.8.0.87"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-9.8.0.87_cuda12-archive.tar.xz"; - hash = "sha256-IvYvR08MuzW+9UCtsdhB2mPJzT33azxOQwEPQ2ss2Fw="; - } - { - version = "9.11.0.98"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.9"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-9.11.0.98_cuda12-archive.tar.xz"; - hash = "sha256-X81kUdiKnTt/rLwASB+l4rsV8sptxvhuCysgG8QuzVY="; - } - - ]; - # x86_64 - linux-x86_64 = [ - { - version = "8.9.7.29"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz"; - hash = "sha256-R1MzYlx+QqevPKCy91BqEG4wyTsaoAgc2cE++24h47s="; - } - { - version = "9.3.0.75"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.6"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-9.3.0.75_cuda12-archive.tar.xz"; - hash = "sha256-PW7xCqBtyTOaR34rBX4IX/hQC73ueeQsfhNlXJ7/LCY="; - } - { - version = "9.7.1.26"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-9.7.1.26_cuda12-archive.tar.xz"; - hash = "sha256-EJpeXGvN9Dlub2Pz+GLtLc8W7pPuA03HBKGxG98AwLE="; - } - { - version = "9.8.0.87"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-9.8.0.87_cuda12-archive.tar.xz"; - hash = "sha256-MhubM7sSh0BNk9VnLTUvFv6rxLIgrGrguG5LJ/JX3PQ="; - } - { - version = "9.11.0.98"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.9"; - url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-9.11.0.98_cuda12-archive.tar.xz"; - hash = "sha256-tgyPrQH6FSHS5x7TiIe5BHjX8Hs9pJ/WirEYqf7k2kg="; - } - ]; - }; -} diff --git a/pkgs/development/cuda-modules/cudnn/shims.nix b/pkgs/development/cuda-modules/cudnn/shims.nix deleted file mode 100644 index 01918e88f07b..000000000000 --- a/pkgs/development/cuda-modules/cudnn/shims.nix +++ /dev/null @@ -1,21 +0,0 @@ -# Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix -{ - package, - # redistSystem :: String - # String is "unsupported" if the given architecture is unsupported. - redistSystem, -}: -{ - featureRelease = { - inherit (package) minCudaVersion maxCudaVersion; - ${redistSystem}.outputs = { - lib = true; - static = true; - dev = true; - }; - }; - redistribRelease = { - name = "NVIDIA CUDA Deep Neural Network library (cuDNN)"; - inherit (package) hash url version; - }; -} diff --git a/pkgs/development/cuda-modules/cusparselt/extension.nix b/pkgs/development/cuda-modules/cusparselt/extension.nix deleted file mode 100644 index f53405e3d099..000000000000 --- a/pkgs/development/cuda-modules/cusparselt/extension.nix +++ /dev/null @@ -1,96 +0,0 @@ -# Support matrix can be found at -# https://docs.nvidia.com/deeplearning/cudnn/archives/cudnn-880/support-matrix/index.html -{ - cudaLib, - lib, - redistSystem, -}: -let - inherit (lib) - attrsets - lists - modules - trivial - ; - - redistName = "cusparselt"; - pname = "libcusparse_lt"; - - cusparseltVersions = [ - "0.7.1" - ]; - - # Manifests :: { redistrib, feature } - - # Each release of cusparselt gets mapped to an evaluated module for that release. - # From there, we can get the min/max CUDA versions supported by that release. - # listOfManifests :: List Manifests - listOfManifests = - let - configEvaluator = - fullCusparseltVersion: - modules.evalModules { - modules = [ - ../modules - # We need to nest the manifests in a config.cusparselt.manifests attribute so the - # module system can evaluate them. - { - cusparselt.manifests = { - redistrib = trivial.importJSON (./manifests + "/redistrib_${fullCusparseltVersion}.json"); - feature = trivial.importJSON (./manifests + "/feature_${fullCusparseltVersion}.json"); - }; - } - ]; - }; - # Un-nest the manifests attribute set. - releaseGrabber = evaluatedModules: evaluatedModules.config.cusparselt.manifests; - in - lists.map (trivial.flip trivial.pipe [ - configEvaluator - releaseGrabber - ]) cusparseltVersions; - - # platformIsSupported :: Manifests -> Boolean - platformIsSupported = - { feature, redistrib, ... }: - (attrsets.attrByPath [ - pname - redistSystem - ] null feature) != null; - - # TODO(@connorbaker): With an auxiliary file keeping track of the CUDA versions each release supports, - # we could filter out releases that don't support our CUDA version. - # However, we don't have that currently, so we make a best-effort to try to build TensorRT with whatever - # libPath corresponds to our CUDA version. - # supportedManifests :: List Manifests - supportedManifests = builtins.filter platformIsSupported listOfManifests; - - # Compute versioned attribute name to be used in this package set - # Patch version changes should not break the build, so we only use major and minor - # computeName :: RedistribRelease -> String - computeName = - { version, ... }: cudaLib.mkVersionedName redistName (lib.versions.majorMinor version); -in -final: _: -let - # buildCusparseltPackage :: Manifests -> AttrSet Derivation - buildCusparseltPackage = - { redistrib, feature }: - let - drv = final.callPackage ../generic-builders/manifest.nix { - inherit pname redistName; - redistribRelease = redistrib.${pname}; - featureRelease = feature.${pname}; - }; - in - attrsets.nameValuePair (computeName redistrib.${pname}) drv; - - extension = - let - nameOfNewest = computeName (lists.last supportedManifests).redistrib.${pname}; - drvs = builtins.listToAttrs (lists.map buildCusparseltPackage supportedManifests); - containsDefault = attrsets.optionalAttrs (drvs != { }) { cusparselt = drvs.${nameOfNewest}; }; - in - drvs // containsDefault; -in -extension diff --git a/pkgs/development/cuda-modules/cusparselt/manifests/feature_0.7.1.json b/pkgs/development/cuda-modules/cusparselt/manifests/feature_0.7.1.json deleted file mode 100644 index 0b368e22bb24..000000000000 --- a/pkgs/development/cuda-modules/cusparselt/manifests/feature_0.7.1.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "libcusparse_lt": { - "linux-aarch64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cusparselt/manifests/redistrib_0.7.1.json b/pkgs/development/cuda-modules/cusparselt/manifests/redistrib_0.7.1.json deleted file mode 100644 index b9609bd4532a..000000000000 --- a/pkgs/development/cuda-modules/cusparselt/manifests/redistrib_0.7.1.json +++ /dev/null @@ -1,35 +0,0 @@ -{ - "release_date": "2025-02-25", - "release_label": "0.7.1", - "release_product": "cusparselt", - "libcusparse_lt": { - "name": "NVIDIA cuSPARSELt", - "license": "cuSPARSELt", - "license_path": "libcusparse_lt/LICENSE.txt", - "version": "0.7.1.0", - "linux-x86_64": { - "relative_path": "libcusparse_lt/linux-x86_64/libcusparse_lt-linux-x86_64-0.7.1.0-archive.tar.xz", - "sha256": "a0d885837887c73e466a31b4e86aaae2b7d0cc9c5de0d40921dbe2a15dbd6a88", - "md5": "b2e5f3c9b9d69e1e0b55b16de33fdc6e", - "size": "353151840" - }, - "linux-sbsa": { - "relative_path": "libcusparse_lt/linux-sbsa/libcusparse_lt-linux-sbsa-0.7.1.0-archive.tar.xz", - "sha256": "4a131d0a54728e53ba536b50bb65380603456f1656e7df8ee52e285618a0b57c", - "md5": "612a712c7da6e801ee773687e99af87e", - "size": "352406784" - }, - "windows-x86_64": { - "relative_path": "libcusparse_lt/windows-x86_64/libcusparse_lt-windows-x86_64-0.7.1.0-archive.zip", - "sha256": "004bcb1b700c24ca8d60a8ddd2124640f61138a6c29914d2afaa0bfa0d0e3cf2", - "md5": "a1d8df8dc8ff4b3bd0e859f992f8f392", - "size": "268594665" - }, - "linux-aarch64": { - "relative_path": "libcusparse_lt/linux-aarch64/libcusparse_lt-linux-aarch64-0.7.1.0-archive.tar.xz", - "sha256": "d3b0a660fd552e0bd9a4491b15299d968674833483d5f164cfea35e70646136c", - "md5": "54e3f3b28c94118991ce54ec38f531fb", - "size": "5494380" - } - } -} diff --git a/pkgs/development/cuda-modules/cutensor/extension.nix b/pkgs/development/cuda-modules/cutensor/extension.nix deleted file mode 100644 index 5f6724549e3e..000000000000 --- a/pkgs/development/cuda-modules/cutensor/extension.nix +++ /dev/null @@ -1,124 +0,0 @@ -# Support matrix can be found at -# https://docs.nvidia.com/deeplearning/cudnn/archives/cudnn-880/support-matrix/index.html -# -# TODO(@connorbaker): -# This is a very similar strategy to CUDA/CUDNN: -# -# - Get all versions supported by the current release of CUDA -# - Build all of them -# - Make the newest the default -# -# Unique twists: -# -# - Instead of providing different releases for each version of CUDA, CuTensor has multiple subdirectories in `lib` -# -- one for each version of CUDA. -{ - cudaLib, - cudaMajorMinorVersion, - lib, - redistSystem, -}: -let - inherit (lib) - attrsets - lists - modules - versions - trivial - ; - - redistName = "cutensor"; - pname = "libcutensor"; - - cutensorVersions = [ - "2.0.2" - "2.1.0" - ]; - - # Manifests :: { redistrib, feature } - - # Each release of cutensor gets mapped to an evaluated module for that release. - # From there, we can get the min/max CUDA versions supported by that release. - # listOfManifests :: List Manifests - listOfManifests = - let - configEvaluator = - fullCutensorVersion: - modules.evalModules { - modules = [ - ../modules - # We need to nest the manifests in a config.cutensor.manifests attribute so the - # module system can evaluate them. - { - cutensor.manifests = { - redistrib = trivial.importJSON (./manifests + "/redistrib_${fullCutensorVersion}.json"); - feature = trivial.importJSON (./manifests + "/feature_${fullCutensorVersion}.json"); - }; - } - ]; - }; - # Un-nest the manifests attribute set. - releaseGrabber = evaluatedModules: evaluatedModules.config.cutensor.manifests; - in - lists.map (trivial.flip trivial.pipe [ - configEvaluator - releaseGrabber - ]) cutensorVersions; - - # Our cudaMajorMinorVersion tells us which version of CUDA we're building against. - # The subdirectories in lib/ tell us which versions of CUDA are supported. - # Typically the names will look like this: - # - # - 11 - # - 12 - - # libPath :: String - libPath = versions.major cudaMajorMinorVersion; - - # A release is supported if it has a libPath that matches our CUDA version for our platform. - # LibPath are not constant across the same release -- one platform may support fewer - # CUDA versions than another. - # platformIsSupported :: Manifests -> Boolean - platformIsSupported = - { feature, redistrib, ... }: - (attrsets.attrByPath [ - pname - redistSystem - ] null feature) != null; - - # TODO(@connorbaker): With an auxiliary file keeping track of the CUDA versions each release supports, - # we could filter out releases that don't support our CUDA version. - # However, we don't have that currently, so we make a best-effort to try to build TensorRT with whatever - # libPath corresponds to our CUDA version. - # supportedManifests :: List Manifests - supportedManifests = builtins.filter platformIsSupported listOfManifests; - - # Compute versioned attribute name to be used in this package set - # Patch version changes should not break the build, so we only use major and minor - # computeName :: RedistribRelease -> String - computeName = - { version, ... }: cudaLib.mkVersionedName redistName (lib.versions.majorMinor version); -in -final: _: -let - # buildCutensorPackage :: Manifests -> AttrSet Derivation - buildCutensorPackage = - { redistrib, feature }: - let - drv = final.callPackage ../generic-builders/manifest.nix { - inherit pname redistName libPath; - redistribRelease = redistrib.${pname}; - featureRelease = feature.${pname}; - }; - in - attrsets.nameValuePair (computeName redistrib.${pname}) drv; - - extension = - let - nameOfNewest = computeName (lists.last supportedManifests).redistrib.${pname}; - drvs = builtins.listToAttrs (lists.map buildCutensorPackage supportedManifests); - containsDefault = attrsets.optionalAttrs (drvs != { }) { cutensor = drvs.${nameOfNewest}; }; - in - drvs // containsDefault; -in -extension diff --git a/pkgs/development/cuda-modules/cutensor/manifests/feature_2.0.2.json b/pkgs/development/cuda-modules/cutensor/manifests/feature_2.0.2.json deleted file mode 100644 index 99679aecbc44..000000000000 --- a/pkgs/development/cuda-modules/cutensor/manifests/feature_2.0.2.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "libcutensor": { - "linux-ppc64le": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cutensor/manifests/feature_2.1.0.json b/pkgs/development/cuda-modules/cutensor/manifests/feature_2.1.0.json deleted file mode 100644 index 4d6a398605a1..000000000000 --- a/pkgs/development/cuda-modules/cutensor/manifests/feature_2.1.0.json +++ /dev/null @@ -1,34 +0,0 @@ -{ - "libcutensor": { - "linux-sbsa": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "linux-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": true, - "sample": false, - "static": true - } - }, - "windows-x86_64": { - "outputs": { - "bin": false, - "dev": true, - "doc": false, - "lib": false, - "sample": false, - "static": false - } - } - } -} diff --git a/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.0.2.json b/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.0.2.json deleted file mode 100644 index cf790b7746c2..000000000000 --- a/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.0.2.json +++ /dev/null @@ -1,35 +0,0 @@ -{ - "release_date": "2024-06-24", - "release_label": "2.0.2", - "release_product": "cutensor", - "libcutensor": { - "name": "NVIDIA cuTENSOR", - "license": "cuTensor", - "license_path": "libcutensor/LICENSE.txt", - "version": "2.0.2.4", - "linux-x86_64": { - "relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-2.0.2.4-archive.tar.xz", - "sha256": "957b04ef6343aca404fe5f4a3f1f1d3ac0bd04ceb3acecc93e53f4d63bd91157", - "md5": "2b994ecba434e69ee55043cf353e05b4", - "size": "545271628" - }, - "linux-ppc64le": { - "relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-2.0.2.4-archive.tar.xz", - "sha256": "db2c05e231a26fb5efee470e1d8e11cb1187bfe0726b665b87cbbb62a9901ba0", - "md5": "6b00e29407452333946744c4084157e8", - "size": "543070992" - }, - "linux-sbsa": { - "relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-2.0.2.4-archive.tar.xz", - "sha256": "9712b54aa0988074146867f9b6f757bf11a61996f3b58b21e994e920b272301b", - "md5": "c9bb31a92626a092d0c7152b8b3eaa18", - "size": "540299376" - }, - "windows-x86_64": { - "relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-2.0.2.4-archive.zip", - "sha256": "ab2fca16d410863d14f2716cec0d07fb21d20ecd24ee47d309e9970c9c01ed4a", - "md5": "f6cfdb29a9a421a1ee4df674dd54028c", - "size": "921154033" - } - } -} diff --git a/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.1.0.json b/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.1.0.json deleted file mode 100644 index cf0ce0aa4b9a..000000000000 --- a/pkgs/development/cuda-modules/cutensor/manifests/redistrib_2.1.0.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "release_date": "2025-01-27", - "release_label": "2.1.0", - "release_product": "cutensor", - "libcutensor": { - "name": "NVIDIA cuTENSOR", - "license": "cuTensor", - "license_path": "libcutensor/LICENSE.txt", - "version": "2.1.0.9", - "linux-x86_64": { - "relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-2.1.0.9-archive.tar.xz", - "sha256": "ee59fcb4e8d59fc0d8cebf5f7f23bf2a196a76e6bcdcaa621aedbdcabd20a759", - "md5": "ed15120c512dfb3e32b49103850bb9dd", - "size": "814871140" - }, - "linux-sbsa": { - "relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-2.1.0.9-archive.tar.xz", - "sha256": "cef7819c4ecf3120d4f99b08463b8db1a8591be25147d1688371024885b1d2f0", - "md5": "fec00a1a825a05c0166eda6625dc587d", - "size": "782008004" - }, - "windows-x86_64": { - "relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-2.1.0.9-archive.zip", - "sha256": "ed835ba7fd617000f77e1dff87403d123edf540bd99339e3da2eaab9d32a4040", - "md5": "9efcbc0c9c372b0e71e11d4487aa5ffa", - "size": "1514752712" - } - } -} diff --git a/pkgs/development/cuda-modules/default.nix b/pkgs/development/cuda-modules/default.nix new file mode 100644 index 000000000000..5190dcecdb4c --- /dev/null +++ b/pkgs/development/cuda-modules/default.nix @@ -0,0 +1,152 @@ +{ + _cuda, + config, + lib, + pkgs, + # Manually provided arguments + manifests, +}: +let + inherit (lib.customisation) callPackagesWith; + inherit (lib.filesystem) packagesFromDirectoryRecursive; + inherit (lib.fixedPoints) composeManyExtensions extends; + inherit (lib.lists) optionals; + inherit (lib.strings) versionAtLeast versionOlder; + inherit (lib.versions) major majorMinor; + inherit (_cuda.lib) + dropDots + formatCapabilities + mkVersionedName + ; + + # NOTE: This value is considered an implementation detail and should not be exposed in the attribute set. + cudaMajorMinorPatchVersion = manifests.cuda.release_label; + cudaMajorMinorVersion = majorMinor cudaMajorMinorPatchVersion; + cudaMajorVersion = major cudaMajorMinorPatchVersion; + + cudaPackagesMajorMinorVersionedName = mkVersionedName "cudaPackages" cudaMajorMinorVersion; + + # We must use an instance of Nixpkgs where the CUDA package set we're building is the default; if we do not, members + # of the versioned, non-default package sets may rely on (transitively) members of the default, unversioned CUDA + # package set. + # See `Using cudaPackages.pkgs` in doc/languages-frameworks/cuda.section.md for more information. + pkgs' = + let + cudaPackagesUnversionedName = "cudaPackages"; + cudaPackagesMajorVersionedName = mkVersionedName cudaPackagesUnversionedName cudaMajorVersion; + in + pkgs.extend ( + final: _: { + recurseForDerivations = false; + # The CUDA package set will be available as cudaPackages_x_y, so we need only update the aliases for the + # minor-versioned and unversioned package sets. + # cudaPackages_x = cudaPackages_x_y + ${cudaPackagesMajorVersionedName} = final.${cudaPackagesMajorMinorVersionedName}; + # cudaPackages = cudaPackages_x + ${cudaPackagesUnversionedName} = final.${cudaPackagesMajorVersionedName}; + } + ); + + cudaPackagesFixedPoint = + finalCudaPackages: + { + # NOTE: + # It is important that _cuda is not part of the package set fixed-point. As described by + # @SomeoneSerge: + # > The layering should be: configuration -> (identifies/is part of) cudaPackages -> (is built using) cudaLib. + # > No arrows should point in the reverse directions. + # That is to say that cudaLib should only know about package sets and configurations, because it implements + # functionality for interpreting configurations, resolving them against data, and constructing package sets. + # This decision is driven both by a separation of concerns and by "NAMESET STRICTNESS" (see above). + # Also see the comment in `pkgs/top-level/all-packages.nix` about the `_cuda` attribute. + + inherit + cudaMajorMinorPatchVersion + cudaMajorMinorVersion + cudaMajorVersion + ; + + pkgs = pkgs'; + + # Core + callPackages = callPackagesWith (pkgs' // finalCudaPackages); + + cudaNamePrefix = "cuda${cudaMajorMinorVersion}"; + + cudaOlder = versionOlder cudaMajorMinorVersion; + cudaAtLeast = versionAtLeast cudaMajorMinorVersion; + + # These must be modified through callPackage, not by overriding the scope, since we cannot + # depend on them recursively as they are used to add top-level attributes. + inherit manifests; + + # Create backendStdenv variants for different host compilers, since users may want to build a CUDA project with + # Clang or GCC specifically. + # TODO(@connorbaker): Because of the way our setup hooks and patching of NVCC works, the user's choice of + # backendStdenv is largely disregarded or will cause build failures; fixing this would require the setup hooks + # and patching to be made aware of the current environment (perhaps by reading certain environment variables set + # by our backendStdenv). + # backendClangStdenv = finalCudaPackages.callPackage ./packages/backendStdenv.nix { + # stdenv = pkgs'.clangStdenv; + # }; + # backendGccStdenv = finalCudaPackages.callPackage ./packages/backendStdenv.nix { + # stdenv = pkgs'.gccStdenv; + # }; + + # Must be constructed without `callPackage` to avoid replacing the `override` attribute with that of + # `callPackage`'s. + buildRedist = import ./buildRedist { + inherit (pkgs) + _cuda + autoAddDriverRunpath + autoPatchelfHook + config + fetchurl + lib + srcOnly + stdenv + stdenvNoCC + ; + inherit (finalCudaPackages) + autoAddCudaCompatRunpath + backendStdenv + cudaMajorMinorVersion + cudaMajorVersion + cudaNamePrefix + manifests + markForCudatoolkitRootHook + setupCudaHook + ; + }; + + flags = + formatCapabilities { + inherit (finalCudaPackages.backendStdenv) cudaCapabilities cudaForwardCompat; + inherit (_cuda.db) cudaCapabilityToInfo; + } + # TODO(@connorbaker): Enable the corresponding warnings in `./aliases.nix` after some + # time to allow users to migrate to cudaLib and backendStdenv. + // { + inherit dropDots; + cudaComputeCapabilityToName = + cudaCapability: _cuda.db.cudaCapabilityToInfo.${cudaCapability}.archName; + dropDot = dropDots; + isJetsonBuild = finalCudaPackages.backendStdenv.hasJetsonCudaCapability; + }; + } + // packagesFromDirectoryRecursive { + inherit (finalCudaPackages) callPackage; + directory = ./packages; + }; + + composedExtensions = composeManyExtensions ( + optionals config.allowAliases [ + (import ./aliases.nix { inherit lib; }) + ] + ++ _cuda.extensions + ); +in +pkgs'.makeScopeWithSplicing' { + otherSplices = pkgs'.generateSplicesForMkScope [ cudaPackagesMajorMinorVersionedName ]; + f = extends composedExtensions cudaPackagesFixedPoint; +} diff --git a/pkgs/development/cuda-modules/generic-builders/manifest.nix b/pkgs/development/cuda-modules/generic-builders/manifest.nix deleted file mode 100644 index 7f346df79809..000000000000 --- a/pkgs/development/cuda-modules/generic-builders/manifest.nix +++ /dev/null @@ -1,356 +0,0 @@ -{ - # General callPackage-supplied arguments - autoAddDriverRunpath, - autoAddCudaCompatRunpath, - autoPatchelfHook, - backendStdenv, - callPackage, - _cuda, - fetchurl, - lib, - markForCudatoolkitRootHook, - flags, - stdenv, - # Builder-specific arguments - # Short package name (e.g., "cuda_cccl") - # pname : String - pname, - # Common name (e.g., "cutensor" or "cudnn") -- used in the URL. - # Also known as the Redistributable Name. - # redistName : String, - redistName, - # If libPath is non-null, it must be a subdirectory of `lib`. - # The contents of `libPath` will be moved to the root of `lib`. - libPath ? null, - # See ./modules/generic/manifests/redistrib/release.nix - redistribRelease, - # See ./modules/generic/manifests/feature/release.nix - featureRelease, - cudaMajorMinorVersion, -}: -let - inherit (lib) - attrsets - lists - strings - trivial - licenses - teams - sourceTypes - ; - - inherit (stdenv) hostPlatform; - - # Last step before returning control to `callPackage` (adds the `.override` method) - # we'll apply (`overrideAttrs`) necessary package-specific "fixup" functions. - # Order is significant. - maybeFixup = _cuda.fixups.${pname} or null; - fixup = if maybeFixup != null then callPackage maybeFixup { } else { }; - - # Get the redist systems for which package provides distributables. - # These are used by meta.platforms. - supportedRedistSystems = builtins.attrNames featureRelease; - # redistSystem :: String - # The redistSystem is the name of the system for which the redistributable is built. - # It is `"unsupported"` if the redistributable is not supported on the target system. - redistSystem = _cuda.lib.getRedistSystem backendStdenv.hasJetsonCudaCapability hostPlatform.system; - - sourceMatchesHost = lib.elem hostPlatform.system (_cuda.lib.getNixSystems redistSystem); -in -(backendStdenv.mkDerivation (finalAttrs: { - # NOTE: Even though there's no actual buildPhase going on here, the derivations of the - # redistributables are sensitive to the compiler flags provided to stdenv. The patchelf package - # is sensitive to the compiler flags provided to stdenv, and we depend on it. As such, we are - # also sensitive to the compiler flags provided to stdenv. - inherit pname; - inherit (redistribRelease) version; - - # Don't force serialization to string for structured attributes, like outputToPatterns - # and brokenConditions. - # Avoids "set cannot be coerced to string" errors. - __structuredAttrs = true; - - # Keep better track of dependencies. - strictDeps = true; - - # NOTE: Outputs are evaluated jointly with meta, so in the case that this is an unsupported platform, - # we still need to provide a list of outputs. - outputs = - let - # Checks whether the redistributable provides an output. - hasOutput = - output: - attrsets.attrByPath [ - redistSystem - "outputs" - output - ] false featureRelease; - # Order is important here so we use a list. - possibleOutputs = [ - "bin" - "lib" - "static" - "dev" - "doc" - "sample" - "python" - ]; - # Filter out outputs that don't exist in the redistributable. - # NOTE: In the case the redistributable isn't supported on the target platform, - # we will have `outputs = [ "out" ] ++ possibleOutputs`. This is of note because platforms which - # aren't supported would otherwise have evaluation errors when trying to access outputs other than `out`. - # The alternative would be to have `outputs = [ "out" ]` when`redistSystem = "unsupported"`, but that would - # require adding guards throughout the entirety of the CUDA package set to ensure `cudaSupport` is true -- - # recall that OfBorg will evaluate packages marked as broken and that `cudaPackages` will be evaluated with - # `cudaSupport = false`! - additionalOutputs = - if redistSystem == "unsupported" then - possibleOutputs - else - builtins.filter hasOutput possibleOutputs; - # The out output is special -- it's the default output and we always include it. - outputs = [ "out" ] ++ additionalOutputs; - in - outputs; - - # Traversed in the order of the outputs specified in outputs; - # entries are skipped if they don't exist in outputs. - outputToPatterns = { - bin = [ "bin" ]; - dev = [ - "share/pkgconfig" - "**/*.pc" - "**/*.cmake" - ]; - lib = [ - "lib" - "lib64" - ]; - static = [ "**/*.a" ]; - sample = [ "samples" ]; - python = [ "**/*.whl" ]; - }; - - # Useful for introspecting why something went wrong. Maps descriptions of why the derivation would be marked as - # broken on have badPlatforms include the current platform. - - # brokenConditions :: AttrSet Bool - # Sets `meta.broken = true` if any of the conditions are true. - # Example: Broken on a specific version of CUDA or when a dependency has a specific version. - brokenConditions = { - # Unclear how this is handled by Nix internals. - "Duplicate entries in outputs" = finalAttrs.outputs != lists.unique finalAttrs.outputs; - # Typically this results in the static output being empty, as all libraries are moved - # back to the lib output. - "lib output follows static output" = - let - libIndex = lists.findFirstIndex (x: x == "lib") null finalAttrs.outputs; - staticIndex = lists.findFirstIndex (x: x == "static") null finalAttrs.outputs; - in - libIndex != null && staticIndex != null && libIndex > staticIndex; - }; - - # badPlatformsConditions :: AttrSet Bool - # Sets `meta.badPlatforms = meta.platforms` if any of the conditions are true. - # Example: Broken on a specific architecture when some condition is met (like targeting Jetson). - badPlatformsConditions = { - "No source" = !sourceMatchesHost; - }; - - # src :: Optional Derivation - # If redistSystem doesn't exist in redistribRelease, return null. - src = trivial.mapNullable ( - { relative_path, sha256, ... }: - fetchurl { - url = "https://developer.download.nvidia.com/compute/${redistName}/redist/${relative_path}"; - inherit sha256; - } - ) (redistribRelease.${redistSystem} or null); - - postPatch = - # Pkg-config's setup hook expects configuration files in $out/share/pkgconfig - '' - for path in pkg-config pkgconfig; do - [[ -d "$path" ]] || continue - mkdir -p share/pkgconfig - mv "$path"/* share/pkgconfig/ - rmdir "$path" - done - '' - # Rewrite FHS paths with store paths - # NOTE: output* fall back to out if the corresponding output isn't defined. - + '' - for pc in share/pkgconfig/*.pc; do - sed -i \ - -e "s|^cudaroot\s*=.*\$|cudaroot=''${!outputDev}|" \ - -e "s|^libdir\s*=.*/lib\$|libdir=''${!outputLib}/lib|" \ - -e "s|^includedir\s*=.*/include\$|includedir=''${!outputDev}/include|" \ - "$pc" - done - '' - # Generate unversioned names. - # E.g. cuda-11.8.pc -> cuda.pc - + '' - for pc in share/pkgconfig/*-"$majorMinorVersion.pc"; do - ln -s "$(basename "$pc")" "''${pc%-$majorMinorVersion.pc}".pc - done - ''; - - env.majorMinorVersion = cudaMajorMinorVersion; - - # We do need some other phases, like configurePhase, so the multiple-output setup hook works. - dontBuild = true; - - nativeBuildInputs = [ - autoPatchelfHook - # This hook will make sure libcuda can be found - # in typically /lib/opengl-driver by adding that - # directory to the rpath of all ELF binaries. - # Check e.g. with `patchelf --print-rpath path/to/my/binary - autoAddDriverRunpath - markForCudatoolkitRootHook - ] - # autoAddCudaCompatRunpath depends on cuda_compat and would cause - # infinite recursion if applied to `cuda_compat` itself (beside the fact - # that it doesn't make sense in the first place) - ++ lib.optionals (pname != "cuda_compat" && flags.isJetsonBuild) [ - # autoAddCudaCompatRunpath must appear AFTER autoAddDriverRunpath. - # See its documentation in ./setup-hooks/extension.nix. - autoAddCudaCompatRunpath - ]; - - buildInputs = [ - # autoPatchelfHook will search for a libstdc++ and we're giving it - # one that is compatible with the rest of nixpkgs, even when - # nvcc forces us to use an older gcc - # NB: We don't actually know if this is the right thing to do - (lib.getLib stdenv.cc.cc) - ]; - - # Picked up by autoPatchelf - # Needed e.g. for libnvrtc to locate (dlopen) libnvrtc-builtins - appendRunpaths = [ "$ORIGIN" ]; - - # NOTE: We don't need to check for dev or doc, because those outputs are handled by - # the multiple-outputs setup hook. - # NOTE: moveToOutput operates on all outputs: - # https://github.com/NixOS/nixpkgs/blob/2920b6fc16a9ed5d51429e94238b28306ceda79e/pkgs/build-support/setup-hooks/multiple-outputs.sh#L105-L107 - installPhase = - let - mkMoveToOutputCommand = - output: - let - template = pattern: ''moveToOutput "${pattern}" "${"$" + output}"''; - patterns = finalAttrs.outputToPatterns.${output} or [ ]; - in - strings.concatMapStringsSep "\n" template patterns; - in - # Pre-install hook - '' - runHook preInstall - '' - # Handle the existence of libPath, which requires us to re-arrange the lib directory - + strings.optionalString (libPath != null) '' - full_lib_path="lib/${libPath}" - if [[ ! -d "$full_lib_path" ]]; then - echo "${finalAttrs.pname}: '$full_lib_path' does not exist, only found:" >&2 - find lib/ -mindepth 1 -maxdepth 1 >&2 - echo "This release might not support your CUDA version" >&2 - exit 1 - fi - echo "Making libPath '$full_lib_path' the root of lib" >&2 - mv "$full_lib_path" lib_new - rm -r lib - mv lib_new lib - '' - # Create the primary output, out, and move the other outputs into it. - + '' - mkdir -p "$out" - mv * "$out" - '' - # Move the outputs into their respective outputs. - + strings.concatMapStringsSep "\n" mkMoveToOutputCommand (builtins.tail finalAttrs.outputs) - # Add a newline to the end of the installPhase, so that the post-install hook doesn't - # get concatenated with the last moveToOutput command. - + "\n" - # Post-install hook - + '' - runHook postInstall - ''; - - doInstallCheck = true; - allowFHSReferences = true; # TODO: Default to `false` - postInstallCheck = '' - echo "Executing postInstallCheck" - - if [[ -z "''${allowFHSReferences-}" ]]; then - mapfile -t outputPaths < <(for o in $(getAllOutputNames); do echo "''${!o}"; done) - if grep --max-count=5 --recursive --exclude=LICENSE /usr/ "''${outputPaths[@]}"; then - echo "Detected references to /usr" >&2 - exit 1 - fi - fi - ''; - - # libcuda needs to be resolved during runtime - autoPatchelfIgnoreMissingDeps = [ - "libcuda.so" - "libcuda.so.*" - ]; - - # _multioutPropagateDev() currently expects a space-separated string rather than an array - preFixup = '' - export propagatedBuildOutputs="''${propagatedBuildOutputs[@]}" - ''; - - # Propagate all outputs, including `static` - propagatedBuildOutputs = builtins.filter (x: x != "dev") finalAttrs.outputs; - - # Kept in case overrides assume postPhases have already been defined - postPhases = [ "postPatchelf" ]; - postPatchelf = '' - true - ''; - - passthru = { - # Provide access to the release information for fixup functions. - inherit redistribRelease featureRelease; - # Make the CUDA-patched stdenv available - stdenv = backendStdenv; - }; - - meta = { - description = "${redistribRelease.name}. By downloading and using the packages you accept the terms and conditions of the ${finalAttrs.meta.license.shortName}"; - sourceProvenance = [ sourceTypes.binaryNativeCode ]; - broken = lists.any trivial.id (attrsets.attrValues finalAttrs.brokenConditions); - platforms = trivial.pipe supportedRedistSystems [ - # Map each redist system to the equivalent nix systems. - (lib.concatMap _cuda.lib.getNixSystems) - # Take all the unique values. - lib.unique - # Sort the list. - lib.naturalSort - ]; - badPlatforms = - let - isBadPlatform = lists.any trivial.id (attrsets.attrValues finalAttrs.badPlatformsConditions); - in - lists.optionals isBadPlatform finalAttrs.meta.platforms; - license = - if redistName == "cuda" then - # Add the package-specific license. - let - licensePath = - if redistribRelease.license_path != null then - redistribRelease.license_path - else - "${pname}/LICENSE.txt"; - url = "https://developer.download.nvidia.com/compute/cuda/redist/${licensePath}"; - in - lib.licenses.nvidiaCudaRedist // { inherit url; } - else - licenses.unfree; - teams = [ teams.cuda ]; - }; -})).overrideAttrs - fixup diff --git a/pkgs/development/cuda-modules/generic-builders/multiplex.nix b/pkgs/development/cuda-modules/generic-builders/multiplex.nix deleted file mode 100644 index 3085ae3e4610..000000000000 --- a/pkgs/development/cuda-modules/generic-builders/multiplex.nix +++ /dev/null @@ -1,130 +0,0 @@ -{ - lib, - cudaLib, - cudaMajorMinorVersion, - redistSystem, - stdenv, - # Builder-specific arguments - # Short package name (e.g., "cuda_cccl") - # pname : String - pname, - # Common name (e.g., "cutensor" or "cudnn") -- used in the URL. - # Also known as the Redistributable Name. - # redistName : String, - redistName, - # releasesModule :: Path - # A path to a module which provides a `releases` attribute - releasesModule, - # shims :: Path - # A path to a module which provides a `shims` attribute - # The redistribRelease is only used in ./manifest.nix for the package version - # and the package description (which NVIDIA's manifest calls the "name"). - # It's also used for fetching the source, but we override that since we can't - # re-use that portion of the functionality (different URLs, etc.). - # The featureRelease is used to populate meta.platforms (by way of looking at the attribute names), determine the - # outputs of the package, and provide additional package-specific constraints (e.g., min/max supported CUDA versions, - # required versions of other packages, etc.). - # shimFn :: {package, redistSystem} -> AttrSet - shimsFn ? (throw "shimsFn must be provided"), -}: -let - evaluatedModules = lib.modules.evalModules { - modules = [ - ../modules - releasesModule - ]; - }; - - # NOTE: Important types: - # - Releases: ../modules/${pname}/releases/releases.nix - # - Package: ../modules/${pname}/releases/package.nix - - # Check whether a package supports our CUDA version. - # satisfiesCudaVersion :: Package -> Bool - satisfiesCudaVersion = - package: - lib.versionAtLeast cudaMajorMinorVersion package.minCudaVersion - && lib.versionAtLeast package.maxCudaVersion cudaMajorMinorVersion; - - # FIXME: do this at the module system level - propagatePlatforms = lib.mapAttrs (redistSystem: lib.map (p: { inherit redistSystem; } // p)); - - # Releases for all platforms and all CUDA versions. - allReleases = propagatePlatforms evaluatedModules.config.${pname}.releases; - - # Releases for all platforms and our CUDA version. - allReleases' = lib.mapAttrs (_: lib.filter satisfiesCudaVersion) allReleases; - - # Packages for all platforms and our CUDA versions. - allPackages = lib.concatLists (lib.attrValues allReleases'); - - packageOlder = p1: p2: lib.versionOlder p1.version p2.version; - packageSupportedPlatform = p: p.redistSystem == redistSystem; - - # Compute versioned attribute name to be used in this package set - # Patch version changes should not break the build, so we only use major and minor - # computeName :: Package -> String - computeName = { version, ... }: cudaLib.mkVersionedName pname (lib.versions.majorMinor version); - - # The newest package for each major-minor version, with newest first. - # newestPackages :: List Package - newestPackages = - let - newestForEachMajorMinorVersion = lib.foldl' ( - newestPackages: package: - let - majorMinorVersion = lib.versions.majorMinor package.version; - existingPackage = newestPackages.${majorMinorVersion} or null; - in - newestPackages - // { - ${majorMinorVersion} = - # Only keep the existing package if it is newer than the one we are considering or it is supported on the - # current platform and the one we are considering is not. - if - existingPackage != null - && ( - packageOlder package existingPackage - || (!packageSupportedPlatform package && packageSupportedPlatform existingPackage) - ) - then - existingPackage - else - package; - } - ) { } allPackages; - in - # Sort the packages by version so the newest is first. - # NOTE: builtins.sort requires a strict weak ordering, so we must use versionOlder rather than versionAtLeast. - # See https://github.com/NixOS/nixpkgs/commit/9fd753ea84e5035b357a275324e7fd7ccfb1fc77. - lib.sort (lib.flip packageOlder) (lib.attrValues newestForEachMajorMinorVersion); - - extension = - final: _: - let - # Builds our package into derivation and wraps it in a nameValuePair, where the name is the versioned name - # of the package. - buildPackage = - package: - let - shims = final.callPackage shimsFn { inherit package redistSystem; }; - name = computeName package; - drv = final.callPackage ./manifest.nix { - inherit pname redistName; - inherit (shims) redistribRelease featureRelease; - }; - in - lib.nameValuePair name drv; - - # versionedDerivations :: AttrSet Derivation - versionedDerivations = builtins.listToAttrs (lib.map buildPackage newestPackages); - - defaultDerivation = { - ${pname} = (buildPackage (lib.head newestPackages)).value; - }; - in - # NOTE: Must condition on the length of newestPackages to avoid non-total function lib.head aborting if - # newestPackages is empty. - lib.optionalAttrs (lib.length newestPackages > 0) (versionedDerivations // defaultDerivation); -in -extension diff --git a/pkgs/development/cuda-modules/modules/README.md b/pkgs/development/cuda-modules/modules/README.md deleted file mode 100644 index ab56463eea59..000000000000 --- a/pkgs/development/cuda-modules/modules/README.md +++ /dev/null @@ -1,56 +0,0 @@ -# Modules - -Modules as they are used in `modules` exist primarily to check the shape and -content of CUDA redistributable and feature manifests. They are ultimately meant -to reduce the repetitive nature of repackaging CUDA redistributables. - -Building most redistributables follows a pattern of a manifest indicating which -packages are available at a location, their versions, and their hashes. To avoid -creating builders for each and every derivation, modules serve as a way for us -to use a single `genericManifestBuilder` to build all redistributables. - -## `generic` - -The modules in `generic` are reusable components meant to check the shape and -content of NVIDIA's CUDA redistributable manifests, our feature manifests (which -are derived from NVIDIA's manifests), or hand-crafted Nix expressions describing -available packages. They are used by the `genericManifestBuilder` to build CUDA -redistributables. - -Generally, each package which relies on manifests or Nix release expressions -will create an alias to the relevant generic module. For example, the [module -for CUDNN](./cudnn/default.nix) aliases the generic module for release -expressions, while the [module for CUDA redistributables](./cuda/default.nix) -aliases the generic module for manifests. - -Alternatively, additional fields or values may need to be configured to account -for the particulars of a package. For example, while the release expressions for -[CUDNN](../cudnn/releases.nix) and [TensorRT](../tensorrt/releases.nix) are very -close, they differ slightly in the fields they have. The [module for -CUDNN](./cudnn/default.nix) is able to use the generic module for -release expressions, while the [module for -TensorRT](./tensorrt/default.nix) must add additional fields to the -generic module. - -### `manifests` - -The modules in `generic/manifests` define the structure of NVIDIA's CUDA -redistributable manifests and our feature manifests. - -NVIDIA's redistributable manifests are retrieved from their web server, while -the feature manifests are produced by -[`cuda-redist-find-features`](https://github.com/connorbaker/cuda-redist-find-features). - -### `releases` - -The modules in `generic/releases` define the structure of our hand-crafted Nix -expressions containing information necessary to download and repackage CUDA -redistributables. These expressions are created when NVIDIA-provided manifests -are unavailable or otherwise unusable. For example, though CUDNN has manifests, -a bug in NVIDIA's CI/CD causes manifests for different versions of CUDA to use -the same name, which leads to the manifests overwriting each other. - -### `types` - -The modules in `generic/types` define reusable types used in both -`generic/manifests` and `generic/releases`. diff --git a/pkgs/development/cuda-modules/modules/cuda/default.nix b/pkgs/development/cuda-modules/modules/cuda/default.nix deleted file mode 100644 index 2ff6c885623d..000000000000 --- a/pkgs/development/cuda-modules/modules/cuda/default.nix +++ /dev/null @@ -1,4 +0,0 @@ -{ options, ... }: -{ - options.cuda.manifests = options.generic.manifests; -} diff --git a/pkgs/development/cuda-modules/modules/cudnn/default.nix b/pkgs/development/cuda-modules/modules/cudnn/default.nix deleted file mode 100644 index 36a9a26bda52..000000000000 --- a/pkgs/development/cuda-modules/modules/cudnn/default.nix +++ /dev/null @@ -1,12 +0,0 @@ -{ options, ... }: -{ - options.cudnn.releases = options.generic.releases; - # TODO(@connorbaker): Figure out how to add additional options to the - # to the generic release. - # { - # url = options.mkOption { - # description = "URL to download the tarball from"; - # type = types.str; - # }; - # } -} diff --git a/pkgs/development/cuda-modules/modules/cusparselt/default.nix b/pkgs/development/cuda-modules/modules/cusparselt/default.nix deleted file mode 100644 index 745bad811c05..000000000000 --- a/pkgs/development/cuda-modules/modules/cusparselt/default.nix +++ /dev/null @@ -1,4 +0,0 @@ -{ options, ... }: -{ - options.cusparselt.manifests = options.generic.manifests; -} diff --git a/pkgs/development/cuda-modules/modules/cutensor/default.nix b/pkgs/development/cuda-modules/modules/cutensor/default.nix deleted file mode 100644 index e3eb5383669b..000000000000 --- a/pkgs/development/cuda-modules/modules/cutensor/default.nix +++ /dev/null @@ -1,4 +0,0 @@ -{ options, ... }: -{ - options.cutensor.manifests = options.generic.manifests; -} diff --git a/pkgs/development/cuda-modules/modules/default.nix b/pkgs/development/cuda-modules/modules/default.nix deleted file mode 100644 index a173d1cae360..000000000000 --- a/pkgs/development/cuda-modules/modules/default.nix +++ /dev/null @@ -1,11 +0,0 @@ -{ - imports = [ - ./generic - # Always after generic - ./cuda - ./cudnn - ./cusparselt - ./cutensor - ./tensorrt - ]; -} diff --git a/pkgs/development/cuda-modules/modules/generic/default.nix b/pkgs/development/cuda-modules/modules/generic/default.nix deleted file mode 100644 index b68aa614f240..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/default.nix +++ /dev/null @@ -1,7 +0,0 @@ -{ - imports = [ - ./types - ./manifests - ./releases - ]; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/default.nix b/pkgs/development/cuda-modules/modules/generic/manifests/default.nix deleted file mode 100644 index c30589af6219..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/default.nix +++ /dev/null @@ -1,7 +0,0 @@ -{ lib, config, ... }: -{ - options.generic.manifests = { - feature = import ./feature/manifest.nix { inherit lib config; }; - redistrib = import ./redistrib/manifest.nix { inherit lib; }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/feature/manifest.nix b/pkgs/development/cuda-modules/modules/generic/manifests/feature/manifest.nix deleted file mode 100644 index 2c874b5e4c25..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/feature/manifest.nix +++ /dev/null @@ -1,10 +0,0 @@ -{ lib, config, ... }: -let - inherit (lib) options trivial types; - Release = import ./release.nix { inherit lib config; }; -in -options.mkOption { - description = "Feature manifest is an attribute set which includes a mapping from package name to release"; - example = trivial.importJSON ../../../../cuda/manifests/feature_11.8.0.json; - type = types.attrsOf Release.type; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/feature/outputs.nix b/pkgs/development/cuda-modules/modules/generic/manifests/feature/outputs.nix deleted file mode 100644 index 961f0b968685..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/feature/outputs.nix +++ /dev/null @@ -1,60 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options types; -in -# https://github.com/ConnorBaker/cuda-redist-find-features/blob/603407bea2fab47f2dfcd88431122a505af95b42/cuda_redist_find_features/manifest/feature/package/package.py -options.mkOption { - description = "Set of outputs that a package can provide"; - example = { - bin = true; - dev = true; - doc = false; - lib = false; - sample = false; - static = false; - }; - type = types.submodule { - options = { - bin = options.mkOption { - description = "`bin` output requires that we have a non-empty `bin` directory containing at least one file with the executable bit set"; - type = types.bool; - }; - dev = options.mkOption { - description = '' - A `dev` output requires that we have at least one of the following non-empty directories: - - - `include` - - `lib/pkgconfig` - - `share/pkgconfig` - - `lib/cmake` - - `share/aclocal` - ''; - type = types.bool; - }; - doc = options.mkOption { - description = '' - A `doc` output requires that we have at least one of the following non-empty directories: - - - `share/info` - - `share/doc` - - `share/gtk-doc` - - `share/devhelp` - - `share/man` - ''; - type = types.bool; - }; - lib = options.mkOption { - description = "`lib` output requires that we have a non-empty lib directory containing at least one shared library"; - type = types.bool; - }; - sample = options.mkOption { - description = "`sample` output requires that we have a non-empty `samples` directory"; - type = types.bool; - }; - static = options.mkOption { - description = "`static` output requires that we have a non-empty lib directory containing at least one static library"; - type = types.bool; - }; - }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/feature/package.nix b/pkgs/development/cuda-modules/modules/generic/manifests/feature/package.nix deleted file mode 100644 index 2563598a7829..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/feature/package.nix +++ /dev/null @@ -1,10 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options types; - Outputs = import ./outputs.nix { inherit lib; }; -in -options.mkOption { - description = "Package in the manifest"; - example = (import ./release.nix { inherit lib; }).linux-x86_64; - type = types.submodule { options.outputs = Outputs; }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/feature/release.nix b/pkgs/development/cuda-modules/modules/generic/manifests/feature/release.nix deleted file mode 100644 index 6754ae56e0b0..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/feature/release.nix +++ /dev/null @@ -1,10 +0,0 @@ -{ lib, config, ... }: -let - inherit (lib) options types; - Package = import ./package.nix { inherit lib config; }; -in -options.mkOption { - description = "Release is an attribute set which includes a mapping from platform to package"; - example = (import ./manifest.nix { inherit lib; }).cuda_cccl; - type = types.attrsOf Package.type; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/manifest.nix b/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/manifest.nix deleted file mode 100644 index ec8cba3c7858..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/manifest.nix +++ /dev/null @@ -1,33 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options trivial types; - Release = import ./release.nix { inherit lib; }; -in -options.mkOption { - description = "Redistributable manifest is an attribute set which includes a mapping from package name to release"; - example = trivial.importJSON ../../../../cuda/manifests/redistrib_11.8.0.json; - type = types.submodule { - # Allow any attribute name as these will be the package names - freeformType = types.attrsOf Release.type; - options = { - release_date = options.mkOption { - description = "Release date of the manifest"; - type = types.nullOr types.str; - default = null; - example = "2023-08-29"; - }; - release_label = options.mkOption { - description = "Release label of the manifest"; - type = types.nullOr types.str; - default = null; - example = "12.2.2"; - }; - release_product = options.mkOption { - example = "cuda"; - description = "Release product of the manifest"; - type = types.nullOr types.str; - default = null; - }; - }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/package.nix b/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/package.nix deleted file mode 100644 index bf3bd478a123..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/package.nix +++ /dev/null @@ -1,32 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options types; -in -options.mkOption { - description = "Package in the manifest"; - example = (import ./release.nix { inherit lib; }).linux-x86_64; - type = types.submodule { - options = { - relative_path = options.mkOption { - description = "Relative path to the package"; - example = "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-11.5.62-archive.tar.xz"; - type = types.str; - }; - sha256 = options.mkOption { - description = "Sha256 hash of the package"; - example = "bbe633d6603d5a96a214dcb9f3f6f6fd2fa04d62e53694af97ae0c7afe0121b0"; - type = types.str; - }; - md5 = options.mkOption { - description = "Md5 hash of the package"; - example = "e5deef4f6cb71f14aac5be5d5745dafe"; - type = types.str; - }; - size = options.mkOption { - description = "Size of the package as a string"; - type = types.str; - example = "960968"; - }; - }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/release.nix b/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/release.nix deleted file mode 100644 index 0165ecbb08bc..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/manifests/redistrib/release.nix +++ /dev/null @@ -1,36 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options types; - Package = import ./package.nix { inherit lib; }; -in -options.mkOption { - description = "Release is an attribute set which includes a mapping from platform to package"; - example = (import ./manifest.nix { inherit lib; }).cuda_cccl; - type = types.submodule { - # Allow any attribute name as these will be the platform names - freeformType = types.attrsOf Package.type; - options = { - name = options.mkOption { - description = "Full name of the package"; - example = "CXX Core Compute Libraries"; - type = types.str; - }; - license = options.mkOption { - description = "License of the package"; - example = "CUDA Toolkit"; - type = types.str; - }; - license_path = options.mkOption { - description = "Path to the license of the package"; - example = "cuda_cccl/LICENSE.txt"; - default = null; - type = types.nullOr types.str; - }; - version = options.mkOption { - description = "Version of the package"; - example = "11.5.62"; - type = types.str; - }; - }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/releases/default.nix b/pkgs/development/cuda-modules/modules/generic/releases/default.nix deleted file mode 100644 index 87985ef08134..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/releases/default.nix +++ /dev/null @@ -1,45 +0,0 @@ -{ lib, config, ... }: -let - inherit (config.generic.types) majorMinorVersion majorMinorPatchBuildVersion; - inherit (lib) options types; -in -{ - options.generic.releases = options.mkOption { - description = "Collection of packages targeting different platforms"; - type = - let - Package = options.mkOption { - description = "Package for a specific platform"; - example = { - version = "8.0.3.4"; - minCudaVersion = "10.2"; - maxCudaVersion = "10.2"; - hash = "sha256-LxcXgwe1OCRfwDsEsNLIkeNsOcx3KuF5Sj+g2dY6WD0="; - }; - type = types.submodule { - # TODO(@connorbaker): Figure out how to extend option sets. - freeformType = types.attrsOf types.anything; - options = { - version = options.mkOption { - description = "Version of the package"; - type = majorMinorPatchBuildVersion; - }; - minCudaVersion = options.mkOption { - description = "Minimum CUDA version supported"; - type = majorMinorVersion; - }; - maxCudaVersion = options.mkOption { - description = "Maximum CUDA version supported"; - type = majorMinorVersion; - }; - hash = options.mkOption { - description = "Hash of the tarball"; - type = types.str; - }; - }; - }; - }; - in - types.attrsOf (types.listOf Package.type); - }; -} diff --git a/pkgs/development/cuda-modules/modules/generic/types/default.nix b/pkgs/development/cuda-modules/modules/generic/types/default.nix deleted file mode 100644 index 31e0a4403e81..000000000000 --- a/pkgs/development/cuda-modules/modules/generic/types/default.nix +++ /dev/null @@ -1,39 +0,0 @@ -{ lib, ... }: -let - inherit (lib) options types; -in -{ - options.generic.types = options.mkOption { - type = types.attrsOf types.optionType; - default = { }; - description = "Set of generic types"; - }; - config.generic.types = { - cudaArch = types.strMatching "^sm_[[:digit:]]+[a-z]?$" // { - name = "cudaArch"; - description = "CUDA architecture name"; - }; - # https://github.com/ConnorBaker/cuda-redist-find-features/blob/c841980e146f8664bbcd0ba1399e486b7910617b/cuda_redist_find_features/types/_lib_so_name.py - libSoName = types.strMatching ".*\\.so(\\.[[:digit:]]+)*$" // { - name = "libSoName"; - description = "Name of a shared object file"; - }; - - majorMinorVersion = types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)$" // { - name = "majorMinorVersion"; - description = "Version number with a major and minor component"; - }; - - majorMinorPatchVersion = types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)$" // { - name = "majorMinorPatchVersion"; - description = "Version number with a major, minor, and patch component"; - }; - - majorMinorPatchBuildVersion = - types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)$" - // { - name = "majorMinorPatchBuildVersion"; - description = "Version number with a major, minor, patch, and build component"; - }; - }; -} diff --git a/pkgs/development/cuda-modules/modules/tensorrt/default.nix b/pkgs/development/cuda-modules/modules/tensorrt/default.nix deleted file mode 100644 index a214a26e434b..000000000000 --- a/pkgs/development/cuda-modules/modules/tensorrt/default.nix +++ /dev/null @@ -1,16 +0,0 @@ -{ options, ... }: -{ - options.tensorrt.releases = options.generic.releases; - # TODO(@connorbaker): Figure out how to add additional options to the - # to the generic release. - # { - # cudnnVersion = lib.options.mkOption { - # description = "CUDNN version supported"; - # type = types.nullOr majorMinorVersion; - # }; - # filename = lib.options.mkOption { - # description = "Tarball name"; - # type = types.str; - # }; - # } -} diff --git a/pkgs/development/cuda-modules/packages/README.md b/pkgs/development/cuda-modules/packages/README.md new file mode 100644 index 000000000000..322522b048de --- /dev/null +++ b/pkgs/development/cuda-modules/packages/README.md @@ -0,0 +1,19 @@ +# packages + +Packages which are not created by the redistributable builder. + +## Conventions + +- All new packages should include the following lines as part of their arguments to `stdenv.mkDerivation`: + + ```nix + finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: Depends on the CUDA package set, so use cudaNamePrefix. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + } + ``` + + If the package does not require elements of the package set, then the `cudaNamePrefix` must be omitted: changing the name of a derivation yields a different hash and store path, so we would end up with multiple different store paths with the same content. diff --git a/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/auto-add-cuda-compat-runpath.sh b/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/auto-add-cuda-compat-runpath.sh index fc41024f1551..000c911887a5 100644 --- a/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/auto-add-cuda-compat-runpath.sh +++ b/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/auto-add-cuda-compat-runpath.sh @@ -3,18 +3,24 @@ # coming from the cuda_compat package by adding it to the RUNPATH. echo "Sourcing auto-add-cuda-compat-runpath-hook" +# shellcheck disable=SC2157 +if [[ -z "@libcudaPath@" ]]; then + echo "auto-add-cuda-compat-runpath-hook: cuda_compat not available, skipping hook" + return +fi + addCudaCompatRunpath() { local libPath local origRpath if [[ $# -eq 0 ]]; then - echo "addCudaCompatRunpath: no library path provided" >&2 + nixLog "no library path provided" >&2 exit 1 elif [[ $# -gt 1 ]]; then - echo "addCudaCompatRunpath: too many arguments" >&2 + nixLog "too many arguments" >&2 exit 1 - elif [[ "$1" == "" ]]; then - echo "addCudaCompatRunpath: empty library path" >&2 + elif [[ $1 == "" ]]; then + nixLog "empty library path" >&2 exit 1 else libPath="$1" diff --git a/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/package.nix b/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/package.nix index 5df6535bc81d..75a279addf78 100644 --- a/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/package.nix +++ b/pkgs/development/cuda-modules/packages/autoAddCudaCompatRunpath/package.nix @@ -6,24 +6,24 @@ { autoFixElfFiles, cuda_compat, + lib, makeSetupHook, }: +let + # cuda_compat can be null or broken, depending on the platform, CUDA release, and compute capability. + # To avoid requiring all consumers of this hook to do these checks, we do them here; the hook is a no-op if + # cuda_compat is not available. + enableHook = cuda_compat.meta.available or false; +in makeSetupHook { name = "auto-add-cuda-compat-runpath-hook"; - propagatedBuildInputs = [ autoFixElfFiles ]; + propagatedBuildInputs = lib.optionals enableHook [ autoFixElfFiles ]; substitutions = { - libcudaPath = "${cuda_compat}/compat"; + libcudaPath = lib.optionalString enableHook "${cuda_compat}/compat"; }; - meta = - let - # Handle `null`s in pre-`cuda_compat` releases, - # and `badPlatform`s for `!isJetsonBuild`. - platforms = cuda_compat.meta.platforms or [ ]; - badPlatforms = cuda_compat.meta.badPlatforms or platforms; - in - { - inherit badPlatforms platforms; - }; + passthru = { + inherit enableHook; + }; } ./auto-add-cuda-compat-runpath.sh diff --git a/pkgs/development/cuda-modules/packages/backendStdenv.nix b/pkgs/development/cuda-modules/packages/backendStdenv.nix index c0fbb7068a9a..c7b0dbd549a5 100644 --- a/pkgs/development/cuda-modules/packages/backendStdenv.nix +++ b/pkgs/development/cuda-modules/packages/backendStdenv.nix @@ -6,8 +6,8 @@ # E.g. for cudaPackages_12_9 we use gcc14 with gcc's libstdc++ # Cf. https://github.com/NixOS/nixpkgs/pull/218265 for context { - config, _cuda, + config, cudaMajorMinorVersion, lib, pkgs, @@ -15,18 +15,35 @@ stdenvAdapters, }: let - inherit (builtins) toJSON; + inherit (builtins) + throw + toJSON + toString + ; inherit (_cuda.db) allSortedCudaCapabilities cudaCapabilityToInfo nvccCompatibilities; inherit (_cuda.lib) _cudaCapabilityIsDefault _cudaCapabilityIsSupported - _evaluateAssertions + _mkFailedAssertionsString getRedistSystem mkVersionedName ; - inherit (lib) addErrorContext; - inherit (lib.customisation) extendDerivation; - inherit (lib.lists) filter intersectLists subtractLists; + inherit (lib) + assertMsg + extendDerivation + filter + findFirst + flip + intersectLists + pipe + range + reverseList + subtractLists + toIntBase10 + versionAtLeast + versionOlder + ; + inherit (lib.versions) major; # NOTE: By virtue of processing a sorted list (allSortedCudaCapabilities), our groups will be sorted. @@ -45,11 +62,18 @@ let passthruExtra = { nvccHostCCMatchesStdenvCC = backendStdenv.cc == stdenv.cc; + # TODO(@connorbaker): Does it make sense to expose the `stdenv` we were called with and the `stdenv` selected + # prior to using `stdenvAdapters.useLibsFrom`? + # The Nix system of the host platform. hostNixSystem = stdenv.hostPlatform.system; # The Nix system of the host platform for the CUDA redistributable. - hostRedistSystem = getRedistSystem passthruExtra.hasJetsonCudaCapability stdenv.hostPlatform.system; + hostRedistSystem = getRedistSystem { + inherit (passthruExtra) cudaCapabilities; + inherit cudaMajorMinorVersion; + inherit (stdenv.hostPlatform) system; + }; # Sets whether packages should be built with forward compatibility. # TODO(@connorbaker): If the requested CUDA capabilities are not supported by the current CUDA version, @@ -98,57 +122,150 @@ let assertions = let - # Jetson devices cannot be targeted by the same binaries which target non-Jetson devices. While + # Jetson devices (pre-Thor) cannot be targeted by the same binaries which target non-Jetson devices. While # NVIDIA provides both `linux-aarch64` and `linux-sbsa` packages, which both target `aarch64`, # they are built with different settings and cannot be mixed. - jetsonMesssagePrefix = "Jetson CUDA capabilities (${toJSON passthruExtra.requestedJetsonCudaCapabilities})"; + preThorJetsonCudaCapabilities = filter (flip versionOlder "10.1") passthruExtra.requestedJetsonCudaCapabilities; + postThorJetsonCudaCapabilities = filter (flip versionAtLeast "10.1") passthruExtra.requestedJetsonCudaCapabilities; # Remove all known capabilities from the user's list to find unrecognized capabilities. unrecognizedCudaCapabilities = subtractLists allSortedCudaCapabilities passthruExtra.cudaCapabilities; - # Remove all supported capabilities from the user's list to find unsupported capabilities. - unsupportedCudaCapabilities = subtractLists passthruExtra.supportedCudaCapabilities passthruExtra.cudaCapabilities; + # Capabilities which are too old for this CUDA version. + tooOldCudaCapabilities = filter ( + cap: + let + # This can be null! + maybeMax = cudaCapabilityToInfo.${cap}.maxCudaMajorMinorVersion; + in + maybeMax != null && lib.versionOlder maybeMax cudaMajorMinorVersion + ) passthruExtra.cudaCapabilities; + + # Capabilities which are too new for this CUDA version. + tooNewCudaCapabilities = filter ( + cap: lib.versionOlder cudaMajorMinorVersion cudaCapabilityToInfo.${cap}.minCudaMajorMinorVersion + ) passthruExtra.cudaCapabilities; in [ { - message = "Unrecognized CUDA capabilities: ${toJSON unrecognizedCudaCapabilities}"; + message = "Requested unrecognized CUDA capabilities: ${toJSON unrecognizedCudaCapabilities}"; assertion = unrecognizedCudaCapabilities == [ ]; } { - message = "Unsupported CUDA capabilities: ${toJSON unsupportedCudaCapabilities}"; - assertion = unsupportedCudaCapabilities == [ ]; + message = "Requested CUDA capabilities which are too old for CUDA ${cudaMajorMinorVersion}: ${toJSON tooOldCudaCapabilities}"; + assertion = tooOldCudaCapabilities == [ ]; + } + { + message = "Requested CUDA capabilities which are too new for CUDA ${cudaMajorMinorVersion}: ${toJSON tooNewCudaCapabilities}"; + assertion = tooNewCudaCapabilities == [ ]; } { message = - "${jetsonMesssagePrefix} require hostPlatform (currently ${passthruExtra.hostNixSystem}) " - + "to be aarch64-linux"; + "Requested Jetson CUDA capabilities (${toJSON passthruExtra.requestedJetsonCudaCapabilities}) require " + + "hostPlatform (${passthruExtra.hostNixSystem}) to be aarch64-linux"; assertion = passthruExtra.hasJetsonCudaCapability -> passthruExtra.hostNixSystem == "aarch64-linux"; } { message = - let - # Find the capabilities which are not Jetson capabilities. - requestedNonJetsonCudaCapabilities = subtractLists ( - passthruExtra.requestedJetsonCudaCapabilities - ++ passthruExtra.requestedArchitectureSpecificCudaCapabilities - ++ passthruExtra.requestedFamilySpecificCudaCapabilities - ) passthruExtra.cudaCapabilities; - in - "${jetsonMesssagePrefix} cannot be specified with non-Jetson capabilities " - + "(${toJSON requestedNonJetsonCudaCapabilities})"; + "Requested pre-Thor (10.1) Jetson CUDA capabilities (${toJSON preThorJetsonCudaCapabilities}) cannot be " + + "specified with other capabilities (${toJSON (subtractLists preThorJetsonCudaCapabilities passthruExtra.cudaCapabilities)})"; assertion = - passthruExtra.hasJetsonCudaCapability - -> passthruExtra.requestedJetsonCudaCapabilities == passthruExtra.cudaCapabilities; + # If there are preThorJetsonCudaCapabilities, they must be the only requested capabilities. + preThorJetsonCudaCapabilities != [ ] + -> preThorJetsonCudaCapabilities == passthruExtra.cudaCapabilities; + } + { + message = + "Requested pre-Thor (10.1) Jetson CUDA capabilities (${toJSON preThorJetsonCudaCapabilities}) require " + + "computed NVIDIA hostRedistSystem (${passthruExtra.hostRedistSystem}) to be linux-aarch64"; + assertion = + preThorJetsonCudaCapabilities != [ ] -> passthruExtra.hostRedistSystem == "linux-aarch64"; + } + { + message = + "Requested post-Thor (10.1) Jetson CUDA capabilities (${toJSON postThorJetsonCudaCapabilities}) require " + + "computed NVIDIA hostRedistSystem (${passthruExtra.hostRedistSystem}) to be linux-sbsa"; + assertion = postThorJetsonCudaCapabilities != [ ] -> passthruExtra.hostRedistSystem == "linux-sbsa"; } ]; - assertCondition = addErrorContext "while evaluating ${mkVersionedName "cudaPackages" cudaMajorMinorVersion}.backendStdenv" ( - _evaluateAssertions assertions - ); + failedAssertionsString = _mkFailedAssertionsString assertions; + # TODO(@connorbaker): Seems like `stdenvAdapters.useLibsFrom` breaks clangStdenv's ability to find header files. + # To reproduce: use `nix shell .#cudaPackages_12_6.backendClangStdenv.cc` since CUDA 12.6 supports at most Clang + # 18, but the current stdenv uses Clang 19, requiring this code path. + # With: + # + # ```cpp + # #include + # + # int main() { + # double value = 0.5; + # double result = std::sin(value); + # return 0; + # } + # ``` + # + # we get: + # + # ```console + # $ clang++ ./main.cpp + # ./main.cpp:1:10: fatal error: 'cmath' file not found + # 1 | #include + # | ^~~~~~~ + # 1 error generated. + # ``` + # TODO(@connorbaker): Seems like even using unmodified `clangStdenv` causes issues -- saxpy fails to build CMake + # errors during CUDA compiler identification about invalid redefinitions of things like `realpath`. backendStdenv = - stdenvAdapters.useLibsFrom stdenv - pkgs."gcc${nvccCompatibilities.${cudaMajorMinorVersion}.gcc.maxMajorVersion}Stdenv"; + let + hostCCName = + if stdenv.cc.isGNU then + "gcc" + else if stdenv.cc.isClang then + "clang" + else + throw "cudaPackages.backendStdenv: unsupported host compiler: ${stdenv.cc.name}"; + + versions = nvccCompatibilities.${cudaMajorMinorVersion}.${hostCCName}; + + stdenvIsSupportedVersion = + versionAtLeast (major stdenv.cc.version) versions.minMajorVersion + && versionAtLeast versions.maxMajorVersion (major stdenv.cc.version); + + maybeGetVersionedCC = + if hostCCName == "gcc" then + version: pkgs."gcc${version}Stdenv" or null + else + version: pkgs."llvmPackages_${version}".stdenv or null; + + maybeHostStdenv = + pipe (range (toIntBase10 versions.minMajorVersion) (toIntBase10 versions.maxMajorVersion)) + [ + # Convert integers to strings. + (map toString) + # Prefer the highest available version. + reverseList + # Map to the actual stdenvs or null if unavailable. + (map maybeGetVersionedCC) + # Get the first available version. + (findFirst (x: x != null) null) + ]; + in + # If the current stdenv's compiler version is compatible, or we're on an unsupported host system, use stdenv + # directly. + # If we're on an unsupported host system (like darwin), there's not much else we can do, but we should not break + # evaluation on unsupported systems. + if stdenvIsSupportedVersion || passthruExtra.hostRedistSystem == "unsupported" then + stdenv + # Otherwise, try to find a compatible stdenv. + else + assert assertMsg (maybeHostStdenv != null) + "backendStdenv: no supported host compiler found (tried ${hostCCName} ${versions.minMajorVersion} to ${versions.maxMajorVersion})"; + stdenvAdapters.useLibsFrom stdenv maybeHostStdenv; in # TODO: Consider testing whether we in fact use the newer libstdc++ -extendDerivation assertCondition passthruExtra backendStdenv +# NOTE: The assertion message we get from `extendDerivation` is not at all helpful. Instead, we use assertMsg. +assert assertMsg (failedAssertionsString == "") + "${mkVersionedName "cudaPackages" cudaMajorMinorVersion}.backendStdenv has failed assertions:${failedAssertionsString}"; +extendDerivation true passthruExtra backendStdenv diff --git a/pkgs/development/cuda-modules/packages/cuda-samples.nix b/pkgs/development/cuda-modules/packages/cuda-samples.nix new file mode 100644 index 000000000000..e77ca8eda743 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda-samples.nix @@ -0,0 +1,220 @@ +{ + backendStdenv, + _cuda, + cmake, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cuda_nvrtc, + cuda_nvtx, + cuda_profiler_api, + cudaAtLeast, + cudaNamePrefix, + cudaOlder, + fetchFromGitHub, + flags, + lib, + libcublas, + libcufft, + libcurand, + libcusolver, + libcusparse, + libnpp, + libnvjitlink, + libnvjpeg, +}: +backendStdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "cuda-samples"; + version = "12.8"; + + # We should be able to use samples from the latest version of CUDA + # on most of the CUDA package sets we have. + # Plus, 12.8 and later are rewritten to use CMake which makes it much, much easier to build. + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "cuda-samples"; + tag = "v${finalAttrs.version}"; + hash = "sha256-Ba0Fi0v/sQ+1iJ4mslgyIAE+oK5KO0lMoTQCC91vpiA="; + }; + + prePatch = + # https://github.com/NVIDIA/cuda-samples/issues/333 + '' + nixLog "removing sample 0_Introduction/UnifiedMemoryStreams which requires OpenMP support for CUDA" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/0_Introduction/CMakeLists.txt" \ + --replace-fail \ + 'add_subdirectory(UnifiedMemoryStreams)' \ + '# add_subdirectory(UnifiedMemoryStreams)' + '' + # This sample tries to use a relative path, which doesn't work for our splayed installation. + + '' + nixLog "patching sample 0_Introduction/matrixMul_nvrtc" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt" \ + --replace-fail \ + "\''${CUDAToolkit_BIN_DIR}/../include/cooperative_groups" \ + "${lib.getOutput "include" cuda_cudart}/include/cooperative_groups" \ + --replace-fail \ + "\''${CUDAToolkit_BIN_DIR}/../include/nv" \ + "${lib.getOutput "include" cuda_cccl}/include/nv" \ + --replace-fail \ + "\''${CUDAToolkit_BIN_DIR}/../include/cuda" \ + "${lib.getOutput "include" cuda_cccl}/include/cuda" + '' + # These three samples give undefined references, like + # nvlink error : Undefined reference to '__cudaCDP2Free' in 'CMakeFiles/cdpBezierTessellation.dir/BezierLineCDP.cu.o' + # nvlink error : Undefined reference to '__cudaCDP2Malloc' in 'CMakeFiles/cdpBezierTessellation.dir/BezierLineCDP.cu.o' + # nvlink error : Undefined reference to '__cudaCDP2GetParameterBufferV2' in 'CMakeFiles/cdpBezierTessellation.dir/BezierLineCDP.cu.o' + # nvlink error : Undefined reference to '__cudaCDP2LaunchDeviceV2' in 'CMakeFiles/cdpBezierTessellation.dir/BezierLineCDP.cu.o' + + '' + for sample in cdp{AdvancedQuicksort,BezierTessellation,Quadtree,SimplePrint,SimpleQuicksort}; do + nixLog "removing sample 3_CUDA_Features/$sample which fails to link" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/3_CUDA_Features/CMakeLists.txt" \ + --replace-fail \ + "add_subdirectory($sample)" \ + "# add_subdirectory($sample)" + done + unset -v sample + '' + + lib.optionalString (cudaOlder "12.4") '' + nixLog "removing sample 3_CUDA_Features/graphConditionalNodes which requires at least CUDA 12.4" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/3_CUDA_Features/CMakeLists.txt" \ + --replace-fail \ + "add_subdirectory(graphConditionalNodes)" \ + "# add_subdirectory(graphConditionalNodes)" + '' + # For some reason this sample requires a static library, which we don't propagate by default due to size. + + '' + nixLog "patching sample 4_CUDA_Libraries/simpleCUFFT_callback to use dynamic library" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/4_CUDA_Libraries/simpleCUFFT_callback/CMakeLists.txt" \ + --replace-fail \ + 'CUDA::cufft_static' \ + 'CUDA::cufft' + '' + # Patch to use the correct path to libnvJitLink.so, or disable the sample if older than 12.4. + + lib.optionalString (cudaOlder "12.4") '' + nixLog "removing sample 4_CUDA_Libraries/jitLto which requires at least CUDA 12.4" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/4_CUDA_Libraries/CMakeLists.txt" \ + --replace-fail \ + "add_subdirectory(jitLto)" \ + "# add_subdirectory(jitLto)" + '' + + lib.optionalString (cudaAtLeast "12.4") '' + nixLog "patching sample 4_CUDA_Libraries/jitLto to use correct path to libnvJitLink.so" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/4_CUDA_Libraries/jitLto/CMakeLists.txt" \ + --replace-fail \ + "\''${CUDAToolkit_LIBRARY_DIR}/libnvJitLink.so" \ + "${lib.getLib libnvjitlink}/lib/libnvJitLink.so" + '' + # /build/NVIDIA-cuda-samples-v12.8/Samples/4_CUDA_Libraries/watershedSegmentationNPP/watershedSegmentationNPP.cpp:272:80: error: cannot convert 'size_t*' {aka 'long unsigned int*'} to 'int*' + # 272 | nppStatus = nppiSegmentWatershedGetBufferSize_8u_C1R(oSizeROI[nImage], &aSegmentationScratchBufferSize[nImage]); + # | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + # | | + # | size_t* {aka long unsigned int*} + + lib.optionalString (cudaOlder "12.8") '' + nixLog "removing sample 4_CUDA_Libraries/watershedSegmentationNPP which requires at least CUDA 12.8" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/4_CUDA_Libraries/CMakeLists.txt" \ + --replace-fail \ + "add_subdirectory(watershedSegmentationNPP)" \ + "# add_subdirectory(watershedSegmentationNPP)" + '' + # NVVM samples require a specific build of LLVM, which is a hassle. + + '' + nixLog "removing samples 7_libNVVM which require a specific build of LLVM" + substituteInPlace \ + "$NIX_BUILD_TOP/$sourceRoot/Samples/CMakeLists.txt" \ + --replace-fail \ + 'add_subdirectory(7_libNVVM)' \ + '# add_subdirectory(7_libNVVM)' + '' + # Don't use hard-coded CUDA architectures + + '' + nixLog "patching CMakeLists.txt to use provided CUDA architectures" + local path="" + while IFS= read -r -d $'\0' path; do + nixLog "removing CMAKE_CUDA_ARCHITECTURES declaration from $path" + substituteInPlace \ + "$path" \ + --replace-fail \ + 'set(CMAKE_CUDA_ARCHITECTURES' \ + '# set(CMAKE_CUDA_ARCHITECTURES' + done < <(grep --files-with-matches --null "set(CMAKE_CUDA_ARCHITECTURES" --recursive "$NIX_BUILD_TOP/$sourceRoot") + unset -v path + ''; + + nativeBuildInputs = [ + cmake + cuda_nvcc + ]; + + buildInputs = [ + cuda_cccl + cuda_cudart + cuda_nvrtc + cuda_nvtx + cuda_profiler_api + libcublas + libcufft + libcurand + libcusolver + libcusparse + libnpp + libnvjitlink + libnvjpeg + ]; + + cmakeFlags = [ + (lib.cmakeFeature "CMAKE_CUDA_ARCHITECTURES" flags.cmakeCudaArchitecturesString) + (lib.cmakeBool "BUILD_TEGRA" backendStdenv.hasJetsonCudaCapability) + ]; + + # TODO(@connorbaker): + # For some reason, using the combined find command doesn't delete directories: + # find "$PWD/Samples" \ + # \( -type d -name CMakeFiles \) \ + # -o \( -type f -name cmake_install.cmake \) \ + # -o \( -type f -name Makefile \) \ + # -exec rm -rf {} + + installPhase = '' + runHook preInstall + + pushd "$NIX_BUILD_TOP/$sourceRoot/''${cmakeBuildDir:?}" >/dev/null + + nixLog "deleting CMake related files" + + find "$PWD/Samples" -type d -name CMakeFiles -exec rm -rf {} + + find "$PWD/Samples" -type f -name cmake_install.cmake -exec rm -rf {} + + find "$PWD/Samples" -type f -name Makefile -exec rm -rf {} + + + nixLog "copying $PWD/Samples to $out/" + mkdir -p "$out" + cp -rv "$PWD/Samples"/* "$out/" + + popd >/dev/null + + runHook postInstall + ''; + + meta = { + description = "Samples for CUDA Developers which demonstrates features in CUDA Toolkit"; + homepage = "https://github.com/NVIDIA/cuda-samples"; + license = lib.licenses.nvidiaCuda; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + maintainers = [ lib.maintainers.connorbaker ]; + teams = [ lib.teams.cuda ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/cuda_cccl.nix b/pkgs/development/cuda-modules/packages/cuda_cccl.nix new file mode 100644 index 000000000000..c4f39f875dd9 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_cccl.nix @@ -0,0 +1,35 @@ +{ + buildRedist, + cudaAtLeast, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "cuda_cccl"; + + # Restrict header-only packages to a single output. + # Also, when using multiple outputs (i.e., `out`, `dev`, and `include`), something isn't being patched correctly, + # so libnvshmem fails to build, complaining about being unable to find the thrust include directory. This is likely + # because the `dev` output contains the CMake configuration and is written to assume it will share a parent + # directory with the include directory rather than be in a separate output. + outputs = [ "out" ]; + + prePatch = lib.optionalString (cudaAtLeast "13.0") '' + nixLog "removing top-level $PWD/include/nv directory" + rm -rfv "$PWD/include/nv" + nixLog "un-nesting top-level $PWD/include/cccl directory" + mv -v "$PWD/include/cccl"/* "$PWD/include/" + nixLog "removing empty $PWD/include/cccl directory" + rmdir -v "$PWD/include/cccl" + ''; + + meta = { + description = "Building blocks that make it easier to write safe and efficient CUDA C++ code"; + longDescription = '' + The goal of CCCL is to provide CUDA C++ developers with building blocks that make it easier to write safe and + efficient code. + ''; + homepage = "https://github.com/NVIDIA/cccl"; + changelog = "https://github.com/NVIDIA/cccl/releases"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_compat.nix b/pkgs/development/cuda-modules/packages/cuda_compat.nix new file mode 100644 index 000000000000..09f04f143322 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_compat.nix @@ -0,0 +1,20 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_compat"; + + # NOTE: Using multiple outputs with symlinks causes build cycles. + # To avoid that (and troubleshooting why), we just use a single output. + outputs = [ "out" ]; + + autoPatchelfIgnoreMissingDeps = [ + "libnvdla_runtime.so" + "libnvrm_gpu.so" + "libnvrm_mem.so" + ]; + + meta = { + description = "Provides minor version forward compatibility for the CUDA runtime"; + homepage = "https://docs.nvidia.com/deploy/cuda-compatibility"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_crt.nix b/pkgs/development/cuda-modules/packages/cuda_crt.nix new file mode 100644 index 000000000000..3cf2246235bd --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_crt.nix @@ -0,0 +1,27 @@ +{ backendStdenv, buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_crt"; + + outputs = [ "out" ]; + + brokenAssertions = [ + # TODO(@connorbaker): Build fails on x86 when using pkgsLLVM. + # .../include/crt/host_defines.h:67:2: + # error: "libc++ is not supported on x86 system" + # + # 67 | #error "libc++ is not supported on x86 system" + # | ^ + # + # 1 error generated. + # + # # --error 0x1 -- + { + message = "cannot use libc++ on x86_64-linux"; + assertion = backendStdenv.hostNixSystem == "x86_64-linux" -> backendStdenv.cc.libcxx == null; + } + ]; + + # There's a comment with a reference to /usr + allowFHSReferences = true; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_ctadvisor.nix b/pkgs/development/cuda-modules/packages/cuda_ctadvisor.nix new file mode 100644 index 000000000000..aa7139a53c94 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_ctadvisor.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_ctadvisor"; + + outputs = [ "out" ]; + + meta = { + description = "Analyzes trace files containing compilation time information generated by NVCC or NVRTC"; + longDescription = '' + CUDA Compile Time Advisor (ctadvisor) analyzes trace files containing compilation time information generated by + NVCC or NVRTC. ctadvisor identifies compilation bottlenecks that take significant amount of time, for examples, + template instantiation and headers processing. The tool provides users with suggestions to reduce compilation + time. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-compile-time-advisor"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_cudart.nix b/pkgs/development/cuda-modules/packages/cuda_cudart.nix new file mode 100644 index 000000000000..8ec7c4f8b3c6 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_cudart.nix @@ -0,0 +1,90 @@ +# TODO(@connorbaker): cuda_cudart.dev depends on crt/host_config.h, which is from +# (getDev cuda_nvcc). It would be nice to be able to encode that. +{ + _cuda, + addDriverRunpath, + buildRedist, + cuda_cccl, + cuda_compat, + cuda_crt, + cuda_nvcc, + cudaAtLeast, + lib, +}: +buildRedist (finalAttrs: { + redistName = "cuda"; + pname = "cuda_cudart"; + + # NOTE: A number of packages expect cuda_cudart to be in a single directory. We restrict the package to a single + # output to avoid breaking these assumptions. As an example, CMake expects the static libraries to exist alongside + # the dynamic libraries. + outputs = [ + "out" + ]; + + propagatedBuildOutputs = + # required by CMake + lib.optionals (lib.elem "static" finalAttrs.outputs) [ "static" ] + # always propagate, even when cuda_compat is used, to avoid symbol linking errors + ++ lib.optionals (lib.elem "stubs" finalAttrs.outputs) [ "stubs" ]; + + # When cuda_compat is available, propagate it. + # NOTE: `cuda_compat` can be disabled by setting the package to `null`. This is useful in cases where + # the host OS has a recent enough CUDA driver that the compatibility library isn't needed. + propagatedBuildInputs = + # Add the dependency on NVCC's include directory. + # - crt/host_config.h + # TODO(@connorbaker): Check that the dependency offset for this is correct. + [ (lib.getOutput "include" cuda_nvcc) ] + # TODO(@connorbaker): From CUDA 13.0, crt/host_config.h is in cuda_crt + ++ lib.optionals (cudaAtLeast "13.0") [ (lib.getOutput "include" cuda_crt) ] + # Add the dependency on CCCL's include directory. + # - nv/target + # TODO(@connorbaker): Check that the dependency offset for this is correct. + ++ [ (lib.getOutput "include" cuda_cccl) ] + # NOTE: cuda_compat may be null or unavailable + ++ lib.optionals (cuda_compat.meta.available or false) [ cuda_compat ]; + + allowFHSReferences = false; + + # Patch the `cudart` package config files so they reference lib + postPatch = '' + local path="" + while IFS= read -r -d $'\0' path; do + nixLog "patching $path" + sed -i \ + -e "s|^cudaroot\s*=.*\$||" \ + -e "s|^Libs\s*:\(.*\)\$|Libs: \1 -Wl,-rpath,${addDriverRunpath.driverLink}/lib|" \ + "$path" + done < <(find -iname 'cudart-*.pc' -print0) + unset -v path + '' + # Patch the `cuda` package config files so they reference stubs + # TODO: Will this always pull in the stubs output and cause its setup hook to be executed? + + '' + local path="" + while IFS= read -r -d $'\0' path; do + nixLog "patching $path" + sed -i \ + -e "s|^cudaroot\s*=.*\$||" \ + -e "s|^libdir\s*=.*/lib\$|libdir=''${!outputStubs:?}/lib/stubs|" \ + -e "s|^Libs\s*:\(.*\)\$|Libs: \1 -Wl,-rpath,${addDriverRunpath.driverLink}/lib|" \ + "$path" + done < <(find -iname 'cuda-*.pc' -print0) + unset -v path + ''; + + # Namelink may not be enough, add a soname. + # Cf. https://gitlab.kitware.com/cmake/cmake/-/issues/25536 + # NOTE: Relative symlinks is fine since this is all within the same output. + postInstall = '' + pushd "''${!outputStubs:?}/lib/stubs" >/dev/null + if [[ -f libcuda.so && ! -f libcuda.so.1 ]]; then + nixLog "creating versioned symlink for libcuda.so stub" + ln -srv libcuda.so libcuda.so.1 + fi + popd >/dev/null + ''; + + meta.description = "CUDA Runtime"; +}) diff --git a/pkgs/development/cuda-modules/packages/cuda_culibos.nix b/pkgs/development/cuda-modules/packages/cuda_culibos.nix new file mode 100644 index 000000000000..c95939a96d86 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_culibos.nix @@ -0,0 +1,6 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_culibos"; + outputs = [ "out" ]; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_cuobjdump.nix b/pkgs/development/cuda-modules/packages/cuda_cuobjdump.nix new file mode 100644 index 000000000000..754c70915497 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_cuobjdump.nix @@ -0,0 +1,17 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_cuobjdump"; + outputs = [ "out" ]; + + meta = { + description = "Extracts information from CUDA binary files (both standalone and those embedded in host binaries) and presents them in human readable format"; + longDescription = '' + `cuobjdump` extracts information from CUDA binary files (both standalone and those embedded in host binaries) + and presents them in human readable format. The output of cuobjdump includes CUDA assembly code for each kernel, + CUDA ELF section headers, string tables, relocators and other CUDA specific sections. It also extracts embedded + ptx text from host binaries. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-binary-utilities#cuobjdump"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_cupti.nix b/pkgs/development/cuda-modules/packages/cuda_cupti.nix new file mode 100644 index 000000000000..4a1eb1d19dac --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_cupti.nix @@ -0,0 +1,30 @@ +{ + backendStdenv, + buildRedist, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "cuda_cupti"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "samples" + ] + ++ lib.optionals (backendStdenv.hostNixSystem == "x86_64-linux") [ "static" ]; + + allowFHSReferences = true; + + meta = { + description = "C-based interface for creating profiling and tracing tools designed for CUDA applications"; + longDescription = '' + The CUDA Profiling Tools Interface (CUPTI) provides a C-based interface for creating profiling and tracing tools + designed for CUDA applications. + ''; + homepage = "https://docs.nvidia.com/cupti"; + changelog = "https://docs.nvidia.com/cupti/release-notes/release-notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_cuxxfilt.nix b/pkgs/development/cuda-modules/packages/cuda_cuxxfilt.nix new file mode 100644 index 000000000000..046ddebebfaf --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_cuxxfilt.nix @@ -0,0 +1,21 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_cuxxfilt"; + + outputs = [ + "out" + "bin" + "dev" + "include" + "static" + ]; + + meta = { + description = "Decode low-level identifiers that have been mangled by CUDA C++ into user readable names"; + longDescription = '' + cu++filt decodes (demangles) low-level identifiers that have been mangled by CUDA C++ into user readable names. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-binary-utilities#cu-filt"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_demo_suite.nix b/pkgs/development/cuda-modules/packages/cuda_demo_suite.nix new file mode 100644 index 000000000000..1a85c258eb0e --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_demo_suite.nix @@ -0,0 +1,33 @@ +{ + buildRedist, + libcufft, + libcurand, + libGLU, + libglut, + libglvnd, + mesa, +}: +buildRedist { + redistName = "cuda"; + pname = "cuda_demo_suite"; + + buildInputs = [ + libcufft + libcurand + libGLU + libglut + libglvnd + mesa + ]; + + outputs = [ "out" ]; + + meta = { + description = "Pre-built applications which use CUDA"; + longDescription = '' + The CUDA Demo Suite contains pre-built applications which use CUDA. These applications demonstrate the + capabilities and details of NVIDIA GPUs. + ''; + homepage = "https://docs.nvidia.com/cuda/demo-suite"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_documentation.nix b/pkgs/development/cuda-modules/packages/cuda_documentation.nix new file mode 100644 index 000000000000..dc872008b58a --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_documentation.nix @@ -0,0 +1,14 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_documentation"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + meta = { + homepage = "https://docs.nvidia.com/cuda"; + changelog = "https://docs.nvidia.com/cuda/cuda-toolkit-release-notes"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_gdb.nix b/pkgs/development/cuda-modules/packages/cuda_gdb.nix new file mode 100644 index 000000000000..8dc2812fd325 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_gdb.nix @@ -0,0 +1,71 @@ +{ + backendStdenv, + buildRedist, + cudaAtLeast, + expat, + gmp, + lib, + libxcrypt-legacy, + ncurses, + python3, +}: +let + python3MajorMinorVersion = lib.versions.majorMinor python3.version; +in +buildRedist { + redistName = "cuda"; + pname = "cuda_gdb"; + + outputs = [ + "out" + "bin" + ]; + + allowFHSReferences = true; + + buildInputs = + # only needs gmp from 12.0 and on + lib.optionals (cudaAtLeast "12.0") [ gmp ] + # aarch64, sbsa needs expat + ++ lib.optionals backendStdenv.hostPlatform.isAarch64 [ expat ] + # From 12.5, cuda-gdb comes with Python TUI wrappers + ++ lib.optionals (cudaAtLeast "12.5") [ + libxcrypt-legacy + ncurses + python3 + ]; + + # Remove binaries requiring Python3 versions we do not have + postInstall = lib.optionalString (cudaAtLeast "12.5") '' + pushd "''${!outputBin}/bin" >/dev/null + nixLog "removing cuda-gdb-python*-tui binaries for Python 3 versions other than ${python3MajorMinorVersion}" + for pygdb in cuda-gdb-python*-tui; do + if [[ "$pygdb" == "cuda-gdb-python${python3MajorMinorVersion}-tui" ]]; then + continue + fi + nixLog "removing $pygdb" + rm -rf "$pygdb" + done + unset -v pygdb + popd >/dev/null + ''; + + brokenAssertions = [ + { + # TODO(@connorbaker): Figure out which are supported. + message = "python 3 version is supported"; + assertion = true; + } + ]; + + meta = { + description = "NVIDIA tool for debugging CUDA applications on Linux and QNX systems"; + longDescription = '' + CUDA-GDB is the NVIDIA tool for debugging CUDA applications running on Linux and QNX. CUDA-GDB is an extension + to GDB, the GNU Project debugger. The tool provides developers with a mechanism for debugging CUDA + applications running on actual hardware. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-gdb"; + changelog = "https://docs.nvidia.com/cuda/cuda-gdb#release-notes"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nsight.nix b/pkgs/development/cuda-modules/packages/cuda_nsight.nix new file mode 100644 index 000000000000..d47e55f6920d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nsight.nix @@ -0,0 +1,19 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_nsight"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + meta = { + description = "Nsight Eclipse Plugins Edition"; + longDescription = '' + NVIDIA Nsight Eclipse Edition is a unified CPU plus GPU integrated development environment (IDE) for developing + CUDA applications on Linux and Mac OS X for the x86, POWER and ARM platforms. It is designed to help developers + on all stages of the software development process. + ''; + homepage = "https://docs.nvidia.com/cuda/nsight-eclipse-plugins-guide"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvcc.nix b/pkgs/development/cuda-modules/packages/cuda_nvcc.nix new file mode 100644 index 000000000000..47906b5977c1 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvcc.nix @@ -0,0 +1,178 @@ +{ + _cuda, + backendStdenv, + buildRedist, + cudaAtLeast, + cudaOlder, + cuda_cccl, + lib, + libnvvm, +}: +buildRedist (finalAttrs: { + redistName = "cuda"; + pname = "cuda_nvcc"; + + # NOTE: We restrict cuda_nvcc to a single output to avoid breaking consumers which expect NVCC to be within a single + # directory structure. This happens partly because NVCC is also home to NVVM. + outputs = [ + "out" + ]; + + # The nvcc and cicc binaries contain hard-coded references to /usr + allowFHSReferences = true; + + # Entries here will be in nativeBuildInputs when cuda_nvcc is in nativeBuildInputs + propagatedBuildInputs = [ backendStdenv.cc ]; + + # Patch the nvcc.profile. + # Syntax: + # - `=` for assignment, + # - `?=` for conditional assignment, + # - `+=` to "prepend", + # - `=+` to "append". + + # Cf. https://web.archive.org/web/20220912081901/https://developer.download.nvidia.com/compute/DevZone/docs/html/C/doc/nvcc.pdf + + # We set all variables with the lowest priority (=+), but we do force + # nvcc to use the fixed backend toolchain. Cf. comments in + # backend-stdenv.nix + + # As an example, here's the nvcc.profile for CUDA 11.8-12.4 (yes, that is a leading newline): + + # + # TOP = $(_HERE_)/.. + # + # NVVMIR_LIBRARY_DIR = $(TOP)/$(_NVVM_BRANCH_)/libdevice + # + # LD_LIBRARY_PATH += $(TOP)/lib: + # PATH += $(TOP)/$(_NVVM_BRANCH_)/bin:$(_HERE_): + # + # INCLUDES += "-I$(TOP)/$(_TARGET_DIR_)/include" $(_SPACE_) + # + # LIBRARIES =+ $(_SPACE_) "-L$(TOP)/$(_TARGET_DIR_)/lib$(_TARGET_SIZE_)/stubs" "-L$(TOP)/$(_TARGET_DIR_)/lib$(_TARGET_SIZE_)" + # + # CUDAFE_FLAGS += + # PTXAS_FLAGS += + + # And here's the nvcc.profile for CUDA 12.5: + + # + # TOP = $(_HERE_)/.. + # + # CICC_PATH = $(TOP)/nvvm/bin + # CICC_NEXT_PATH = $(TOP)/nvvm-next/bin + # NVVMIR_LIBRARY_DIR = $(TOP)/nvvm/libdevice + # + # LD_LIBRARY_PATH += $(TOP)/lib: + # PATH += $(CICC_PATH):$(_HERE_): + # + # INCLUDES += "-I$(TOP)/$(_TARGET_DIR_)/include" $(_SPACE_) + # + # LIBRARIES =+ $(_SPACE_) "-L$(TOP)/$(_TARGET_DIR_)/lib$(_TARGET_SIZE_)/stubs" "-L$(TOP)/$(_TARGET_DIR_)/lib$(_TARGET_SIZE_)" + # + # CUDAFE_FLAGS += + # PTXAS_FLAGS += + + postInstall = + let + # TODO: Should we also patch the LIBRARIES line's use of $(TOP)/$(_TARGET_DIR_)? + oldNvvmDir = lib.concatStringsSep "/" ( + [ "$(TOP)" ] + ++ lib.optionals (cudaOlder "12.5") [ "$(_NVVM_BRANCH_)" ] + ++ lib.optionals (cudaAtLeast "12.5") [ "nvvm" ] + ); + newNvvmDir = ''''${!outputBin:?}/nvvm''; + in + lib.optionalString finalAttrs.finalPackage.meta.available ( + # From CUDA 13.0, NVVM is available as a separate library and not bundled in the NVCC redist. + lib.optionalString (cudaOlder "13.0") '' + nixLog "moving $PWD/nvvm to ''${!outputBin:?} and renaming lib64 to lib" + moveToOutput "nvvm" "''${!outputBin:?}" + mv --verbose --no-clobber "${newNvvmDir}/lib64" "${newNvvmDir}/lib" + '' + # NVVM is unpacked and made top-level; we cannot make a symlink to it because build systems (like CMake) + # may take the target and do relative path operations to it. + + lib.optionalString (cudaAtLeast "13.0") '' + nixLog "copying ${libnvvm} to ${newNvvmDir} and fixing permissions" + cp -rv "${libnvvm}" "${newNvvmDir}" + chmod -Rv u+w "${newNvvmDir}" + '' + # Unconditional patching to remove the use of $(_TARGET_SIZE_) since we don't use lib64 in Nixpkgs + + '' + nixLog 'removing $(_TARGET_SIZE_) from nvcc.profile' + substituteInPlace "''${!outputBin:?}/bin/nvcc.profile" \ + --replace-fail \ + '$(_TARGET_SIZE_)' \ + "" + '' + # CUDA 13.0+ introduced + # SYSTEM_INCLUDES += "-isystem" "$(TOP)/$(_TARGET_DIR_)/include/cccl" $(_SPACE_) + # so we need to make sure to patch the reference to cccl. + + lib.optionalString (cudaAtLeast "13.0") '' + nixLog "patching nvcc.profile to include correct path to cccl" + substituteInPlace "''${!outputBin:?}/bin/nvcc.profile" \ + --replace-fail \ + '$(TOP)/$(_TARGET_DIR_)/include/cccl' \ + "${lib.getOutput "include" cuda_cccl}/include" + '' + # Unconditional patching to switch to the correct include paths. + # NOTE: _TARGET_DIR_ appears to be used for the target architecture, which is relevant for cross-compilation. + + '' + nixLog "patching nvcc.profile to use the correct include paths" + substituteInPlace "''${!outputBin:?}/bin/nvcc.profile" \ + --replace-fail \ + '$(TOP)/$(_TARGET_DIR_)/include' \ + "''${!outputInclude:?}/include" + '' + # Fixup the nvcc.profile to use the correct paths for NVVM. + # NOTE: In our replacement substitution, we use double quotes to allow for variable expansion. + # NOTE: We use a trailing slash only on the NVVM directory replacement to prevent partial matches. + + '' + nixLog "patching nvcc.profile to use the correct NVVM paths" + substituteInPlace "''${!outputBin:?}/bin/nvcc.profile" \ + --replace-fail \ + '${oldNvvmDir}/' \ + "${newNvvmDir}/" + + nixLog "adding ${newNvvmDir} to nvcc.profile" + cat << EOF >> "''${!outputBin:?}/bin/nvcc.profile" + + # Expose the split-out nvvm + LIBRARIES =+ \$(_SPACE_) "-L${newNvvmDir}/lib" + INCLUDES =+ \$(_SPACE_) "-I${newNvvmDir}/include" + EOF + '' + # Add the dependency on backendStdenv.cc to the nvcc.profile. + + '' + nixLog "adding backendStdenv.cc to nvcc.profile" + cat << EOF >> "''${!outputBin:?}/bin/nvcc.profile" + + # Fix a compatible backend compiler + PATH += "${backendStdenv.cc}/bin": + EOF + '' + ); + + brokenAssertions = [ + # TODO(@connorbaker): Build fails on x86 when using pkgsLLVM. + # .../include/crt/host_defines.h:67:2: + # error: "libc++ is not supported on x86 system" + # + # 67 | #error "libc++ is not supported on x86 system" + # | ^ + # + # 1 error generated. + # + # # --error 0x1 -- + { + message = "cannot use libc++ on x86_64-linux"; + assertion = backendStdenv.hostNixSystem == "x86_64-linux" -> backendStdenv.cc.libcxx == null; + } + ]; + + meta = { + description = "CUDA compiler driver"; + homepage = "https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc"; + mainProgram = "nvcc"; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/cuda_nvdisasm.nix b/pkgs/development/cuda-modules/packages/cuda_nvdisasm.nix new file mode 100644 index 000000000000..981a0ce420a7 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvdisasm.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvdisasm"; + + outputs = [ "out" ]; + + meta = { + description = "Extracts information from standalone cubin files and presents them in human readable format"; + longDescription = '' + `nvdisasm` extracts information from standalone cubin files and presents them in human readable format. The + output of `nvdisasm` includes CUDA assembly code for each kernel, listing of ELF data sections and other CUDA + specific sections. Output style and options are controlled through `nvdisasm` command-line options. `nvdisasm` + also does control flow analysis to annotate jump/branch targets and makes the output easier to read. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-binary-utilities#nvdisasm"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvml_dev.nix b/pkgs/development/cuda-modules/packages/cuda_nvml_dev.nix new file mode 100644 index 000000000000..cb97f2c76210 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvml_dev.nix @@ -0,0 +1,45 @@ +{ buildRedist, lib }: +buildRedist (finalAttrs: { + redistName = "cuda"; + pname = "cuda_nvml_dev"; + + outputs = [ + "out" + "dev" + "include" + "stubs" + ]; + + # TODO(@connorbaker): Add a setup hook to the outputStubs output to automatically replace rpath entries + # containing the stubs output with the driver link. + + allowFHSReferences = true; + + # Include the stubs output since it provides libnvidia-ml.so. + propagatedBuildOutputs = lib.optionals (lib.elem "stubs" finalAttrs.outputs) [ "stubs" ]; + + # TODO: Some programs try to link against libnvidia-ml.so.1, so make an alias. + # Not sure about the version number though! + postInstall = lib.optionalString (lib.elem "stubs" finalAttrs.outputs) '' + pushd "''${!outputStubs:?}/lib/stubs" >/dev/null + if [[ -f libnvidia-ml.so && ! -f libnvidia-ml.so.1 ]]; then + nixLog "creating versioned symlink for libnvidia-ml.so stub" + ln -sr libnvidia-ml.so libnvidia-ml.so.1 + fi + if [[ -f libnvidia-ml.a && ! -f libnvidia-ml.a.1 ]]; then + nixLog "creating versioned symlink for libnvidia-ml.a stub" + ln -sr libnvidia-ml.a libnvidia-ml.a.1 + fi + popd >/dev/null + ''; + + meta = { + description = "C-based programmatic interface for monitoring and managing various states within Data Center GPUs"; + longDescription = '' + The NVIDIA Management Library (NVML) is a C-based programmatic interface for monitoring and managing various + states within Data Center GPUs. It is intended to be a platform for building 3rd party applications, and is also + the underlying library for the NVIDIA-supported nvidia-smi tool. + ''; + homepage = "https://developer.nvidia.com/management-library-nvml"; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/cuda_nvprof.nix b/pkgs/development/cuda-modules/packages/cuda_nvprof.nix new file mode 100644 index 000000000000..994e6ea1126d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvprof.nix @@ -0,0 +1,43 @@ +{ + backendStdenv, + buildRedist, + cuda_cupti, + cudaAtLeast, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvprof"; + + allowFHSReferences = true; + + outputs = [ + "out" + ] + # The `bin` and `lib` output are only available on SBSA starting with CUDA 11.8. + ++ lib.optionals (backendStdenv.hostRedistSystem != "linux-sbsa" || cudaAtLeast "11.8") [ + "bin" + "lib" + ]; + + buildInputs = [ + cuda_cupti + ]; + + autoPatchelfIgnoreMissingDeps = [ + "libcuda.so.1" + ]; + + meta = { + description = "Collect and view profiling data from the command-line"; + longDescription = '' + The `nvprof` profiling tool enables you to collect and view profiling data from the command-line. `nvprof` + enables the collection of a timeline of CUDA-related activities on both CPU and GPU, including kernel execution, + memory transfers, memory set and CUDA API calls and events or metrics for CUDA kernels. Profiling options are + provided to `nvprof` through command-line options. Profiling results are displayed in the console after the + profiling data is collected, and may also be saved for later viewing by either `nvprof` or the Visual Profiler. + ''; + homepage = "https://docs.nvidia.com/cuda/profiler-users-guide#nvprof"; + changelog = "https://docs.nvidia.com/cuda/profiler-users-guide#changelog"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvprune.nix b/pkgs/development/cuda-modules/packages/cuda_nvprune.nix new file mode 100644 index 000000000000..db3c7b60e6f5 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvprune.nix @@ -0,0 +1,15 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvprune"; + + outputs = [ "out" ]; + + meta = { + description = "Prune host object files and libraries to only contain device code for the specified targets"; + longDescription = '' + `nvprune` prunes host object files and libraries to only contain device code for the specified targets. + ''; + homepage = "https://docs.nvidia.com/cuda/cuda-binary-utilities#nvprune"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvrtc.nix b/pkgs/development/cuda-modules/packages/cuda_nvrtc.nix new file mode 100644 index 000000000000..d3cc276ab67e --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvrtc.nix @@ -0,0 +1,29 @@ +{ + buildRedist, + cudaAtLeast, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvrtc"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ] + ++ lib.optionals (cudaAtLeast "11.5") [ "static" ] + ++ [ "stubs" ]; + + allowFHSReferences = true; + + meta = { + description = "Runtime compilation library for CUDA C++"; + longDescription = '' + NVRTC is a runtime compilation library for CUDA C++. It accepts CUDA C++ source code in character string form + and creates handles that can be used to obtain the PTX. + ''; + homepage = "https://docs.nvidia.com/cuda/nvrtc"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvtx.nix b/pkgs/development/cuda-modules/packages/cuda_nvtx.nix new file mode 100644 index 000000000000..ef079fe0110d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvtx.nix @@ -0,0 +1,23 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvtx"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "C-based Application Programming Interface (API) for annotating events, code ranges, and resources in your applications"; + longDescription = '' + NVTX is a cross-platform API for annotating source code to provide contextual information to developer tools. + + The NVTX API is written in C, with wrappers provided for C++ and Python. + ''; + homepage = "https://github.com/NVIDIA/NVTX"; + changelog = "https://github.com/NVIDIA/NVTX/releases"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_nvvp.nix b/pkgs/development/cuda-modules/packages/cuda_nvvp.nix new file mode 100644 index 000000000000..8aeb178a2ace --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_nvvp.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_nvvp"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + meta = { + description = "Cross-platform performance profiling tool for optimizing CUDA C/C++ applications"; + longDescription = '' + The NVIDIA Visual Profiler is a cross-platform performance profiling tool that delivers developers vital + feedback for optimizing CUDA C/C++ applications. + ''; + homepage = "https://developer.nvidia.com/nvidia-visual-profiler"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_opencl.nix b/pkgs/development/cuda-modules/packages/cuda_opencl.nix new file mode 100644 index 000000000000..50d94e44dbea --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_opencl.nix @@ -0,0 +1,22 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_opencl"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "Low-level API for heterogeneous computing that runs on CUDA-powered GPUs"; + longDescription = '' + OpenCL™ (Open Computing Language) is a low-level API for heterogeneous computing that runs on CUDA-powered GPUs. + Using the OpenCL API, developers can launch compute kernels written using a limited subset of the C programming + language on a GPU. + ''; + homepage = "https://developer.nvidia.com/opencl"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_profiler_api.nix b/pkgs/development/cuda-modules/packages/cuda_profiler_api.nix new file mode 100644 index 000000000000..39a90d72df2c --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_profiler_api.nix @@ -0,0 +1,13 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_profiler_api"; + + outputs = [ + "out" + "dev" + "include" + ]; + + meta.description = "API for profiling CUDA runtime"; +} diff --git a/pkgs/development/cuda-modules/packages/cuda_sanitizer_api.nix b/pkgs/development/cuda-modules/packages/cuda_sanitizer_api.nix new file mode 100644 index 000000000000..eab5b6c35cb2 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuda_sanitizer_api.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "cuda_sanitizer_api"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + meta = { + description = "Enables the creation of sanitizing and tracing tools that target CUDA applications"; + longDescription = '' + The Compute Sanitizer API enables the creation of sanitizing and tracing tools that target CUDA applications. + Examples of such tools are memory and race condition checkers. + ''; + homepage = "https://docs.nvidia.com/compute-sanitizer/SanitizerApiGuide"; + }; +} diff --git a/pkgs/development/cuda-modules/cudatoolkit/redist-wrapper.nix b/pkgs/development/cuda-modules/packages/cudatoolkit.nix similarity index 85% rename from pkgs/development/cuda-modules/cudatoolkit/redist-wrapper.nix rename to pkgs/development/cuda-modules/packages/cudatoolkit.nix index 56ef05a09d6c..4df552d048cc 100644 --- a/pkgs/development/cuda-modules/cudatoolkit/redist-wrapper.nix +++ b/pkgs/development/cuda-modules/packages/cudatoolkit.nix @@ -26,11 +26,10 @@ }: let - getAllOutputs = p: [ - (lib.getBin p) - (lib.getLib p) - (lib.getDev p) - ]; + # Retrieve all the outputs of a package except for the "static" output. + getAllOutputs = + p: lib.concatMap (output: lib.optionals (output != "static") [ p.${output} ]) p.outputs; + hostPackages = [ cuda_cuobjdump cuda_gdb @@ -73,8 +72,9 @@ symlinkJoin rec { }; }; - meta = with lib; { + meta = { description = "Wrapper substituting the deprecated runfile-based CUDA installation"; - license = licenses.nvidiaCuda; + license = lib.licenses.nvidiaCudaRedist; + teams = [ lib.teams.cuda ]; }; } diff --git a/pkgs/development/cuda-modules/packages/cudnn-frontend/package.nix b/pkgs/development/cuda-modules/packages/cudnn-frontend/package.nix index b9e622b9f31e..79a19e321b39 100644 --- a/pkgs/development/cuda-modules/packages/cudnn-frontend/package.nix +++ b/pkgs/development/cuda-modules/packages/cudnn-frontend/package.nix @@ -1,21 +1,23 @@ { autoAddDriverRunpath, + backendStdenv, catch2_3, cmake, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cuda_nvrtc, + cudaNamePrefix, + cudnn, fetchFromGitHub, gitUpdater, lib, + libcublas, ninja, nlohmann_json, - stdenv, - cuda_cccl ? null, - cuda_cudart ? null, - cuda_nvcc ? null, - cuda_nvrtc ? null, - cudnn ? null, - libcublas ? null, }: let + inherit (lib) licenses maintainers teams; inherit (lib.lists) optionals; inherit (lib.strings) cmakeBool @@ -23,9 +25,14 @@ let optionalString ; in - # TODO(@connorbaker): This should be a hybrid C++/Python package. -stdenv.mkDerivation (finalAttrs: { +backendStdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: Depends on the CUDA package set, so use cudaNamePrefix. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "cudnn-frontend"; version = "1.9.0"; @@ -46,9 +53,9 @@ stdenv.mkDerivation (finalAttrs: { # nlohmann_json should be the only vendored dependency. postPatch = '' - echo "patching source to use nlohmann_json from nixpkgs" - rm -rf include/cudnn_frontend/thirdparty/nlohmann - rmdir include/cudnn_frontend/thirdparty + nixLog "patching source to use nlohmann_json from nixpkgs" + rm -rfv include/cudnn_frontend/thirdparty/nlohmann + rmdir -v include/cudnn_frontend/thirdparty substituteInPlace include/cudnn_frontend_utils.h \ --replace-fail \ '#include "cudnn_frontend/thirdparty/nlohmann/json.hpp"' \ @@ -120,13 +127,14 @@ stdenv.mkDerivation (finalAttrs: { meta = { description = "A c++ wrapper for the cudnn backend API"; homepage = "https://github.com/NVIDIA/cudnn-frontend"; - license = lib.licenses.mit; - badPlatforms = optionals (cudnn == null) finalAttrs.meta.platforms; + license = licenses.mit; + # TODO(@connorbaker): How tightly coupled is this library to specific cuDNN versions? + # Should it be marked as broken if it doesn't match our expected version? platforms = [ "aarch64-linux" "x86_64-linux" ]; - maintainers = with lib.maintainers; [ connorbaker ]; - teams = [ lib.teams.cuda ]; + maintainers = [ maintainers.connorbaker ]; + teams = [ teams.cuda ]; }; }) diff --git a/pkgs/development/cuda-modules/packages/cudnn.nix b/pkgs/development/cuda-modules/packages/cudnn.nix new file mode 100644 index 000000000000..9dec6fbf5fbb --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cudnn.nix @@ -0,0 +1,77 @@ +{ + _cuda, + buildRedist, + lib, + libcublas, + patchelf, + zlib, +}: +buildRedist (finalAttrs: { + redistName = "cudnn"; + pname = "cudnn"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + buildInputs = [ + # NOTE: Verions of CUDNN after 9.0 no longer depend on libcublas: + # https://docs.nvidia.com/deeplearning/cudnn/latest/release-notes.html?highlight=cublas#cudnn-9-0-0 + # However, NVIDIA only provides libcublasLT via the libcublas package. + (lib.getLib libcublas) + zlib + ]; + + # Tell autoPatchelf about runtime dependencies. *_infer* libraries only + # exist in CuDNN 8. + # NOTE: Versions from CUDNN releases have four components. + postFixup = + lib.optionalString + (lib.versionAtLeast finalAttrs.version "8.0.5.0" && lib.versionOlder finalAttrs.version "9.0.0.0") + '' + ${lib.getExe patchelf} $lib/lib/libcudnn.so --add-needed libcudnn_cnn_infer.so + ${lib.getExe patchelf} $lib/lib/libcudnn_ops_infer.so --add-needed libcublas.so --add-needed libcublasLt.so + ''; + + # TODO(@connorbaker): Broken conditions for cuDNN used out of scope. + # platformAssertions = + # let + # cudaTooOld = cudaOlder finalAttrs.passthru.featureRelease.minCudaVersion; + # cudaTooNew = + # (finalAttrs.passthru.featureRelease.maxCudaVersion != null) + # && lib.versionOlder finalAttrs.passthru.featureRelease.maxCudaVersion cudaMajorMinorVersion; + # in + # prevAttrs.passthru.platformAssertions or [ ] + # ++ [ + # { + # message = "CUDA version is too old"; + # assertion = cudaTooOld; + # } + # { + # message = "CUDA version is too new"; + # assertion = cudaTooNew; + # } + # ]; + + meta = { + description = "GPU-accelerated library of primitives for deep neural networks"; + longDescription = '' + The NVIDIA CUDA Deep Neural Network library (cuDNN) is a GPU-accelerated library of primitives for deep neural + networks. + ''; + homepage = "https://developer.nvidia.com/cudnn"; + changelog = "https://docs.nvidia.com/deeplearning/cudnn/backend/latest/release-notes.html"; + + license = _cuda.lib.licenses.cudnn; + + maintainers = with lib.maintainers; [ + mdaiter + samuela + connorbaker + ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/cuquantum.nix b/pkgs/development/cuda-modules/packages/cuquantum.nix new file mode 100644 index 000000000000..b9fed9c551c0 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cuquantum.nix @@ -0,0 +1,42 @@ +{ + buildRedist, + cuda_cudart, + libcublas, + libcurand, + libcusolver, + libcutensor, +}: +buildRedist { + redistName = "cuquantum"; + pname = "cuquantum"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + buildInputs = [ + cuda_cudart + libcublas + libcurand + libcusolver + libcutensor + ]; + + autoPatchelfIgnoreMissingDeps = [ + "libnvidia-ml.so.1" + ]; + + meta = { + description = "Set of high-performance libraries and tools for accelerating quantum computing simulations at both the circuit and device level by orders of magnitude"; + longDescription = '' + NVIDIA cuQuantum SDK is a set of high-performance libraries and tools for accelerating quantum computing + simulations at both the circuit and device level by orders of magnitude. + ''; + homepage = "https://developer.nvidia.com/cuquantum-sdk"; + changelog = "https://docs.nvidia.com/cuda/cuquantum/latest/cuquantum-sdk-release-notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/cutlass.nix b/pkgs/development/cuda-modules/packages/cutlass.nix new file mode 100644 index 000000000000..c6e0126504f0 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/cutlass.nix @@ -0,0 +1,232 @@ +{ + _cuda, + addDriverRunpath, + backendStdenv, + cmake, + cuda_cudart, + cuda_nvcc, + cuda_nvrtc, + cudaNamePrefix, + cudnn, + fetchFromGitHub, + flags, + gtest, + lib, + libcublas, + libcurand, + ninja, + python3Packages, + # Options + pythonSupport ? true, + enableF16C ? false, + enableTools ? false, + # passthru.updateScript + gitUpdater, +}: +let + inherit (_cuda.lib) _mkMetaBadPlatforms; + inherit (lib) licenses maintainers teams; + inherit (lib.asserts) assertMsg; + inherit (lib.attrsets) getBin; + inherit (lib.lists) all optionals; + inherit (lib.strings) + cmakeBool + cmakeFeature + optionalString + versionAtLeast + ; + inherit (lib.trivial) flip; +in +# TODO: Tests. +assert assertMsg (!enableTools) "enableTools is not yet implemented"; +backendStdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + # NOTE: Depends on the CUDA package set, so use cudaNamePrefix. + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "cutlass"; + version = "3.9.2"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "cutlass"; + tag = "v${finalAttrs.version}"; + hash = "sha256-teziPNA9csYvhkG5t2ht8W8x5+1YGGbHm8VKx4JoxgI="; + }; + + # TODO: As a header-only library, we should make sure we have an `include` directory or similar which is not a + # superset of the `out` (`bin`) or `dev` outputs (whih is what the multiple-outputs setup hook does by default). + outputs = [ "out" ] ++ optionals pythonSupport [ "dist" ]; + + nativeBuildInputs = [ + cuda_nvcc + cmake + ninja + python3Packages.python # Python is always required + ] + ++ optionals pythonSupport ( + with python3Packages; + [ + build + pythonOutputDistHook + setuptools + ] + ); + + postPatch = + # Prepend some commands to the CUDA.cmake file so it can find the CUDA libraries using CMake's FindCUDAToolkit + # module. These target names are used throughout the project; I (@connorbaker) did not choose them. + '' + nixLog "patching CUDA.cmake to use FindCUDAToolkit" + mv ./CUDA.cmake ./_CUDA_Append.cmake + cat > ./_CUDA_Prepend.cmake <<'EOF' + find_package(CUDAToolkit REQUIRED) + foreach(_target cudart cuda_driver nvrtc) + if (NOT TARGET CUDA::''${_target}) + message(FATAL_ERROR "''${_target} Not Found") + endif() + message(STATUS "''${_target} library: ''${CUDA_''${_target}_LIBRARY}") + add_library(''${_target} ALIAS CUDA::''${_target}) + endforeach() + EOF + cat ./_CUDA_Prepend.cmake ./_CUDA_Append.cmake > ./CUDA.cmake + '' + # Patch cutlass to use the provided NVCC. + # '_CUDA_INSTALL_PATH = os.getenv("CUDA_INSTALL_PATH", _cuda_install_path_from_nvcc())' \ + # '_CUDA_INSTALL_PATH = "${getBin cuda_nvcc}"' + + '' + nixLog "patching python bindings to make cuda_install_path fail" + substituteInPlace ./python/cutlass/__init__.py \ + --replace-fail \ + 'def cuda_install_path():' \ + ' + def cuda_install_path(): + raise RuntimeException("not supported with Nixpkgs CUDA packaging") + ' + '' + # Patch the python bindings to use environment variables set by Nixpkgs. + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L80 + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L81 + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L317 + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L319 + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L344 + # https://github.com/NVIDIA/cutlass/blob/e94e888df3551224738bfa505787b515eae8352f/python/cutlass/backend/compiler.py#L360 + + '' + nixLog "patching python bindings to use environment variables" + substituteInPlace ./python/cutlass/backend/compiler.py \ + --replace-fail \ + 'self.include_paths = include_paths' \ + 'self.include_paths = include_paths + [root + "/include" for root in os.getenv("CUDAToolkit_ROOT").split(";")]' \ + --replace-fail \ + 'self.flags = flags' \ + 'self.flags = flags + ["-L" + root + "/lib" for root in os.getenv("CUDAToolkit_ROOT").split(";")]' \ + --replace-fail \ + "\''${cuda_install_path}/bin/nvcc" \ + '${getBin cuda_nvcc}/bin/nvcc' \ + --replace-fail \ + '"cuda_install_path": cuda_install_path(),' \ + "" \ + --replace-fail \ + 'f"{cuda_install_path()}/bin/nvcc"' \ + '"${getBin cuda_nvcc}/bin/nvcc"' \ + --replace-fail \ + 'cuda_install_path() + "/include",' \ + "" + ''; + + enableParallelBuilding = true; + + buildInputs = [ + cuda_cudart + cuda_nvrtc + libcurand + ] + ++ optionals enableTools [ + cudnn + libcublas + ]; + + cmakeFlags = [ + (cmakeFeature "CUTLASS_NVCC_ARCHS" flags.cmakeCudaArchitecturesString) + (cmakeBool "CUTLASS_ENABLE_EXAMPLES" false) + + # Tests. + (cmakeBool "CUTLASS_ENABLE_TESTS" finalAttrs.doCheck) + (cmakeBool "CUTLASS_ENABLE_GTEST_UNIT_TESTS" finalAttrs.doCheck) + (cmakeBool "CUTLASS_USE_SYSTEM_GOOGLETEST" true) + + # NOTE: Both CUDNN and CUBLAS can be used by the examples and the profiler. Since they are large dependencies, they + # are disabled by default. + (cmakeBool "CUTLASS_ENABLE_TOOLS" enableTools) + (cmakeBool "CUTLASS_ENABLE_CUBLAS" enableTools) + (cmakeBool "CUTLASS_ENABLE_CUDNN" enableTools) + + # NOTE: Requires x86_64 and hardware support. + (cmakeBool "CUTLASS_ENABLE_F16C" enableF16C) + + # TODO: Unity builds are supposed to reduce build time, but this seems to just reduce the number of tasks + # generated? + # NOTE: Good explanation of unity builds: + # https://www.methodpark.de/blog/how-to-speed-up-clang-tidy-with-unity-builds. + (cmakeBool "CUTLASS_UNITY_BUILD_ENABLED" false) + ]; + + postBuild = lib.optionalString pythonSupport '' + pushd "$NIX_BUILD_TOP/$sourceRoot" + nixLog "building Python wheel" + pyproject-build \ + --no-isolation \ + --outdir "$NIX_BUILD_TOP/$sourceRoot/''${cmakeBuildDir:?}/dist/" \ + --wheel + popd >/dev/null + ''; + + doCheck = false; + + checkInputs = [ gtest ]; + + # NOTE: Because the test cases immediately create and try to run the binaries, we don't have an opportunity + # to patch them with autoAddDriverRunpath. To get around this, we add the driver runpath to the environment. + # TODO: This would break Jetson when using cuda_compat, as it must come first. + preCheck = optionalString finalAttrs.doCheck '' + export LD_LIBRARY_PATH="$(readlink -mnv "${addDriverRunpath.driverLink}/lib")" + ''; + + # This is *not* a derivation you want to build on a small machine. + requiredSystemFeatures = optionals finalAttrs.doCheck [ + "big-parallel" + "cuda" + ]; + + passthru = { + updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; + # TODO: + # tests.test = cutlass.overrideAttrs { doCheck = true; }; + + # Include required architectures in compatibility check. + # https://github.com/NVIDIA/cutlass/tree/main?tab=readme-ov-file#compatibility + platformAssertions = [ + { + message = "all capabilities are >= 7.0 (${builtins.toJSON flags.cudaCapabilities})"; + assertion = all (flip versionAtLeast "7.0") flags.cudaCapabilities; + } + ]; + }; + + meta = { + description = "CUDA Templates for Linear Algebra Subroutines"; + homepage = "https://github.com/NVIDIA/cutlass"; + license = licenses.asl20; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + badPlatforms = _mkMetaBadPlatforms finalAttrs; + maintainers = [ maintainers.connorbaker ]; + teams = [ teams.cuda ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/fabricmanager.nix b/pkgs/development/cuda-modules/packages/fabricmanager.nix new file mode 100644 index 000000000000..a380c3de5d9b --- /dev/null +++ b/pkgs/development/cuda-modules/packages/fabricmanager.nix @@ -0,0 +1,19 @@ +{ buildRedist, zlib }: +buildRedist { + redistName = "cuda"; + pname = "fabricmanager"; + + outputs = [ + "out" + "bin" + "dev" + "include" + "lib" + ]; + + allowFHSReferences = true; + + buildInputs = [ zlib ]; + + meta.homepage = "https://docs.nvidia.com/datacenter/tesla/fabric-manager-user-guide"; +} diff --git a/pkgs/development/cuda-modules/packages/gdrcopy.nix b/pkgs/development/cuda-modules/packages/gdrcopy.nix new file mode 100644 index 000000000000..433b8b3f3130 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/gdrcopy.nix @@ -0,0 +1,113 @@ +{ + _cuda, + backendStdenv, + cuda_cudart, + cuda_nvcc, + cudaMajorMinorVersion, + cudaNamePrefix, + fetchFromGitHub, + flags, + lib, + # passthru.updateScript + gitUpdater, +}: +let + inherit (_cuda.lib) _mkMetaBadPlatforms; + inherit (lib) licenses maintainers teams; +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 = "gdrcopy"; + version = "2.5.1"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "gdrcopy"; + tag = "v${finalAttrs.version}"; + hash = "sha256-2cDsDc1lGW9rNF1q3EhjmiJhNaIwuFYlNdooPe7/R2I="; + }; + + outputs = [ "out" ]; + + nativeBuildInputs = [ + cuda_nvcc + ]; + + postPatch = '' + nixLog "patching shebang in $PWD/config_arch" + patchShebangs "$PWD/config_arch" + + nixLog "patching awk expression in $PWD/Makefile" + substituteInPlace "$PWD/Makefile" \ + --replace-fail \ + "/\#" \ + "/#" \ + --replace-fail \ + 'lib64' \ + 'lib' + + nixLog "patching $PWD/src/Makefile" + substituteInPlace "$PWD/src/Makefile" \ + --replace-fail \ + "/\#" \ + "/#" + + nixLog "patching $PWD/tests/Makefile" + substituteInPlace "$PWD/tests/Makefile" \ + --replace-fail \ + 'CUDA_VERSION := $(shell $(GET_CUDA_VERSION) $(NVCC))' \ + 'CUDA_VERSION := ${cudaMajorMinorVersion}' \ + --replace-fail \ + 'NVCCFLAGS ?= $(shell $(GET_CUDA_GENCODE) $(NVCC)) $(NVCC_STD)' \ + 'NVCCFLAGS ?= ${flags.gencodeString} $(NVCC_STD)' \ + --replace-fail \ + 'lib64' \ + 'lib' + ''; + + enableParallelBuilding = true; + + buildInputs = [ + cuda_cudart + ]; + + buildFlags = [ + # Makefile variables which must be set explicitly + "CUDA=${lib.getLib cuda_cudart}" + "NVCC=${lib.getExe cuda_nvcc}" # TODO: shoud be using cuda_nvcc from pkgsBuildHost + + # Make targets + # NOTE: We cannot use `all` because it includes the driver, which needs the driver source code. + "lib" + "exes" + ]; + + # Tests require gdrdrv be installed (don't know how to communicate dependency on the driver). + doCheck = false; + + installFlags = [ + "DESTDIR=${placeholder "out"}" + "prefix=/" + ]; + + passthru.updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; + + meta = { + description = "Fast GPU memory copy library based on NVIDIA GPUDirect RDMA technology"; + homepage = "https://github.com/NVIDIA/gdrcopy"; + license = licenses.mit; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + maintainers = [ maintainers.connorbaker ]; + teams = [ teams.cuda ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/imex.nix b/pkgs/development/cuda-modules/packages/imex.nix new file mode 100644 index 000000000000..1325f7044d3d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/imex.nix @@ -0,0 +1,16 @@ +{ buildRedist, zlib }: +buildRedist { + redistName = "cuda"; + pname = "imex"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + buildInputs = [ zlib ]; + + meta = { + description = "Service which supports GPU memory export and import (NVLink P2P) and shared memory operations across OS domains in an NVLink multi-node deployment"; + homepage = "https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcublas.nix b/pkgs/development/cuda-modules/packages/libcublas.nix new file mode 100644 index 000000000000..0606bba7eb5d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcublas.nix @@ -0,0 +1,22 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libcublas"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "CUDA Basic Linear Algebra Subroutine library"; + longDescription = '' + The cuBLAS library is an implementation of BLAS (Basic Linear Algebra Subprograms) on top of the NVIDIA CUDA runtime. + ''; + homepage = "https://developer.nvidia.com/cublas"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcublasmp.nix b/pkgs/development/cuda-modules/packages/libcublasmp.nix new file mode 100644 index 000000000000..cd77b6dcb56a --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcublasmp.nix @@ -0,0 +1,43 @@ +{ + _cuda, + buildRedist, + libcublas, + libnvshmem, + nccl, +}: +buildRedist { + redistName = "cublasmp"; + pname = "libcublasmp"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + # TODO: Looks like the minimum supported capability is 7.0 as of the latest: + # https://docs.nvidia.com/cuda/cublasmp/getting_started/index.html + buildInputs = [ + libcublas + libnvshmem + nccl + ]; + + autoPatchelfIgnoreMissingDeps = [ + "libcuda.so.1" + ]; + + meta = { + description = "High-performance, multi-process, GPU-accelerated library for distributed basic dense linear algebra"; + longDescription = '' + NVIDIA cuBLASMp is a high-performance, multi-process, GPU-accelerated library for distributed basic dense linear + algebra. + + cuBLASMp is compatible with 2D block-cyclic data layout and provides PBLAS-like C APIs. + ''; + homepage = "https://docs.nvidia.com/cuda/cublasmp"; + changelog = "https://docs.nvidia.com/cuda/cublasmp/release_notes"; + license = _cuda.lib.licenses.math_sdk_sla; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcudla.nix b/pkgs/development/cuda-modules/packages/libcudla.nix new file mode 100644 index 000000000000..a24a06b80b36 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcudla.nix @@ -0,0 +1,38 @@ +{ + backendStdenv, + buildRedist, + cudaMajorMinorVersion, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "libcudla"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "stubs" + ]; + + autoPatchelfIgnoreMissingDeps = [ + "libnvcudla.so" + ] + ++ lib.optionals (cudaMajorMinorVersion == "11.8") [ + "libcuda.so.1" + "libnvdla_runtime.so" + ]; + + platformAssertions = [ + { + message = "Only Xavier (7.2) and Orin (8.7) Jetson devices are supported"; + assertion = + let + inherit (backendStdenv) hasJetsonCudaCapability requestedJetsonCudaCapabilities; + in + hasJetsonCudaCapability + -> (lib.subtractLists [ "7.2" "8.7" ] requestedJetsonCudaCapabilities == [ ]); + } + ]; +} diff --git a/pkgs/development/cuda-modules/packages/libcudss.nix b/pkgs/development/cuda-modules/packages/libcudss.nix new file mode 100644 index 000000000000..6dc547d592bd --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcudss.nix @@ -0,0 +1,68 @@ +{ + buildRedist, + lib, + libcublas, + mpi, + nccl, +}: +buildRedist { + redistName = "cudss"; + pname = "libcudss"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + buildInputs = [ + libcublas + ] + # MPI brings in NCCL dependency by way of UCC/UCX. + ++ lib.optionals nccl.meta.available [ + mpi + nccl + ]; + + # Update the CMake configurations + postFixup = '' + pushd "''${!outputDev:?}/lib/cmake/cudss" >/dev/null + + nixLog "patching $PWD/cudss-config.cmake to fix relative paths" + substituteInPlace "$PWD/cudss-config.cmake" \ + --replace-fail \ + 'get_filename_component(PACKAGE_PREFIX_DIR "''${CMAKE_CURRENT_LIST_DIR}/../../../../" ABSOLUTE)' \ + "" \ + --replace-fail \ + 'file(REAL_PATH "../../" _cudss_search_prefix BASE_DIRECTORY "''${_cudss_cmake_config_realpath}")' \ + "set(_cudss_search_prefix \"''${!outputDev:?}/lib;''${!outputLib:?}/lib;''${!outputInclude:?}/include\")" + + nixLog "patching $PWD/cudss-static-targets.cmake to fix INTERFACE_LINK_DIRECTORIES for cublas" + sed -Ei \ + 's|INTERFACE_LINK_DIRECTORIES "/usr/local/cuda.*/lib64"|INTERFACE_LINK_DIRECTORIES "${lib.getLib libcublas}/lib"|g' \ + "$PWD/cudss-static-targets.cmake" + if grep -Eq 'INTERFACE_LINK_DIRECTORIES "/usr/local/cuda.*/lib64"' "$PWD/cudss-static-targets.cmake"; then + nixErrorLog "failed to patch $PWD/cudss-static-targets.cmake" + exit 1 + fi + + nixLog "patching $PWD/cudss-static-targets-release.cmake to fix the path to the static library" + substituteInPlace "$PWD/cudss-static-targets-release.cmake" \ + --replace-fail \ + '"''${cudss_LIBRARY_DIR}/libcudss_static.a"' \ + "\"''${!outputStatic:?}/lib/libcudss_static.a\"" + + popd >/dev/null + ''; + + meta = { + description = "Library of GPU-accelerated linear solvers with sparse matrices"; + longDescription = '' + NVIDIA cuDSS (Preview) is a library of GPU-accelerated linear solvers with sparse matrices. + ''; + homepage = "https://developer.nvidia.com/cudss"; + changelog = "https://docs.nvidia.com/cuda/cudss/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcufft.nix b/pkgs/development/cuda-modules/packages/libcufft.nix new file mode 100644 index 000000000000..7b7aa3611936 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcufft.nix @@ -0,0 +1,19 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libcufft"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "High-performance FFT product CUDA library"; + homepage = "https://developer.nvidia.com/cufft"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcufile.nix b/pkgs/development/cuda-modules/packages/libcufile.nix new file mode 100644 index 000000000000..c32a0d0478f1 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcufile.nix @@ -0,0 +1,38 @@ +{ + buildRedist, + cudaOlder, + lib, + numactl, + rdma-core, +}: +buildRedist { + redistName = "cuda"; + pname = "libcufile"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + allowFHSReferences = true; + + # TODO(@connorbaker): At some point before 12.6, libcufile depends on libcublas. + buildInputs = [ + numactl + rdma-core + ]; + + # Before 11.7 libcufile depends on itself for some reason. + autoPatchelfIgnoreMissingDeps = [ + "libcuda.so.1" + ] + ++ lib.optionals (cudaOlder "11.7") [ "libcufile.so.0" ]; + + meta = { + description = "Library to leverage GDS technology"; + homepage = "https://docs.nvidia.com/gpudirect-storage/api-reference-guide"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcurand.nix b/pkgs/development/cuda-modules/packages/libcurand.nix new file mode 100644 index 000000000000..e05287b1c2d0 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcurand.nix @@ -0,0 +1,24 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libcurand"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "Helper module for the cuBLASMp library that allows it to efficiently perform communications between different GPUs"; + longDescription = '' + Communication Abstraction Library (CAL) is a helper module for the cuBLASMp library that allows it to + efficiently perform communications between different GPUs. + ''; + homepage = "https://developer.nvidia.com/curand"; + changelog = "https://docs.nvidia.com/cuda/cublasmp/release_notes"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcusolver.nix b/pkgs/development/cuda-modules/packages/libcusolver.nix new file mode 100644 index 000000000000..0ff5e26d7d52 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcusolver.nix @@ -0,0 +1,39 @@ +{ + buildRedist, + cudaAtLeast, + lib, + libcublas, + libcusparse, + libnvjitlink, +}: +buildRedist { + redistName = "cuda"; + pname = "libcusolver"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + buildInputs = + # Always depends on this + [ (lib.getLib libcublas) ] + # Dependency from 12.0 and on + ++ lib.optionals (cudaAtLeast "12.0") [ libnvjitlink ] + # Dependency from 12.1 and on + ++ lib.optionals (cudaAtLeast "12.1") [ (lib.getLib libcusparse) ]; + + meta = { + description = "Collection of dense and sparse direct linear solvers and Eigen solvers"; + longDescription = '' + The NVIDIA cuSOLVER library provides a collection of dense and sparse direct linear solvers and Eigen solvers + which deliver significant acceleration for Computer Vision, CFD, Computational Chemistry, and Linear + Optimization applications. + ''; + homepage = "https://developer.nvidia.com/cusolver"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcusolvermp.nix b/pkgs/development/cuda-modules/packages/libcusolvermp.nix new file mode 100644 index 000000000000..eb18e2cb7b25 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcusolvermp.nix @@ -0,0 +1,35 @@ +{ + _cuda, + buildRedist, + cuda_cudart, + libcublas, + libcusolver, + nccl, +}: +buildRedist { + redistName = "cusolvermp"; + pname = "libcusolvermp"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + buildInputs = [ + cuda_cudart + libcublas + libcusolver + nccl + ]; + + meta = { + description = "High-performance, distributed-memory, GPU-accelerated library that provides tools for solving dense linear systems and eigenvalue problems"; + longDescription = '' + The NVIDIA cuSOLVERMp library is a high-performance, distributed-memory, GPU-accelerated library that provides + tools for solving dense linear systems and eigenvalue problems. + ''; + homepage = "https://developer.nvidia.com/cusolver"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcusparse.nix b/pkgs/development/cuda-modules/packages/libcusparse.nix new file mode 100644 index 000000000000..959cbf8d343b --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcusparse.nix @@ -0,0 +1,33 @@ +{ + buildRedist, + cudaAtLeast, + lib, + libnvjitlink, +}: +buildRedist { + redistName = "cuda"; + pname = "libcusparse"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + buildInputs = + # Dependency from 12.0 and on + lib.optionals (cudaAtLeast "12.0") [ libnvjitlink ]; + + meta = { + description = "GPU-accelerated basic linear algebra subroutines for sparse matrix computations for unstructured sparsity"; + longDescription = '' + The cuSPARSE APIs provides GPU-accelerated basic linear algebra subroutines for sparse matrix computations for + unstructured sparsity. + ''; + homepage = "https://developer.nvidia.com/cusparse"; + changelog = "https://docs.nvidia.com/cuda/cusparse"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libcusparse_lt.nix b/pkgs/development/cuda-modules/packages/libcusparse_lt.nix new file mode 100644 index 000000000000..9b326baaa96a --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcusparse_lt.nix @@ -0,0 +1,38 @@ +{ + _cuda, + buildRedist, + cuda_cudart, + lib, + libcublas, +}: +buildRedist (finalAttrs: { + redistName = "cusparselt"; + pname = "libcusparse_lt"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + buildInputs = [ + (lib.getLib libcublas) + ] + # For some reason, the 1.4.x release of cusparselt requires the cudart library. + ++ lib.optionals (lib.hasPrefix "1.4" finalAttrs.version) [ (lib.getLib cuda_cudart) ]; + + meta = { + description = "High-performance CUDA library dedicated to general matrix-matrix operations in which at least one operand is a structured sparse matrix with 50% sparsity ratio"; + longDescription = '' + NVIDIA cuSPARSELt is a high-performance CUDA library dedicated to general matrix-matrix operations in which at + least one operand is a structured sparse matrix with 50% sparsity ratio. + ''; + homepage = "https://developer.nvidia.com/cusparselt-downloads"; + changelog = "https://docs.nvidia.com/cuda/cublasmp/release_notes"; + + maintainers = [ lib.maintainers.sepiabrown ]; + license = _cuda.lib.licenses.cusparse_lt; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/libcutensor.nix b/pkgs/development/cuda-modules/packages/libcutensor.nix new file mode 100644 index 000000000000..0b193619021d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libcutensor.nix @@ -0,0 +1,42 @@ +{ + _cuda, + buildRedist, + cuda_cudart, + lib, + libcublas, +}: +buildRedist (finalAttrs: { + redistName = "cutensor"; + pname = "libcutensor"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + allowFHSReferences = true; + + buildInputs = [ + (lib.getLib libcublas) + ] + # For some reason, the 1.4.x release of cuTENSOR requires the cudart library. + ++ lib.optionals (lib.hasPrefix "1.4" finalAttrs.version) [ (lib.getLib cuda_cudart) ]; + + meta = { + description = "GPU-accelerated tensor linear algebra library for tensor contraction, reduction, and elementwise operations"; + longDescription = '' + NVIDIA cuTENSOR is a GPU-accelerated tensor linear algebra library for tensor contraction, reduction, and + elementwise operations. Using cuTENSOR, applications can harness the specialized tensor cores on NVIDIA GPUs for + high-performance tensor computations and accelerate deep learning training and inference, computer vision, + quantum chemistry, and computational physics workloads. + ''; + homepage = "https://developer.nvidia.com/cutensor"; + changelog = "https://docs.nvidia.com/cuda/cutensor/latest/release_notes.html"; + + maintainers = [ lib.maintainers.obsidian-systems-maintenance ]; + license = _cuda.lib.licenses.cutensor; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/libnpp.nix b/pkgs/development/cuda-modules/packages/libnpp.nix new file mode 100644 index 000000000000..5527345a6aab --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnpp.nix @@ -0,0 +1,23 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libnpp"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "Library of primitives for image and signal processing"; + longDescription = '' + NPP is a library of over 5,000 primitives for image and signal processing that lets you easily perform tasks + such as color conversion, image compression, filtering, thresholding, and image manipulation. + ''; + homepage = "https://developer.nvidia.com/npp"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnpp_plus.nix b/pkgs/development/cuda-modules/packages/libnpp_plus.nix new file mode 100644 index 000000000000..44e905570472 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnpp_plus.nix @@ -0,0 +1,24 @@ +{ buildRedist }: +buildRedist { + redistName = "nppplus"; + pname = "libnpp_plus"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "C++ support for interfacing with the NVIDIA Performance Primitives (NPP) library"; + longDescription = '' + NPP is a library of over 5,000 primitives for image and signal processing that lets you easily perform tasks + such as color conversion, image compression, filtering, thresholding, and image manipulation. + ''; + homepage = "https://developer.nvidia.com/npp"; + changelog = "https://docs.nvidia.com/cuda/nppplus/releasenotes"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvfatbin.nix b/pkgs/development/cuda-modules/packages/libnvfatbin.nix new file mode 100644 index 000000000000..965bd22d18cb --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvfatbin.nix @@ -0,0 +1,12 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libnvfatbin"; + + outputs = [ "out" ]; + + meta = { + description = "APIs which can be used at runtime to combine multiple CUDA objects into one CUDA fat binary (fatbin)"; + homepage = "https://docs.nvidia.com/cuda/nvfatbin"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvjitlink.nix b/pkgs/development/cuda-modules/packages/libnvjitlink.nix new file mode 100644 index 000000000000..c641cea10d38 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvjitlink.nix @@ -0,0 +1,23 @@ +{ + buildRedist, + cudaAtLeast, + lib, +}: +buildRedist { + redistName = "cuda"; + pname = "libnvjitlink"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ] + ++ lib.optionals (cudaAtLeast "12.2") [ "stubs" ]; + + meta = { + description = "APIs which can be used at runtime to link together GPU device code"; + homepage = "https://docs.nvidia.com/cuda/nvjitlink"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvjpeg.nix b/pkgs/development/cuda-modules/packages/libnvjpeg.nix new file mode 100644 index 000000000000..4cdb9bddfd12 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvjpeg.nix @@ -0,0 +1,23 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libnvjpeg"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + "stubs" + ]; + + meta = { + description = "Provides high-performance, GPU accelerated JPEG decoding functionality for image formats commonly used in deep learning and hyperscale multimedia applications"; + longDescription = '' + The nvJPEG library provides high-performance, GPU accelerated JPEG decoding functionality for image formats + commonly used in deep learning and hyperscale multimedia applications. + ''; + homepage = "https://docs.nvidia.com/cuda/nvjpeg"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvjpeg_2k.nix b/pkgs/development/cuda-modules/packages/libnvjpeg_2k.nix new file mode 100644 index 000000000000..b9250be6248b --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvjpeg_2k.nix @@ -0,0 +1,22 @@ +{ buildRedist }: +buildRedist { + redistName = "nvjpeg2000"; + pname = "libnvjpeg_2k"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + meta = { + description = "Accelerates the decoding and encoding of JPEG2000 images on NVIDIA GPUs"; + longDescription = '' + The nvJPEG2000 library accelerates the decoding and encoding of JPEG2000 images on NVIDIA GPUs. + ''; + homepage = "https://docs.nvidia.com/cuda/nvjpeg2000"; + changelog = "https://docs.nvidia.com/cuda/nvjpeg2000/releasenotes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvptxcompiler.nix b/pkgs/development/cuda-modules/packages/libnvptxcompiler.nix new file mode 100644 index 000000000000..84f0ff1a1932 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvptxcompiler.nix @@ -0,0 +1,12 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libnvptxcompiler"; + + outputs = [ "out" ]; + + meta = { + description = "APIs which can be used to compile a PTX program into GPU assembly code"; + homepage = "https://docs.nvidia.com/cuda/ptx-compiler-api"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvshmem.nix b/pkgs/development/cuda-modules/packages/libnvshmem.nix new file mode 100644 index 000000000000..37a4a79d14a4 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvshmem.nix @@ -0,0 +1,182 @@ +{ + backendStdenv, + buildPackages, + cmake, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cuda_nvml_dev, + cuda_nvtx, + cudaAtLeast, + cudaNamePrefix, + fetchFromGitHub, + flags, + gdrcopy, + lib, + libfabric, + mpi, + nccl, + ninja, + pmix, + python3Packages, + rdma-core, + ucx, + # passthru.updateScript + gitUpdater, +}: +let + inherit (lib) + cmakeBool + cmakeFeature + getBin + getDev + getExe + getLib + licenses + maintainers + teams + ; +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 = "libnvshmem"; + version = "3.4.5-0"; + + src = fetchFromGitHub { + owner = "NVIDIA"; + repo = "nvshmem"; + tag = "v${finalAttrs.version}"; + hash = "sha256-RHZzjDMYlL7vAVP1/UXM/Pt4bhajeWdCi3ihICeD2mc="; + }; + + outputs = [ "out" ]; + + nativeBuildInputs = [ + cuda_nvcc + cmake + ninja + + # NOTE: mpi is in nativeBuildInputs because it contains compilers and is only discoverable by CMake + # when a nativeBuildInput. + mpi + + # NOTE: Python is required even if not building nvshmem4py: + # https://github.com/NVIDIA/nvshmem/blob/131da55f643ac87c810ba0bc51d359258bf433a1/CMakeLists.txt#L173 + python3Packages.python + ]; + + # NOTE: Hardcoded standard versions mean CMake doesn't respect values we provide, so we need to patch the files. + postPatch = lib.optionalString (cudaAtLeast "12.8") '' + for standardName in {CXX,CUDA}_STANDARD + do + while IFS= read -r cmakeFileToPatch + do + nixLog "patching $PWD/$cmakeFileToPatch to fix $standardName" + substituteInPlace "$PWD/$cmakeFileToPatch" \ + --replace-fail \ + "$standardName 11" \ + "$standardName 17" + done < <(grep --recursive --files-with-matches "$standardName 11") + done + unset -v cmakeFileToPatch + unset -v standardName + ''; + + enableParallelBuilding = true; + + buildInputs = [ + cuda_cccl + cuda_cudart + cuda_nvml_dev + cuda_nvtx + gdrcopy + libfabric + nccl + pmix + rdma-core + ucx + ]; + + # NOTE: This *must* be an environment variable NVIDIA saw fit to *configure and build CMake projects* while *inside* + # a CMake build and didn't correctly thread arguments through, so the environment is the only way to get + # configurations to the nested build. + env.CUDA_HOME = (getBin cuda_nvcc).outPath; + + # https://docs.nvidia.com/nvshmem/release-notes-install-guide/install-guide/nvshmem-install-proc.html#other-distributions + cmakeFlags = [ + (cmakeFeature "NVSHMEM_PREFIX" (placeholder "out")) + + (cmakeFeature "CUDA_HOME" (getBin cuda_nvcc).outPath) + (cmakeFeature "CMAKE_CUDA_COMPILER" (getExe cuda_nvcc)) + + (cmakeFeature "CMAKE_CUDA_ARCHITECTURES" flags.cmakeCudaArchitecturesString) + + (cmakeBool "NVSHMEM_USE_NCCL" true) + (cmakeFeature "NCCL_HOME" (getDev nccl).outPath) + + (cmakeBool "NVSHMEM_USE_GDRCOPY" true) + (cmakeFeature "GDRCOPY_HOME" (getDev gdrcopy).outPath) + + # NOTE: Make sure to use mpi from buildPackages to match the spliced version created through nativeBuildInputs. + (cmakeBool "NVSHMEM_MPI_SUPPORT" true) + (cmakeFeature "MPI_HOME" (getLib buildPackages.mpi).outPath) + + # TODO: Doesn't UCX need to be built with some argument when we want to use it with libnvshmem? + (cmakeBool "NVSHMEM_UCX_SUPPORT" true) + (cmakeFeature "UCX_HOME" (getDev ucx).outPath) + + (cmakeBool "NVSHMEM_LIBFABRIC_SUPPORT" true) + (cmakeFeature "LIBFABRIC_HOME" (getDev libfabric).outPath) + + (cmakeBool "NVSHMEM_IBGDA_SUPPORT" true) + # NOTE: no corresponding _HOME variable for IBGDA. + + (cmakeBool "NVSHMEM_PMIX_SUPPORT" true) + (cmakeFeature "PMIX_HOME" (getDev pmix).outPath) + + (cmakeBool "NVSHMEM_BUILD_TESTS" true) + (cmakeBool "NVSHMEM_BUILD_EXAMPLES" true) + + (cmakeBool "NVSHMEM_BUILD_DEB_PACKAGE" false) + (cmakeBool "NVSHMEM_BUILD_RPM_PACKAGE" false) + + # TODO: Looks like a nightmare to package and depends on things we haven't packaged yet + # https://github.com/NVIDIA/nvshmem/tree/131da55f643ac87c810ba0bc51d359258bf433a1/nvshmem4py + (cmakeBool "NVSHMEM_BUILD_PYTHON_LIB" false) + + # NOTE: unsupported because it requires Clang + (cmakeBool "NVSHMEM_BUILD_BITCODE_LIBRARY" false) + ]; + + postInstall = '' + nixLog "moving top-level files in $out to $out/share" + mv -v "$out"/{changelog,git_commit.txt,License.txt,version.txt} "$out/share/" + ''; + + doCheck = false; + + passthru = { + updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; + }; + + meta = { + description = "Parallel programming interface for NVIDIA GPUs based on OpenSHMEM"; + homepage = "https://github.com/NVIDIA/nvshmem"; + # NOTE: There are many licenses: + # https://github.com/NVIDIA/nvshmem/blob/7dd48c9fd7aa2134264400802881269b7822bd2f/License.txt + license = licenses.nvidiaCudaRedist; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + maintainers = [ maintainers.connorbaker ]; + teams = [ teams.cuda ]; + }; +}) diff --git a/pkgs/development/cuda-modules/packages/libnvtiff.nix b/pkgs/development/cuda-modules/packages/libnvtiff.nix new file mode 100644 index 000000000000..e3623eb3b47d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvtiff.nix @@ -0,0 +1,22 @@ +{ buildRedist }: +buildRedist { + redistName = "nvtiff"; + pname = "libnvtiff"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + meta = { + description = "Accelerates TIFF encode/decode on NVIDIA GPUs"; + longDescription = '' + nvTIFF is a GPU accelerated TIFF(Tagged Image File Format) encode/decode library built on the CUDA platform. + ''; + homepage = "https://docs.nvidia.com/cuda/nvtiff"; + changelog = "https://docs.nvidia.com/cuda/nvtiff/releasenotes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/libnvvm.nix b/pkgs/development/cuda-modules/packages/libnvvm.nix new file mode 100644 index 000000000000..868cacae3eba --- /dev/null +++ b/pkgs/development/cuda-modules/packages/libnvvm.nix @@ -0,0 +1,25 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "libnvvm"; + + # NOTE(@connorbaker): CMake and other build systems may not react well to this library being split into multiple + # outputs; they may use relative path accesses. + outputs = [ "out" ]; + + # Everything is nested under the nvvm directory. + prePatch = '' + nixLog "un-nesting top-level $PWD/nvvm directory" + mv -v "$PWD/nvvm"/* "$PWD/" + nixLog "removing empty $PWD/nvvm directory" + rmdir -v "$PWD/nvvm" + ''; + + meta = { + description = "Interface for generating PTX code from both binary and text NVVM IR inputs"; + longDescription = '' + libNVVM API provides an interface for generating PTX code from both binary and text NVVM IR inputs. + ''; + homepage = "https://docs.nvidia.com/cuda/libnvvm-api"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/markForCudatoolkitRootHook/mark-for-cudatoolkit-root-hook.sh b/pkgs/development/cuda-modules/packages/markForCudatoolkitRootHook/mark-for-cudatoolkit-root-hook.sh index 0abd651005c6..2540116c017b 100644 --- a/pkgs/development/cuda-modules/packages/markForCudatoolkitRootHook/mark-for-cudatoolkit-root-hook.sh +++ b/pkgs/development/cuda-modules/packages/markForCudatoolkitRootHook/mark-for-cudatoolkit-root-hook.sh @@ -1,25 +1,25 @@ # shellcheck shell=bash -(( ${hostOffset:?} == -1 && ${targetOffset:?} == 0)) || return 0 +((${hostOffset:?} == -1 && ${targetOffset:?} == 0)) || return 0 echo "Sourcing mark-for-cudatoolkit-root-hook" >&2 markForCUDAToolkit_ROOT() { - mkdir -p "${prefix:?}/nix-support" - local markerPath="$prefix/nix-support/include-in-cudatoolkit-root" + mkdir -p "${prefix:?}/nix-support" + local markerPath="$prefix/nix-support/include-in-cudatoolkit-root" - # Return early if the file already exists. - [[ -f "$markerPath" ]] && return 0 + # Return early if the file already exists. + [[ -f $markerPath ]] && return 0 - # Always create the file, even if it's empty, since setup-cuda-hook relies on its existence. - # However, only populate it if strictDeps is not set. - touch "$markerPath" + # Always create the file, even if it's empty, since setup-cuda-hook relies on its existence. + # However, only populate it if strictDeps is not set. + touch "$markerPath" - # Return early if strictDeps is set. - [[ -n "${strictDeps-}" ]] && return 0 + # Return early if strictDeps is set. + [[ -n ${strictDeps-} ]] && return 0 - # Populate the file with the package name and output. - echo "${pname:?}-${output:?}" > "$markerPath" + # Populate the file with the package name and output. + echo "${pname:?}-${output:?}" >"$markerPath" } fixupOutputHooks+=(markForCUDAToolkit_ROOT) diff --git a/pkgs/development/cuda-modules/packages/nccl-tests.nix b/pkgs/development/cuda-modules/packages/nccl-tests.nix index 4ce489a34d00..4a7528a10356 100644 --- a/pkgs/development/cuda-modules/packages/nccl-tests.nix +++ b/pkgs/development/cuda-modules/packages/nccl-tests.nix @@ -2,29 +2,35 @@ # the names of dependencies from that package set directly to avoid evaluation errors # in the case redistributable packages are not available. { - config, - cudaPackages, + backendStdenv, + _cuda, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cudaNamePrefix, fetchFromGitHub, + flags, gitUpdater, lib, mpi, mpiSupport ? false, + nccl, which, }: let - inherit (cudaPackages) - backendStdenv - cuda_cccl - cuda_cudart - cuda_nvcc - cudaAtLeast - nccl - ; + inherit (_cuda.lib) _mkMetaBroken; + inherit (lib) licenses maintainers teams; + inherit (lib.attrsets) getBin; + inherit (lib.lists) optionals; 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 = "nccl-tests"; - version = "2.15.0"; + version = "2.14.1"; src = fetchFromGitHub { owner = "NVIDIA"; @@ -34,11 +40,18 @@ backendStdenv.mkDerivation (finalAttrs: { }; postPatch = '' - # fix build failure with GCC14 - substituteInPlace src/Makefile --replace-fail "-std=c++11" "-std=c++14" - ''; + nixLog "patching $PWD/src/Makefile to remove NVIDIA's ccbin declaration" + substituteInPlace ./src/Makefile \ + --replace-fail \ + '-ccbin $(CXX)' \ + "" - strictDeps = true; + nixLog "patching $PWD/src/Makefile to replace -std=c++11 with -std=c++14" + substituteInPlace ./src/Makefile \ + --replace-fail \ + '-std=c++11' \ + '-std=c++14' + ''; nativeBuildInputs = [ which @@ -46,37 +59,55 @@ backendStdenv.mkDerivation (finalAttrs: { ]; buildInputs = [ - nccl - cuda_nvcc # crt/host_config.h - cuda_cudart cuda_cccl # + cuda_cudart + nccl ] - ++ lib.optionals mpiSupport [ mpi ]; + ++ optionals mpiSupport [ mpi ]; makeFlags = [ + # NOTE: CUDA_HOME is expected to have the bin directory + # TODO: This won't work with cross-compilation since cuda_nvcc will come from hostPackages by default (aka pkgs). + "CUDA_HOME=${getBin cuda_nvcc}" "NCCL_HOME=${nccl}" - "CUDA_HOME=${cuda_nvcc}" + "NVCC_GENCODE=${flags.gencodeString}" ] - ++ lib.optionals mpiSupport [ "MPI=1" ]; + ++ optionals mpiSupport [ "MPI=1" ]; enableParallelBuilding = true; installPhase = '' - mkdir -p $out/bin - cp -r build/* $out/bin/ + runHook preInstall + mkdir -p "$out/bin" + install -Dm755 \ + $(find build -type f -executable) \ + "$out/bin" + runHook postInstall ''; - passthru.updateScript = gitUpdater { - inherit (finalAttrs) pname version; - rev-prefix = "v"; + passthru = { + brokenAssertions = [ + { + message = "mpi is non-null when mpiSupport is true"; + assertion = mpiSupport -> mpi != null; + } + ]; + + updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; }; - meta = with lib; { + meta = { description = "Tests to check both the performance and the correctness of NVIDIA NCCL operations"; homepage = "https://github.com/NVIDIA/nccl-tests"; - platforms = platforms.linux; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; license = licenses.bsd3; - broken = !config.cudaSupport || (mpiSupport && mpi == null); + broken = _mkMetaBroken finalAttrs; maintainers = with maintainers; [ jmillerpdt ]; teams = [ teams.cuda ]; }; diff --git a/pkgs/development/cuda-modules/packages/nccl.nix b/pkgs/development/cuda-modules/packages/nccl.nix index 2d89653ebe0d..07f0ba06a067 100644 --- a/pkgs/development/cuda-modules/packages/nccl.nix +++ b/pkgs/development/cuda-modules/packages/nccl.nix @@ -2,57 +2,62 @@ # the names of dependencies from that package set directly to avoid evaluation errors # in the case redistributable packages are not available. { - lib, + _cuda, + backendStdenv, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cudaNamePrefix, fetchFromGitHub, + flags, + lib, python3, which, - autoAddDriverRunpath, - cudaPackages, # passthru.updateScript gitUpdater, }: let - inherit (cudaPackages) - backendStdenv - cuda_cccl - cuda_cudart - cuda_nvcc - cudaAtLeast - flags + inherit (_cuda.lib) _mkMetaBadPlatforms; + inherit (backendStdenv) hasJetsonCudaCapability requestedJetsonCudaCapabilities; + inherit (lib) licenses maintainers teams; + inherit (lib.attrsets) + getBin + getLib + getOutput ; - version = "2.27.6-1"; - hash = "sha256-/BiLSZaBbVIqOfd8nQlgUJub0YR3SR4B93x2vZpkeiU="; 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 = "nccl"; - version = version; + version = "2.27.6-1"; src = fetchFromGitHub { owner = "NVIDIA"; repo = "nccl"; - rev = "v${finalAttrs.version}"; - hash = hash; + tag = "v${finalAttrs.version}"; + hash = "sha256-/BiLSZaBbVIqOfd8nQlgUJub0YR3SR4B93x2vZpkeiU="; }; - __structuredAttrs = true; - strictDeps = true; - outputs = [ "out" "dev" + "static" ]; nativeBuildInputs = [ - which - autoAddDriverRunpath - python3 cuda_nvcc + python3 + which ]; buildInputs = [ - cuda_nvcc # crt/host_config.h - cuda_cudart + (getOutput "include" cuda_nvcc) cuda_cccl + cuda_cudart ]; env.NIX_CFLAGS_COMPILE = toString [ "-Wno-unused-function" ]; @@ -60,35 +65,56 @@ backendStdenv.mkDerivation (finalAttrs: { postPatch = '' patchShebangs ./src/device/generate.py patchShebangs ./src/device/symmetric/generate.py + + nixLog "patching $PWD/makefiles/common.mk to remove NVIDIA's ccbin declaration" + substituteInPlace ./makefiles/common.mk \ + --replace-fail \ + '-ccbin $(CXX)' \ + "" ''; + # TODO: This would likely break under cross; need to delineate between build and host packages. makeFlags = [ - "PREFIX=$(out)" + "CUDA_HOME=${getBin cuda_nvcc}" + "CUDA_INC=${getOutput "include" cuda_cudart}/include" + "CUDA_LIB=${getLib cuda_cudart}/lib" "NVCC_GENCODE=${flags.gencodeString}" - "CUDA_HOME=${cuda_nvcc}" - "CUDA_LIB=${lib.getLib cuda_cudart}/lib" - "CUDA_INC=${lib.getDev cuda_cudart}/include" + "PREFIX=$(out)" ]; enableParallelBuilding = true; postFixup = '' - moveToOutput lib/libnccl_static.a $dev + moveToOutput lib/libnccl_static.a "$static" ''; - passthru.updateScript = gitUpdater { - inherit (finalAttrs) pname version; - rev-prefix = "v"; + passthru = { + platformAssertions = [ + { + message = "Pre-Thor Jetson devices (CUDA capabilities < 10.1) are not supported by NCCL"; + assertion = + !hasJetsonCudaCapability + || lib.all (lib.flip lib.versionAtLeast "10.1") requestedJetsonCudaCapabilities; + } + ]; + + updateScript = gitUpdater { + inherit (finalAttrs) pname version; + rev-prefix = "v"; + }; }; - meta = with lib; { + meta = { description = "Multi-GPU and multi-node collective communication primitives for NVIDIA GPUs"; homepage = "https://developer.nvidia.com/nccl"; license = licenses.bsd3; - platforms = platforms.linux; - # NCCL is not supported on Jetson, because it does not use NVLink or PCI-e for inter-GPU communication. + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + # NCCL is not supported on Pre-Thor Jetsons, because it does not use NVLink or PCI-e for inter-GPU communication. # https://forums.developer.nvidia.com/t/can-jetson-orin-support-nccl/232845/9 - badPlatforms = lib.optionals flags.isJetsonBuild [ "aarch64-linux" ]; + badPlatforms = _mkMetaBadPlatforms finalAttrs; maintainers = with maintainers; [ mdaiter orivej diff --git a/pkgs/development/cuda-modules/packages/nsight_compute.nix b/pkgs/development/cuda-modules/packages/nsight_compute.nix new file mode 100644 index 000000000000..6f7f1d0772b2 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nsight_compute.nix @@ -0,0 +1,139 @@ +{ + backendStdenv, + buildRedist, + cudaAtLeast, + cudaMajorMinorVersion, + cudaOlder, + e2fsprogs, + elfutils, + flags, + gst_all_1, + lib, + libjpeg8, + qt5 ? null, + qt6 ? null, + rdma-core, + ucx, +}: +let + archDir = + { + aarch64-linux = "linux-" + (if flags.isJetsonBuild then "v4l_l4t" else "desktop") + "-t210-a64"; + x86_64-linux = "linux-desktop-glibc_2_11_3-x64"; + } + .${backendStdenv.hostPlatform.system} + or (throw "Unsupported system: ${backendStdenv.hostPlatform.system}"); +in +buildRedist ( + finalAttrs: + let + qt = if lib.versionOlder finalAttrs.version "2022.2.0" then qt5 else qt6; + qtwayland = + if lib.versions.major qt.qtbase.version == "5" then + lib.getBin qt.qtwayland + else + lib.getLib qt.qtwayland; + inherit (qt) wrapQtAppsHook qtwebengine qtwebview; + in + { + redistName = "cuda"; + pname = "nsight_compute"; + + # NOTE(@connorbaker): It might be a problem that when nsight_compute contains hosts and targets of different + # architectures, that we patchelf just the binaries matching the builder's platform; autoPatchelfHook prints + # messages like + # skipping [$out]/host/linux-desktop-glibc_2_11_3-x64/libQt6Core.so.6 because its architecture (x64) differs from + # target (AArch64) + outputs = [ "out" ]; + + allowFHSReferences = true; + + nativeBuildInputs = [ wrapQtAppsHook ]; + + buildInputs = [ + (lib.getLib qtwayland) + qtwebengine + qtwebview + rdma-core + ] + ++ lib.optionals (cudaMajorMinorVersion == "12.0" && backendStdenv.hostPlatform.isAarch64) [ + libjpeg8 + ] + ++ lib.optionals (cudaAtLeast "12.1" && cudaOlder "12.4") [ + gst_all_1.gstreamer + gst_all_1.gst-plugins-base + ] + ++ lib.optionals (cudaAtLeast "12.0" && cudaOlder "12.7") [ + e2fsprogs + ucx + ] + ++ lib.optionals (cudaAtLeast "12.9") [ elfutils ]; + + dontWrapQtApps = true; + + preInstall = '' + if [[ -d nsight-compute ]]; then + nixLog "Lifting components of Nsight Compute to the top level" + mv -v nsight-compute/*/* . + nixLog "Removing empty directories" + rmdir -pv nsight-compute/* + fi + + rm -rf host/${archDir}/Mesa/ + + patchShebangs . + ''; + + postInstall = '' + moveToOutput 'ncu' "''${!outputBin}/bin" + moveToOutput 'ncu-ui' "''${!outputBin}/bin" + moveToOutput 'host/${archDir}' "''${!outputBin}/bin" + moveToOutput 'target/${archDir}' "''${!outputBin}/bin" + wrapQtApp "''${!outputBin}/bin/host/${archDir}/ncu-ui.bin" + '' + # NOTE(@connorbaker): No idea what this platform is or how to patchelf for it. + + lib.optionalString (flags.isJetsonBuild && cudaAtLeast "11.8" && cudaOlder "12.9") '' + nixLog "Removing QNX 700 target directory for Jetson builds" + rm -rfv "''${!outputBin}/target/qnx-700-t210-a64" + '' + + lib.optionalString (flags.isJetsonBuild && cudaAtLeast "12.8") '' + nixLog "Removing QNX 800 target directory for Jetson builds" + rm -rfv "''${!outputBin}/target/qnx-800-tegra-a64" + ''; + + # lib needs libtiff.so.5, but nixpkgs provides libtiff.so.6 + preFixup = '' + patchelf --replace-needed libtiff.so.5 libtiff.so "''${!outputBin}/bin/host/${archDir}/Plugins/imageformats/libqtiff.so" + ''; + + autoPatchelfIgnoreMissingDeps = [ + "libcuda.so.1" + "libnvidia-ml.so.1" + ]; + + brokenAssertions = [ + { + message = "Qt 5 is required and available"; + assertion = lib.versionOlder finalAttrs.version "2022.2.0" -> qt5 != null; + } + { + message = "Qt 6 is required and available"; + assertion = lib.versionAtLeast finalAttrs.version "2022.2.0" -> qt6 != null; + } + ]; + + meta = { + description = "Interactive profiler for CUDA and NVIDIA OptiX"; + longDescription = '' + NVIDIA Nsight Compute is an interactive profiler for CUDA and NVIDIA OptiX that provides detailed performance + metrics and API debugging via a user interface and command-line tool. Users can run guided analysis and compare + results with a customizable and data-driven user interface, as well as post-process and analyze results in their + own workflows. + ''; + homepage = "https://developer.nvidia.com/nsight-compute"; + changelog = "https://docs.nvidia.com/nsight-compute/ReleaseNotes"; + + mainProgram = "ncu"; + }; + } +) diff --git a/pkgs/development/cuda-modules/packages/nsight_systems.nix b/pkgs/development/cuda-modules/packages/nsight_systems.nix new file mode 100644 index 000000000000..3f575214a2ef --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nsight_systems.nix @@ -0,0 +1,176 @@ +{ + backendStdenv, + boost178, + buildRedist, + cudaAtLeast, + e2fsprogs, + gst_all_1, + lib, + nss, + numactl, + pulseaudio, + qt5 ? null, + qt6 ? null, + rdma-core, + ucx, + wayland, + xorg, +}: +let + # NOTE(@connorbaker): nsight_systems doesn't support Jetson, so no need for case splitting on aarch64-linux. + hostDir = + { + aarch64-linux = "host-linux-armv8"; + x86_64-linux = "host-linux-x64"; + } + .${backendStdenv.hostPlatform.system} + or (throw "Unsupported system: ${backendStdenv.hostPlatform.system}"); + targetDir = + { + aarch64-linux = "target-linux-sbsa-armv8"; + x86_64-linux = "target-linux-x64"; + } + .${backendStdenv.hostPlatform.system} + or (throw "Unsupported system: ${backendStdenv.hostPlatform.system}"); +in +buildRedist ( + finalAttrs: + let + qt = if lib.strings.versionOlder finalAttrs.version "2022.4.2.1" then qt5 else qt6; + qtwayland = + if lib.versions.major qt.qtbase.version == "5" then + lib.getBin qt.qtwayland + else + lib.getLib qt.qtwayland; + qtWaylandPlugins = "${qtwayland}/${qt.qtbase.qtPluginPrefix}"; + inherit (qt) wrapQtAppsHook qtwebengine; + in + { + redistName = "cuda"; + pname = "nsight_systems"; + + allowFHSReferences = true; + + outputs = [ "out" ]; + + # An ad hoc replacement for + # https://github.com/ConnorBaker/cuda-redist-find-features/issues/11 + env.rmPatterns = toString [ + "${hostDir}/lib{arrow,jpeg}*" + "${hostDir}/lib{ssl,ssh,crypto}*" + "${hostDir}/libboost*" + "${hostDir}/libexec" + "${hostDir}/libstdc*" + "${hostDir}/python/bin/python" + "${hostDir}/Mesa" + ]; + + # NOTE(@connorbaker): nsight-exporter and nsight-sys are deprecated scripts wrapping nsys, it's fine to remove them. + prePatch = '' + if [[ -d bin ]]; then + nixLog "Removing bin wrapper scripts" + for knownWrapper in bin/{nsys{,-ui},nsight-{exporter,sys}}; do + [[ -e $knownWrapper ]] && rm -v "$knownWrapper" + done + unset -v knownWrapper + + nixLog "Removing empty bin directory" + rmdir -v bin + fi + + if [[ -d nsight-systems ]]; then + nixLog "Lifting components of Nsight System to the top level" + mv -v nsight-systems/*/* . + nixLog "Removing empty nsight-systems directory" + rmdir -pv nsight-systems/* + fi + ''; + + postPatch = '' + for path in $rmPatterns; do + rm -r "$path" + done + patchShebangs nsight-systems + ''; + + nativeBuildInputs = [ wrapQtAppsHook ]; + + dontWrapQtApps = true; + + # TODO(@connorbaker): Fix dependencies for earlier (CUDA <12.6) versions of nsight_systems. + buildInputs = [ + qt6.qtdeclarative + qt6.qtsvg + qt6.qtimageformats + qt6.qtpositioning + qt6.qtscxml + qt6.qttools + qtwebengine + qt6.qtwayland + boost178 + e2fsprogs + gst_all_1.gst-plugins-base + gst_all_1.gstreamer + nss + numactl + pulseaudio + qt6.qtbase + qtWaylandPlugins + rdma-core + ucx + wayland + xorg.libXcursor + xorg.libXdamage + xorg.libXrandr + xorg.libXtst + ] + # NOTE(@connorbaker): Seems to be required only for aarch64-linux. + ++ lib.optionals (backendStdenv.hostPlatform.isAarch64 && cudaAtLeast "11.8") [ + gst_all_1.gst-plugins-bad + ]; + + postInstall = '' + moveToOutput '${hostDir}' "''${!outputBin}" + moveToOutput '${targetDir}' "''${!outputBin}" + moveToOutput 'bin' "''${!outputBin}" + wrapQtApp "''${!outputBin}/${hostDir}/nsys-ui.bin" + ''; + + # lib needs libtiff.so.5, but nixpkgs provides libtiff.so.6 + preFixup = '' + patchelf --replace-needed libtiff.so.5 libtiff.so "''${!outputBin}/${hostDir}/Plugins/imageformats/libqtiff.so" + ''; + + autoPatchelfIgnoreMissingDeps = [ + "libcuda.so.1" + "libnvidia-ml.so.1" + ]; + + brokenAssertions = [ + { + # Boost 1.70 has been deprecated in Nixpkgs; releases older than the one for CUDA 11.8 are not supported. + message = "Boost 1.70 is required and available"; + assertion = lib.versionAtLeast finalAttrs.version "2022.4.2.1"; + } + { + message = "Qt 5 is required and available"; + assertion = lib.versionOlder finalAttrs.version "2022.4.2.1" -> qt5 != null; + } + { + message = "Qt 6 is required and available"; + assertion = lib.versionAtLeast finalAttrs.version "2022.4.2.1" -> qt6 != null; + } + ]; + + meta = { + description = "System-wide performance analysis and visualization tool"; + longDescription = '' + NVIDIA Nsight Systems is a system-wide performance analysis tool designed to visualize an application's + algorithms, identify the largest opportunities to optimize, and tune to scale efficiently across any quantity or + size of CPUs and GPUs, from large servers to our smallest systems-on-a-chip (SoCs). + ''; + homepage = "https://developer.nvidia.com/nsight-systems"; + changelog = "https://docs.nvidia.com/nsight-systems/ReleaseNotes"; + }; + } +) diff --git a/pkgs/development/cuda-modules/packages/nvcomp.nix b/pkgs/development/cuda-modules/packages/nvcomp.nix new file mode 100644 index 000000000000..eb5889c69d60 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvcomp.nix @@ -0,0 +1,22 @@ +{ buildRedist }: +buildRedist { + redistName = "nvcomp"; + pname = "nvcomp"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + meta = { + description = "High-speed data compression and decompression library optimized for NVIDIA GPUs"; + longDescription = '' + NVIDIA nvCOMP is a high-speed data compression and decompression library optimized for NVIDIA GPUs. + ''; + homepage = "https://developer.nvidia.com/nvcomp"; + changelog = "https://docs.nvidia.com/cuda/nvcomp/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvidia_fs.nix b/pkgs/development/cuda-modules/packages/nvidia_fs.nix new file mode 100644 index 000000000000..1dbe5d9c9baf --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvidia_fs.nix @@ -0,0 +1,19 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvidia_fs"; + + outputs = [ "out" ]; + + allowFHSReferences = true; + + meta = { + description = "GPUDirect Storage kernel driver to read/write data from supported storage using cufile APIs"; + longDescription = '' + GPUDirect Storage kernel driver nvidia-fs.ko is a kernel module to orchestrate IO directly from DMA/RDMA + capable storage to user allocated GPU memory on NVIDIA Graphics cards. + ''; + homepage = "https://github.com/NVIDIA/gds-nvidia-fs"; + changelog = "https://github.com/NVIDIA/gds-nvidia-fs/releases"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_blas.nix b/pkgs/development/cuda-modules/packages/nvpl_blas.nix new file mode 100644 index 000000000000..94661a67067d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_blas.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_blas"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "Part of NVIDIA Performance Libraries that provides standard Fortran 77 BLAS APIs as well as C (CBLAS)"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/blas/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_common.nix b/pkgs/development/cuda-modules/packages/nvpl_common.nix new file mode 100644 index 000000000000..86330f5187ed --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_common.nix @@ -0,0 +1,16 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_common"; + + outputs = [ + "out" + "dev" + ]; + + meta = { + description = "Common part of NVIDIA Performance Libraries"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_fft.nix b/pkgs/development/cuda-modules/packages/nvpl_fft.nix new file mode 100644 index 000000000000..30eb09ff9a11 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_fft.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_fft"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "Perform Fast Fourier Transform (FFT) calculations on ARM CPUs"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/fft/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_lapack.nix b/pkgs/development/cuda-modules/packages/nvpl_lapack.nix new file mode 100644 index 000000000000..64637f45d9b5 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_lapack.nix @@ -0,0 +1,20 @@ +{ buildRedist, nvpl_blas }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_lapack"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + buildInputs = [ nvpl_blas ]; + + meta = { + description = "Part of NVIDIA Performance Libraries that provides standard Fortran 90 LAPACK and LAPACKE APIs"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/lapack/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_rand.nix b/pkgs/development/cuda-modules/packages/nvpl_rand.nix new file mode 100644 index 000000000000..f65e6f15f0ee --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_rand.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_rand"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "Collection of efficient pseudorandom and quasirandom number generators for ARM CPUs"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/rand/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_scalapack.nix b/pkgs/development/cuda-modules/packages/nvpl_scalapack.nix new file mode 100644 index 000000000000..d9bf55082b6c --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_scalapack.nix @@ -0,0 +1,18 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_scalapack"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + meta = { + description = "Provides an optimized implementation of ScaLAPACK for distributed-memory architectures"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/scalapack/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_sparse.nix b/pkgs/development/cuda-modules/packages/nvpl_sparse.nix new file mode 100644 index 000000000000..3bd6985e66e0 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_sparse.nix @@ -0,0 +1,19 @@ +{ buildRedist }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_sparse"; + + outputs = [ + "out" + "dev" + "include" + "lib" + "static" + ]; + + meta = { + description = "Provides a set of CPU-accelerated basic linear algebra subroutines used for handling sparse matrices"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/sparse/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/nvpl_tensor.nix b/pkgs/development/cuda-modules/packages/nvpl_tensor.nix new file mode 100644 index 000000000000..177c267465bd --- /dev/null +++ b/pkgs/development/cuda-modules/packages/nvpl_tensor.nix @@ -0,0 +1,20 @@ +{ buildRedist, nvpl_blas }: +buildRedist { + redistName = "cuda"; + pname = "nvpl_tensor"; + + outputs = [ + "out" + "dev" + "include" + "lib" + ]; + + buildInputs = [ nvpl_blas ]; + + meta = { + description = "Part of NVIDIA Performance Libraries that provides tensor primitives"; + homepage = "https://developer.nvidia.com/nvpl"; + changelog = "https://docs.nvidia.com/nvpl/latest/tensor/release_notes.html"; + }; +} diff --git a/pkgs/development/cuda-modules/packages/saxpy/package.nix b/pkgs/development/cuda-modules/packages/saxpy/package.nix index 5e3c2bb168ad..076afb708895 100644 --- a/pkgs/development/cuda-modules/packages/saxpy/package.nix +++ b/pkgs/development/cuda-modules/packages/saxpy/package.nix @@ -1,43 +1,34 @@ { - autoAddDriverRunpath, + backendStdenv, cmake, - cudaPackages, + cuda_cccl, + cuda_cudart, + cuda_nvcc, + cudaNamePrefix, + flags, lib, + libcublas, saxpy, }: -let - inherit (cudaPackages) - backendStdenv - cuda_cccl - cuda_cudart - cuda_nvcc - cudaAtLeast - flags - libcublas - ; - inherit (lib) getDev getLib getOutput; -in -backendStdenv.mkDerivation { - pname = "saxpy"; - version = "unstable-2023-07-11"; - - src = ./src; - +backendStdenv.mkDerivation (finalAttrs: { __structuredAttrs = true; strictDeps = true; + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "saxpy"; + version = "0-unstable-2023-07-11"; + + src = ./src; + nativeBuildInputs = [ cmake - autoAddDriverRunpath cuda_nvcc ]; buildInputs = [ - (getDev libcublas) - (getLib libcublas) - (getOutput "static" libcublas) - cuda_cudart cuda_cccl + cuda_cudart + libcublas ]; cmakeFlags = [ @@ -60,4 +51,4 @@ backendStdenv.mkDerivation { mainProgram = "saxpy"; platforms = lib.platforms.unix; }; -} +}) diff --git a/pkgs/development/cuda-modules/packages/setupCudaHook/setup-cuda-hook.sh b/pkgs/development/cuda-modules/packages/setupCudaHook/setup-cuda-hook.sh index 95d1cee2c14a..1b0e6bf9c868 100644 --- a/pkgs/development/cuda-modules/packages/setupCudaHook/setup-cuda-hook.sh +++ b/pkgs/development/cuda-modules/packages/setupCudaHook/setup-cuda-hook.sh @@ -1,128 +1,129 @@ # shellcheck shell=bash # Only run the hook from nativeBuildInputs -(( "$hostOffset" == -1 && "$targetOffset" == 0)) || return 0 +# shellcheck disable=SC2154 +(("$hostOffset" == -1 && "$targetOffset" == 0)) || return 0 guard=Sourcing reason= [[ -n ${cudaSetupHookOnce-} ]] && guard=Skipping && reason=" because the hook has been propagated more than once" -if (( "${NIX_DEBUG:-0}" >= 1 )) ; then - echo "$guard hostOffset=$hostOffset targetOffset=$targetOffset setup-cuda-hook$reason" >&2 +if (("${NIX_DEBUG:-0}" >= 1)); then + echo "$guard hostOffset=$hostOffset targetOffset=$targetOffset setup-cuda-hook$reason" >&2 else - echo "$guard setup-cuda-hook$reason" >&2 + echo "$guard setup-cuda-hook$reason" >&2 fi -[[ "$guard" = Sourcing ]] || return 0 +[[ $guard == Sourcing ]] || return 0 declare -g cudaSetupHookOnce=1 declare -Ag cudaHostPathsSeen=() declare -Ag cudaOutputToPath=() extendcudaHostPathsSeen() { - (( "${NIX_DEBUG:-0}" >= 1 )) && echo "extendcudaHostPathsSeen $1" >&2 + (("${NIX_DEBUG:-0}" >= 1)) && echo "extendcudaHostPathsSeen $1" >&2 - local markerPath="$1/nix-support/include-in-cudatoolkit-root" - [[ ! -f "${markerPath}" ]] && return 0 - [[ -v cudaHostPathsSeen[$1] ]] && return 0 + local markerPath="$1/nix-support/include-in-cudatoolkit-root" + [[ ! -f ${markerPath} ]] && return 0 + [[ -v cudaHostPathsSeen[$1] ]] && return 0 - cudaHostPathsSeen["$1"]=1 + cudaHostPathsSeen["$1"]=1 - # E.g. cuda_cudart-lib - local cudaOutputName - # Fail gracefully if the file is empty. - # One reason the file may be empty: the package was built with strictDeps set, but the current build does not have - # strictDeps set. - read -r cudaOutputName < "$markerPath" || return 0 + # E.g. cuda_cudart-lib + local cudaOutputName + # Fail gracefully if the file is empty. + # One reason the file may be empty: the package was built with strictDeps set, but the current build does not have + # strictDeps set. + read -r cudaOutputName <"$markerPath" || return 0 - [[ -z "$cudaOutputName" ]] && return 0 + [[ -z $cudaOutputName ]] && return 0 - local oldPath="${cudaOutputToPath[$cudaOutputName]-}" - [[ -n "$oldPath" ]] && echo "extendcudaHostPathsSeen: warning: overwriting $cudaOutputName from $oldPath to $1" >&2 - cudaOutputToPath["$cudaOutputName"]="$1" + local oldPath="${cudaOutputToPath[$cudaOutputName]-}" + [[ -n $oldPath ]] && echo "extendcudaHostPathsSeen: warning: overwriting $cudaOutputName from $oldPath to $1" >&2 + cudaOutputToPath["$cudaOutputName"]="$1" } addEnvHooks "$targetOffset" extendcudaHostPathsSeen setupCUDAToolkit_ROOT() { - (( "${NIX_DEBUG:-0}" >= 1 )) && echo "setupCUDAToolkit_ROOT: cudaHostPathsSeen=${!cudaHostPathsSeen[*]}" >&2 + (("${NIX_DEBUG:-0}" >= 1)) && echo "setupCUDAToolkit_ROOT: cudaHostPathsSeen=${!cudaHostPathsSeen[*]}" >&2 - for path in "${!cudaHostPathsSeen[@]}" ; do - addToSearchPathWithCustomDelimiter ";" CUDAToolkit_ROOT "$path" - if [[ -d "$path/include" ]] ; then - addToSearchPathWithCustomDelimiter ";" CUDAToolkit_INCLUDE_DIR "$path/include" - fi - done + for path in "${!cudaHostPathsSeen[@]}"; do + addToSearchPathWithCustomDelimiter ";" CUDAToolkit_ROOT "$path" + if [[ -d "$path/include" ]]; then + addToSearchPathWithCustomDelimiter ";" CUDAToolkit_INCLUDE_DIR "$path/include" + fi + done - # Use array form so semicolon-separated lists are passed safely. - if [[ -n "${CUDAToolkit_INCLUDE_DIR-}" ]]; then - cmakeFlagsArray+=("-DCUDAToolkit_INCLUDE_DIR=${CUDAToolkit_INCLUDE_DIR}") - fi - if [[ -n "${CUDAToolkit_ROOT-}" ]]; then - cmakeFlagsArray+=("-DCUDAToolkit_ROOT=${CUDAToolkit_ROOT}") - fi + # Use array form so semicolon-separated lists are passed safely. + if [[ -n ${CUDAToolkit_INCLUDE_DIR-} ]]; then + cmakeFlagsArray+=("-DCUDAToolkit_INCLUDE_DIR=${CUDAToolkit_INCLUDE_DIR}") + fi + if [[ -n ${CUDAToolkit_ROOT-} ]]; then + cmakeFlagsArray+=("-DCUDAToolkit_ROOT=${CUDAToolkit_ROOT}") + fi } preConfigureHooks+=(setupCUDAToolkit_ROOT) setupCUDAToolkitCompilers() { - echo Executing setupCUDAToolkitCompilers >&2 + echo Executing setupCUDAToolkitCompilers >&2 - if [[ -n "${dontSetupCUDAToolkitCompilers-}" ]] ; then - return 0 - fi + if [[ -n ${dontSetupCUDAToolkitCompilers-} ]]; then + return 0 + fi - # Point NVCC at a compatible compiler + # Point NVCC at a compatible compiler - # For CMake-based projects: - # https://cmake.org/cmake/help/latest/module/FindCUDA.html#input-variables - # https://cmake.org/cmake/help/latest/envvar/CUDAHOSTCXX.html - # https://cmake.org/cmake/help/latest/variable/CMAKE_CUDA_HOST_COMPILER.html + # For CMake-based projects: + # https://cmake.org/cmake/help/latest/module/FindCUDA.html#input-variables + # https://cmake.org/cmake/help/latest/envvar/CUDAHOSTCXX.html + # https://cmake.org/cmake/help/latest/variable/CMAKE_CUDA_HOST_COMPILER.html - appendToVar cmakeFlags "-DCUDA_HOST_COMPILER=@ccFullPath@" - appendToVar cmakeFlags "-DCMAKE_CUDA_HOST_COMPILER=@ccFullPath@" + appendToVar cmakeFlags "-DCUDA_HOST_COMPILER=@ccFullPath@" + appendToVar cmakeFlags "-DCMAKE_CUDA_HOST_COMPILER=@ccFullPath@" - # For non-CMake projects: - # We prepend --compiler-bindir to nvcc flags. - # Downstream packages can override these, because NVCC - # uses the last --compiler-bindir it gets on the command line. - # FIXME: this results in "incompatible redefinition" warnings. - # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#compiler-bindir-directory-ccbin - if [ -z "${CUDAHOSTCXX-}" ]; then - export CUDAHOSTCXX="@ccFullPath@"; - fi + # For non-CMake projects: + # We prepend --compiler-bindir to nvcc flags. + # Downstream packages can override these, because NVCC + # uses the last --compiler-bindir it gets on the command line. + # FIXME: this results in "incompatible redefinition" warnings. + # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#compiler-bindir-directory-ccbin + if [ -z "${CUDAHOSTCXX-}" ]; then + export CUDAHOSTCXX="@ccFullPath@" + fi - appendToVar NVCC_PREPEND_FLAGS "--compiler-bindir=@ccRoot@/bin" + appendToVar NVCC_PREPEND_FLAGS "--compiler-bindir=@ccRoot@/bin" - # NOTE: We set -Xfatbin=-compress-all, which reduces the size of the compiled - # binaries. If binaries grow over 2GB, they will fail to link. This is a problem for us, as - # the default set of CUDA capabilities we build can regularly cause this to occur (for - # example, with Magma). - # - # @SomeoneSerge: original comment was made by @ConnorBaker in .../cudatoolkit/common.nix - if [[ -z "${dontCompressFatbin-}" ]]; then - appendToVar NVCC_PREPEND_FLAGS "-Xfatbin=-compress-all" - fi + # NOTE: We set -Xfatbin=-compress-all, which reduces the size of the compiled + # binaries. If binaries grow over 2GB, they will fail to link. This is a problem for us, as + # the default set of CUDA capabilities we build can regularly cause this to occur (for + # example, with Magma). + # + # @SomeoneSerge: original comment was made by @ConnorBaker in .../cudatoolkit/common.nix + if [[ -z ${dontCompressFatbin-} ]]; then + appendToVar NVCC_PREPEND_FLAGS "-Xfatbin=-compress-all" + fi } preConfigureHooks+=(setupCUDAToolkitCompilers) propagateCudaLibraries() { - (( "${NIX_DEBUG:-0}" >= 1 )) && echo "propagateCudaLibraries: cudaPropagateToOutput=$cudaPropagateToOutput cudaHostPathsSeen=${!cudaHostPathsSeen[*]}" >&2 + (("${NIX_DEBUG:-0}" >= 1)) && echo "propagateCudaLibraries: cudaPropagateToOutput=$cudaPropagateToOutput cudaHostPathsSeen=${!cudaHostPathsSeen[*]}" >&2 - [[ -z "${cudaPropagateToOutput-}" ]] && return 0 + [[ -z ${cudaPropagateToOutput-} ]] && return 0 - mkdir -p "${!cudaPropagateToOutput}/nix-support" - # One'd expect this should be propagated-bulid-build-deps, but that doesn't seem to work - echo "@setupCudaHook@" >> "${!cudaPropagateToOutput}/nix-support/propagated-native-build-inputs" + mkdir -p "${!cudaPropagateToOutput}/nix-support" + # One'd expect this should be propagated-bulid-build-deps, but that doesn't seem to work + echo "@setupCudaHook@" >>"${!cudaPropagateToOutput}/nix-support/propagated-native-build-inputs" - local propagatedBuildInputs=( "${!cudaHostPathsSeen[@]}" ) - for output in $(getAllOutputNames) ; do - if [[ ! "$output" = "$cudaPropagateToOutput" ]] ; then - appendToVar propagatedBuildInputs "${!output}" - fi - break - done + local propagatedBuildInputs=("${!cudaHostPathsSeen[@]}") + for output in $(getAllOutputNames); do + if [[ $output != "$cudaPropagateToOutput" ]]; then + appendToVar propagatedBuildInputs "${!output}" + fi + break + done - # One'd expect this should be propagated-host-host-deps, but that doesn't seem to work - printWords "${propagatedBuildInputs[@]}" >> "${!cudaPropagateToOutput}/nix-support/propagated-build-inputs" + # One'd expect this should be propagated-host-host-deps, but that doesn't seem to work + printWords "${propagatedBuildInputs[@]}" >>"${!cudaPropagateToOutput}/nix-support/propagated-build-inputs" } postFixupHooks+=(propagateCudaLibraries) diff --git a/pkgs/development/cuda-modules/packages/tensorrt.nix b/pkgs/development/cuda-modules/packages/tensorrt.nix new file mode 100644 index 000000000000..0a1192090e90 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tensorrt.nix @@ -0,0 +1,161 @@ +{ + _cuda, + backendStdenv, + buildRedist, + cuda_cudart, + cudnn, + cuda_nvrtc, + lib, + libcudla, # only for Jetson + patchelf, +}: +let + inherit (_cuda.lib) majorMinorPatch; + inherit (backendStdenv) hasJetsonCudaCapability; + inherit (lib.attrsets) getLib; + inherit (lib.lists) optionals; + inherit (lib.strings) concatStringsSep; +in +buildRedist ( + finalAttrs: + let + majorMinorPatchVersion = majorMinorPatch finalAttrs.version; + majorVersion = lib.versions.major finalAttrs.version; + in + { + redistName = "tensorrt"; + pname = "tensorrt"; + + outputs = [ + "out" + "bin" + "dev" + "include" + "lib" + "samples" + "static" + # "stubs" removed in postInstall + ]; + + allowFHSReferences = true; + + nativeBuildInputs = [ patchelf ]; + + buildInputs = [ + (getLib cudnn) + (getLib cuda_nvrtc) + cuda_cudart + ] + ++ optionals libcudla.meta.available [ libcudla ]; + + preInstall = + let + inherit (backendStdenv.hostPlatform) parsed; + # x86_64-linux-gnu + targetString = concatStringsSep "-" [ + parsed.cpu.name + parsed.kernel.name + parsed.abi.name + ]; + in + # Replace symlinks to bin and lib with the actual directories from targets. + '' + for dir in bin lib; do + [[ -L "$dir" ]] || continue + nixLog "replacing symlink $NIX_BUILD_TOP/$sourceRoot/$dir with $NIX_BUILD_TOP/$sourceRoot/targets/${targetString}/$dir" + rm --verbose "$NIX_BUILD_TOP/$sourceRoot/$dir" + mv --verbose --no-clobber "$NIX_BUILD_TOP/$sourceRoot/targets/${targetString}/$dir" "$NIX_BUILD_TOP/$sourceRoot/$dir" + done + unset -v dir + '' + # Remove symlinks if they exist + + '' + for dir in include samples; do + if [[ -L "$NIX_BUILD_TOP/$sourceRoot/targets/${targetString}/$dir" ]]; then + nixLog "removing symlink $NIX_BUILD_TOP/$sourceRoot/targets/${targetString}/$dir" + rm --verbose "$NIX_BUILD_TOP/$sourceRoot/targets/${targetString}/$dir" + fi + done + unset -v dir + + if [[ -d "$NIX_BUILD_TOP/$sourceRoot/targets" ]]; then + nixLog "removing targets directory" + rm --recursive --verbose "$NIX_BUILD_TOP/$sourceRoot/targets" || { + nixErrorLog "could not delete $NIX_BUILD_TOP/$sourceRoot/targets: $(ls -laR "$NIX_BUILD_TOP/$sourceRoot/targets")" + exit 1 + } + fi + ''; + + autoPatchelfIgnoreMissingDeps = optionals hasJetsonCudaCapability [ + "libnvdla_compiler.so" + ]; + + # Create a symlink for the Onnx header files in include/onnx + # NOTE(@connorbaker): This is shared with the tensorrt-oss package, with the `out` output swapped with `include`. + # When updating one, check if the other should be updated. + postInstall = '' + mkdir "''${!outputInclude:?}/include/onnx" + pushd "''${!outputInclude:?}/include" >/dev/null + nixLog "creating symlinks for Onnx header files" + ln -srvt "''${!outputInclude:?}/include/onnx/" NvOnnx*.h + popd >/dev/null + '' + # Move the python directory, which contains header files, to the include output. + + '' + nixLog "moving python directory to include output" + moveToOutput python "''${!outputInclude:?}" + + nixLog "remove python wheels" + rm --verbose "''${!outputInclude:?}"/python/*.whl + '' + + '' + nixLog "moving data directory to samples output" + moveToOutput data "''${!outputSamples:?}" + '' + # Remove the Windows library used for cross-compilation if it exists. + + '' + if [[ -e "''${!outputLib:?}/lib/libnvinfer_builder_resource_win.so.${majorMinorPatchVersion}" ]]; then + nixLog "removing Windows library" + rm --verbose "''${!outputLib:?}/lib/libnvinfer_builder_resource_win.so.${majorMinorPatchVersion}" + fi + '' + # Remove the stub libraries. + + '' + nixLog "removing stub libraries" + rm --recursive --verbose "''${!outputLib:?}/lib/stubs" || { + nixErrorLog "could not delete ''${!outputLib:?}/lib/stubs" + exit 1 + } + ''; + + # Tell autoPatchelf about runtime dependencies. + postFixup = '' + nixLog "patchelf-ing ''${!outputBin:?}/bin/trtexec with runtime dependencies" + patchelf \ + "''${!outputBin:?}/bin/trtexec" \ + --add-needed libnvinfer_plugin.so.${majorVersion} + ''; + + passthru = { + # The CUDNN used with TensorRT. + inherit cudnn; + }; + + meta = { + description = "SDK that facilitates high-performance machine learning inference"; + longDescription = '' + NVIDIA TensorRT is an SDK that facilitates high-performance machine learning inference. It complements training + frameworks such as TensorFlow, PyTorch, and MXNet. It focuses on running an already-trained network quickly and + efficiently on NVIDIA hardware. + ''; + homepage = "https://developer.nvidia.com/tensorrt"; + # NOTE: As of 2025-08-31, TensorRT doesn't follow the standard naming convention for URL paths that the rest of + # the redistributables do. As such, we need to specify downloadPage manually. + downloadPage = "https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt"; + changelog = "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes.html#release-notes"; + + license = _cuda.lib.licenses.tensorrt; + }; + } +) diff --git a/pkgs/development/cuda-modules/packages/tests/cmake/package.nix b/pkgs/development/cuda-modules/packages/tests/cmake/package.nix new file mode 100644 index 000000000000..3a1ce899624d --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/cmake/package.nix @@ -0,0 +1,203 @@ +{ + backendStdenv, + cmake, + cuda_cudart, + cuda_nvcc, + cudaNamePrefix, + fetchpatch2, + flags, + lib, + srcOnly, + stdenv, + stdenvNoCC, +}: +let + inherit (backendStdenv) cc; + inherit (lib.attrsets) mapAttrs optionalAttrs recurseIntoAttrs; + inherit (lib.fixedPoints) composeExtensions toExtension; + inherit (lib.lists) optionals; + inherit (lib.strings) + cmakeBool + cmakeFeature + optionalString + versionAtLeast + ; + + cmake' = cmake.overrideAttrs (prevAttrs: { + patches = prevAttrs.patches or [ ] ++ [ + # Fix errors during configuration when C/CXX is not loaded + # https://gitlab.kitware.com/cmake/cmake/-/merge_requests/10354 + (fetchpatch2 { + name = "find-cuda-toolkit-check-for-language-enablement.patch"; + url = "https://gitlab.kitware.com/cmake/cmake/-/commit/c5d81a246852e1ad81a3d55fcaff7e6feb779db7.patch"; + hash = "sha256-oGxzbp+x88+79V+Cyx0l7+nMxX+n3ixzAFKPK26NMI8="; + }) + # https://gitlab.kitware.com/cmake/cmake/-/merge_requests/10289 + (fetchpatch2 { + name = "update-arch-supported-by-cuda-12_8.patch"; + url = "https://gitlab.kitware.com/cmake/cmake/-/commit/a745b6869ee3681e39544d96d936c95c196c7398.patch"; + hash = "sha256-B6ny6AZFIcyFhsEnzNk7+vJTb36HeguM53sk/LCnjS4="; + }) + ]; + }); + + isBroken = _: prevAttrs: { + meta = prevAttrs.meta or { } // { + broken = true; + }; + }; + + cmakeSrc = srcOnly { + name = "cmake-unpacked"; + inherit (cmake) src version; + stdenv = stdenvNoCC; + }; + + mkTest = + let + generic = stdenv.mkDerivation (finalAttrs: { + __structuredAttrs = true; + strictDeps = true; + + testSuiteName = builtins.throw "testSuiteName must be set"; + testName = builtins.throw "testName must be set"; + + name = "${cudaNamePrefix}-${finalAttrs.pname}-${finalAttrs.version}"; + pname = "tests-cmake-${finalAttrs.testSuiteName}-${finalAttrs.testName}"; + inherit (cmakeSrc) version; + + src = cmakeSrc; + + setSourceRoot = '' + sourceRoot="$(echo */Tests/${finalAttrs.testSuiteName}/${finalAttrs.testName})" + ''; + + nativeBuildInputs = [ + cmake' + cuda_nvcc + ]; + + # If our compiler uses C++14, we must modify the CMake files so they don't hardcode C++11. + # This behavior has only been seen with GCC 14, but it's possible Clang would also require this. + requireCxxStandard14 = cc.isGNU && versionAtLeast cc.version "14"; + + cmakeListsReplacements = optionalAttrs finalAttrs.requireCxxStandard14 { + "cuda_std_11" = "cuda_std_14"; + "cxx_std_11" = "cxx_std_14"; + "set(CMAKE_CUDA_STANDARD 11)" = "set(CMAKE_CUDA_STANDARD 14)"; + "set(CMAKE_CXX_STANDARD 11)" = "set(CMAKE_CXX_STANDARD 14)"; + }; + + prePatch = optionalString finalAttrs.requireCxxStandard14 '' + for key in "''${!cmakeListsReplacements[@]}"; do + if grep -q "$key" CMakeLists.txt; then + nixLog "replacing occurrences of \"$key\" with \"''${cmakeListsReplacements[$key]}\" in $PWD/CMakeLists.txt" + substituteInPlace CMakeLists.txt --replace-fail "$key" "''${cmakeListsReplacements[$key]}" + fi + done + ''; + + buildInputs = [ + cuda_cudart + ]; + + cmakeFlags = [ + (cmakeBool "CMAKE_VERBOSE_MAKEFILE" true) + (cmakeFeature "CMAKE_CUDA_ARCHITECTURES" flags.cmakeCudaArchitecturesString) + ] + ++ optionals finalAttrs.requireCxxStandard14 [ + (cmakeFeature "CMAKE_CXX_STANDARD" "14") + (cmakeFeature "CMAKE_CUDA_STANDARD" "14") + ]; + + # The build *is* the check. + doCheck = false; + + installPhase = '' + runHook preInstall + touch "$out" + runHook postInstall + ''; + + # Don't try to run stuff in the patch phase as the setup hooks will error on empty output. + dontFixup = true; + + meta = { + description = "Generic builder for running CMake tests"; + license = lib.licenses.mit; + maintainers = lib.teams.cuda.members; + platforms = [ + "aarch64-linux" + "x86_64-linux" + ]; + }; + }); + in + testSuiteName: testName: overrideAttrsArg: + generic.overrideAttrs ( + composeExtensions (toExtension { inherit testSuiteName testName; }) (toExtension overrideAttrsArg) + ); +in +recurseIntoAttrs ( + mapAttrs (testSuiteName: testSuite: recurseIntoAttrs (mapAttrs (mkTest testSuiteName) testSuite)) { + # TODO: Handle set(Cuda.Toolkit_BUILD_OPTIONS -DHAS_CUPTI:BOOL=${CMake_TEST_CUDA_CUPTI}) + # from Tests/Cuda/CMakeLists.txt + Cuda = { + Complex = { }; + CXXStandardSetTwice = { }; + IncludePathNoToolkit = { }; + MixedStandardLevels1 = { }; + MixedStandardLevels2 = { }; + MixedStandardLevels3 = { }; + MixedStandardLevels4 = if cc.isClang then isBroken else { }; + MixedStandardLevels5 = if cc.isClang then isBroken else { }; + NotEnabled = { }; + ObjectLibrary = { }; + ProperDeviceLibraries = + if cc.isClang then + isBroken # Clang lacks __CUDACC_VER*__ defines. + else + isBroken; # TODO: Fix + ProperLinkFlags = { }; + SeparableCompCXXOnly = { }; + SharedRuntimePlusToolkit = isBroken; # TODO: Fix + StaticRuntimePlusToolkit = isBroken; # TODO: Fix + StubRPATH = { }; + Toolkit = isBroken; # TODO: Fix + ToolkitBeforeLang = if cc.isClang then isBroken else { }; # Clang lacks __CUDACC_VER*__ defines. + WithC = { }; + }; + # TODO: Handle set(CudaOnly.Toolkit_BUILD_OPTIONS -DHAS_CUPTI:BOOL=${CMake_TEST_CUDA_CUPTI}) + # from Tests/CudaOnly/CMakeLists.txt + CudaOnly = { + Architecture = { }; + ArchSpecial = isBroken; # Tries to detect the native architecture, which is impure. + CircularLinkLine = { }; + CompileFlags = { }; + CUBIN = if cc.isClang then isBroken else { }; # Only NVCC defines __CUDACC_DEBUG__ when compiling in debug mode. + DeviceLTO = isBroken; # TODO: Fix + DontResolveDeviceSymbols = { }; + EnableStandard = { }; + ExportPTX = { }; + Fatbin = if cc.isClang then isBroken else { }; # Only NVCC defines __CUDACC_DEBUG__ when compiling in debug mode. + GPUDebugFlag = if cc.isClang then isBroken else { }; # Only NVCC defines __CUDACC_DEBUG__ when compiling in debug mode. + OptixIR = if cc.isClang then isBroken else { }; # Only NVCC defines __CUDACC_DEBUG__ when compiling in debug mode. + PDB = isBroken; # Tests for features that only work with MSVC + ResolveDeviceSymbols = { }; + RuntimeControls = { }; + SeparateCompilation = { }; + SeparateCompilationPTX = isBroken; # TODO: Fix + SeparateCompilationTargetObjects = { }; + SharedRuntimePlusToolkit = isBroken; # TODO: Fix + SharedRuntimeViaCUDAFlags = if cc.isClang then isBroken else { }; # Clang doesn't have flags for selecting the runtime. + Standard98 = if cc.isClang then isBroken else { }; + StaticRuntimePlusToolkit = isBroken; # TODO: Fix + Toolkit = isBroken; # TODO: Fix + ToolkitBeforeLang = { }; + ToolkitMultipleDirs = { }; + TryCompileTargetStatic = { }; + Unity = { }; + WithDefs = { }; + }; + } +) diff --git a/pkgs/development/cuda-modules/cuda-library-samples/generic.nix b/pkgs/development/cuda-modules/packages/tests/cuda-library-samples.nix similarity index 79% rename from pkgs/development/cuda-modules/cuda-library-samples/generic.nix rename to pkgs/development/cuda-modules/packages/tests/cuda-library-samples.nix index 529716220351..67bab4b3483c 100644 --- a/pkgs/development/cuda-modules/cuda-library-samples/generic.nix +++ b/pkgs/development/cuda-modules/packages/tests/cuda-library-samples.nix @@ -4,18 +4,17 @@ autoPatchelfHook, backendStdenv, cmake, - cuda_cccl ? null, - cuda_cudart ? null, - cuda_nvcc ? null, + cuda_cccl, + cuda_cudart, + cuda_nvcc, cudatoolkit, - cusparselt ? null, - cutensor ? null, + libcusparse_lt, + libcutensor, fetchFromGitHub, lib, - libcusparse ? null, + libcusparse, setupCudaHook, }: - let base = backendStdenv.mkDerivation (finalAttrs: { src = fetchFromGitHub { @@ -72,7 +71,7 @@ in sourceRoot = "${finalAttrs.src.name}/cuTENSOR"; - buildInputs = prevAttrs.buildInputs or [ ] ++ [ cutensor ]; + buildInputs = prevAttrs.buildInputs or [ ] ++ [ libcutensor ]; cmakeFlags = prevAttrs.cmakeFlags or [ ] ++ [ "-DCUTENSOR_EXAMPLE_BINARY_INSTALL_DIR=${placeholder "out"}/bin" @@ -81,14 +80,10 @@ in # CUTENSOR_ROOT is double escaped postPatch = prevAttrs.postPatch or "" + '' substituteInPlace CMakeLists.txt \ - --replace-fail "\''${CUTENSOR_ROOT}/include" "${lib.getDev cutensor}/include" + --replace-fail "\''${CUTENSOR_ROOT}/include" "${lib.getOutput "include" libcutensor}/include" ''; - CUTENSOR_ROOT = cutensor; - - meta = prevAttrs.meta or { } // { - broken = cutensor == null; - }; + CUTENSOR_ROOT = libcutensor; } ); @@ -101,7 +96,7 @@ in nativeBuildInputs = prevAttrs.nativeBuildInputs or [ ] ++ [ cmake addDriverRunpath - (lib.getDev cusparselt) + (lib.getDev libcusparse_lt) (lib.getDev libcusparse) cuda_nvcc (lib.getDev cuda_cudart) # @@ -110,8 +105,8 @@ in postPatch = prevAttrs.postPatch or "" + '' substituteInPlace CMakeLists.txt \ - --replace-fail "''${CUSPARSELT_ROOT}/lib64/libcusparseLt.so" "${lib.getLib cusparselt}/lib/libcusparseLt.so" \ - --replace-fail "''${CUSPARSELT_ROOT}/lib64/libcusparseLt_static.a" "${lib.getStatic cusparselt}/lib/libcusparseLt_static.a" + --replace-fail "''${CUSPARSELT_ROOT}/lib64/libcusparseLt.so" "${lib.getLib libcusparse_lt}/lib/libcusparseLt.so" \ + --replace-fail "''${CUSPARSELT_ROOT}/lib64/libcusparseLt_static.a" "${lib.getStatic libcusparse_lt}/lib/libcusparseLt_static.a" ''; postInstall = prevAttrs.postInstall or "" + '' @@ -121,17 +116,7 @@ in ''; CUDA_TOOLKIT_PATH = lib.getLib cudatoolkit; - CUSPARSELT_PATH = lib.getLib cusparselt; - - meta = prevAttrs.meta or { } // { - broken = - # Base dependencies - cusparselt == null - || libcusparse == null - || cuda_nvcc == null - || cuda_cudart == null - || cuda_cccl == null; - }; + CUSPARSELT_PATH = lib.getLib libcusparse_lt; } ); } diff --git a/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/legacy_samples.nix b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/legacy_samples.nix new file mode 100644 index 000000000000..ae3226b5a753 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/legacy_samples.nix @@ -0,0 +1,39 @@ +{ + cudaNamePrefix, + cudnn-frontend, + jq, + lib, + writeShellApplication, +}: +let + inherit (lib.meta) getExe'; +in +writeShellApplication { + derivationArgs = { + __structuredAttrs = true; + strictDeps = true; + }; + name = "${cudaNamePrefix}-tests-cudnn-frontend-legacy-samples"; + runtimeInputs = [ + cudnn-frontend.legacy_samples + jq + ]; + text = '' + args=( "${getExe' cudnn-frontend.legacy_samples "legacy_samples"}" ) + + if (( $# != 0 )) + then + args+=( "$@" ) + "''${args[@]}" + else + args+=( + --success + --rng-seed=0 + --reporter=json + exclude:"Scale Bias Conv BNGenstats with CPU Reference" + ) + echo "Running with default arguments: ''${args[*]}" >&2 + "''${args[@]}" | jq + fi + ''; +} diff --git a/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/samples.nix b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/samples.nix new file mode 100644 index 000000000000..0aa16703acda --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/samples.nix @@ -0,0 +1,38 @@ +{ + cudaNamePrefix, + cudnn-frontend, + jq, + lib, + writeShellApplication, +}: +let + inherit (lib.meta) getExe'; +in +writeShellApplication { + derivationArgs = { + __structuredAttrs = true; + strictDeps = true; + }; + name = "${cudaNamePrefix}-tests-cudnn-frontend-samples"; + runtimeInputs = [ + cudnn-frontend.samples + jq + ]; + text = '' + args=( "${getExe' cudnn-frontend.samples "samples"}" ) + + if (( $# != 0 )) + then + args+=( "$@" ) + "''${args[@]}" + else + args+=( + --success + --rng-seed=0 + --reporter=json + ) + echo "Running with default arguments: ''${args[*]}" >&2 + "''${args[@]}" | jq + fi + ''; +} diff --git a/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/tests.nix b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/tests.nix new file mode 100644 index 000000000000..d0949a0f53e6 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/cudnn-frontend/tests.nix @@ -0,0 +1,38 @@ +{ + cudaNamePrefix, + cudnn-frontend, + jq, + lib, + writeShellApplication, +}: +let + inherit (lib.meta) getExe'; +in +writeShellApplication { + derivationArgs = { + __structuredAttrs = true; + strictDeps = true; + }; + name = "${cudaNamePrefix}-tests-cudnn-frontend-tests"; + runtimeInputs = [ + cudnn-frontend.tests + jq + ]; + text = '' + args=( "${getExe' cudnn-frontend.tests "tests"}" ) + + if (( $# != 0 )) + then + args+=( "$@" ) + "''${args[@]}" + else + args+=( + --success + --rng-seed=0 + --reporter=json + ) + echo "Running with default arguments: ''${args[*]}" >&2 + "''${args[@]}" | jq + fi + ''; +} diff --git a/pkgs/development/cuda-modules/tests/flags.nix b/pkgs/development/cuda-modules/packages/tests/flags.nix similarity index 100% rename from pkgs/development/cuda-modules/tests/flags.nix rename to pkgs/development/cuda-modules/packages/tests/flags.nix diff --git a/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/long.nix b/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/long.nix new file mode 100644 index 000000000000..eb0fa74db933 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/long.nix @@ -0,0 +1,40 @@ +{ + cuda_cudart, + cudaNamePrefix, + onnx-tensorrt, + python3, + writeShellApplication, +}: +writeShellApplication { + derivationArgs = { + __structuredAttrs = true; + strictDeps = true; + }; + name = "${cudaNamePrefix}-tests-onnx-tensorrt-long"; + runtimeInputs = [ + cuda_cudart + (python3.withPackages (ps: [ + ps.onnx-tensorrt + ps.pytest + ps.six + ])) + ]; + text = '' + args=( + python3 + "${onnx-tensorrt.test_script}/onnx_backend_test.py" + ) + + if (( $# != 0 )) + then + args+=( "$@" ) + else + args+=( --verbose ) + echo "Running with default arguments: ''${args[*]}" >&2 + fi + + mkdir -p "$HOME/.onnx" + chmod -R +w "$HOME/.onnx" + "''${args[@]}" + ''; +} diff --git a/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/short.nix b/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/short.nix new file mode 100644 index 000000000000..9415246f7c67 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/onnx-tensorrt/short.nix @@ -0,0 +1,43 @@ +{ + cuda_cudart, + cudaNamePrefix, + onnx-tensorrt, + python3, + writeShellApplication, +}: +writeShellApplication { + derivationArgs = { + __structuredAttrs = true; + strictDeps = true; + }; + name = "${cudaNamePrefix}-tests-onnx-tensorrt-short"; + runtimeInputs = [ + cuda_cudart + (python3.withPackages (ps: [ + ps.onnx-tensorrt + ps.pytest + ps.six + ])) + ]; + text = '' + args=( + python3 + "${onnx-tensorrt.test_script}/onnx_backend_test.py" + ) + + if (( $# != 0 )) + then + args+=( "$@" ) + else + args+=( + --verbose + OnnxBackendRealModelTest + ) + echo "Running with default arguments: ''${args[*]}" >&2 + fi + + mkdir -p "$HOME/.onnx" + chmod -R +w "$HOME/.onnx" + "''${args[@]}" + ''; +} diff --git a/pkgs/development/cuda-modules/packages/tests/opencv-and-torch/package.nix b/pkgs/development/cuda-modules/packages/tests/opencv-and-torch/package.nix new file mode 100644 index 000000000000..86b2780944ea --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/opencv-and-torch/package.nix @@ -0,0 +1,122 @@ +{ + cudaPackages, + lib, + writeGpuTestPython, +}: +let + inherit (lib) + listToAttrs + mapCartesianProduct + optionals + concatStringsSep + optionalString + ; + + bools = [ + true + false + ]; + + configs = { + openCVFirst = bools; + useOpenCVDefaultCuda = bools; + useTorchDefaultCuda = bools; + }; + + openCVBlock = '' + + import cv2 + print("OpenCV version:", cv2.__version__) + + # Ensure OpenCV can access the GPU. + assert cv2.cuda.getCudaEnabledDeviceCount() > 0, "No CUDA devices found for OpenCV" + print("OpenCV CUDA device:", cv2.cuda.printCudaDeviceInfo(cv2.cuda.getDevice())) + + # Ensure OpenCV can access the GPU. + print(cv2.getBuildInformation()) + + a = cv2.cuda.GpuMat(size=(256, 256), type=cv2.CV_32S, s=1) + b = cv2.cuda.GpuMat(size=(256, 256), type=cv2.CV_32S, s=1) + c = int(cv2.cuda.sum(cv2.cuda.add(a, b))[0]) # OpenCV returns a Scalar float object. + + assert c == 2 * 256 * 256, f"Expected {2 * 256 * 256} OpenCV, got {c}" + + ''; + + torchBlock = '' + + import torch + print("Torch version:", torch.__version__) + + # Set up the GPU. + torch.cuda.init() + # Ensure the GPU is available. + assert torch.cuda.is_available(), "CUDA is not available to Torch" + print("Torch CUDA device:", torch.cuda.get_device_properties(torch.cuda.current_device())) + + a = torch.ones(256, 256, dtype=torch.int32).cuda() + b = torch.ones(256, 256, dtype=torch.int32).cuda() + c = (a + b).sum().item() + assert c == 2 * 256 * 256, f"Expected {2 * 256 * 256} for Torch, got {c}" + + ''; + + mkNamedTest = + { + openCVFirst, + useOpenCVDefaultCuda, + useTorchDefaultCuda, + }: + { + name = concatStringsSep "-" ( + [ + "test" + (if openCVFirst then "opencv" else "torch") + ] + ++ optionals (if openCVFirst then useOpenCVDefaultCuda else useTorchDefaultCuda) [ + "with-default-cuda" + ] + ++ [ + "then" + (if openCVFirst then "torch" else "opencv") + ] + ++ optionals (if openCVFirst then useTorchDefaultCuda else useOpenCVDefaultCuda) [ + "with-default-cuda" + ] + ); + value = + let + content = if openCVFirst then openCVBlock + torchBlock else torchBlock + openCVBlock; + + torchName = "torch" + optionalString useTorchDefaultCuda "-with-default-cuda"; + openCVName = "opencv4" + optionalString useOpenCVDefaultCuda "-with-default-cuda"; + in + # TODO: Ensure the expected CUDA libraries are loaded. + # TODO: Ensure GPU access works as expected. + writeGpuTestPython { + name = if openCVFirst then "${openCVName}-then-${torchName}" else "${torchName}-then-${openCVName}"; + libraries = + # NOTE: These are purposefully in this order. + pythonPackages: + let + effectiveOpenCV = pythonPackages.opencv4.override (prevAttrs: { + cudaPackages = if useOpenCVDefaultCuda then prevAttrs.cudaPackages else cudaPackages; + }); + effectiveTorch = pythonPackages.torchWithCuda.override (prevAttrs: { + cudaPackages = if useTorchDefaultCuda then prevAttrs.cudaPackages else cudaPackages; + }); + in + if openCVFirst then + [ + effectiveOpenCV + effectiveTorch + ] + else + [ + effectiveTorch + effectiveOpenCV + ]; + } content; + }; +in +listToAttrs (mapCartesianProduct mkNamedTest configs) diff --git a/pkgs/development/cuda-modules/packages/tests/redists-installed.nix b/pkgs/development/cuda-modules/packages/tests/redists-installed.nix new file mode 100644 index 000000000000..6a0ee88ae883 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/redists-installed.nix @@ -0,0 +1,60 @@ +{ + _cuda, + backendStdenv, + cudaNamePrefix, + lib, + linkFarm, + tests, +}: +# NOTE: Because Nixpkgs, by default, allows aliases, this derivation may contain multiple entries for a single redistributable. +let + # redists-unpacked has already found all the names of the redistributables + availableRedistsForPlatform = lib.filterAttrs ( + _: value: + let + canInstantiate = + (builtins.tryEval ( + builtins.deepSeq ((value.drvPath or null) != null) ((value.drvPath or null) != null) + )).value; + in + lib.warnIfNot canInstantiate + "Package ${value.name} is unavailable and will not be included in redists-installed" + canInstantiate + ) tests.redists-unpacked.passthru.redistsForPlatform; + + mkOutputs = + name: drv: + lib.genAttrs' drv.outputs (output: { + name = "${name}-${output}"; + value = drv.${output}; + }); + + linkedWithoutLicenses = linkFarm "${cudaNamePrefix}-redists-installed" ( + lib.concatMapAttrs mkOutputs availableRedistsForPlatform + ); +in +linkedWithoutLicenses.overrideAttrs ( + finalAttrs: prevAttrs: { + passthru = prevAttrs.passthru or { } // { + inherit availableRedistsForPlatform; + + brokenAssertions = prevAttrs.passthru.brokenAssertions or [ ] ++ [ + { + message = + "No redists are available for the current NVIDIA system identifier (${backendStdenv.hostRedistSystem});" + + " ensure proper licenses are allowed and that the CUDA version in use supports the system"; + assertion = availableRedistsForPlatform != { }; + } + ]; + }; + + meta = prevAttrs.meta or { } // { + broken = _cuda.lib._mkMetaBroken finalAttrs; + license = lib.unique ( + lib.concatMap (drv: lib.toList (drv.meta.license or [ ])) ( + lib.attrValues availableRedistsForPlatform + ) + ); + }; + } +) diff --git a/pkgs/development/cuda-modules/packages/tests/redists-unpacked.nix b/pkgs/development/cuda-modules/packages/tests/redists-unpacked.nix new file mode 100644 index 000000000000..cbc0e49de360 --- /dev/null +++ b/pkgs/development/cuda-modules/packages/tests/redists-unpacked.nix @@ -0,0 +1,27 @@ +{ + cudaNamePrefix, + cudaPackages, + lib, + linkFarm, +}: +# NOTE: Because Nixpkgs, by default, allows aliases, this derivation may contain multiple entries for a single redistributable. +let + redistsForPlatform = lib.filterAttrs ( + _: value: value ? passthru.redistName && value.src or null != null + ) cudaPackages; + + linkedWithoutLicenses = linkFarm "${cudaNamePrefix}-redists-unpacked" ( + lib.mapAttrs (_: drv: drv.src) redistsForPlatform + ); +in +linkedWithoutLicenses.overrideAttrs (prevAttrs: { + passthru = prevAttrs.passthru or { } // { + inherit redistsForPlatform; + }; + + meta = prevAttrs.meta or { } // { + license = lib.unique ( + lib.concatMap (drv: lib.toList (drv.meta.license or [ ])) (lib.attrValues redistsForPlatform) + ); + }; +}) diff --git a/pkgs/development/cuda-modules/tensorrt/releases.nix b/pkgs/development/cuda-modules/tensorrt/releases.nix deleted file mode 100644 index 9ead3767a286..000000000000 --- a/pkgs/development/cuda-modules/tensorrt/releases.nix +++ /dev/null @@ -1,50 +0,0 @@ -# NOTE: Check https://developer.nvidia.com/nvidia-tensorrt-8x-download -# https://developer.nvidia.com/nvidia-tensorrt-10x-download - -# Version policy is to keep the latest minor release for each major release. -{ - tensorrt.releases = { - # jetson - linux-aarch64 = [ ]; - # powerpc - linux-ppc64le = [ ]; - # server-grade arm - linux-sbsa = [ - { - version = "10.8.0.43"; - minCudaVersion = "12.8"; - maxCudaVersion = "12.8"; - cudnnVersion = "9.7"; - filename = "TensorRT-10.8.0.43.Linux.aarch64-gnu.cuda-12.8.tar.gz"; - hash = "sha256-sB5d0sfGQyUhGdA9ku6pcCNBjpL0Wjvg0Ilulikj5Do="; - } - { - version = "10.9.0.34"; - minCudaVersion = "12.8"; - maxCudaVersion = "12.8"; - cudnnVersion = "9.7"; - filename = "TensorRT-10.9.0.34.Linux.aarch64-gnu.cuda-12.8.tar.gz"; - hash = "sha256-uB7CoGf2fwgsE8rsLc71Q4W0Kp3mpOyubzGKotQZZPI="; - } - ]; - # x86_64 - linux-x86_64 = [ - { - version = "10.8.0.43"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - cudnnVersion = "9.7"; - filename = "TensorRT-10.8.0.43.Linux.x86_64-gnu.cuda-12.8.tar.gz"; - hash = "sha256-V31tivU4FTQUuYZ8ZmtPZYUvwusefA6jogbl+vvH1J4="; - } - { - version = "10.9.0.34"; - minCudaVersion = "12.0"; - maxCudaVersion = "12.8"; - cudnnVersion = "9.7"; - filename = "TensorRT-10.9.0.34.Linux.x86_64-gnu.cuda-12.8.tar.gz"; - hash = "sha256-M74OYeO/F3u7yrtIkr8BPwyKxx0r5z8oA4SKOCyxQnI="; - } - ]; - }; -} diff --git a/pkgs/development/cuda-modules/tensorrt/shims.nix b/pkgs/development/cuda-modules/tensorrt/shims.nix deleted file mode 100644 index b452a515404c..000000000000 --- a/pkgs/development/cuda-modules/tensorrt/shims.nix +++ /dev/null @@ -1,24 +0,0 @@ -# Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix -{ - package, - # redistSystem :: String - # String is `"unsupported"` if the given architecture is unsupported. - redistSystem, -}: -{ - featureRelease = { - inherit (package) cudnnVersion minCudaVersion maxCudaVersion; - ${redistSystem}.outputs = { - bin = true; - lib = true; - static = true; - dev = true; - sample = true; - python = true; - }; - }; - redistribRelease = { - name = "TensorRT: a high-performance deep learning interface"; - inherit (package) hash filename version; - }; -} diff --git a/pkgs/development/cuda-modules/tests/opencv-and-torch/default.nix b/pkgs/development/cuda-modules/tests/opencv-and-torch/default.nix deleted file mode 100644 index 442bfb8a2dd0..000000000000 --- a/pkgs/development/cuda-modules/tests/opencv-and-torch/default.nix +++ /dev/null @@ -1,81 +0,0 @@ -{ - cudaPackages, - lib, - writeGpuTestPython, - # Configuration flags - openCVFirst, - useOpenCVDefaultCuda, - useTorchDefaultCuda, -}: -let - inherit (lib.strings) optionalString; - - openCVBlock = '' - - import cv2 - print("OpenCV version:", cv2.__version__) - - # Ensure OpenCV can access the GPU. - assert cv2.cuda.getCudaEnabledDeviceCount() > 0, "No CUDA devices found for OpenCV" - print("OpenCV CUDA device:", cv2.cuda.printCudaDeviceInfo(cv2.cuda.getDevice())) - - # Ensure OpenCV can access the GPU. - print(cv2.getBuildInformation()) - - a = cv2.cuda.GpuMat(size=(256, 256), type=cv2.CV_32S, s=1) - b = cv2.cuda.GpuMat(size=(256, 256), type=cv2.CV_32S, s=1) - c = int(cv2.cuda.sum(cv2.cuda.add(a, b))[0]) # OpenCV returns a Scalar float object. - - assert c == 2 * 256 * 256, f"Expected {2 * 256 * 256} OpenCV, got {c}" - - ''; - - torchBlock = '' - - import torch - print("Torch version:", torch.__version__) - - # Set up the GPU. - torch.cuda.init() - # Ensure the GPU is available. - assert torch.cuda.is_available(), "CUDA is not available to Torch" - print("Torch CUDA device:", torch.cuda.get_device_properties(torch.cuda.current_device())) - - a = torch.ones(256, 256, dtype=torch.int32).cuda() - b = torch.ones(256, 256, dtype=torch.int32).cuda() - c = (a + b).sum().item() - assert c == 2 * 256 * 256, f"Expected {2 * 256 * 256} for Torch, got {c}" - - ''; - - content = if openCVFirst then openCVBlock + torchBlock else torchBlock + openCVBlock; - - torchName = "torch" + optionalString useTorchDefaultCuda "-with-default-cuda"; - openCVName = "opencv4" + optionalString useOpenCVDefaultCuda "-with-default-cuda"; -in -# TODO: Ensure the expected CUDA libraries are loaded. -# TODO: Ensure GPU access works as expected. -writeGpuTestPython { - name = if openCVFirst then "${openCVName}-then-${torchName}" else "${torchName}-then-${openCVName}"; - libraries = - # NOTE: These are purposefully in this order. - pythonPackages: - let - effectiveOpenCV = pythonPackages.opencv4.override (prevAttrs: { - cudaPackages = if useOpenCVDefaultCuda then prevAttrs.cudaPackages else cudaPackages; - }); - effectiveTorch = pythonPackages.torchWithCuda.override (prevAttrs: { - cudaPackages = if useTorchDefaultCuda then prevAttrs.cudaPackages else cudaPackages; - }); - in - if openCVFirst then - [ - effectiveOpenCV - effectiveTorch - ] - else - [ - effectiveTorch - effectiveOpenCV - ]; -} content diff --git a/pkgs/development/libraries/science/math/suitesparse/default.nix b/pkgs/development/libraries/science/math/suitesparse/default.nix index df867ee42121..bf3eeab4682e 100644 --- a/pkgs/development/libraries/science/math/suitesparse/default.nix +++ b/pkgs/development/libraries/science/math/suitesparse/default.nix @@ -80,7 +80,7 @@ effectiveStdenv.mkDerivation rec { "CFLAGS=-DBLAS64" ] ++ lib.optionals enableCuda [ - "CUDA_PATH=${cudaPackages.cuda_nvcc}" + "CUDA_PATH=${lib.getBin cudaPackages.cuda_nvcc}" "CUDART_LIB=${lib.getLib cudaPackages.cuda_cudart}/lib/libcudart.so" "CUBLAS_LIB=${lib.getLib cudaPackages.libcublas}/lib/libcublas.so" ] diff --git a/pkgs/development/python-modules/cupy/default.nix b/pkgs/development/python-modules/cupy/default.nix index f1527a2dd8cf..fbf48fe98d2b 100644 --- a/pkgs/development/python-modules/cupy/default.nix +++ b/pkgs/development/python-modules/cupy/default.nix @@ -17,41 +17,36 @@ let inherit (cudaPackages) cudnn; - shouldUsePkg = - pkg: if pkg != null && lib.meta.availableOn stdenv.hostPlatform pkg then pkg else null; + shouldUsePkg = lib.mapNullable (pkg: if pkg.meta.available or true then pkg else null); # some packages are not available on all platforms cuda_nvprof = shouldUsePkg (cudaPackages.nvprof or null); - cutensor = shouldUsePkg (cudaPackages.cutensor or null); + libcutensor = shouldUsePkg (cudaPackages.libcutensor or null); nccl = shouldUsePkg (cudaPackages.nccl or null); - outpaths = with cudaPackages; [ - cuda_cccl # - cuda_cudart - cuda_nvcc # - cuda_nvprof - cuda_nvrtc - cuda_nvtx - cuda_profiler_api - libcublas - libcufft - libcurand - libcusolver - libcusparse - - # Missing: - # cusparselt - ]; + outpaths = lib.filter (outpath: outpath != null) ( + with cudaPackages; + [ + cuda_cccl # + cuda_cudart + cuda_nvcc # + cuda_nvprof + cuda_nvrtc + cuda_nvtx + cuda_profiler_api + libcublas + libcufft + libcurand + libcusolver + libcusparse + # NOTE: libcusparse_lt is too new for CuPy, so we must do without. + # libcusparse_lt + ] + ); cudatoolkit-joined = symlinkJoin { name = "cudatoolkit-joined-${cudaPackages.cudaMajorMinorVersion}"; paths = - outpaths - ++ lib.concatMap (f: lib.map f outpaths) [ - lib.getLib - lib.getDev - (lib.getOutput "static") - (lib.getOutput "stubs") - ]; + outpaths ++ lib.concatMap (outpath: lib.map (output: outpath.${output}) outpath.outputs) outpaths; }; in buildPythonPackage rec { @@ -69,6 +64,11 @@ buildPythonPackage rec { fetchSubmodules = true; }; + env.LDFLAGS = toString [ + # Fake libcuda.so (the real one is deployed impurely) + "-L${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs" + ]; + # See https://docs.cupy.dev/en/v10.2.0/reference/environment.html. Setting both # CUPY_NUM_BUILD_JOBS and CUPY_NUM_NVCC_THREADS to NIX_BUILD_CORES results in # a small amount of thrashing but it turns out there are a large number of @@ -87,17 +87,17 @@ buildPythonPackage rec { nativeBuildInputs = [ addDriverRunpath - cudaPackages.cuda_nvcc + cudatoolkit-joined ]; buildInputs = [ cudatoolkit-joined cudnn - cutensor + libcutensor nccl ]; - NVCC = "${lib.getExe cudaPackages.cuda_nvcc}"; # FIXME: splicing/buildPackages + # NVCC = "${lib.getExe cudaPackages.cuda_nvcc}"; # FIXME: splicing/buildPackages CUDA_PATH = "${cudatoolkit-joined}"; dependencies = [ diff --git a/pkgs/development/python-modules/gpuctypes/default.nix b/pkgs/development/python-modules/gpuctypes/default.nix index d4669e89e001..1a27da65f4e2 100644 --- a/pkgs/development/python-modules/gpuctypes/default.nix +++ b/pkgs/development/python-modules/gpuctypes/default.nix @@ -103,7 +103,7 @@ buildPythonPackage rec { }; preCheck = lib.optionalString (cudaSupport && !testCudaRuntime) '' - addToSearchPath LD_LIBRARY_PATH ${lib.getLib cudaPackages.cuda_cudart}/lib/stubs + addToSearchPath LD_LIBRARY_PATH ${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs ''; # If neither rocmSupport or cudaSupport is enabled, no tests are selected diff --git a/pkgs/development/python-modules/onnxruntime/default.nix b/pkgs/development/python-modules/onnxruntime/default.nix index dbd2db24232b..4d2ed826d456 100644 --- a/pkgs/development/python-modules/onnxruntime/default.nix +++ b/pkgs/development/python-modules/onnxruntime/default.nix @@ -68,6 +68,8 @@ buildPythonPackage { libcufft # libcufft.so.XX cudnn # libcudnn.soXX cuda_cudart # libcudart.so.XX + ] + ++ lib.optionals onnxruntime.passthru.ncclSupport [ nccl # libnccl.so.XX ] ); diff --git a/pkgs/development/python-modules/tensorrt/default.nix b/pkgs/development/python-modules/tensorrt/default.nix index 94a3504b95fa..86580550c7af 100644 --- a/pkgs/development/python-modules/tensorrt/default.nix +++ b/pkgs/development/python-modules/tensorrt/default.nix @@ -1,41 +1,35 @@ { + autoPatchelfHook, + buildPythonPackage, + cudaPackages, lib, python, - autoAddDriverRunpath, - buildPythonPackage, - autoPatchelfHook, - unzip, - cudaPackages, + stdenv, }: - let - pyVersion = "${lib.versions.major python.version}${lib.versions.minor python.version}"; - buildVersion = lib.optionalString (cudaPackages ? tensorrt) cudaPackages.tensorrt.version; + inherit (cudaPackages.tensorrt) src pname version; + inherit (lib.versions) major minor; + inherit (stdenv.hostPlatform) parsed; in buildPythonPackage { - pname = "tensorrt"; - version = buildVersion; + inherit pname version; - src = cudaPackages.tensorrt.src; + src = + let + # https://peps.python.org/pep-0427/#file-name-convention + distribution = pname; + pythonTag = "cp${major python.version}${minor python.version}"; + abiTag = "none"; + platformTag = "${parsed.kernel.name}_${parsed.cpu.name}"; + in + src + "/python/${distribution}-${version}-${pythonTag}-${abiTag}-${platformTag}.whl"; format = "wheel"; - # We unpack the wheel ourselves because of the odd packaging. - dontUseWheelUnpack = true; nativeBuildInputs = [ - unzip autoPatchelfHook - autoAddDriverRunpath ]; - preUnpack = '' - mkdir -p dist - tar --strip-components=2 -xf "$src" --directory=dist \ - "TensorRT-${buildVersion}/python/tensorrt-${buildVersion}-cp${pyVersion}-none-linux_x86_64.whl" - ''; - - sourceRoot = "."; - buildInputs = [ cudaPackages.cudnn cudaPackages.tensorrt diff --git a/pkgs/development/python-modules/torch/bin/default.nix b/pkgs/development/python-modules/torch/bin/default.nix index eb03276cf909..a24774985149 100644 --- a/pkgs/development/python-modules/torch/bin/default.nix +++ b/pkgs/development/python-modules/torch/bin/default.nix @@ -65,13 +65,13 @@ buildPythonPackage { cuda_cupti cuda_nvrtc cudnn - cusparselt libcublas libcufft libcufile libcurand libcusolver libcusparse + libcusparse_lt nccl ] ); diff --git a/pkgs/development/python-modules/torch/source/default.nix b/pkgs/development/python-modules/torch/source/default.nix index f806c2ded5f8..6e333a4f13c6 100644 --- a/pkgs/development/python-modules/torch/source/default.nix +++ b/pkgs/development/python-modules/torch/source/default.nix @@ -24,7 +24,7 @@ magma-hip, magma-cuda-static, # Use the system NCCL as long as we're targeting CUDA on a supported platform. - useSystemNccl ? (cudaSupport && !cudaPackages.nccl.meta.unsupported || rocmSupport), + useSystemNccl ? (cudaSupport && cudaPackages.nccl.meta.available || rocmSupport), MPISupport ? false, mpi, buildDocs ? false, @@ -571,18 +571,19 @@ buildPythonPackage.override { inherit stdenv; } rec { cuda_nvml_dev # cuda_nvrtc cuda_nvtx # -llibNVToolsExt - cusparselt libcublas libcufft libcufile libcurand libcusolver libcusparse + libcusparse_lt ] ++ lists.optionals (cudaPackages ? cudnn) [ cudnn ] ++ lists.optionals useSystemNccl [ # Some platforms do not support NCCL (i.e., Jetson) - nccl # Provides nccl.h AND a static copy of NCCL! + (lib.getDev nccl) # Provides nccl.h + (lib.getOutput "static" nccl) # Provides static library ] ++ [ cuda_profiler_api # diff --git a/pkgs/development/python-modules/warp-lang/default.nix b/pkgs/development/python-modules/warp-lang/default.nix index cd521021b7f8..9de805812305 100644 --- a/pkgs/development/python-modules/warp-lang/default.nix +++ b/pkgs/development/python-modules/warp-lang/default.nix @@ -1,4 +1,5 @@ { + _cuda, autoAddDriverRunpath, buildPythonPackage, config, @@ -107,12 +108,7 @@ let # By downloading and using the software, you agree to fully # comply with the terms and conditions of the NVIDIA Software # License Agreement. - ( - nvidiaCudaRedist - // { - url = "https://developer.download.nvidia.cn/compute/mathdx/License.txt"; - } - ) + _cuda.lib.licenses.math_sdk_sla # Some of the libmathdx routines were written by or derived # from code written by Meta Platforms, Inc. and affiliates and diff --git a/pkgs/stdenv/generic/check-meta.nix b/pkgs/stdenv/generic/check-meta.nix index 1a3e65ea650d..c59e92e114ea 100644 --- a/pkgs/stdenv/generic/check-meta.nix +++ b/pkgs/stdenv/generic/check-meta.nix @@ -64,8 +64,8 @@ let in if envVar != "" then envVar != "0" else config.allowNonSource or true; - allowlist = config.allowlistedLicenses or config.whitelistedLicenses or [ ]; - blocklist = config.blocklistedLicenses or config.blacklistedLicenses or [ ]; + allowlist = config.allowlistedLicenses; + blocklist = config.blocklistedLicenses; areLicenseListsValid = if mutuallyExclusive allowlist blocklist then diff --git a/pkgs/test/cuda/default.nix b/pkgs/test/cuda/default.nix index 242d3c71b273..88c58169d2a6 100644 --- a/pkgs/test/cuda/default.nix +++ b/pkgs/test/cuda/default.nix @@ -1,31 +1,28 @@ { lib, + pkgs, recurseIntoAttrs, - - cudaPackages, - - cudaPackages_12_6, - cudaPackages_12_8, - cudaPackages_12_9, - cudaPackages_12, -}@args: - +}: let - isTest = - name: package: - builtins.elem (package.pname or null) [ - "cuda-library-samples" - "saxpy" - ]; + getTests = + cps: + recurseIntoAttrs { + inherit (cps) saxpy; + inherit (cps.tests) cuda-library-samples; + }; in -(lib.trivial.pipe args [ - (lib.filterAttrs (name: _: lib.hasPrefix "cudaPackages" name)) - (lib.mapAttrs ( - _: ps: - lib.pipe ps [ - (lib.filterAttrs isTest) - recurseIntoAttrs - ] - )) - recurseIntoAttrs -]) +recurseIntoAttrs ( + lib.mapAttrs (_: getTests) { + inherit (pkgs) + cudaPackages + + cudaPackages_12 + cudaPackages_12_6 + cudaPackages_12_8 + cudaPackages_12_9 + + cudaPackages_13 + cudaPackages_13_0 + ; + } +) diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 2c97e7a192ea..dea6298048fc 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -2539,10 +2539,24 @@ with pkgs; # Top-level fix-point used in `cudaPackages`' internals _cuda = import ../development/cuda-modules/_cuda; - cudaPackages_12_6 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "12.6"; }; - cudaPackages_12_8 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "12.8"; }; - cudaPackages_12_9 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "12.9"; }; - cudaPackages_12 = cudaPackages_12_8; # Latest supported by cudnn + inherit + (import ./cuda-packages.nix { + inherit + _cuda + callPackage + config + lib + ; + }) + cudaPackages_12_6 + cudaPackages_12_8 + cudaPackages_12_9 + cudaPackages_13_0 + ; + + cudaPackages_12 = cudaPackages_12_8; + + cudaPackages_13 = cudaPackages_13_0; cudaPackages = recurseIntoAttrs cudaPackages_12; @@ -6836,10 +6850,6 @@ with pkgs; sloc = nodePackages.sloc; - slurm = callPackage ../by-name/sl/slurm/package.nix { - nvml = cudaPackages.cuda_nvml_dev; - }; - speedtest-cli = with python3Packages; toPythonApplication speedtest-cli; splint = callPackage ../development/tools/analysis/splint { diff --git a/pkgs/top-level/config.nix b/pkgs/top-level/config.nix index 09d31a2d117c..bf9419571158 100644 --- a/pkgs/top-level/config.nix +++ b/pkgs/top-level/config.nix @@ -229,6 +229,36 @@ let ''; }; + allowlistedLicenses = mkOption { + description = '' + Allow licenses that are specifically acceptable. `allowlistedLicenses` only applies to unfree licenses unless + `allowUnfree` is enabled. It is not a generic allowlist for all types of licenses. + ''; + default = [ ]; + type = types.listOf (types.attrsOf types.anything); + example = literalExpression '' + with lib.licenses; [ + amd + wtfpl + ] + ''; + }; + + blocklistedLicenses = mkOption { + description = '' + Block licenses that are specifically unacceptable. Unlike `allowlistedLicenses`, `blocklistedLicenses` + applies to all licenses. + ''; + default = [ ]; + type = types.listOf (types.attrsOf types.anything); + example = literalExpression '' + with lib.licenses; [ + agpl3Only + gpl3Only + ] + ''; + }; + cudaSupport = mkMassRebuild { feature = "build packages with CUDA support by default"; }; diff --git a/pkgs/top-level/cuda-packages.nix b/pkgs/top-level/cuda-packages.nix index cc92f7ae3491..3c90f71ed35e 100644 --- a/pkgs/top-level/cuda-packages.nix +++ b/pkgs/top-level/cuda-packages.nix @@ -1,240 +1,105 @@ -# Notes: -# -# Silvan (Tweag) covered some things on recursive attribute sets in the Nix Hour: -# https://www.youtube.com/watch?v=BgnUFtd1Ivs -# -# I (@connorbaker) highly recommend watching it. -# -# Most helpful comment regarding recursive attribute sets: -# -# https://github.com/NixOS/nixpkgs/pull/256324#issuecomment-1749935979 -# -# To summarize: -# -# - `prev` should only be used to access attributes which are going to be overridden. -# - `final` should only be used to access `callPackage` to build new packages. -# - Attribute names are evaluated eagerly ("NAMESET STRICTNESS"). -# - Extensions must not depend on `final` when computing names and count of new attributes. -# -# Silvan's recommendation then is to explicitly use `callPackage` to provide everything our -# extensions need to compute the attribute names, without relying on `final`. -# -# I've (@connorbaker) attempted to do that, though I'm unsure of how this will interact with overrides. { - config, _cuda, - cudaMajorMinorVersion, + callPackage, + config, lib, - pkgs, - stdenv, - runCommand, }: let - inherit (lib) - attrsets - customisation - fixedPoints - lists - strings - versions - ; + mkCudaPackages = + manifestVersions: + callPackage ../development/cuda-modules { + manifests = _cuda.lib.selectManifests manifestVersions; + }; - cudaLib = _cuda.lib; - - # Since Jetson capabilities are never built by default, we can check if any of them were requested - # through final.config.cudaCapabilities and use that to determine if we should change some manifest versions. - # Copied from backendStdenv. - jetsonCudaCapabilities = lib.filter ( - cudaCapability: _cuda.db.cudaCapabilityToInfo.${cudaCapability}.isJetson - ) _cuda.db.allSortedCudaCapabilities; - hasJetsonCudaCapability = - lib.intersectLists jetsonCudaCapabilities (config.cudaCapabilities or [ ]) != [ ]; - redistSystem = _cuda.lib.getRedistSystem hasJetsonCudaCapability stdenv.hostPlatform.system; - - # We must use an instance of Nixpkgs where the CUDA package set we're building is the default; if we do not, members - # of the versioned, non-default package sets may rely on (transitively) members of the default, unversioned CUDA - # package set. - # See `Using cudaPackages.pkgs` in doc/languages-frameworks/cuda.section.md for more information. - pkgs' = + cudaPackages_12_6 = let - cudaPackagesUnversionedName = "cudaPackages"; - cudaPackagesMajorVersionName = cudaLib.mkVersionedName cudaPackagesUnversionedName ( - versions.major cudaMajorMinorVersion - ); - cudaPackagesMajorMinorVersionName = cudaLib.mkVersionedName cudaPackagesUnversionedName cudaMajorMinorVersion; + inherit (cudaPackages_12_6.backendStdenv) hasJetsonCudaCapability; in - # If the CUDA version of pkgs matches our CUDA version, we are constructing the default package set and can use - # pkgs without modification. - if pkgs.cudaPackages.cudaMajorMinorVersion == cudaMajorMinorVersion then - pkgs - else - pkgs.extend ( - final: _: { - recurseForDerivations = false; - # The CUDA package set will be available as cudaPackages_x_y, so we need only update the aliases for the - # minor-versioned and unversioned package sets. - # cudaPackages_x = cudaPackages_x_y - ${cudaPackagesMajorVersionName} = final.${cudaPackagesMajorMinorVersionName}; - # cudaPackages = cudaPackages_x - ${cudaPackagesUnversionedName} = final.${cudaPackagesMajorVersionName}; - } - ); + mkCudaPackages { + cublasmp = "0.6.0"; + cuda = "12.6.3"; + cudnn = "9.13.0"; + cudss = "0.6.0"; + cuquantum = "25.09.0"; + cusolvermp = "0.7.0"; + cusparselt = "0.6.3"; + cutensor = "2.3.1"; + nppplus = "0.10.0"; + nvcomp = "5.0.0.6"; + nvjpeg2000 = "0.9.0"; + nvpl = "25.5"; + nvtiff = "0.5.1"; + tensorrt = if hasJetsonCudaCapability then "10.7.0" else "10.9.0"; + }; - passthruFunction = final: { - # NOTE: - # It is important that _cuda is not part of the package set fixed-point. As described by - # @SomeoneSerge: - # > The layering should be: configuration -> (identifies/is part of) cudaPackages -> (is built using) cudaLib. - # > No arrows should point in the reverse directions. - # That is to say that cudaLib should only know about package sets and configurations, because it implements - # functionality for interpreting configurations, resolving them against data, and constructing package sets. - # This decision is driven both by a separation of concerns and by "NAMESET STRICTNESS" (see above). - # Also see the comment in `pkgs/top-level/all-packages.nix` about the `_cuda` attribute. + cudaPackages_12_8 = + let + inherit (cudaPackages_12_8.backendStdenv) hasJetsonCudaCapability; + in + mkCudaPackages { + cublasmp = "0.6.0"; + cuda = "12.8.1"; + cudnn = "9.13.0"; + cudss = "0.6.0"; + cuquantum = "25.09.0"; + cusolvermp = "0.7.0"; + cusparselt = "0.8.1"; + cutensor = "2.3.1"; + nppplus = "0.10.0"; + nvcomp = "5.0.0.6"; + nvjpeg2000 = "0.9.0"; + nvpl = "25.5"; + nvtiff = "0.5.1"; + tensorrt = if hasJetsonCudaCapability then "10.7.0" else "10.9.0"; + }; - inherit cudaMajorMinorVersion; + cudaPackages_12_9 = + let + inherit (cudaPackages_12_9.backendStdenv) hasJetsonCudaCapability; + in + mkCudaPackages { + cublasmp = "0.6.0"; + cuda = "12.9.1"; + cudnn = "9.13.0"; + cudss = "0.6.0"; + cuquantum = "25.09.0"; + cusolvermp = "0.7.0"; + cusparselt = "0.8.1"; + cutensor = "2.3.1"; + nppplus = "0.10.0"; + nvcomp = "5.0.0.6"; + nvjpeg2000 = "0.9.0"; + nvpl = "25.5"; + nvtiff = "0.5.1"; + tensorrt = if hasJetsonCudaCapability then "10.7.0" else "10.9.0"; + }; - pkgs = pkgs'; - - cudaNamePrefix = "cuda${cudaMajorMinorVersion}"; - - cudaMajorVersion = versions.major cudaMajorMinorVersion; - cudaOlder = strings.versionOlder cudaMajorMinorVersion; - cudaAtLeast = strings.versionAtLeast cudaMajorMinorVersion; - - flags = - cudaLib.formatCapabilities { - inherit (final.backendStdenv) cudaCapabilities cudaForwardCompat; - inherit (_cuda.db) cudaCapabilityToInfo; - } - # TODO(@connorbaker): Enable the corresponding warnings in `../development/cuda-modules/aliases.nix` after some - # time to allow users to migrate to cudaLib and backendStdenv. - // { - inherit (cudaLib) dropDots; - cudaComputeCapabilityToName = - cudaCapability: _cuda.db.cudaCapabilityToInfo.${cudaCapability}.archName; - dropDot = cudaLib.dropDots; - isJetsonBuild = final.backendStdenv.hasJetsonCudaCapability; - }; - - # Loose packages - # Barring packages which share a home (e.g., cudatoolkit), new packages - # should be added to ../development/cuda-modules/packages in "by-name" style, where they will be automatically - # discovered and added to the package set. - - # TODO: Move to aliases.nix once all Nixpkgs has migrated to the splayed CUDA packages - cudatoolkit = final.callPackage ../development/cuda-modules/cudatoolkit/redist-wrapper.nix { }; - - tests = - let - bools = [ - true - false - ]; - configs = { - openCVFirst = bools; - useOpenCVDefaultCuda = bools; - useTorchDefaultCuda = bools; - }; - builder = - { - openCVFirst, - useOpenCVDefaultCuda, - useTorchDefaultCuda, - }@config: - { - name = strings.concatStringsSep "-" ( - [ - "test" - (if openCVFirst then "opencv" else "torch") - ] - ++ lists.optionals (if openCVFirst then useOpenCVDefaultCuda else useTorchDefaultCuda) [ - "with-default-cuda" - ] - ++ [ - "then" - (if openCVFirst then "torch" else "opencv") - ] - ++ lists.optionals (if openCVFirst then useTorchDefaultCuda else useOpenCVDefaultCuda) [ - "with-default-cuda" - ] - ); - value = final.callPackage ../development/cuda-modules/tests/opencv-and-torch config; - }; - in - attrsets.listToAttrs (attrsets.mapCartesianProduct builder configs) - // { - flags = final.callPackage ../development/cuda-modules/tests/flags.nix { }; - }; - }; - - composedExtension = fixedPoints.composeManyExtensions ( - [ - ( - final: _: - { - # Prevent missing attribute errors - # NOTE(@connorbaker): CUDA 12.3 does not have a cuda_compat package; indeed, none of the release supports - # Jetson devices. To avoid errors in the case that cuda_compat is not defined, we have a dummy package which - # is always defined, but does nothing, will not build successfully, and has no platforms. - cuda_compat = runCommand "cuda_compat" { meta.platforms = [ ]; } "false"; - } - // lib.packagesFromDirectoryRecursive { - inherit (final) callPackage; - directory = ../development/cuda-modules/packages; - } - ) - (import ../development/cuda-modules/cuda/extension.nix { inherit cudaMajorMinorVersion lib; }) - (import ../development/cuda-modules/generic-builders/multiplex.nix { - inherit - cudaLib - cudaMajorMinorVersion - lib - redistSystem - stdenv - ; - pname = "cudnn"; - redistName = "cudnn"; - releasesModule = ../development/cuda-modules/cudnn/releases.nix; - shimsFn = ../development/cuda-modules/cudnn/shims.nix; - }) - (import ../development/cuda-modules/cutensor/extension.nix { - inherit - cudaLib - cudaMajorMinorVersion - lib - redistSystem - ; - }) - (import ../development/cuda-modules/cusparselt/extension.nix { - inherit - cudaLib - lib - redistSystem - ; - }) - (import ../development/cuda-modules/generic-builders/multiplex.nix { - inherit - cudaLib - cudaMajorMinorVersion - lib - redistSystem - stdenv - ; - pname = "tensorrt"; - redistName = "tensorrt"; - releasesModule = ../development/cuda-modules/tensorrt/releases.nix; - shimsFn = ../development/cuda-modules/tensorrt/shims.nix; - }) - (import ../development/cuda-modules/cuda-library-samples/extension.nix { inherit lib stdenv; }) - ] - ++ lib.optionals config.allowAliases [ - (import ../development/cuda-modules/aliases.nix { inherit lib; }) - ] - ++ _cuda.extensions - ); - - cudaPackages = customisation.makeScope pkgs'.newScope ( - fixedPoints.extends composedExtension passthruFunction - ); + cudaPackages_13_0 = + let + inherit (cudaPackages_13_0.backendStdenv) hasJetsonCudaCapability; + in + mkCudaPackages { + cublasmp = "0.6.0"; + cuda = "13.0.2"; + cudnn = "9.13.0"; + cudss = "0.6.0"; + cuquantum = "25.09.0"; + cusolvermp = "0.7.0"; + cusparselt = "0.8.1"; + cutensor = "2.3.1"; + nppplus = "0.10.0"; + nvcomp = "5.0.0.6"; + nvjpeg2000 = "0.9.0"; + nvpl = "25.5"; + nvtiff = "0.5.1"; + tensorrt = if hasJetsonCudaCapability then "10.7.0" else "10.9.0"; + }; in -cudaPackages +{ + inherit + cudaPackages_12_6 + cudaPackages_12_8 + cudaPackages_12_9 + cudaPackages_13_0 + ; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 6d0597a9052b..7c30ff851608 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -3190,13 +3190,19 @@ self: super: with self; { cucumber-tag-expressions = callPackage ../development/python-modules/cucumber-tag-expressions { }; cupy = callPackage ../development/python-modules/cupy { - cudaPackages = pkgs.cudaPackages.overrideScope ( - cu-fi: _: { - # CuDNN 9 is not supported: - # https://github.com/cupy/cupy/issues/8215 - cudnn = cu-fi.cudnn_8_9; - } - ); + cudaPackages = + # CuDNN 9 is not supported: + # https://github.com/cupy/cupy/issues/8215 + # NOTE: cupy 14 will drop support for cuDNN entirely. + # https://github.com/cupy/cupy/pull/9326 + let + version = if pkgs.cudaPackages.backendStdenv.hasJetsonCudaCapability then "8.9.5" else "8.9.7"; + in + pkgs.cudaPackages.override (prevArgs: { + manifests = prevArgs.manifests // { + cudnn = pkgs._cuda.manifests.cudnn.${version}; + }; + }); }; curated-tokenizers = callPackage ../development/python-modules/curated-tokenizers { };