colin/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge master into staging-next

Browse Source
This commit is contained in:
github-actions[bot] 2023-12-08 00:02:27 +00:00 committed by GitHub
commit 728281e1ea
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
129 changed files with 19741 additions and 18518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
doc/languages-frameworks/cuda.section.md
View File

@ -68,16 +68,45 @@ All new projects should use the CUDA redistributables available in [`cudaPackage
### Updating CUDA redistributables {#updating-cuda-redistributables}
1. Go to NVIDIA's index of CUDA redistributables: <https://developer.download.nvidia.com/compute/cuda/redist/>
2. Copy the `redistrib_*.json` corresponding to the release to `pkgs/development/compilers/cudatoolkit/redist/manifests`.
3. Generate the `redistrib_features_*.json` file by running:
2. Make a note of the new version of CUDA available.
3. Run
```bash
nix run github:ConnorBaker/cuda-redist-find-features -- <path to manifest>
```
```bash
nix run github:connorbaker/cuda-redist-find-features -- \
download-manifests \
--log-level DEBUG \
--version <newest CUDA version> \
https://developer.download.nvidia.com/compute/cuda/redist \
./pkgs/development/cuda-modules/cuda/manifests
```
That command will generate the `redistrib_features_*.json` file in the same directory as the manifest.
This will download a copy of the manifest for the new version of CUDA.
4. Run
4. Include the path to the new manifest in `pkgs/development/compilers/cudatoolkit/redist/extension.nix`.
```bash
nix run github:connorbaker/cuda-redist-find-features -- \
process-manifests \
--log-level DEBUG \
--version <newest CUDA version> \
https://developer.download.nvidia.com/compute/cuda/redist \
./pkgs/development/cuda-modules/cuda/manifests
```
This will generate a `redistrib_features_<newest CUDA version>.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 {#updating-cutensor}
1. Repeat the steps present in [Updating CUDA redistributables](#updating-cuda-redistributables) with the following changes:
- Use the index of cuTensor redistributables: <https://developer.download.nvidia.com/compute/cutensor/redist>
- 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`.
### Updating supported compilers and GPUs {#updating-supported-compilers-and-gpus}
1. Update `nvcc-compatibilities.nix` in `pkgs/development/cuda-modules/` to include the newest release of NVCC, as well as any newly supported host compilers.
2. Update `gpus.nix` in `pkgs/development/cuda-modules/` to include any new GPUs supported by the new release of CUDA.
### Updating the CUDA Toolkit runfile installer {#updating-the-cuda-toolkit}
@ -99,7 +128,7 @@ All new projects should use the CUDA redistributables available in [`cudaPackage
nix store prefetch-file --hash-type sha256 <link>
```
4. Update `pkgs/development/compilers/cudatoolkit/versions.toml` to include the release.
4. Update `pkgs/development/cuda-modules/cudatoolkit/releases.nix` to include the release.
### Updating the CUDA package set {#updating-the-cuda-package-set}
@ -107,7 +136,7 @@ All new projects should use the CUDA redistributables available in [`cudaPackage
- NOTE: Changing the default CUDA package set should occur in a separate PR, allowing time for additional testing.
2. Successfully build the closure of the new package set, updating `pkgs/development/compilers/cudatoolkit/redist/overrides.nix` as needed. Below are some common failures:
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:
| Unable to ... | During ... | Reason | Solution | Note |
| --- | --- | --- | --- | --- |

1
nixos/modules/services/audio/wyoming/faster-whisper.nix
View File

@ -121,6 +121,7 @@ in
in mkIf (cfg.servers != {}) {
systemd.services = mapAttrs' (server: options:
nameValuePair "wyoming-faster-whisper-${server}" {
inherit (options) enable;
description = "Wyoming faster-whisper server instance ${server}";
after = [
"network-online.target"

1
nixos/modules/services/audio/wyoming/piper.nix
View File

@ -116,6 +116,7 @@ in
in mkIf (cfg.servers != {}) {
systemd.services = mapAttrs' (server: options:
nameValuePair "wyoming-piper-${server}" {
inherit (options) enable;
description = "Wyoming Piper server instance ${server}";
after = [
"network-online.target"

4
pkgs/applications/blockchains/bitcoin/default.nix
View File

@ -72,6 +72,10 @@ stdenv.mkDerivation rec {
install -Dm644 share/pixmaps/bitcoin256.png $out/share/pixmaps/bitcoin.png
'';
preConfigure = lib.optionalString stdenv.isDarwin ''
export MACOSX_DEPLOYMENT_TARGET=10.13
'';
configureFlags = [
"--with-boost-libdir=${boost.out}/lib"
"--disable-bench"

6
pkgs/applications/editors/vscode/generic.nix
View File

@ -247,7 +247,11 @@ in
);
postFixup = lib.optionalString stdenv.isLinux ''
patchelf --add-needed ${libglvnd}/lib/libGLESv2.so.2 $out/lib/vscode/${executableName}
patchelf \
--add-needed ${libglvnd}/lib/libGLESv2.so.2 \
--add-needed ${libglvnd}/lib/libGL.so.1 \
--add-needed ${libglvnd}/lib/libEGL.so.1 \
$out/lib/vscode/${executableName}
'';
inherit meta;

27
pkgs/applications/science/math/caffe/default.nix
View File

@ -26,24 +26,17 @@ let
# The default for cudatoolkit 10.1 is CUDNN 8.0.5, the last version to support CUDA 10.1.
# However, this caffe does not build with CUDNN 8.x, so we use CUDNN 7.6.5 instead.
# Earlier versions of cudatoolkit use pre-8.x CUDNN, so we use the default.
cudnn = if lib.versionOlder cudatoolkit.version "10.1"
then cudaPackages.cudnn
else cudaPackages.cudnn_7_6;
in
hasCudnn =
if lib.versionOlder cudatoolkit.version "10.1"
then cudaPackages ? cudnn
else cudaPackages ? cudnn_7_6;
assert leveldbSupport -> (leveldb != null && snappy != null);
assert cudnnSupport -> cudaSupport;
assert ncclSupport -> cudaSupport;
assert pythonSupport -> (python != null && numpy != null);
let
toggle = bool: if bool then "ON" else "OFF";
test_model_weights = fetchurl {
url = "http://dl.caffe.berkeleyvision.org/bvlc_reference_caffenet.caffemodel";
sha256 = "472d4a06035497b180636d8a82667129960371375bd10fcb6df5c6c7631f25e0";
};
in
stdenv.mkDerivation rec {
@ -74,7 +67,8 @@ stdenv.mkDerivation rec {
buildInputs = [ boost gflags glog protobuf hdf5-cpp opencv4 blas ]
++ lib.optional cudaSupport cudatoolkit
++ lib.optional cudnnSupport cudnn
++ lib.optional (lib.versionOlder cudatoolkit.version "10.1" && hasCudnn) cudaPackages.cudnn
++ lib.optional (lib.versionAtLeast cudatoolkit.version "10.1" && hasCudnn) cudaPackages.cudnn_7_6
++ lib.optional lmdbSupport lmdb
++ lib.optional ncclSupport nccl
++ lib.optionals leveldbSupport [ leveldb snappy ]
@ -154,7 +148,14 @@ stdenv.mkDerivation rec {
'';
homepage = "http://caffe.berkeleyvision.org/";
maintainers = with maintainers; [ ];
broken = (pythonSupport && (python.isPy310)) || cudaSupport;
broken =
(pythonSupport && (python.isPy310))
|| cudaSupport
|| !(leveldbSupport -> (leveldb != null && snappy != null))
|| !(cudnnSupport -> (hasCudnn && cudaSupport))
|| !(ncclSupport -> cudaSupport)
|| !(pythonSupport -> (python != null && numpy != null))
;
license = licenses.bsd2;
platforms = platforms.linux ++ platforms.darwin;
};

4
pkgs/applications/version-management/gh/default.nix
View File

@ -2,13 +2,13 @@
buildGoModule rec {
pname = "gh";
version = "2.39.2";
version = "2.40.0";
src = fetchFromGitHub {
owner = "cli";
repo = "cli";
rev = "v${version}";
hash = "sha256-6FjsUEroHpAjQj+7Z/C935LunYbgAzRvQI2pORiLo3s=";
hash = "sha256-ffmOyifoJPrrC9J4lZ7HWq+fww5/EOCYhYIfx6Been0=";
};
vendorHash = "sha256-jM9nwTMOTh+eXztLvHIwwH4qu3ZIMOtBrPEtByB9Ry8=";

38
pkgs/by-name/ar/arduino-ide/package.nix Normal file
View File

@ -0,0 +1,38 @@
{ appimageTools
, fetchurl
, lib
}:
let
pname = "arduino-ide";
version = "2.2.1";
src = fetchurl {
url = "https://github.com/arduino/arduino-ide/releases/download/${version}/arduino-ide_${version}_Linux_64bit.AppImage";
hash = "sha256-77uS/3ean3dWG/vDHG+ry238hiJlYub7H03f15eJu+I=";
};
appimageContents = appimageTools.extractType2 { inherit pname version src; };
in
appimageTools.wrapType2 {
inherit pname version src;
extraInstallCommands = ''
mv $out/bin/{${pname}-${version},${pname}}
install -Dm444 ${appimageContents}/${pname}.desktop -t $out/share/applications/
install -Dm444 ${appimageContents}/${pname}.png -t $out/share/pixmaps/
'';
extraPkgs = pkgs: with pkgs; [ libsecret ];
meta = with lib; {
description = "Open-source electronics prototyping platform";
homepage = "https://www.arduino.cc/en/software";
changelog = "https://github.com/arduino/arduino-ide/releases/tag/${version}";
license = licenses.agpl3Only;
mainProgram = "arduino-ide";
maintainers = with maintainers; [ clerie ];
platforms = [ "x86_64-linux" ];
};
}

14
pkgs/data/themes/catppuccin/default.nix
View File

@ -1,5 +1,5 @@
let
validThemes = [ "bat" "bottom" "btop" "grub" "hyprland" "k9s" "kvantum" "lazygit" "plymouth" "refind" "rofi" "waybar" ];
validThemes = [ "bat" "bottom" "btop" "grub" "hyprland" "k9s" "kvantum" "lazygit" "plymouth" "qt5ct" "refind" "rofi" "waybar" ];
in
{ fetchFromGitHub
, lib
@ -88,6 +88,14 @@ let
hash = "sha256-quBSH8hx3gD7y1JNWAKQdTk3CmO4t1kVo4cOGbeWlNE=";
};
qt5ct = fetchFromGitHub {
name = "qt5ct";
owner = "catppuccin";
repo = "qt5ct";
rev = "89ee948e72386b816c7dad72099855fb0d46d41e";
hash = "sha256-t/uyK0X7qt6qxrScmkTU2TvcVJH97hSQuF0yyvSO/qQ=";
};
refind = fetchFromGitHub {
name = "refind";
owner = "catppuccin";
@ -174,6 +182,10 @@ stdenvNoCC.mkDerivation {
cp ${sources.plymouth}/themes/catppuccin-${variant}/* $out/share/plymouth/themes/catppuccin-${variant}
sed -i 's:\(^ImageDir=\)/usr:\1'"$out"':' $out/share/plymouth/themes/catppuccin-${variant}/catppuccin-${variant}.plymouth
'' + lib.optionalString (lib.elem "qt5ct" themeList) ''
mkdir -p $out/qt5ct
cp ${sources.qt5ct}/themes/Catppuccin-"$capitalizedVariant".conf $out/qt5ct/
'' + lib.optionalString (lib.elem "rofi" themeList) ''
mkdir -p $out/rofi
cp ${sources.rofi}/basic/.local/share/rofi/themes/catppuccin-${variant}.rasi $out/rofi/

367
pkgs/development/compilers/cudatoolkit/common.nix
View File

@ -1,367 +0,0 @@
args@
{ version
, sha256
, url ? ""
, name ? ""
, developerProgram ? false
, runPatches ? []
, autoPatchelfHook
, autoAddOpenGLRunpathHook
, addOpenGLRunpath
, alsa-lib
, curlMinimal
, expat
, fetchurl
, fontconfig
, freetype
, gdk-pixbuf
, glib
, glibc
, gst_all_1
, gtk2
, lib
, libxkbcommon
, libkrb5
, krb5
, makeWrapper
, markForCudatoolkitRootHook
, ncurses5
, numactl
, nss
, perl
, python3 # FIXME: CUDAToolkit 10 may still need python27
, pulseaudio
, requireFile
, setupCudaHook
, stdenv
, backendStdenv # E.g. gcc11Stdenv, set in extension.nix
, unixODBC
, wayland
, xorg
, zlib
, freeglut
, libGLU
, libsForQt5
, libtiff
, qt6Packages
, qt6
, rdma-core
, ucx
, rsync
}:
backendStdenv.mkDerivation rec {
pname = "cudatoolkit";
inherit version runPatches;
dontPatchELF = true;
dontStrip = true;
src =
if developerProgram then
requireFile {
message = ''
This nix expression requires that ${args.name} is already part of the store.
Register yourself to NVIDIA Accelerated Computing Developer Program, retrieve the CUDA toolkit
at https://developer.nvidia.com/cuda-toolkit, and run the following command in the download directory:
nix-prefetch-url file://\$PWD/${args.name}
'';
inherit (args) name sha256;
}
else
fetchurl {
inherit (args) url sha256;
};
outputs = [ "out" "lib" "doc" ];
nativeBuildInputs = [
perl
makeWrapper
rsync
addOpenGLRunpath
autoPatchelfHook
autoAddOpenGLRunpathHook
markForCudatoolkitRootHook
] ++ lib.optionals (lib.versionOlder version "11") [
libsForQt5.wrapQtAppsHook
] ++ lib.optionals (lib.versionAtLeast version "11.8") [
qt6Packages.wrapQtAppsHook
];
depsTargetTargetPropagated = [
setupCudaHook
];
buildInputs = lib.optionals (lib.versionOlder version "11") [
libsForQt5.qt5.qtwebengine
freeglut
libGLU
] ++ [
# To get $GDK_PIXBUF_MODULE_FILE via setup-hook
gdk-pixbuf
# For autoPatchelf
ncurses5
expat
python3
zlib
glibc
xorg.libX11
xorg.libXext
xorg.libXrender
xorg.libXt
xorg.libXtst
xorg.libXi
xorg.libXext
xorg.libXdamage
xorg.libxcb
xorg.xcbutilimage
xorg.xcbutilrenderutil
xorg.xcbutilwm
xorg.xcbutilkeysyms
pulseaudio
libxkbcommon
libkrb5
krb5
gtk2
glib
fontconfig
freetype
numactl
nss
unixODBC
alsa-lib
wayland
] ++ lib.optionals (lib.versionAtLeast version "11.8") [
(lib.getLib libtiff)
qt6Packages.qtwayland
rdma-core
(ucx.override { enableCuda = false; }) # Avoid infinite recursion
xorg.libxshmfence
xorg.libxkbfile
] ++ (lib.optionals (lib.versionAtLeast version "12") (map lib.getLib ([
# Used by `/target-linux-x64/CollectX/clx` and `/target-linux-x64/CollectX/libclx_api.so` for:
# - `libcurl.so.4`
curlMinimal
# Used by `/host-linux-x64/Scripts/WebRTCContainer/setup/neko/server/bin/neko`
gst_all_1.gstreamer
gst_all_1.gst-plugins-base
]) ++ (with qt6; [
qtmultimedia
qttools
qtpositioning
qtscxml
qtsvg
qtwebchannel
qtwebengine
])));
# Prepended to runpaths by autoPatchelf.
# The order inherited from older rpath preFixup code
runtimeDependencies = [
(placeholder "lib")
(placeholder "out")
"${placeholder "out"}/nvvm"
# NOTE: use the same libstdc++ as the rest of nixpkgs, not from backendStdenv
"${lib.getLib stdenv.cc.cc}/lib64"
"${placeholder "out"}/jre/lib/amd64/jli"
"${placeholder "out"}/lib64"
"${placeholder "out"}/nvvm/lib64"
];
autoPatchelfIgnoreMissingDeps = [
# This is the hardware-dependent userspace driver that comes from
# nvidia_x11 package. It must be deployed at runtime in
# /run/opengl-driver/lib or pointed at by LD_LIBRARY_PATH variable, rather
# than pinned in runpath
"libcuda.so.1"
# The krb5 expression ships libcom_err.so.3 but cudatoolkit asks for the
# older
# This dependency is asked for by target-linux-x64/CollectX/RedHat/x86_64/libssl.so.10
# - do we even want to use nvidia-shipped libssl?
"libcom_err.so.2"
];
preFixup = if lib.versionOlder version "11" then ''
patchelf $out/targets/*/lib/libnvrtc.so --add-needed libnvrtc-builtins.so
'' else ''
patchelf $out/lib64/libnvrtc.so --add-needed libnvrtc-builtins.so
'';
unpackPhase = ''
sh $src --keep --noexec
${lib.optionalString (lib.versionOlder version "10.1") ''
cd pkg/run_files
sh cuda-linux*.run --keep --noexec
sh cuda-samples*.run --keep --noexec
mv pkg ../../$(basename $src)
cd ../..
rm -rf pkg
for patch in $runPatches; do
sh $patch --keep --noexec
mv pkg $(basename $patch)
done
''}
'';
installPhase = ''
runHook preInstall
mkdir $out
${lib.optionalString (lib.versionOlder version "10.1") ''
cd $(basename $src)
export PERL5LIB=.
perl ./install-linux.pl --prefix="$out"
cd ..
for patch in $runPatches; do
cd $(basename $patch)
perl ./install_patch.pl --silent --accept-eula --installdir="$out"
cd ..
done
''}
${lib.optionalString (lib.versionAtLeast version "10.1" && lib.versionOlder version "11") ''
cd pkg/builds/cuda-toolkit
mv * $out/
''}
${lib.optionalString (lib.versionAtLeast version "11") ''
mkdir -p $out/bin $out/lib64 $out/include $doc
for dir in pkg/builds/* pkg/builds/cuda_nvcc/nvvm pkg/builds/cuda_cupti/extras/CUPTI; do
if [ -d $dir/bin ]; then
mv $dir/bin/* $out/bin
fi
if [ -d $dir/doc ]; then
(cd $dir/doc && find . -type d -exec mkdir -p $doc/\{} \;)
(cd $dir/doc && find . \( -type f -o -type l \) -exec mv \{} $doc/\{} \;)
fi
if [ -L $dir/include ] || [ -d $dir/include ]; then
(cd $dir/include && find . -type d -exec mkdir -p $out/include/\{} \;)
(cd $dir/include && find . \( -type f -o -type l \) -exec mv \{} $out/include/\{} \;)
fi
if [ -L $dir/lib64 ] || [ -d $dir/lib64 ]; then
(cd $dir/lib64 && find . -type d -exec mkdir -p $out/lib64/\{} \;)
(cd $dir/lib64 && find . \( -type f -o -type l \) -exec mv \{} $out/lib64/\{} \;)
fi
done
mv pkg/builds/cuda_nvcc/nvvm $out/nvvm
mv pkg/builds/cuda_sanitizer_api $out/cuda_sanitizer_api
ln -s $out/cuda_sanitizer_api/compute-sanitizer/compute-sanitizer $out/bin/compute-sanitizer
mv pkg/builds/nsight_systems/target-linux-x64 $out/target-linux-x64
mv pkg/builds/nsight_systems/host-linux-x64 $out/host-linux-x64
rm $out/host-linux-x64/libstdc++.so*
''}
${lib.optionalString (lib.versionAtLeast version "11.8")
# error: auto-patchelf could not satisfy dependency libtiff.so.5 wanted by /nix/store/.......-cudatoolkit-12.0.1/host-linux-x64/Plugins/imageformats/libqtiff.so
# we only ship libtiff.so.6, so let's use qt plugins built by Nix.
# TODO: don't copy, come up with a symlink-based "merge"
''
rsync ${lib.getLib qt6Packages.qtimageformats}/lib/qt-6/plugins/ $out/host-linux-x64/Plugins/ -aP
''}
rm -f $out/tools/CUDA_Occupancy_Calculator.xls # FIXME: why?
${lib.optionalString (lib.versionOlder version "10.1") ''
# let's remove the 32-bit libraries, they confuse the lib64->lib mover
rm -rf $out/lib
''}
${lib.optionalString (lib.versionAtLeast version "12.0") ''
rm $out/host-linux-x64/libQt6*
''}
# Remove some cruft.
${lib.optionalString ((lib.versionAtLeast version "7.0") && (lib.versionOlder version "10.1"))
"rm $out/bin/uninstall*"}
# Fixup path to samples (needed for cuda 6.5 or else nsight will not find them)
if [ -d "$out"/cuda-samples ]; then
mv "$out"/cuda-samples "$out"/samples
fi
# Change the #error on GCC > 4.9 to a #warning.
sed -i $out/include/host_config.h -e 's/#error\(.*unsupported GNU version\)/#warning\1/'
# Fix builds with newer glibc version
sed -i "1 i#define _BITS_FLOATN_H" "$out/include/host_defines.h"
'' +
# Point NVCC at a compatible compiler
# CUDA_TOOLKIT_ROOT_DIR is legacy,
# Cf. https://cmake.org/cmake/help/latest/module/FindCUDA.html#input-variables
''
mkdir -p $out/nix-support
cat <<EOF >> $out/nix-support/setup-hook
cmakeFlags+=' -DCUDA_TOOLKIT_ROOT_DIR=$out'
EOF
# Move some libraries to the lib output so that programs that
# depend on them don't pull in this entire monstrosity.
mkdir -p $lib/lib
mv -v $out/lib64/libcudart* $lib/lib/
# Remove OpenCL libraries as they are provided by ocl-icd and driver.
rm -f $out/lib64/libOpenCL*
${lib.optionalString (lib.versionAtLeast version "10.1" && (lib.versionOlder version "11")) ''
mv $out/lib64 $out/lib
mv $out/extras/CUPTI/lib64/libcupti* $out/lib
''}
# nvprof do not find any program to profile if LD_LIBRARY_PATH is not set
wrapProgram $out/bin/nvprof \
--prefix LD_LIBRARY_PATH : $out/lib
'' + lib.optionalString (lib.versionOlder version "8.0") ''
# Hack to fix building against recent Glibc/GCC.
echo "NIX_CFLAGS_COMPILE+=' -D_FORCE_INLINES'" >> $out/nix-support/setup-hook
''
# 11.8 includes a broken symlink, include/include, pointing to targets/x86_64-linux/include
+ lib.optionalString (lib.versions.majorMinor version == "11.8") ''
rm $out/include/include
'' + ''
runHook postInstall
'';
postInstall = ''
for b in nvvp ${lib.optionalString (lib.versionOlder version "11") "nsight"}; do
wrapProgram "$out/bin/$b" \
--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE"
done
'';
# cuda-gdb doesn't run correctly when not using sandboxing, so
# temporarily disabling the install check. This should be set to true
# when we figure out how to get `cuda-gdb --version` to run correctly
# when not using sandboxing.
doInstallCheck = false;
postInstallCheck = let
in ''
# Smoke test binaries
pushd $out/bin
for f in *; do
case $f in
crt) continue;;
nvcc.profile) continue;;
nsight_ee_plugins_manage.sh) continue;;
uninstall_cuda_toolkit_6.5.pl) continue;;
computeprof|nvvp|nsight) continue;; # GUIs don't feature "--version"
*) echo "Executing '$f --version':"; ./$f --version;;
esac
done
popd
'';
passthru = {
inherit (backendStdenv) cc;
majorMinorVersion = lib.versions.majorMinor version;
majorVersion = lib.versions.majorMinor version;
};
meta = with lib; {
description = "A compiler for NVIDIA GPUs, math libraries, and tools";
homepage = "https://developer.nvidia.com/cuda-toolkit";
platforms = [ "x86_64-linux" ];
license = licenses.nvidiaCuda;
maintainers = teams.cuda.members;
};
}

170
pkgs/development/compilers/cudatoolkit/flags.nix
View File

@ -1,170 +0,0 @@
{ config
, lib
, cudaVersion
}:
# Type aliases
# Gpu :: AttrSet
# - See the documentation in ./gpus.nix.
let
inherit (lib) attrsets lists strings trivial versions;
# Flags are determined based on your CUDA toolkit by default. You may benefit
# from improved performance, reduced file size, or greater hardware support by
# passing a configuration based on your specific GPU environment.
#
# config.cudaCapabilities :: List Capability
# List of hardware generations to build.
# E.g. [ "8.0" ]
# Currently, the last item is considered the optional forward-compatibility arch,
# but this may change in the future.
#
# config.cudaForwardCompat :: Bool
# Whether to include the forward compatibility gencode (+PTX)
# to support future GPU generations.
# E.g. true
#
# Please see the accompanying documentation or https://github.com/NixOS/nixpkgs/pull/205351
# gpus :: List Gpu
gpus = builtins.import ./gpus.nix;
# isSupported :: Gpu -> Bool
isSupported = gpu:
let
inherit (gpu) minCudaVersion maxCudaVersion;
lowerBoundSatisfied = strings.versionAtLeast cudaVersion minCudaVersion;
upperBoundSatisfied = (maxCudaVersion == null)
|| !(strings.versionOlder maxCudaVersion cudaVersion);
in
lowerBoundSatisfied && upperBoundSatisfied;
# isDefault :: Gpu -> Bool
isDefault = gpu:
let
inherit (gpu) dontDefaultAfter;
newGpu = dontDefaultAfter == null;
recentGpu = newGpu || strings.versionAtLeast dontDefaultAfter cudaVersion;
in
recentGpu;
# supportedGpus :: List Gpu
# GPUs which are supported by the provided CUDA version.
supportedGpus = builtins.filter isSupported gpus;
# defaultGpus :: List Gpu
# GPUs which are supported by the provided CUDA version and we want to build for by default.
defaultGpus = builtins.filter isDefault supportedGpus;
# supportedCapabilities :: List Capability
supportedCapabilities = lists.map (gpu: gpu.computeCapability) supportedGpus;
# defaultCapabilities :: List Capability
# The default capabilities to target, if not overridden by the user.
defaultCapabilities = lists.map (gpu: gpu.computeCapability) defaultGpus;
# cudaArchNameToVersions :: AttrSet String (List String)
# Maps the name of a GPU architecture to different versions of that architecture.
# For example, "Ampere" maps to [ "8.0" "8.6" "8.7" ].
cudaArchNameToVersions =
lists.groupBy'
(versions: gpu: versions ++ [ gpu.computeCapability ])
[ ]
(gpu: gpu.archName)
supportedGpus;
# cudaComputeCapabilityToName :: AttrSet String String
# Maps the version of a GPU architecture to the name of that architecture.
# For example, "8.0" maps to "Ampere".
cudaComputeCapabilityToName = builtins.listToAttrs (
lists.map
(gpu: {
name = gpu.computeCapability;
value = gpu.archName;
})
supportedGpus
);
# dropDot :: String -> String
dropDot = ver: builtins.replaceStrings [ "." ] [ "" ] ver;
# archMapper :: String -> List String -> List String
# Maps a feature across a list of architecture versions to produce a list of architectures.
# For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "sm_80" "sm_86" "sm_87" ].
archMapper = feat: lists.map (computeCapability: "${feat}_${dropDot computeCapability}");
# gencodeMapper :: String -> List String -> List String
# Maps a feature across a list of architecture versions to produce a list of gencode arguments.
# For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "-gencode=arch=compute_80,code=sm_80"
# "-gencode=arch=compute_86,code=sm_86" "-gencode=arch=compute_87,code=sm_87" ].
gencodeMapper = feat: lists.map (
computeCapability:
"-gencode=arch=compute_${dropDot computeCapability},code=${feat}_${dropDot computeCapability}"
);
formatCapabilities = { cudaCapabilities, enableForwardCompat ? true }: rec {
inherit cudaCapabilities enableForwardCompat;
# archNames :: List String
# E.g. [ "Turing" "Ampere" ]
archNames = lists.unique (builtins.map (cap: cudaComputeCapabilityToName.${cap} or (throw "missing cuda compute capability")) cudaCapabilities);
# realArches :: List String
# The real architectures are physical architectures supported by the CUDA version.
# E.g. [ "sm_75" "sm_86" ]
realArches = archMapper "sm" cudaCapabilities;
# virtualArches :: List String
# The virtual architectures are typically used for forward compatibility, when trying to support
# an architecture newer than the CUDA version allows.
# E.g. [ "compute_75" "compute_86" ]
virtualArches = archMapper "compute" cudaCapabilities;
# arches :: List String
# By default, build for all supported architectures and forward compatibility via a virtual
# architecture for the newest supported architecture.
# E.g. [ "sm_75" "sm_86" "compute_86" ]
arches = realArches ++
lists.optional enableForwardCompat (lists.last virtualArches);
# gencode :: List String
# A list of CUDA gencode arguments to pass to NVCC.
# E.g. [ "-gencode=arch=compute_75,code=sm_75" ... "-gencode=arch=compute_86,code=compute_86" ]
gencode =
let
base = gencodeMapper "sm" cudaCapabilities;
forward = gencodeMapper "compute" [ (lists.last cudaCapabilities) ];
in
base ++ lib.optionals enableForwardCompat forward;
};
in
# When changing names or formats: pause, validate, and update the assert
assert (formatCapabilities { cudaCapabilities = [ "7.5" "8.6" ]; }) == {
cudaCapabilities = [ "7.5" "8.6" ];
enableForwardCompat = true;
archNames = [ "Turing" "Ampere" ];
realArches = [ "sm_75" "sm_86" ];
virtualArches = [ "compute_75" "compute_86" ];
arches = [ "sm_75" "sm_86" "compute_86" ];
gencode = [ "-gencode=arch=compute_75,code=sm_75" "-gencode=arch=compute_86,code=sm_86" "-gencode=arch=compute_86,code=compute_86" ];
};
{
# formatCapabilities :: { cudaCapabilities: List Capability, cudaForwardCompat: Boolean } -> { ... }
inherit formatCapabilities;
# cudaArchNameToVersions :: String => String
inherit cudaArchNameToVersions;
# cudaComputeCapabilityToName :: String => String
inherit cudaComputeCapabilityToName;
# dropDot :: String -> String
inherit dropDot;
} // formatCapabilities {
cudaCapabilities = config.cudaCapabilities or defaultCapabilities;
enableForwardCompat = config.cudaForwardCompat or true;
}

148
pkgs/development/compilers/cudatoolkit/gpus.nix
View File

@ -1,148 +0,0 @@
[
# Type alias
# Gpu = {
# archName: String
# - The name of the microarchitecture.
# computeCapability: String
# - The compute capability of the GPU.
# minCudaVersion: String
# - The minimum (inclusive) CUDA version that supports this GPU.
# dontDefaultAfter: null | String
# - The CUDA version after which to exclude this GPU from the list of default capabilities
# we build. null means we always include this GPU in the default capabilities if it is
# supported.
# maxCudaVersion: null | String
# - The maximum (exclusive) CUDA version that supports this GPU. null means there is no
# maximum.
# }
{
archName = "Kepler";
computeCapability = "3.0";
minCudaVersion = "10.0";
dontDefaultAfter = "10.2";
maxCudaVersion = "10.2";
}
{
archName = "Kepler";
computeCapability = "3.2";
minCudaVersion = "10.0";
dontDefaultAfter = "10.2";
maxCudaVersion = "10.2";
}
{
archName = "Kepler";
computeCapability = "3.5";
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = "11.8";
}
{
archName = "Kepler";
computeCapability = "3.7";
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = "11.8";
}
{
archName = "Maxwell";
computeCapability = "5.0";
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = null;
}
{
archName = "Maxwell";
computeCapability = "5.2";
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = null;
}
{
archName = "Maxwell";
computeCapability = "5.3";
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = null;
}
{
archName = "Pascal";
computeCapability = "6.0";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Pascal";
computeCapability = "6.1";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Pascal";
computeCapability = "6.2";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Volta";
computeCapability = "7.0";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Volta";
computeCapability = "7.2";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Turing";
computeCapability = "7.5";
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Ampere";
computeCapability = "8.0";
minCudaVersion = "11.2";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Ampere";
computeCapability = "8.6";
minCudaVersion = "11.2";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Ampere";
computeCapability = "8.7";
minCudaVersion = "11.5";
# NOTE: This is purposefully before 11.5 to ensure it is never a capability we target by
# default. 8.7 is the Jetson Orin series of devices which are a very specific platform.
# We keep this entry here in case we ever want to target it explicitly, but we don't
# want to target it by default.
dontDefaultAfter = "11.4";
maxCudaVersion = null;
}
{
archName = "Ada";
computeCapability = "8.9";
minCudaVersion = "11.8";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
archName = "Hopper";
computeCapability = "9.0";
minCudaVersion = "11.8";
dontDefaultAfter = null;
maxCudaVersion = null;
}
]

178
pkgs/development/compilers/cudatoolkit/redist/build-cuda-redist-package.nix
View File

@ -1,178 +0,0 @@
# Type Aliases
#
# See ./extension.nix:
# - ReleaseAttrs
# - ReleaseFeaturesAttrs
#
# General callPackage-supplied arguments
{ lib
, stdenv
, backendStdenv
, fetchurl
, autoPatchelfHook
, autoAddOpenGLRunpathHook
, markForCudatoolkitRootHook
, lndir
, symlinkJoin
}:
# Function arguments
{
# Short package name (e.g., "cuda_cccl")
# pname : String
pname
, # Long package name (e.g., "CXX Core Compute Libraries")
# description : String
description
, # platforms : List System
platforms
, # version : Version
version
, # releaseAttrs : ReleaseAttrs
releaseAttrs
, # releaseFeaturesAttrs : ReleaseFeaturesAttrs
releaseFeaturesAttrs
,
}:
let
# Useful imports
inherit (lib.lists) optionals;
inherit (lib.meta) getExe;
inherit (lib.strings) optionalString;
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 version;
strictDeps = true;
outputs = with releaseFeaturesAttrs;
[ "out" ]
++ optionals hasBin [ "bin" ]
++ optionals hasLib [ "lib" ]
++ optionals hasStatic [ "static" ]
++ optionals hasDev [ "dev" ]
++ optionals hasDoc [ "doc" ]
++ optionals hasSample [ "sample" ];
src = fetchurl {
url = "https://developer.download.nvidia.com/compute/cuda/redist/${releaseAttrs.relative_path}";
inherit (releaseAttrs) sha256;
};
# 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
autoAddOpenGLRunpathHook
markForCudatoolkitRootHook
];
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
stdenv.cc.cc.lib
];
# Picked up by autoPatchelf
# Needed e.g. for libnvrtc to locate (dlopen) libnvrtc-builtins
appendRunpaths = [
"$ORIGIN"
];
installPhase = with releaseFeaturesAttrs;
# Pre-install hook
''
runHook preInstall
''
# doc and dev have special output handling. Other outputs need to be moved to their own
# output.
# Note that moveToOutput operates on all outputs:
# https://github.com/NixOS/nixpkgs/blob/2920b6fc16a9ed5d51429e94238b28306ceda79e/pkgs/build-support/setup-hooks/multiple-outputs.sh#L105-L107
+ ''
mkdir -p "$out"
rm LICENSE
mv * "$out"
''
# Handle bin, which defaults to out
+ optionalString hasBin ''
moveToOutput "bin" "$bin"
''
# Handle lib, which defaults to out
+ optionalString hasLib ''
moveToOutput "lib" "$lib"
''
# Handle static libs, which isn't handled by the setup hook
+ optionalString hasStatic ''
moveToOutput "**/*.a" "$static"
''
# Handle samples, which isn't handled by the setup hook
+ optionalString hasSample ''
moveToOutput "samples" "$sample"
''
# Post-install hook
+ ''
runHook postInstall
'';
# The out output leverages the same functionality which backs the `symlinkJoin` function in
# Nixpkgs:
# https://github.com/NixOS/nixpkgs/blob/d8b2a92df48f9b08d68b0132ce7adfbdbc1fbfac/pkgs/build-support/trivial-builders/default.nix#L510
#
# That should allow us to emulate "fat" default outputs without having to actually create them.
#
# It is important that this run after the autoPatchelfHook, otherwise the symlinks in out will reference libraries in lib, creating a circular dependency.
postPhases = [ "postPatchelf" ];
# For each output, create a symlink to it in the out output.
# NOTE: We must recreate the out output here, because the setup hook will have deleted it
# if it was empty.
# NOTE: Do not use optionalString based on whether `outputs` contains only `out` -- phases
# which are empty strings are skipped/unset and result in errors of the form "command not
# found: <customPhaseName>".
postPatchelf = ''
mkdir -p "$out"
for output in $outputs; do
if [ "$output" = "out" ]; then
continue
fi
${getExe lndir} "''${!output}" "$out"
done
'';
# Make the CUDA-patched stdenv available
passthru.stdenv = backendStdenv;
# Setting propagatedBuildInputs to false will prevent outputs known to the multiple-outputs
# from depending on `out` by default.
# https://github.com/NixOS/nixpkgs/blob/2920b6fc16a9ed5d51429e94238b28306ceda79e/pkgs/build-support/setup-hooks/multiple-outputs.sh#L196
# Indeed, we want to do the opposite -- fat "out" outputs that contain all the other outputs.
propagatedBuildOutputs = false;
# By default, if the dev output exists it just uses that.
# However, because we disabled propagatedBuildOutputs, dev doesn't contain libraries or
# anything of the sort. To remedy this, we set outputSpecified to true, and use
# outputsToInstall, which tells Nix which outputs to use when the package name is used
# unqualified (that is, without an explicit output).
outputSpecified = true;
meta = {
inherit platforms;
description = "${description}. By downloading and using the packages you accept the terms and conditions of the ${finalAttrs.meta.license.shortName}";
license = lib.licenses.nvidiaCudaRedist // {
url = "https://developer.download.nvidia.com/compute/cuda/redist/${releaseAttrs.license_path or "${pname}/LICENSE.txt"}";
};
sourceProvenance = [ lib.sourceTypes.binaryNativeCode ];
maintainers = lib.teams.cuda.members;
# Force the use of the default, fat output by default (even though `dev` exists, which
# causes Nix to prefer that output over the others if outputSpecified isn't set).
outputsToInstall = [ "out" ];
};
})

139
pkgs/development/compilers/cudatoolkit/redist/extension.nix
View File

@ -1,139 +0,0 @@
# Type Aliases
#
# ReleaseAttrs : {
# "relative_path" : String,
# "sha256" : String,
# "md5" : String,
# "size" : String,
# }
#
# NOTE: PackageAttrs must have at least one of the arches.
# PackageAttrs : {
# "name" : String,
# "license" : String,
# "version" : String,
# "license_path" : None | String,
# "linux-aarch64" : None | ReleaseAttrs,
# "linux-ppc64le" : None | ReleaseAttrs,
# "linux-sbsa" : None | ReleaseAttrs,
# "linux-x86_64" : None | ReleaseAttrs,
# "windows-x86_64" : None | ReleaseAttrs,
# }
#
# ReleaseFeaturesAttrs : {
# "hasBin" : Boolean,
# "hasDev" : Boolean,
# "hasDoc" : Boolean,
# "hasLib" : Boolean,
# "hasOut" : Boolean,
# "hasSample" : Boolean,
# "hasStatic" : Boolean,
# "rootDirs" : List String,
# }
#
# NOTE: PackageFeatureAttrs must have at least one of the arches.
# PackageFeatureAttrs : {
# "linux-aarch64" : None | ReleaseFeaturesAttrs,
# "linux-ppc64le" : None | ReleaseFeaturesAttrs,
# "linux-sbsa" : None | ReleaseFeaturesAttrs,
# "linux-x86_64" : None | ReleaseFeaturesAttrs,
# "windows-x86_64" : None | ReleaseFeaturesAttrs,
# }
#
final: prev:
let
# NOTE: We use hasAttr throughout instead of the (?) operator because hasAttr does not require
# us to interpolate our variables into strings (like ${attrName}).
inherit (builtins) attrNames concatMap hasAttr listToAttrs removeAttrs;
inherit (final) callPackage;
inherit (prev) cudaVersion;
inherit (prev.lib.attrsets) nameValuePair optionalAttrs;
inherit (prev.lib.lists) optionals;
inherit (prev.lib.trivial) flip importJSON pipe;
# 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 = {
"11.4" = "11.4.4";
"11.5" = "11.5.2";
"11.6" = "11.6.2";
"11.7" = "11.7.0";
"11.8" = "11.8.0";
"12.0" = "12.0.1";
"12.1" = "12.1.1";
"12.2" = "12.2.0";
};
# Check if the current CUDA version is supported.
cudaVersionMappingExists = hasAttr cudaVersion cudaVersionMap;
# Maps a cuda version to its manifest files.
# The manifest itself is from NVIDIA, but the features manifest is generated
# by us ahead of time and allows us to split pacakges into multiple outputs.
# Package names (e.g., "cuda_cccl") are mapped to their attributes or features.
# Since we map each attribute to a package name, we need to make sure to get rid of meta
# attributes included in the manifest. Currently, these are any of the following:
# - release_date
# - release_label
# - release_product
redistManifests =
let
# Remove meta attributes from the manifest
# removeAttrs : AttrSet String b -> Attr String b
removeMetaAttrs = flip removeAttrs [ "release_date" "release_label" "release_product" ];
# processManifest : Path -> Attr Set (String PackageAttrs)
processManifest = flip pipe [ importJSON removeMetaAttrs ];
# fullCudaVersion : String
fullCudaVersion = cudaVersionMap.${cudaVersion};
in
{
# features : Attr Set (String PackageFeatureAttrs)
features = processManifest (./manifests + "/redistrib_features_${fullCudaVersion}.json");
# manifest : Attr Set (String PackageAttrs)
manifest = processManifest (./manifests + "/redistrib_${fullCudaVersion}.json");
};
# Function to build a single redist package
buildRedistPackage = callPackage ./build-cuda-redist-package.nix { };
# Function that builds all redist packages given manifests
buildRedistPackages = { features, manifest }:
let
wrapper = pname:
let
# Get the redist architectures the package provides distributables for
packageAttrs = manifest.${pname};
# Check if supported
# TODO(@connorbaker): Currently hardcoding x86_64-linux as the only supported platform.
isSupported = packageAttrs ? linux-x86_64;
# Build the derivation
drv = buildRedistPackage {
inherit pname;
# TODO(@connorbaker): We currently discard the license attribute.
inherit (manifest.${pname}) version;
description = manifest.${pname}.name;
platforms = [ "x86_64-linux" ];
releaseAttrs = manifest.${pname}.linux-x86_64;
releaseFeaturesAttrs = features.${pname}.linux-x86_64;
};
# Wrap in an optional so we can filter out the empty lists created by unsupported
# packages with concatMap.
wrapped = optionals isSupported [ (nameValuePair pname drv) ];
in
wrapped;
# concatMap provides us an easy way to filter out packages for unsupported platforms.
# We wrap the buildRedistPackage call in a list to prevent errors when the package is not
# supported (by returning an empty list).
redistPackages = listToAttrs (concatMap wrapper (attrNames manifest));
in
redistPackages;
# All redistributable packages for the current CUDA version
redistPackages = optionalAttrs cudaVersionMappingExists (buildRedistPackages redistManifests);
in
redistPackages

879
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.7.0.json
View File

@ -1,879 +0,0 @@
{
"release_date": "2022-05-11",
"cuda_cccl": {
"name": "CXX Core Compute Libraries",
"license": "CUDA Toolkit",
"version": "11.7.58",
"linux-x86_64": {
"relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-11.7.58-archive.tar.xz",
"sha256": "a66261d174a3f8fea87e0dc91e5cd084dda89be8bb0a1f5ca0ab5d05a93ade4a",
"md5": "674edc3ec85126c08f78e4e3280789fd",
"size": "1004048"
},
"linux-ppc64le": {
"relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-11.7.58-archive.tar.xz",
"sha256": "5482355647143e61b15cb6193f33a317dce94bb2475123d4b08eebbd7a801802",
"md5": "64c9f42b84cb64a7f67645cb74d2153f",
"size": "1004332"
},
"linux-sbsa": {
"relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-11.7.58-archive.tar.xz",
"sha256": "70a8a42135e4ab817cd3c3413dd993bfc7920a42f057838d2a4a2ff0966258bd",
"md5": "f6ac243b4b8d182941025040b0c375c3",
"size": "1003936"
},
"windows-x86_64": {
"relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-11.7.58-archive.zip",
"sha256": "29958e300229c7af43df57bed0519f34f3aa64332c84fb80e481c131e4594938",
"md5": "3a40e674c975fc35376e66b08b93a42c",
"size": "2563581"
}
},
"cuda_cudart": {
"name": "CUDA Runtime (cudart)",
"license": "CUDA Toolkit",
"version": "11.7.60",
"linux-x86_64": {
"relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-11.7.60-archive.tar.xz",
"sha256": "1c079add60a107f6dd9e72a0cc9cde03eb9d833506f355c22b9177c47a977552",
"md5": "1ef515eb31691f2c43fb0de1443893a3",
"size": "854744"
},
"linux-ppc64le": {
"relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-11.7.60-archive.tar.xz",
"sha256": "95ea51eb4d60754a080920105aa578cc8da8772295912f198fcaa13fafce6d24",
"md5": "ce9c3ac2d0a25de182e5519354e0e01b",
"size": "795244"
},
"linux-sbsa": {
"relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-11.7.60-archive.tar.xz",
"sha256": "bdfdb8467a0d1a5c6aeb696ec0c203d1da732093b5e5ee0a79b03ef53f5ab622",
"md5": "7d6290b6e7a0086c5dbf5706013dfdda",
"size": "798208"
},
"windows-x86_64": {
"relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-11.7.60-archive.zip",
"sha256": "e1c72413c42e9bda52d1868bb67136d66d03b394b9accdfd9224080bb5a9663e",
"md5": "bbeee57a158e8ce3abce79b19eae7110",
"size": "2884824"
}
},
"cuda_cuobjdump": {
"name": "cuobjdump",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "f901085d83f83ae549de45e4410c74c3adddd2d541ba2780c23105df39008820",
"md5": "76a614c84b7221cc9282a3bf009ca401",
"size": "127416"
},
"linux-ppc64le": {
"relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "2fe257ab7027c7598d1351bb473d6a67a8da81fec17f60b389d16ef076c31da7",
"md5": "9ffb04f10fced993411d0601709c80fd",
"size": "140924"
},
"linux-sbsa": {
"relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "d44352344de0408d175b045401865ab82db4a53f3894e50c01445f42bbebdf8f",
"md5": "0b3bb58d13089bea74b3351cd7ed03d2",
"size": "123968"
},
"windows-x86_64": {
"relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-11.7.50-archive.zip",
"sha256": "3e7072d0a09c021252925ff9644d67294793afc5dc55ff2fac291528711ba0f9",
"md5": "070b5f13066888c471b90868485767ae",
"size": "2523866"
}
},
"cuda_cupti": {
"name": "CUPTI",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "441f7da2608d1965f0e3e2e03aeea86b0a3454cbea8e7af8112529c9acef3853",
"md5": "6433be7629030ddbcf37f5286464bb0d",
"size": "16577596"
},
"linux-ppc64le": {
"relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "df70ad634864572b4eff7ebe15b768d48d909aabddf3b54da05cf7e27442bd8f",
"md5": "011ea37fd2f4af0755414c5432ba2649",
"size": "8627816"
},
"linux-sbsa": {
"relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "4615695d9240a423926238640c69d4b39044acc44d3d513bc08c51f16bea371e",
"md5": "53cefdd716d8c40ff7143822341c09b7",
"size": "8436580"
},
"windows-x86_64": {
"relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-11.7.50-archive.zip",
"sha256": "42a04b9ef71e4d95bc235a68dd4a75d1501a44e9964371435994f7a7c59cd489",
"md5": "4c61155dc79555ef6b389284a4f7b65a",
"size": "11546349"
}
},
"cuda_cuxxfilt": {
"name": "CUDA cuxxfilt (demangler)",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "8a9cb0af698fe39c1b92d179e9ac22e8acb752eb8c531dbfdd049ddcd3c2caa6",
"md5": "0f7eb48184c16e51ad76574cc112e01c",
"size": "186432"
},
"linux-ppc64le": {
"relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "a2a9a5ace0908071f0bcf4fa1e537c8373d7ef6a18d086d85a2c72cb8dc245b7",
"md5": "6be41e32ff0274c1be4cb3b6a6429b21",
"size": "181612"
},
"linux-sbsa": {
"relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "c7c014ec407c77eae16451559a7499c8ff371606abc8e1b40e47eedab8d5a5b8",
"md5": "2a7553a48f6c8048d1667c16fec03035",
"size": "172292"
},
"windows-x86_64": {
"relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-11.7.50-archive.zip",
"sha256": "e93e1d37332ad5adf663a712250710d03a718f4d85702aec4e24b5bf98e2fe7a",
"md5": "f34c83f9a81d0fdae3950a9778442345",
"size": "168940"
}
},
"cuda_demo_suite": {
"name": "CUDA Demo Suite",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "10dec9f42f7c60ba8d2e839bedf155addb6a02ebf9a3b2b1c7acbcc47e6e4721",
"md5": "4501fa48dcf450f1de5e7b0352859dfa",
"size": "3985972"
},
"windows-x86_64": {
"relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-11.7.50-archive.zip",
"sha256": "803bab94b1b4f304ddba4c2adcc013a1aaf5251f962d154287f6d880cb3f16a1",
"md5": "a240da5cbf8ddcbf44ec969a7c57d68d",
"size": "5023822"
}
},
"cuda_documentation": {
"name": "CUDA Documentation",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "90a169f4c1c782cdd1b1bf1e13f3e9f4ef57f731d87d8fefae115b166032a084",
"md5": "1d5f61928ed525f7324e1f600719a786",
"size": "67056"
},
"linux-ppc64le": {
"relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "8c799c128afcf870ea63e73b8a33d924d60bc4281ef77c32c92d0081a7d523c8",
"md5": "e5f4d0b477f90698adb4919e1341c407",
"size": "67060"
},
"linux-sbsa": {
"relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "a2f50b49fe31b0637602743a756df16e6ec3dfc95279d4bb25a9eb1f6de3a80b",
"md5": "9316169eca11c975157e77e3649f8a1f",
"size": "67060"
},
"windows-x86_64": {
"relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-11.7.50-archive.zip",
"sha256": "2c497e6ca5ffb440d0504adef51d4e979273959d42a6a22b20cd702085b71f39",
"md5": "957cde6fd6211919ac4ca823d3cc90e9",
"size": "105283"
}
},
"cuda_gdb": {
"name": "CUDA GDB",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "ff44bffb8034a694ba6a2c5e171fc766ddc6d9e328b29eab8dd02177d6914f6c",
"md5": "72b1fa5a914443acc3eeda12da0aa059",
"size": "64209508"
},
"linux-ppc64le": {
"relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "e442ef2eaaa778ffadb6af3ed92316eddff0dff15b69e334338da5f450203f43",
"md5": "6a02488128531898f252163a41c84f93",
"size": "64109072"
},
"linux-sbsa": {
"relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "f67bae946aaa60a57d7b781a2fe044bde267da58c418067d8be6cbb63959966b",
"md5": "3a654d775d9b1466ca00585adc179744",
"size": "64025944"
}
},
"cuda_memcheck": {
"name": "CUDA Memcheck",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_memcheck/linux-x86_64/cuda_memcheck-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "12fa99422d9a7ce1714e100cc9faa4c9d37590d79d0af93abc8321217cbf5abd",
"md5": "5b29092a20eb8501651f64af028623aa",
"size": "139652"
},
"linux-ppc64le": {
"relative_path": "cuda_memcheck/linux-ppc64le/cuda_memcheck-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "3bed410c4fcaf106f1411a9373bb0091ee46a29f2e980eba4ee274710d8e4f19",
"md5": "952e68b3e321df1bdc94327ea186603d",
"size": "148036"
},
"windows-x86_64": {
"relative_path": "cuda_memcheck/windows-x86_64/cuda_memcheck-windows-x86_64-11.7.50-archive.zip",
"sha256": "79294688bdbed786b68873bc02f8a279b6ce7a468486da365642e3c727cedd9e",
"md5": "a6512b0c6fe6aa4f81a6027a64110860",
"size": "172868"
}
},
"cuda_nsight": {
"name": "Nsight Eclipse Edition Plugin",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "483a4970a38c9366c2d3bf7d2ea9d2e2486a13ecaa3bd6ed143a4b18a8fe84b9",
"md5": "50eaa0de2047b89aa358682c6937a83a",
"size": "118603148"
},
"linux-ppc64le": {
"relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "93ece42ff578135e10cc7d8bfa4c42449f259d955cf1b71652b7436e2f6854f2",
"md5": "9e2cfb70f748efcc22c611938099ccbf",
"size": "118603136"
}
},
"cuda_nvcc": {
"name": "CUDA NVCC",
"license": "CUDA Toolkit",
"version": "11.7.64",
"linux-x86_64": {
"relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-11.7.64-archive.tar.xz",
"sha256": "7721fcfa3eb183ecb1d7fe138ce52d8238f0a6ecf1e9964cf8cfe5d8b7ec3c92",
"md5": "640e1e412e0ff6d7eee95e513f67cadb",
"size": "37056600"
},
"linux-ppc64le": {
"relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-11.7.64-archive.tar.xz",
"sha256": "59792975fe7ba2cb75977965a1eebfc684d4e301a34c43f5f4295124d21c097c",
"md5": "0f409845cbe3ed70a6abc971024b1d72",
"size": "34873208"
},
"linux-sbsa": {
"relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-11.7.64-archive.tar.xz",
"sha256": "4ba91cfcc7b12b997ed2ceced176f6aa1f7c101a65c0ab6faae9a8fee6d107f1",
"md5": "a3ef626196d63f7db7c3c62d80564ab3",
"size": "32632012"
},
"windows-x86_64": {
"relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-11.7.64-archive.zip",
"sha256": "dcb47e8c04560a369cc6154242afdb29223e8ceaaf6ea6097e2add09ed64d386",
"md5": "de3eb321caac960358731fb07c26e2a2",
"size": "47659565"
}
},
"cuda_nvdisasm": {
"name": "CUDA nvdisasm",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "4e22b735b9553a286390dc76b02e5a7f21dc71234852d7f4f8cf2572fef1a479",
"md5": "471deeab3bc3ce504c75b77670ad5140",
"size": "32776640"
},
"linux-ppc64le": {
"relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "1111d62bd0baefdf86de2dd148e44815d04c53d66dff2a1f5a700dd6ec32cce5",
"md5": "a1ec03d58d37927080425425a820dee8",
"size": "32780884"
},
"linux-sbsa": {
"relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "3a9ece8dfb6e93c0e9b6da6753c77c9fb815b42ffc91ee710fbc02b421b0d864",
"md5": "3e2cb3ff5390077d97d0d847c423d499",
"size": "32730316"
},
"windows-x86_64": {
"relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-11.7.50-archive.zip",
"sha256": "03403fc8ea81178855e5338623700421c91606e71ef8747568554a0ab5b18355",
"md5": "03ea5bb697502568d5b9fb9577974cf7",
"size": "33004702"
}
},
"cuda_nvml_dev": {
"name": "CUDA NVML Headers",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "b6f101106e5ed980bf89b2868cf0b32dd36a28c47e879ee70fca1b85de047fba",
"md5": "f8c3a8033eda7215cf2a7b0b1325b5f1",
"size": "76548"
},
"linux-ppc64le": {
"relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "a3f4dbeeec6d6eb6562fd4c432c70a5071aa3e0bbf008118a1676079b4bf646f",
"md5": "cd92d1a16f3e60e9620320d18c0e5a6a",
"size": "76088"
},
"linux-sbsa": {
"relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "ddc4d1c7dafa9a05e387048a561ec01cad16e33276358201f8682780e451037d",
"md5": "156e76ed54c7547a11fc6a725d212762",
"size": "76728"
},
"windows-x86_64": {
"relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-11.7.50-archive.zip",
"sha256": "f3cea20a5c75dbe341b11c3fabfbafcc2da6d0d60654cdd46960e941e33dca50",
"md5": "2d92f9c4ef5dac8253f5e73e6f428251",
"size": "106750"
}
},
"cuda_nvprof": {
"name": "CUDA nvprof",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "8222eebaf3fe6ca1e4df6fda09cbd58f11de6d5b80b5596dcf5c5c45ae246028",
"md5": "1fa983b921821b0d38dfc7c5b8234d88",
"size": "1944796"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "dbf2f41b1c42fe05c9ce0865dfefe867c91a22394acfb03606a4de9cbf07f236",
"md5": "865a189bcdc7900e55f1a3e545c312da",
"size": "1600116"
},
"linux-sbsa": {
"relative_path": "cuda_nvprof/linux-sbsa/cuda_nvprof-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "5894195fdaf1e550601649fdf93aa93fa042bd3e298867cf95007080b10757ac",
"md5": "e3e336dd70f215866864131b889a8261",
"size": "16148"
},
"windows-x86_64": {
"relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-11.7.50-archive.zip",
"sha256": "3a115b5bc3bf733cb6fe9d414ae5375928ea75fb1f84112b897015434bc4fc25",
"md5": "7fc781f7e740bb6a7a45b593fe8c70a0",
"size": "1603305"
}
},
"cuda_nvprune": {
"name": "CUDA nvprune",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "b5c13830f910979be229943cefe70297382ba6c1bddba91174d4837a94c7922d",
"md5": "d57409d45bd27a917b90e05e78941326",
"size": "55220"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "ecace952b4b4631fa347f77371de485f7611525773bc90587f4c639cd51362e7",
"md5": "5359a59af33523f5d5d58d0bf6cb6b9a",
"size": "55928"
},
"linux-sbsa": {
"relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "dfc069568ca54425a8bb8c674f2d70218546f64a6836fb918d233becff046624",
"md5": "6fdc59145fe540946f9e3ea793f09152",
"size": "47656"
},
"windows-x86_64": {
"relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-11.7.50-archive.zip",
"sha256": "605aed14b9832712c81cf36acf389a22023a0737604ff3a1cbdd7338b0780ea4",
"md5": "3f105e39da981703ab5a95bfeaf112b9",
"size": "144827"
}
},
"cuda_nvrtc": {
"name": "CUDA NVRTC",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "a0891b98d5d38f6ae64833c483ccf51417e25b54f0242a5872fabc7c96300f3a",
"md5": "e1e1bdd085b979196fc87d2d7d20d237",
"size": "28103056"
},
"linux-ppc64le": {
"relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "b801983bd480b6a75eeb3b4db41a840de66d3f764ca89440e135d62ae249144e",
"md5": "f39ef8fbca0ed175a4815b2c4482b676",
"size": "26239068"
},
"linux-sbsa": {
"relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "5d4788a5b3c06d88179824976c8e5e7c76683dfe3bd1e5634ac2037de62b385f",
"md5": "609d991b06e17e9f0a85c6e93bbf052b",
"size": "26084572"
},
"windows-x86_64": {
"relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-11.7.50-archive.zip",
"sha256": "252ae0cd65b1b73208454966f91239d0e8f11232de966c41d8cf3009fe402415",
"md5": "6476681ad45cfd18e7cc3f5b16c9111b",
"size": "93548358"
}
},
"cuda_nvtx": {
"name": "CUDA NVTX",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "b90454efe80e4fcd328e6250279e4392a01db9035c7317355760c66048899568",
"md5": "b14a508a57f1311321b6cb552fde7a9f",
"size": "48176"
},
"linux-ppc64le": {
"relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "3dc37a91b9a7769d4ab329d99d8779b7f6feaae63e8fc69d7d5da284cb82efe9",
"md5": "eae8b204b8af373dc52ec1cad399dce5",
"size": "48156"
},
"linux-sbsa": {
"relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "b803160fe20715c23a6266849d2a23d298fe7c7e427ec77aca9121d667526441",
"md5": "5262caba03904cf79884266f30962f8b",
"size": "48768"
},
"windows-x86_64": {
"relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-11.7.50-archive.zip",
"sha256": "cec2aabca78c95a2d6c793372684b060fc695035f568225fd735880331d71e25",
"md5": "27b8357312c82ee327b3ec86cb2cecec",
"size": "65690"
}
},
"cuda_nvvp": {
"name": "CUDA NVVP",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "6489169df1a4f37cba0c00c3c0e24ac6265bfe06fcca1d4bf3f5824bc937ef9f",
"md5": "94951715e2f099553ddd57f40ab4f06c",
"size": "117571592"
},
"linux-ppc64le": {
"relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "b54fa7fc79788f991332139ecf722cc834b544d111f476531a3db82b8c15c2b0",
"md5": "ece4a0e7524037f64cd81a9a6c85db0c",
"size": "117008156"
},
"windows-x86_64": {
"relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-11.7.50-archive.zip",
"sha256": "8b8ddaca9958a58a78f7f50f87ecee3ecb148fe99b0cce6ed37e3ba0ecb6d14f",
"md5": "6880ab3d2ae9526e6d5a376fb24dea8e",
"size": "120360546"
}
},
"cuda_sanitizer_api": {
"name": "CUDA Compute Sanitizer API",
"license": "CUDA Toolkit",
"version": "11.7.50",
"linux-x86_64": {
"relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-11.7.50-archive.tar.xz",
"sha256": "9555ae397290608c7a64c929fc80186860008cc8c4afb0bd49deece3a5ca2fc4",
"md5": "6b5910c5096decaa4b5c30f3bff3df38",
"size": "8314100"
},
"linux-ppc64le": {
"relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-11.7.50-archive.tar.xz",
"sha256": "f303a56fd501ce13aa7f12c03137fefd823899b19c26ab53cd314baf47b9b3c7",
"md5": "6dc14023de7354aa6f17b833d3adf89e",
"size": "7739868"
},
"linux-sbsa": {
"relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-11.7.50-archive.tar.xz",
"sha256": "14c5ffde6606c97a92b7e72dd0987509c3fe876ad57bfe3a88d2b897125a442e",
"md5": "84fd52cea0512e63d95ebf62038137f0",
"size": "6453516"
},
"windows-x86_64": {
"relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-11.7.50-archive.zip",
"sha256": "090f657396b35d749f0f755b684151d274ae3f392790055f3b659daeee068622",
"md5": "685f72ea969afbbebeaba721310618ed",
"size": "13477221"
}
},
"fabricmanager": {
"name": "NVIDIA Fabric Manager",
"license": "NVIDIA Driver",
"version": "515.43.04",
"linux-x86_64": {
"relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-515.43.04-archive.tar.xz",
"sha256": "2f4bce4620ce69683428d1752464adcaef466fc471d82618e28d554c7591efe6",
"md5": "3dfc3ea1f13a346cfc155c09d80fb48c",
"size": "1470572"
},
"linux-sbsa": {
"relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-515.43.04-archive.tar.xz",
"sha256": "eb5cda2505cb5fcc3508ab84e8703d9cf318e0df5c2e5b0a832b4fa243b88bea",
"md5": "6fd2d3c94b8ccb826d4986fa970261f1",
"size": "1358156"
}
},
"libcublas": {
"name": "CUDA cuBLAS",
"license": "CUDA Toolkit",
"version": "11.10.1.25",
"linux-x86_64": {
"relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-11.10.1.25-archive.tar.xz",
"sha256": "27f5975b0b373f5fc96ac2f4ec9f28de3eb07f674acc0b0a5262dd2c76ddc5ff",
"md5": "f183769621c14cd447bb50fa51088c7b",
"size": "432986132"
},
"linux-ppc64le": {
"relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-11.10.1.25-archive.tar.xz",
"sha256": "85aa62b4c23f42f28bc428e84604b4dcb04960db1926c8c2216d5747f0366ab1",
"md5": "ca6ce43480df02cd6e5b96e416a02e64",
"size": "422295044"
},
"linux-sbsa": {
"relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-11.10.1.25-archive.tar.xz",
"sha256": "76c50490afd19dc5fdab31281380e0d1a7217dfebecb31477e78e452cac4e0a6",
"md5": "748bd159248469f80f67edd4028ac2dd",
"size": "422563144"
},
"windows-x86_64": {
"relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-11.10.1.25-archive.zip",
"sha256": "d1b47527b0fc33f1b185af38590a1d5d7d04c0c71c74c19a488547f9c0a62e7c",
"md5": "989c46ebd961d177f8bc2ba0a03955b7",
"size": "311249638"
}
},
"libcufft": {
"name": "CUDA cuFFT",
"license": "CUDA Toolkit",
"version": "10.7.2.50",
"linux-x86_64": {
"relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-10.7.2.50-archive.tar.xz",
"sha256": "70c4c2abb9d77210a5d2313abfdddf1857d654d1cf925946a645793bc14714c5",
"md5": "fe80583fbf4ce9195db760dc9465da2f",
"size": "213404700"
},
"linux-ppc64le": {
"relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-10.7.2.50-archive.tar.xz",
"sha256": "f229818bfee4d90aa4a9022a00d26efa749fdb4f61af1ba47b65a9f8dffd1521",
"md5": "66768c4e73bd0402be32486ef9ff4952",
"size": "213735112"
},
"linux-sbsa": {
"relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-10.7.2.50-archive.tar.xz",
"sha256": "9aaeae3c1a53ee4cc17c05557f2e30b65581d5d590130d5e205193beceed345d",
"md5": "967617dbb350fdd19771bea836e68744",
"size": "212335968"
},
"windows-x86_64": {
"relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-10.7.2.50-archive.zip",
"sha256": "931f380e666dd8dc44b72fb79224c27c720d37310312e9e421e71f16a5e312e1",
"md5": "24eb68afe151ab2d7a2c787aeb382d9a",
"size": "287120306"
}
},
"libcufile": {
"name": "CUDA cuFile",
"license": "CUDA Toolkit",
"version": "1.3.0.44",
"linux-x86_64": {
"relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.3.0.44-archive.tar.xz",
"sha256": "2a0a9102596c84afa9afed014fee73630a534ceaef2857c43646f6c9ffba2b95",
"md5": "1bacdbc9a48e4e188dfffe15ab062358",
"size": "46784140"
}
},
"libcurand": {
"name": "CUDA cuRAND",
"license": "CUDA Toolkit",
"version": "10.2.10.50",
"linux-x86_64": {
"relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.2.10.50-archive.tar.xz",
"sha256": "a05411f1775d5783800b71f6b43fae660e3baf900ae07efb853e615116ee479b",
"md5": "a9f272f6683a79c7b8fa02ae1149f3ad",
"size": "82110640"
},
"linux-ppc64le": {
"relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.2.10.50-archive.tar.xz",
"sha256": "4c9bc79ab38c3aca8081ea4fcd05876742657659f640c87f7af2a00f4f968787",
"md5": "6c714d6725554dd57265812c7a721454",
"size": "82156504"
},
"linux-sbsa": {
"relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.2.10.50-archive.tar.xz",
"sha256": "78577951e086501bb9222a55a07bd271dceae5fecdce17625bc453db549e96eb",
"md5": "911370c7ba791366d281e4ff62daa2b4",
"size": "82100856"
},
"windows-x86_64": {
"relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.2.10.50-archive.zip",
"sha256": "c96a539a76e6062222e66abde64ca19ff6d89729af81a0efc157ba50277edfa9",
"md5": "6afa80c834b57ab398708e735b564592",
"size": "53656547"
}
},
"libcusolver": {
"name": "CUDA cuSOLVER",
"license": "CUDA Toolkit",
"version": "11.3.5.50",
"linux-x86_64": {
"relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.3.5.50-archive.tar.xz",
"sha256": "7ed168c7fda04a4a640f6225cb76d5251a39e3d35db7630d3646cec58de724f8",
"md5": "cc6b0e4d97d7d73f302095cda1499167",
"size": "80742472"
},
"linux-ppc64le": {
"relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.3.5.50-archive.tar.xz",
"sha256": "341889b3c3107f7e3700693fcf815f816a8ffdfc6f2a1ca0f132ea651cb51739",
"md5": "0f038f45a4d5195d771d812ba47a34fa",
"size": "80769552"
},
"linux-sbsa": {
"relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.3.5.50-archive.tar.xz",
"sha256": "4832fd6dca50b2b05d07f086eaa44f953e9b1cd0f00b083f780e0ee1c17461db",
"md5": "a7361cc09dc63a6dee54937a12a8004b",
"size": "79972404"
},
"windows-x86_64": {
"relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.3.5.50-archive.zip",
"sha256": "918a8ed855ef683fa2b4f38e50e8275246b48c266e1066fdcf2bf6db16c9fc6a",
"md5": "68c75bd8d556a24d6d204e8007eb1f38",
"size": "111712983"
}
},
"libcusparse": {
"name": "CUDA cuSPARSE",
"license": "CUDA Toolkit",
"version": "11.7.3.50",
"linux-x86_64": {
"relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-11.7.3.50-archive.tar.xz",
"sha256": "c56ddd2d4deebb02bf1e082905f13cac7c685bfa415f1c489dd5fe382cf1f5de",
"md5": "04a62c2f92bc0608989bd82b4034d91f",
"size": "199048536"
},
"linux-ppc64le": {
"relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-11.7.3.50-archive.tar.xz",
"sha256": "d756707e6c84c9ae4b174467d8afba10883f8f286aba26a9230698b73fd187e3",
"md5": "bf56661d346440de2242530fed4027b9",
"size": "199115552"
},
"linux-sbsa": {
"relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-11.7.3.50-archive.tar.xz",
"sha256": "e2f8a0339739c3d7aa163d98452dcf3e6b71b164d7ff5b999dd35af31d950bc4",
"md5": "21ae0da8af1b60bb0e9f658c16730300",
"size": "198793236"
},
"windows-x86_64": {
"relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-11.7.3.50-archive.zip",
"sha256": "e7044f4cbce8712f407d041f2116cf61a8831e21d96f28c4c9ca8512847afc28",
"md5": "b20eef48a3a956b8643eb7cf457764b9",
"size": "167174067"
}
},
"libnpp": {
"name": "CUDA NPP",
"license": "CUDA Toolkit",
"version": "11.7.3.21",
"linux-x86_64": {
"relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-11.7.3.21-archive.tar.xz",
"sha256": "4d5f12e756304828cdbbe67dfa94a75432ee07cfe11f034aa4325e59e3c708f7",
"md5": "9c7ba42831e40f15b5b94543c659a74b",
"size": "164601168"
},
"linux-ppc64le": {
"relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-11.7.3.21-archive.tar.xz",
"sha256": "e3064176e6e0843e5f2d1bd247512be76ca3018364fd7bf77fec34b0bfae37a2",
"md5": "4106d95423169f59b5af3bbe3a9e38bf",
"size": "164864392"
},
"linux-sbsa": {
"relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-11.7.3.21-archive.tar.xz",
"sha256": "9cb63cd9d79a490a2504dbf8186d35d391d3e69f74353784955d33d550c83010",
"md5": "d5780f7e9a1ba1c3441f810fad68fc32",
"size": "163688528"
},
"windows-x86_64": {
"relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-11.7.3.21-archive.zip",
"sha256": "490a171c6db5e42f67502c0774678166f8018fe464f7e6c8a7b47e10c9fa3861",
"md5": "db863d019ff3029a9a14855ff85f6958",
"size": "125480452"
}
},
"libnvidia_nscq": {
"name": "NVIDIA NSCQ API",
"license": "NVIDIA Driver",
"version": "515.43.04",
"linux-x86_64": {
"relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-515.43.04-archive.tar.xz",
"sha256": "b0690b271e65cc2096a0de15aa7003c64e336bc5f4c48a7fc87a9b355d240e2a",
"md5": "03edfd4d08b358ec3cc98cef63e5138c",
"size": "334904"
}
},
"libnvjpeg": {
"name": "CUDA nvJPEG",
"license": "CUDA Toolkit",
"version": "11.7.2.34",
"linux-x86_64": {
"relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-11.7.2.34-archive.tar.xz",
"sha256": "0457a11af6903d63aec942e2884e02002c3d579071eacd89f08a25cab339f5eb",
"md5": "d6acf73e518edb33c4b7e7f3cb85aa46",
"size": "2042120"
},
"linux-ppc64le": {
"relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-11.7.2.34-archive.tar.xz",
"sha256": "70afb2d27b430dd4c43f1dc342e8725d148701093cdebc68a75d6dbaf6615d3f",
"md5": "acdf6594c58b6178cf0d83948e8c69b5",
"size": "2060012"
},
"linux-sbsa": {
"relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-11.7.2.34-archive.tar.xz",
"sha256": "8638f70021ad0e9006ec78c0b4f88f787e9d7862176447288f84a2b7d68769f2",
"md5": "e3d6b429ab22b4c16476df2f936e46ba",
"size": "1893316"
},
"windows-x86_64": {
"relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-11.7.2.34-archive.zip",
"sha256": "a3594ff7a5431495bc70763c2578ade0a32c74745803b820e49ef52cca2a872b",
"md5": "c4c259d4b7833e6cbe1505bf6b62229d",
"size": "2055730"
}
},
"nsight_compute": {
"name": "Nsight Compute",
"license": "NVIDIA SLA",
"version": "2022.2.0.13",
"linux-x86_64": {
"relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2022.2.0.13-archive.tar.xz",
"sha256": "426949d42646164b884ee3025bd5e6b6fef8e904ed69705b7cf3cab9af1fc531",
"md5": "0f5700c465c92210a1eadea199b9e07a",
"size": "420951860"
},
"linux-ppc64le": {
"relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2022.2.0.13-archive.tar.xz",
"sha256": "42c090ffe500b3a6c54c60a17b4f4856d230c558642841edb2b7bb725438be8c",
"md5": "ee1f8f57b827862c36bc6807e9a38424",
"size": "126737380"
},
"linux-sbsa": {
"relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2022.2.0.13-archive.tar.xz",
"sha256": "4a442d5b6d0b599669ae30d342f46a0c8d047b3a7476b4419435dfe7187e23b8",
"md5": "11eec62f941d071b9f7c46855cc75a0b",
"size": "246004808"
},
"windows-x86_64": {
"relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2022.2.0.13-archive.zip",
"sha256": "1f06f2d769c9c61c691c59f8c33f214aae6514d41f3eac5073c9310b7b487764",
"md5": "c2eb253d66b9258babc1bf9471033691",
"size": "354364680"
}
},
"nsight_nvtx": {
"name": "Nsight NVTX",
"license": "CUDA Toolkit",
"version": "1.21018621",
"windows-x86_64": {
"relative_path": "nsight_nvtx/windows-x86_64/nsight_nvtx-windows-x86_64-1.21018621-archive.zip",
"sha256": "d99b015bfb1308206f9d7c16ea401bf426fed3a5a99953b855fe4e68be5ed2d1",
"md5": "34ee04d45cfca1c4e3cbfba0ec8f6f80",
"size": "315692"
}
},
"nsight_systems": {
"name": "Nsight Systems",
"license": "NVIDIA SLA",
"version": "2022.1.3.3",
"linux-x86_64": {
"relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2022.1.3.3-archive.tar.xz",
"sha256": "bd95553d573f117be2e3b2bda6e79d14dbb038b136c12c6e5467bbd9a891681d",
"md5": "40d12d33aa2d496817d959a9551418aa",
"size": "166785296"
},
"linux-ppc64le": {
"relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2022.1.3.3-archive.tar.xz",
"sha256": "4c228bfbd38b80612afeb65a406cba829d2b2e2352ea4a810cd6a386d6190151",
"md5": "0d5da67cb5393a0e961509cd7dab98f1",
"size": "49700384"
},
"linux-sbsa": {
"relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2022.1.3.3-archive.tar.xz",
"sha256": "9025f56b9fe70288ee3f2d30477c9cfbe8c17a304b31f7f22caf7f78153d8d23",
"md5": "3559eeb8416d9a984012d2b397560740",
"size": "50415564"
},
"windows-x86_64": {
"relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2022.1.3.3-archive.zip",
"sha256": "294738ba0aa0621395740a6d039a490aa0bf5fceec449b1fd4135a97b81eda0f",
"md5": "91e316744714c168c1a75804c9a198c9",
"size": "315748009"
}
},
"nsight_vse": {
"name": "Nsight Visual Studio Edition (VSE)",
"license": "NVIDIA SLA",
"version": "2022.2.0.22095",
"windows-x86_64": {
"relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2022.2.0.22095-archive.zip",
"sha256": "b346aadf59d633b114b5e5b3ed437f8eee2bb2b8d532da0ee374ef8af9149cb2",
"md5": "63d3a5f0c9abaa027efbe0f476dc7c21",
"size": "459001482"
}
},
"nvidia_driver": {
"name": "NVIDIA Linux Driver",
"license": "NVIDIA Driver",
"version": "515.43.04",
"linux-x86_64": {
"relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-515.43.04-archive.tar.xz",
"sha256": "933ffd8f73e86e78299daf0b8612f8c24fe4b55cc15c2be353fbfbda3f1d62ea",
"md5": "19cf2b2e3d3f6f7786791db89e3a193a",
"size": "361628336"
},
"linux-ppc64le": {
"relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-515.43.04-archive.tar.xz",
"sha256": "369998c33a867945193cc3c1c3c78defa7c0309767d926bc871cc02ad659ed61",
"md5": "486f222d765d7ce5163d257a4b0e5420",
"size": "75667264"
},
"linux-sbsa": {
"relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-515.43.04-archive.tar.xz",
"sha256": "a534d8112bc15deb5f0e1c471382d776f4daebef25244869eaf5c935016b8fb7",
"md5": "5e699844a414a6f40e8c1399dd0f4c9d",
"size": "221246660"
}
},
"nvidia_fs": {
"name": "NVIDIA filesystem",
"license": "CUDA Toolkit",
"version": "2.12.4",
"linux-x86_64": {
"relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.12.4-archive.tar.xz",
"sha256": "913010942a7b6781a9e8fb8082654fda7ad0cce703f726e05d571fe6551f450a",
"md5": "48d30f73ec1b6c8df7e70139aefeec4e",
"size": "67152"
}
},
"visual_studio_integration": {
"name": "CUDA Visual Studio Integration",
"license": "CUDA Toolkit",
"version": "11.7.50",
"windows-x86_64": {
"relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-11.7.50-archive.zip",
"sha256": "4eb993cfb46ec925b6907f1433102ae00f0141e57bcfd40489eeaf72e67f0eeb",
"md5": "d770d51465dc15345a1ca1307e269832",
"size": "517028"
}
}
}

1151
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_12.2.0.json
View File

File diff suppressed because it is too large Load Diff

1518
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_11.4.4.json
View File

File diff suppressed because it is too large Load Diff

1536
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_11.5.2.json
View File

File diff suppressed because it is too large Load Diff

1546
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_11.6.2.json
View File

File diff suppressed because it is too large Load Diff

1565
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_11.7.0.json
View File

File diff suppressed because it is too large Load Diff

1938
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_11.8.0.json
View File

File diff suppressed because it is too large Load Diff

2050
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_12.0.1.json
View File

File diff suppressed because it is too large Load Diff

2050
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_12.1.1.json
View File

File diff suppressed because it is too large Load Diff

2030
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_features_12.2.0.json
View File

File diff suppressed because it is too large Load Diff

119
pkgs/development/compilers/cudatoolkit/redist/overrides.nix
View File

@ -1,119 +0,0 @@
final: prev:
let
inherit (prev) lib pkgs;
cudaVersionOlder = lib.versionOlder final.cudaVersion;
cudaVersionAtLeast = lib.versionAtLeast final.cudaVersion;
in
(lib.filterAttrs (attr: _: (prev ? "${attr}")) {
### Overrides to fix the components of cudatoolkit-redist
# Attributes that don't exist in the previous set are removed.
# That means only overrides can go here, and not new expressions!
libcufile = prev.libcufile.overrideAttrs (oldAttrs: {
buildInputs = oldAttrs.buildInputs ++ [
final.libcublas.lib
pkgs.numactl
pkgs.rdma-core
];
# libcuda needs to be resolved during runtime
autoPatchelfIgnoreMissingDeps =
["libcuda.so.1"]
# Before 12.0 libcufile depends on itself for some reason.
++ lib.optionals (cudaVersionOlder "12.0") [
"libcufile.so.0"
];
});
libcusolver = final.addBuildInputs prev.libcusolver (
# Always depends on this
[final.libcublas.lib]
# Dependency from 12.0 and on
++ lib.optionals (cudaVersionAtLeast "12.0") [
final.libnvjitlink.lib
]
# Dependency from 12.1 and on
++ lib.optionals (cudaVersionAtLeast "12.1") [
final.libcusparse.lib
]
);
libcusparse = final.addBuildInputs prev.libcusparse (
lib.optionals (cudaVersionAtLeast "12.0") [
final.libnvjitlink.lib
]
);
cuda_gdb = final.addBuildInputs prev.cuda_gdb (
# x86_64 only needs gmp from 12.0 and on
lib.optionals (cudaVersionAtLeast "12.0") [
pkgs.gmp
]
);
cuda_nvcc = prev.cuda_nvcc.overrideAttrs (oldAttrs: {
propagatedBuildInputs = [
final.setupCudaHook
];
meta = (oldAttrs.meta or { }) // {
mainProgram = "nvcc";
};
});
cuda_nvprof = prev.cuda_nvprof.overrideAttrs (oldAttrs: {
nativeBuildInputs = oldAttrs.nativeBuildInputs ++ [ pkgs.addOpenGLRunpath ];
buildInputs = oldAttrs.buildInputs ++ [ final.cuda_cupti.lib ];
# libcuda needs to be resolved during runtime
autoPatchelfIgnoreMissingDeps = ["libcuda.so.1"];
});
cuda_demo_suite = final.addBuildInputs prev.cuda_demo_suite [
pkgs.freeglut
pkgs.libGLU
pkgs.libglvnd
pkgs.mesa
final.libcufft.lib
final.libcurand.lib
];
nsight_compute = prev.nsight_compute.overrideAttrs (oldAttrs: {
nativeBuildInputs = oldAttrs.nativeBuildInputs
++ (if (lib.versionOlder prev.nsight_compute.version "2022.2.0")
then [ pkgs.qt5.wrapQtAppsHook ]
else [ pkgs.qt6.wrapQtAppsHook ]);
buildInputs = oldAttrs.buildInputs
++ (if (lib.versionOlder prev.nsight_compute.version "2022.2.0")
then [ pkgs.qt5.qtwebview ]
else [ pkgs.qt6.qtwebview ]);
});
nsight_systems = prev.nsight_systems.overrideAttrs (oldAttrs: {
nativeBuildInputs = oldAttrs.nativeBuildInputs ++ [
pkgs.addOpenGLRunpath
pkgs.qt5.wrapQtAppsHook
];
buildInputs = oldAttrs.buildInputs ++ [
pkgs.alsa-lib
pkgs.e2fsprogs
pkgs.nss
pkgs.numactl
pkgs.pulseaudio
pkgs.wayland
pkgs.xorg.libXcursor
pkgs.xorg.libXdamage
pkgs.xorg.libXrandr
pkgs.xorg.libXtst
];
# libcuda needs to be resolved during runtime
autoPatchelfIgnoreMissingDeps = true;
});
nvidia_driver = prev.nvidia_driver.overrideAttrs (oldAttrs: {
# libcuda needs to be resolved during runtime
autoPatchelfIgnoreMissingDeps = ["libcuda.so.1"];
# No need to support this package as we have drivers already
# in linuxPackages.
meta.broken = true;
});
})

52
pkgs/development/compilers/cudatoolkit/saxpy/default.nix
View File

@ -1,52 +0,0 @@
{ autoAddOpenGLRunpathHook
, backendStdenv
, cmake
, cuda_cccl ? null
, cuda_cudart ? null
, cudaFlags
, cuda_nvcc ? null
, cudatoolkit ? null
, lib
, libcublas ? null
, setupCudaHook
, stdenv
}:
backendStdenv.mkDerivation {
pname = "saxpy";
version = "unstable-2023-07-11";
src = ./.;
buildInputs = lib.optionals (cuda_cudart != null) [
libcublas
cuda_cudart
cuda_cccl
] ++ lib.optionals (cuda_cudart == null) [
cudatoolkit
];
nativeBuildInputs = [
cmake
# Alternatively, we could remove the propagated hook from cuda_nvcc and add
# directly:
# setupCudaHook
autoAddOpenGLRunpathHook
] ++ lib.optionals (cuda_nvcc != null) [
cuda_nvcc
] ++ lib.optionals (cuda_nvcc == null) [
cudatoolkit
];
cmakeFlags = [
"-DCMAKE_VERBOSE_MAKEFILE=ON"
"-DCMAKE_CUDA_ARCHITECTURES=${with cudaFlags; builtins.concatStringsSep ";" (map dropDot cudaCapabilities)}"
];
meta = {
description = "A simple (Single-precision AX Plus Y) FindCUDAToolkit.cmake example for testing cross-compilation";
license = lib.licenses.mit;
maintainers = lib.teams.cuda.members;
platforms = lib.platforms.unix;
};
}

33
pkgs/development/compilers/cudatoolkit/stdenv.nix
View File

@ -1,33 +0,0 @@
{ lib
, nixpkgsCompatibleLibstdcxx
, nvccCompatibleCC
, overrideCC
, stdenv
, wrapCCWith
}:
let
cc = wrapCCWith
{
cc = nvccCompatibleCC;
# This option is for clang's libcxx, but we (ab)use it for gcc's libstdc++.
# Note that libstdc++ maintains forward-compatibility: if we load a newer
# libstdc++ into the process, we can still use libraries built against an
# older libstdc++. This, in practice, means that we should use libstdc++ from
# the same stdenv that the rest of nixpkgs uses.
# We currently do not try to support anything other than gcc and linux.
libcxx = nixpkgsCompatibleLibstdcxx;
};
cudaStdenv = overrideCC stdenv cc;
passthruExtra = {
inherit nixpkgsCompatibleLibstdcxx;
# cc already exposed
};
assertCondition = true;
in
lib.extendDerivation
assertCondition
passthruExtra
cudaStdenv

91
pkgs/development/compilers/cudatoolkit/versions.toml
View File

@ -1,91 +0,0 @@
["10.0"]
version = "10.0.130"
url = "https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux"
sha256 = "16p3bv1lwmyqpxil8r951h385sy9asc578afrc7lssa68c71ydcj"
gcc = "gcc7"
["10.1"]
version = "10.1.243"
url = "https://developer.download.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.243_418.87.00_linux.run"
sha256 = "0caxhlv2bdq863dfp6wj7nad66ml81vasq2ayf11psvq2b12vhp7"
gcc = "gcc7"
["10.2"]
version = "10.2.89"
url = "http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run"
sha256 = "04fasl9sjkb1jvchvqgaqxprnprcz7a8r52249zp2ijarzyhf3an"
gcc = "gcc7"
["11.0"]
version = "11.0.3"
url = "https://developer.download.nvidia.com/compute/cuda/11.0.3/local_installers/cuda_11.0.3_450.51.06_linux.run"
sha256 = "1h4c69nfrgm09jzv8xjnjcvpq8n4gnlii17v3wzqry5d13jc8ydh"
gcc = "gcc9"
["11.1"]
version = "11.1.1"
url = "https://developer.download.nvidia.com/compute/cuda/11.1.1/local_installers/cuda_11.1.1_455.32.00_linux.run"
sha256 = "13yxv2fgvdnqqbwh1zb80x4xhyfkbajfkwyfpdg9493010kngbiy"
gcc = "gcc9"
["11.2"]
version = "11.2.1"
url = "https://developer.download.nvidia.com/compute/cuda/11.2.1/local_installers/cuda_11.2.1_460.32.03_linux.run"
sha256 = "sha256-HamMuJfMX1inRFpKZspPaSaGdwbLOvWKZpzc2Nw9F8g="
gcc = "gcc9"
["11.3"]
version = "11.3.1"
url = "https://developer.download.nvidia.com/compute/cuda/11.3.1/local_installers/cuda_11.3.1_465.19.01_linux.run"
sha256 = "0d19pwcqin76scbw1s5kgj8n0z1p4v1hyfldqmamilyfxycfm4xd"
gcc = "gcc9"
["11.4"]
version = "11.4.2"
url = "https://developer.download.nvidia.com/compute/cuda/11.4.2/local_installers/cuda_11.4.2_470.57.02_linux.run"
sha256 = "sha256-u9h8oOkT+DdFSnljZ0c1E83e9VUILk2G7Zo4ZZzIHwo="
gcc = "gcc10"
["11.5"]
version = "11.5.0"
url = "https://developer.download.nvidia.com/compute/cuda/11.5.0/local_installers/cuda_11.5.0_495.29.05_linux.run"
sha256 = "sha256-rgoWk9lJfPPYHmlIlD43lGNpANtxyY1Y7v2sr38aHkw="
# cuda 11.5 has problems with glibc 2.4 -> keeping gcc10
# cf. https://forums.developer.nvidia.com/t/cuda-11-5-samples-throw-multiple-error-attribute-malloc-does-not-take-arguments/192750/15
gcc = "gcc10"
["11.6"]
version = "11.6.1"
url = "https://developer.download.nvidia.com/compute/cuda/11.6.1/local_installers/cuda_11.6.1_510.47.03_linux.run"
sha256 = "sha256-qyGa/OALdCABEyaYZvv/derQN7z8I1UagzjCaEyYTX4="
gcc = "gcc11"
["11.7"]
version = "11.7.0"
url = "https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda_11.7.0_515.43.04_linux.run"
sha256 = "sha256-CH/fy7ofeVQ7H3jkOo39rF9tskLQQt3oIOFtwYWJLyY="
gcc = "gcc11"
["11.8"]
version = "11.8.0"
url = "https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run"
sha256 = "sha256-kiPErzrr5Ke77Zq9mxY7A6GzS4VfvCtKDRtwasCaWhY="
gcc = "gcc11"
["12.0"]
version = "12.0.1"
url = "https://developer.download.nvidia.com/compute/cuda/12.0.1/local_installers/cuda_12.0.1_525.85.12_linux.run"
sha256 = "sha256-GyBaBicvFGP0dydv2rkD8/ZmkXwGjlIHOAAeacehh1s="
gcc = "gcc12"
["12.1"]
version = "12.1.1"
url = "https://developer.download.nvidia.com/compute/cuda/12.1.1/local_installers/cuda_12.1.1_530.30.02_linux.run"
sha256 = "sha256-10Ai1B2AEFMZ36Ib7qObd6W5kZU5wEh6BcqvJEbWpw4="
gcc = "gcc12"
["12.2"]
version = "12.2.0"
url = "https://developer.download.nvidia.com/compute/cuda/12.2.0/local_installers/cuda_12.2.0_535.54.03_linux.run"
sha256 = "sha256-7PPSr63LrAKfD0UFeFgQ1S0AbkuHunn/P5hDNqK79Rg="
gcc = "gcc12"

32
pkgs/development/cuda-modules/README.md Normal file
View File

@ -0,0 +1,32 @@
# cuda-modules
> [!NOTE]
> This document is meant to help CUDA maintainers understand the structure of the CUDA packages in Nixpkgs. It is not meant to be a user-facing document.
> For a user-facing document, see [the CUDA section of the manual](../../../doc/languages-frameworks/cuda.section.md).
The files in this directory are added (in some way) to the `cudaPackages` package set by [cuda-packages.nix](../../top-level/cuda-packages.nix).
## Top-level files
Top-level nix files are included in the initial creation of the `cudaPackages` scope. These are typically required for the creation of the finalized `cudaPackages` scope:
- `backend-stdenv.nix`: Standard environment for CUDA packages.
- `flags.nix`: Flags set, or consumed by, NVCC in order to build packages.
- `gpus.nix`: A list of supported NVIDIA GPUs.
- `nvcc-compatibilities.nix`: NVCC releases and the version range of GCC/Clang they support.
## Top-level directories
- `cuda`: CUDA redistributables! Provides extension to `cudaPackages` scope.
- `cudatoolkit`: monolothic CUDA Toolkit run-file installer. Provides extension to `cudaPackages` scope.
- `cudnn`: NVIDIA cuDNN library.
- `cutensor`: NVIDIA cuTENSOR library.
- `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.
- `nccl`: NVIDIA NCCL library.
- `nccl-tests`: NVIDIA NCCL tests.
- `saxpy`: Example CMake project that uses CUDA.
- `setup-hooks`: Nixpkgs setup hooks for CUDA.
- `tensorrt`: NVIDIA TensorRT library.

39
pkgs/development/cuda-modules/backend-stdenv.nix Normal file
View File

@ -0,0 +1,39 @@
{
lib,
nvccCompatibilities,
cudaVersion,
buildPackages,
overrideCC,
stdenv,
wrapCCWith,
}:
let
gccMajorVersion = nvccCompatibilities.${cudaVersion}.gccMaxMajorVersion;
# We use buildPackages (= pkgsBuildHost) because we look for a gcc that
# runs on our build platform, and that produces executables for the host
# platform (= platform on which we deploy and run the downstream packages).
# The target platform of buildPackages.gcc is our host platform, so its
# .lib output should be the libstdc++ we want to be writing in the runpaths
# Cf. https://github.com/NixOS/nixpkgs/pull/225661#discussion_r1164564576
nixpkgsCompatibleLibstdcxx = buildPackages.gcc.cc.lib;
nvccCompatibleCC = buildPackages."gcc${gccMajorVersion}".cc;
cc = wrapCCWith {
cc = nvccCompatibleCC;
# This option is for clang's libcxx, but we (ab)use it for gcc's libstdc++.
# Note that libstdc++ maintains forward-compatibility: if we load a newer
# libstdc++ into the process, we can still use libraries built against an
# older libstdc++. This, in practice, means that we should use libstdc++ from
# the same stdenv that the rest of nixpkgs uses.
# We currently do not try to support anything other than gcc and linux.
libcxx = nixpkgsCompatibleLibstdcxx;
};
cudaStdenv = overrideCC stdenv cc;
passthruExtra = {
inherit nixpkgsCompatibleLibstdcxx;
# cc already exposed
};
assertCondition = true;
in
lib.extendDerivation assertCondition passthruExtra cudaStdenv

102
pkgs/development/cuda-modules/cuda/extension.nix Normal file
View File

@ -0,0 +1,102 @@
{cudaVersion, 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 = {
"11.4" = "11.4.4";
"11.5" = "11.5.2";
"11.6" = "11.6.2";
"11.7" = "11.7.1";
"11.8" = "11.8.0";
"12.0" = "12.0.1";
"12.1" = "12.1.1";
"12.2" = "12.2.2";
"12.3" = "12.3.0";
};
# Check if the current CUDA version is supported.
cudaVersionMappingExists = builtins.hasAttr cudaVersion cudaVersionMap;
# fullCudaVersion : String
fullCudaVersion = cudaVersionMap.${cudaVersion};
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 architecture
# 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:
let
redistribRelease = redistribManifest.${pname};
featureRelease = featureManifest.${pname};
drv =
(callPackage ../generic-builders/manifest.nix {
# 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.
inherit
pname
redistName
redistribRelease
featureRelease
;
}).overrideAttrs
(
prevAttrs: {
# Add the package-specific license.
meta = prevAttrs.meta // {
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;};
};
}
);
in
drv;
# 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

1212
pkgs/development/cuda-modules/cuda/manifests/feature_11.4.4.json Normal file
View File

File diff suppressed because it is too large Load Diff

1224
pkgs/development/cuda-modules/cuda/manifests/feature_11.5.2.json Normal file
View File

File diff suppressed because it is too large Load Diff

1224
pkgs/development/cuda-modules/cuda/manifests/feature_11.6.2.json Normal file
View File

File diff suppressed because it is too large Load Diff

1244
pkgs/development/cuda-modules/cuda/manifests/feature_11.7.1.json Normal file
View File

File diff suppressed because it is too large Load Diff

1540
pkgs/development/cuda-modules/cuda/manifests/feature_11.8.0.json Normal file
View File

File diff suppressed because it is too large Load Diff

1622
pkgs/development/cuda-modules/cuda/manifests/feature_12.0.1.json Normal file
View File

File diff suppressed because it is too large Load Diff

1622
pkgs/development/cuda-modules/cuda/manifests/feature_12.1.1.json Normal file
View File

File diff suppressed because it is too large Load Diff

1600
pkgs/development/cuda-modules/cuda/manifests/feature_12.2.2.json Normal file
View File

File diff suppressed because it is too large Load Diff

1316
pkgs/development/cuda-modules/cuda/manifests/feature_12.3.0.json Normal file
View File

File diff suppressed because it is too large Load Diff

0
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.4.4.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_11.4.4.json
View File

0
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.5.2.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_11.5.2.json
View File

0
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.6.2.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_11.6.2.json
View File

885
pkgs/development/cuda-modules/cuda/manifests/redistrib_11.7.1.json Normal file
View File

@ -0,0 +1,885 @@
{
"release_date": "2022-08-03",
"cuda_cccl": {
"name": "CXX Core Compute Libraries",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "bf051d7b22581e31fac992c12af1400036d38e6a53e230b08f2aac3fa93d593e",
"md5": "ba8caa16f0f0b2a34d65a83b501369eb",
"size": "1004116"
},
"linux-ppc64le": {
"relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "5c4c56a91054e0bff1052b1359774c86b2d10f0bd0712d50cdc78b5ea636f6ee",
"md5": "55710f4bf751a12b3bb0525cc3794e1a",
"size": "1004352"
},
"linux-sbsa": {
"relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "1137f6b08aac445070ed467e61fb68494339b798a1c6e1929647e87053b05c86",
"md5": "3a5cb39720d7be44f32eb1331326a9ec",
"size": "1004092"
},
"windows-x86_64": {
"relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-11.7.91-archive.zip",
"sha256": "638ec54f6d180d17c6f70ba45e7694a29f1d7014a434e4f1c081198c04017147",
"md5": "a5f9bf5a16ed2a7c0132168c1e0782c4",
"size": "2563581"
}
},
"cuda_cudart": {
"name": "CUDA Runtime (cudart)",
"license": "CUDA Toolkit",
"version": "11.7.99",
"linux-x86_64": {
"relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-11.7.99-archive.tar.xz",
"sha256": "7892409299c6865d0652373cb385add31b0faa2e5421a931ae9fbc103e1472ad",
"md5": "31bf77729efe1d1f09ff65faba0f67f8",
"size": "854756"
},
"linux-ppc64le": {
"relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-11.7.99-archive.tar.xz",
"sha256": "0a326ec6b1abcc6e54172a09bf9ba44b3b75ae536eb1287ebf4baa76609012c9",
"md5": "d007dc5ec2752717db482e1d0ec4c70e",
"size": "795684"
},
"linux-sbsa": {
"relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-11.7.99-archive.tar.xz",
"sha256": "b7c90ae963e67825b9b518062902d4b80a55a3f3ada6f5bb3a7c19b8e93df024",
"md5": "1ffd4fde62beb2c429837a365aea5760",
"size": "798380"
},
"windows-x86_64": {
"relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-11.7.99-archive.zip",
"sha256": "1eb967fe01843dbe4b41a43352df193018077dd28b06eb2fd5af897b03f92d5c",
"md5": "c8cc7f3f93444de4652a6fb2b08c2397",
"size": "2884857"
}
},
"cuda_cuobjdump": {
"name": "cuobjdump",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "a345694cf430a668b2fb9aac34e01b373c4283751cd8ee3f91439c8c9613455d",
"md5": "6584e15dac6ce66f10f0f76ac618c1ea",
"size": "127260"
},
"linux-ppc64le": {
"relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "345dc2651a8e069a766ee9ceaa7052764964fbb75d17c765bd1f3656f22e45b6",
"md5": "c82c84e46f6d2c4c154faa81d341e3ec",
"size": "140532"
},
"linux-sbsa": {
"relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "f408a0534081a1e8e3cc2b3aaec33f9ba09c7c60bdd8a6d20b3ec69c688a576e",
"md5": "71e958168e3d637751f3bb2f948a0d8e",
"size": "124120"
},
"windows-x86_64": {
"relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-11.7.91-archive.zip",
"sha256": "6024efc79c78668de3e21b608035e77f1d40dc7bb250630255d627ccb2e51380",
"md5": "5034e6496a31fb6c8b722590076f41a0",
"size": "2523878"
}
},
"cuda_cupti": {
"name": "CUPTI",
"license": "CUDA Toolkit",
"version": "11.7.101",
"linux-x86_64": {
"relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-11.7.101-archive.tar.xz",
"sha256": "7193f5d9b23e91b5cc34df57f7500f891b8461c1ace2d2489beed38da6d22f23",
"md5": "8251f46de255ad61d1fa5df01de6d44f",
"size": "16923928"
},
"linux-ppc64le": {
"relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-11.7.101-archive.tar.xz",
"sha256": "6f99b8a421235932974d7b14a20b8e61e7f5e65efc65b73b9f8455ef7627dbce",
"md5": "396fc8ebdeca795b4553e0837d1f5900",
"size": "8661172"
},
"linux-sbsa": {
"relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-11.7.101-archive.tar.xz",
"sha256": "42c2f7b9734a18dec5f63b954e3bc1ff45f4283b1707d88e7eb298d40c2a7390",
"md5": "103742737a3f76cc7fe53926cbcec00e",
"size": "8506536"
},
"windows-x86_64": {
"relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-11.7.101-archive.zip",
"sha256": "9d2d98b73cf70165a0c7652b5c764da2816209f519a8c73cdf01733a83502170",
"md5": "0103f854be9331a3fed35d1d2f1217e5",
"size": "11548637"
}
},
"cuda_cuxxfilt": {
"name": "CUDA cuxxfilt (demangler)",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "7d6c8074e76fdcf294569a92883355b71ac591c0c117daf0752320f60e254506",
"md5": "cf471de3ea0d22b0382e4c32abcba2fd",
"size": "186264"
},
"linux-ppc64le": {
"relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "f44e311983ced0ab98fed509b08a682b2c9f9c93d31bc3f7bec4dacfe6c24d22",
"md5": "84f06154873f165a427e457c5bb367b3",
"size": "181312"
},
"linux-sbsa": {
"relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "e9798ddebc419fdc03bfe627cd1c8a3a683fd87b7f0a0b0ee2b76bfc98e951f1",
"md5": "9b42db5debcbd34c96ea11a975d8a487",
"size": "172664"
},
"windows-x86_64": {
"relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-11.7.91-archive.zip",
"sha256": "af41ea6a2673222cfea3aaf77ba369b17741cbed528f4d4482341d9f00a2cd18",
"md5": "a16ae2cef58dd60a6f505a4525a85e4e",
"size": "168946"
}
},
"cuda_demo_suite": {
"name": "CUDA Demo Suite",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "f1ec9416a2bee5ceea0e7db9ba1936d661b5a5ab5193d19219d646018f789048",
"md5": "a6eddd4dc84a1996cf42d186307aa582",
"size": "3987624"
},
"windows-x86_64": {
"relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-11.7.91-archive.zip",
"sha256": "5116656f74f894707e4eb3eb0028a8fc935b905f5fc3e7aa8ca7c4ee5454ce95",
"md5": "760a960af1d6565f15aa83df0fa3c3cf",
"size": "5023831"
}
},
"cuda_documentation": {
"name": "CUDA Documentation",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "680d7b7df3b627eb00046d9b051120a5568306a405c97fec46ce005d4cde7177",
"md5": "5ffc2d1e1b59a640b9a9889830d2fd4d",
"size": "65688"
},
"linux-ppc64le": {
"relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "229b39ec29343137f2cf3a77cb0b1de5546b0dfbf8a7c0ffb82b7e2348f2d70a",
"md5": "18a638ca4c87283393a91b003e1552bb",
"size": "65892"
},
"linux-sbsa": {
"relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "bdfdad5afcb5e2a2915f1c0b6af022ae4c2496af66928bbcd2b6148fa1cb02f9",
"md5": "48358932a272ad97c5d87368b31c7895",
"size": "65696"
},
"windows-x86_64": {
"relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-11.7.91-archive.zip",
"sha256": "47571f8292a07552388fe92eaea6e571a8cdc6bf4aa0d87795232cd4c6256242",
"md5": "7f435e81b21d65224d056d8e1f2a2293",
"size": "103883"
}
},
"cuda_gdb": {
"name": "CUDA GDB",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "88139baf0eff8350f5250bfa0b335d6a8a21efb125e5340264cf715c6f717dee",
"md5": "1b7ba763ba29aa3b867313daac3f6306",
"size": "64326484"
},
"linux-ppc64le": {
"relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "31f91a7c13d2524bde919b2cd0f4d946522af58a0937341606e96e8e5099b8af",
"md5": "5e294385247fc88eaef4c27e2f2b26b0",
"size": "64156680"
},
"linux-sbsa": {
"relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "c00a2de57e3f293e0236c4aa23f2a2c4842a7a9a0f4e0a156e8c7073e15300c9",
"md5": "a9129971763d386d8f95021e0821e0f1",
"size": "63933124"
}
},
"cuda_memcheck": {
"name": "CUDA Memcheck",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_memcheck/linux-x86_64/cuda_memcheck-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "4e8b01194aea23ec2c5e8fec8fcb12bae60594e34552d2339dc4fc695c6a7454",
"md5": "5937f55b86d1b4c7a55989d2baff4a1b",
"size": "139772"
},
"linux-ppc64le": {
"relative_path": "cuda_memcheck/linux-ppc64le/cuda_memcheck-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "750834023e2b233a604d6bd61e3736e3fbd9271050b84c85b8fbc83e5bdba221",
"md5": "a13f6fded406078a14d46c69bf5b9fbf",
"size": "147880"
},
"windows-x86_64": {
"relative_path": "cuda_memcheck/windows-x86_64/cuda_memcheck-windows-x86_64-11.7.91-archive.zip",
"sha256": "0ec79164f5bc925ad9e1c0fd481dd5341be5c6f8c7bb366ac6a106be7f585730",
"md5": "5dec2fb14dace02a1be4648b4ef9d45c",
"size": "172868"
}
},
"cuda_nsight": {
"name": "Nsight Eclipse Edition Plugin",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "1a5a0e4b8ee7885f80953b5547bf9c94dd4b050fbf66e213ce527d3926ce4473",
"md5": "7bd236c01d795c19ed68b19da44614ea",
"size": "118610820"
},
"linux-ppc64le": {
"relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "86a94c7f1f0a4746937dc77c33d3774fa8aa8fa45b48b5843a76956a8ef4642b",
"md5": "8679d0658976ae91ed1ef73fb73746eb",
"size": "118610828"
}
},
"cuda_nvcc": {
"name": "CUDA NVCC",
"license": "CUDA Toolkit",
"version": "11.7.99",
"linux-x86_64": {
"relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-11.7.99-archive.tar.xz",
"sha256": "4a75e5bd6a0e0e664ec5895ba050cf9d7cda08f41db2b6b4c36fb91cfb9627bc",
"md5": "9f0fad0ba21b72ef1813a8705b0e8171",
"size": "37045896"
},
"linux-ppc64le": {
"relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-11.7.99-archive.tar.xz",
"sha256": "0cb5ca0b171bb0e513d1960fde4106457ad6a3d4f770984bfb69d736fb403e83",
"md5": "62bd522c15dd86bcff7a7bb0acad50c3",
"size": "34878168"
},
"linux-sbsa": {
"relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-11.7.99-archive.tar.xz",
"sha256": "59016452808b9b2eb83eeb05bdc0737983a1debb3812513c860869092a8152b8",
"md5": "3b9b2692ef4bbf413b1aa68aa8477288",
"size": "32636812"
},
"windows-x86_64": {
"relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-11.7.99-archive.zip",
"sha256": "55aac64b0c81b96628ad9511514c591c33a4649d15d5a579d351be5b89632276",
"md5": "e897644755a92a4681c8816cb6317981",
"size": "47663877"
}
},
"cuda_nvdisasm": {
"name": "CUDA nvdisasm",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "da935b2d88a3e75095981143174026ca1d2a5ea43783240e7312874ae3e73217",
"md5": "d573df50a5f7dc07aa9e09df81b14d98",
"size": "32787620"
},
"linux-ppc64le": {
"relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "daf6a45fd71f80e697720445734a52422fec4eed07664bfa1154c1d84a2f0b71",
"md5": "e967c5fd7d9a44cc8fa07d84eb1cfe5f",
"size": "32792832"
},
"linux-sbsa": {
"relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "09e183b991019eb102a8592ab3f3cf64fa1969a4ec42deb96407549938ece485",
"md5": "a7be5d6186b166d731f870ecbdab99ee",
"size": "32731196"
},
"windows-x86_64": {
"relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-11.7.91-archive.zip",
"sha256": "be716596ea300a295ab06b92caa92d7a17e4dd23f7a3f9ef0f98f1f81a63d241",
"md5": "189329f03aa56788ddabf00f7be6ac46",
"size": "33004702"
}
},
"cuda_nvml_dev": {
"name": "CUDA NVML Headers",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "b8ea7d2a5adb138a9121911dd03eaa7b7d04c96c64d2fcc585c29be2a73ddfef",
"md5": "439c09ca1fecea5431f9f1684cb76118",
"size": "76392"
},
"linux-ppc64le": {
"relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "a60c92d8eb6d014b4f5e961d9d64a6fee9f0b381c6238146b55210d142a501f9",
"md5": "fcc7b6ae2467ffca24326b4b934d0bde",
"size": "76108"
},
"linux-sbsa": {
"relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "891de12a4aa2941e95b1d3d84f57ffe38840bc3883d02b1c9ff1777b16ed07d9",
"md5": "4441e23289ee0246aa026585677e4ade",
"size": "76732"
},
"windows-x86_64": {
"relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-11.7.91-archive.zip",
"sha256": "f8a9be7526d4c201759346911145a026acafb72e664bae9ec8b9690f8ac4c56c",
"md5": "81fb3e254d1da50d6335beafb0f761c5",
"size": "106750"
}
},
"cuda_nvprof": {
"name": "CUDA nvprof",
"license": "CUDA Toolkit",
"version": "11.7.101",
"linux-x86_64": {
"relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-11.7.101-archive.tar.xz",
"sha256": "028c9ae359e037fd8b3b7976304821704818d141284e8878577061dc41e19afe",
"md5": "90fa02884b5cab3163f9ca94a5c3bea3",
"size": "1944168"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-11.7.101-archive.tar.xz",
"sha256": "be5cfe846f87968a7425cc210899b2c50dece34d79d975c235887ddac6453fcb",
"md5": "41c8f4a4ad5e8780ccb2dbd160b58775",
"size": "1600192"
},
"linux-sbsa": {
"relative_path": "cuda_nvprof/linux-sbsa/cuda_nvprof-linux-sbsa-11.7.101-archive.tar.xz",
"sha256": "e910c6d39ef34317b4b6c57da4186ac88934ce6282c6392631141291821a482e",
"md5": "8899dafe69b323e2acb13d46cb9d3322",
"size": "16144"
},
"windows-x86_64": {
"relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-11.7.101-archive.zip",
"sha256": "2199a24ea32c4df25e55e4308bb5f620ec8e409ba904cb20f0fe57d081ac501a",
"md5": "625bf74f6cc19181010cd66c07d15c76",
"size": "1603321"
}
},
"cuda_nvprune": {
"name": "CUDA nvprune",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "94a6bd85e944f89ce0192fae649ab9b213a7cea28d7bafa5f6a1d57c49148f84",
"md5": "41e4d4e51f7f96cf7e1db29009db780b",
"size": "55136"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "93d9e2ba9819ca19bac6c17e96bfd9bc56524a60372ab9d57286430df1c2265e",
"md5": "2fd26dccb2e78ff92dac81ee1cf23b02",
"size": "55756"
},
"linux-sbsa": {
"relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "f7325009c1e73f7b4f70117073af1e698dcf81ceb07569527760606b348385fa",
"md5": "1511a5b8b7bb2924e8324e93a2c16a07",
"size": "47604"
},
"windows-x86_64": {
"relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-11.7.91-archive.zip",
"sha256": "dcff80bce25f5d3f3b53a3f08b346ff5b38e5274a0e54572f97762e56d619236",
"md5": "09f6a56f13c677f6042472561529138f",
"size": "144825"
}
},
"cuda_nvrtc": {
"name": "CUDA NVRTC",
"license": "CUDA Toolkit",
"version": "11.7.99",
"linux-x86_64": {
"relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-11.7.99-archive.tar.xz",
"sha256": "cd6ed198ef77898bb3025145570d981cc7a0d2bda792e9a70822fcd274b18248",
"md5": "1afd3d6203308995b731a20563ea8303",
"size": "28033228"
},
"linux-ppc64le": {
"relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-11.7.99-archive.tar.xz",
"sha256": "a99594647a16839612f078913252809fe2cbe3ff23b9023304ddd181f5ad0362",
"md5": "76d6e4a29cf3652c30154ec6b8e7780d",
"size": "26189204"
},
"linux-sbsa": {
"relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-11.7.99-archive.tar.xz",
"sha256": "32a94a6993edc24aadeebdae7c4e8fad04a9c7214bd1f505aec16256305feb4e",
"md5": "e52f252b10a8207e9d7464dc07ae55f8",
"size": "26042768"
},
"windows-x86_64": {
"relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-11.7.99-archive.zip",
"sha256": "d4b5027eee2e20155ba317b6b62f8fc36b2baa0c23b5c7031d93fa7d5b260fd1",
"md5": "340f20034bac368af3b3229fea99602d",
"size": "93547997"
}
},
"cuda_nvtx": {
"name": "CUDA NVTX",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "a7741ed4911a0f1d17ab8da20f4e7fdc01fdd3d911b3592fa874cede9f82fd64",
"md5": "3120a53ef3be9e9074d62c5692a30d24",
"size": "48152"
},
"linux-ppc64le": {
"relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "d572ad45a4e878c38454b19263666f0668222390568697ada3eda376a54ecc42",
"md5": "d751517c504774e5b95829cefb12a8c9",
"size": "48132"
},
"linux-sbsa": {
"relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "ab2350160efdfc1024511c94eb1ecffbee4260575a57cf2d48bdc533d942e3ef",
"md5": "f0e663c07f942cbbd0de8df1163074ba",
"size": "48696"
},
"windows-x86_64": {
"relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-11.7.91-archive.zip",
"sha256": "3918a2edeef7c2da6af036451b3768c1b9298a38776f8010f91f5366e1a3419f",
"md5": "c53c9e694b4c643cc36b4cbf1b07e8cf",
"size": "65690"
}
},
"cuda_nvvp": {
"name": "CUDA NVVP",
"license": "CUDA Toolkit",
"version": "11.7.101",
"linux-x86_64": {
"relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-11.7.101-archive.tar.xz",
"sha256": "1689e5a52f683e02f7ad47eae0c182f33bf8988c2ec9b8b8fe61b4a40ab97989",
"md5": "cd892070d2cfabadf2133039a0370de0",
"size": "117559820"
},
"linux-ppc64le": {
"relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-11.7.101-archive.tar.xz",
"sha256": "81b670e1fa0e415446c6eeadc44c8f5e5d4eab7709cc280a494104ee7b636187",
"md5": "7920cebfb571c798d1a1b652f9960453",
"size": "117016948"
},
"windows-x86_64": {
"relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-11.7.101-archive.zip",
"sha256": "5fdf67691bf16a13fb3f472e7d7261f0a5112477c77e81aabd11d1ad27a5ae59",
"md5": "036b87efba3ee5982cf740b632a9f0ec",
"size": "120353825"
}
},
"cuda_sanitizer_api": {
"name": "CUDA Compute Sanitizer API",
"license": "CUDA Toolkit",
"version": "11.7.91",
"linux-x86_64": {
"relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-11.7.91-archive.tar.xz",
"sha256": "232bc60afa687d75825fce271ee8d5b56f2d58528785500448b830d61795840f",
"md5": "d94e9fe874ac1226fd69f2cad7245b23",
"size": "8316344"
},
"linux-ppc64le": {
"relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-11.7.91-archive.tar.xz",
"sha256": "2aa8cacf505c2f3cea263193df80e6411cbcb8eca5a46c539821324619fad47f",
"md5": "616b19f4001b6798f7f90a390912480a",
"size": "7742156"
},
"linux-sbsa": {
"relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-11.7.91-archive.tar.xz",
"sha256": "a98ad5ae882cfcf57439668f7b4fa736d85a0726160bba5c058dfce5f79cc4a4",
"md5": "a08127236f6343a3d7e84488f97bd1e7",
"size": "6454908"
},
"windows-x86_64": {
"relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-11.7.91-archive.zip",
"sha256": "1dc3858fc0e843fff830a260f00c9f2aed61882804735bea8154e577c8da42a2",
"md5": "b34204afa13f28bfdf567c2128806311",
"size": "13478900"
}
},
"fabricmanager": {
"name": "NVIDIA Fabric Manager",
"license": "NVIDIA Driver",
"version": "515.65.01",
"linux-x86_64": {
"relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-515.65.01-archive.tar.xz",
"sha256": "f3271a899151c762641e2beab68335ab1f52cb5beecef0f474780f8fbe804f58",
"md5": "8e158a039561f3fc7cec3d61dd19c525",
"size": "1470560"
},
"linux-sbsa": {
"relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-515.65.01-archive.tar.xz",
"sha256": "dac775eaed6bf26ffb7b8e281db7fd83f5edca5625dc86a0aca26f479263b38d",
"md5": "b30674e7fb23b2c189bb71e200764248",
"size": "1359224"
}
},
"libcublas": {
"name": "CUDA cuBLAS",
"license": "CUDA Toolkit",
"version": "11.10.3.66",
"linux-x86_64": {
"relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-11.10.3.66-archive.tar.xz",
"sha256": "15c117c74bc1401dbc87cc8a9f510155818786c030fc3396f4af6bc425aef6f3",
"md5": "b7ef03a0126377d8a1b3fa14b0d9c8c8",
"size": "417046836"
},
"linux-ppc64le": {
"relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-11.10.3.66-archive.tar.xz",
"sha256": "89020ee3be5143b10915d78dfc1dbe44aef952c9a0aad44b3bb973288bcf98c7",
"md5": "32b4ffb9312b7311ae46030b6007409f",
"size": "417479596"
},
"linux-sbsa": {
"relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-11.10.3.66-archive.tar.xz",
"sha256": "3d64f899d4e88bd85ff410aa8fda0fe3c14d0e3acadba9ef550924ac8f34b52d",
"md5": "c2641e424ea84665a9f67721ecb4bf34",
"size": "417698300"
},
"windows-x86_64": {
"relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-11.10.3.66-archive.zip",
"sha256": "f6d80b92b0c4ae077d71ee83aaa5057c4e6419b80e25ef22ff03a80aad700fe0",
"md5": "06edf73511fb738724264e59488f9935",
"size": "307337197"
}
},
"libcufft": {
"name": "CUDA cuFFT",
"license": "CUDA Toolkit",
"version": "10.7.2.91",
"linux-x86_64": {
"relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-10.7.2.91-archive.tar.xz",
"sha256": "4f1ed4817de6be53474a27c47097eb618a33b5a3e0ad08f5f68abc8b7312aa28",
"md5": "41a6e0c3dd3d38e2a73f38d1949e032e",
"size": "213585020"
},
"linux-ppc64le": {
"relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-10.7.2.91-archive.tar.xz",
"sha256": "1a80975288256a894a435a9bd2e842bfcb4dbfec3e52741f4808e90ab270828a",
"md5": "0cbe542f6d2aa5bc2641d37cf7c7dcb8",
"size": "213738992"
},
"linux-sbsa": {
"relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-10.7.2.91-archive.tar.xz",
"sha256": "c6147c67db716824d8b7ff61306ccbf1897e3d5e1399d37e6c5ede0334db4ce9",
"md5": "2a0ff67d0f1829a1e34f167e272da10a",
"size": "212515324"
},
"windows-x86_64": {
"relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-10.7.2.91-archive.zip",
"sha256": "88643d092d3d8ef30d2b5ca3757ea87577eaefc1268f350507a3b132abeb7f24",
"md5": "7860b8f5ca73b58c7038e7c3f710e8cd",
"size": "287120070"
}
},
"libcufile": {
"name": "CUDA cuFile",
"license": "CUDA Toolkit",
"version": "1.3.1.18",
"linux-x86_64": {
"relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.3.1.18-archive.tar.xz",
"sha256": "782473d5b2d0ae57eeb9044a0f6dc6f205787767f7a247bdeb9e916af1db61c2",
"md5": "66add7faa97bb2a7d5b1f2ac2af4bdba",
"size": "46933808"
}
},
"libcurand": {
"name": "CUDA cuRAND",
"license": "CUDA Toolkit",
"version": "10.2.10.91",
"linux-x86_64": {
"relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.2.10.91-archive.tar.xz",
"sha256": "283323c93050b3904d58417a6dd4055c156407c2df0c064ae81592e532b69a31",
"md5": "26ad932ad9ee5fc4e4b4afd91f95fa29",
"size": "82110404"
},
"linux-ppc64le": {
"relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.2.10.91-archive.tar.xz",
"sha256": "0d483258a04dcbbf845481d6bd15f061e06ba7608d54827eae026039aa9edaa4",
"md5": "1b609ba95d5a668056b0474dbf715fc8",
"size": "82156300"
},
"linux-sbsa": {
"relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.2.10.91-archive.tar.xz",
"sha256": "ce68130a726152a7f68a0cec85773e4074a2f2049e16ca41e462fde12affda94",
"md5": "3c1fc54570aa317d6ac15edf6799fefa",
"size": "82105144"
},
"windows-x86_64": {
"relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.2.10.91-archive.zip",
"sha256": "90e043d540765f410fa8d3d569e95b8eac15940037cd1159335f99d4caab484f",
"md5": "8be38680d09aafdf3c7c06d630c7aaf0",
"size": "53656549"
}
},
"libcusolver": {
"name": "CUDA cuSOLVER",
"license": "CUDA Toolkit",
"version": "11.4.0.1",
"linux-x86_64": {
"relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.4.0.1-archive.tar.xz",
"sha256": "9f56bfdfeccd63f4cde99bc4a573d5ab45e2339cf6a1b2a0fc7ff83ff9775b3d",
"md5": "b9eea1b15fd5ff72286ff31751aa3d9e",
"size": "75670492"
},
"linux-ppc64le": {
"relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.4.0.1-archive.tar.xz",
"sha256": "45a7645ad81a8874c192b816b227730aeb771443f54a34fa35e3496041ddcc09",
"md5": "0dfc2d853f84f7ce7a44a8f87e60d367",
"size": "75649948"
},
"linux-sbsa": {
"relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.4.0.1-archive.tar.xz",
"sha256": "eb9c08d184226c616a4ff041cec178b29480f8afe034f7537c0d07b6afe84588",
"md5": "7f0af50206ce081a67b05eadf607873a",
"size": "74862860"
},
"windows-x86_64": {
"relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.4.0.1-archive.zip",
"sha256": "bfce43d0437ae10a7250c9f173e04e048fc46f9e5c9ed2c2bd4db4e661c77ba1",
"md5": "e677373b0ba75e2aec8df60868fb8363",
"size": "95990827"
}
},
"libcusparse": {
"name": "CUDA cuSPARSE",
"license": "CUDA Toolkit",
"version": "11.7.4.91",
"linux-x86_64": {
"relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-11.7.4.91-archive.tar.xz",
"sha256": "16841f9d4350ca21b6b362d4265983a58e675d64a14f168687b1b68995bec32e",
"md5": "a7e7936e601b0645fc086e71e1e6f6f6",
"size": "203663528"
},
"linux-ppc64le": {
"relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-11.7.4.91-archive.tar.xz",
"sha256": "45b65fa9e864d2df5d0d8fd36e5fad28cb3d5793689ea214b310086d034ad4a8",
"md5": "3a6780fb8a79dce74a310c14cfd31a1c",
"size": "203731380"
},
"linux-sbsa": {
"relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-11.7.4.91-archive.tar.xz",
"sha256": "b7f1ba9c18f87db594847b318fa73b5c76945777b5c03a507434bfa6aba2f2a2",
"md5": "aa027c7f4b72d94be7f86fa243ac54ef",
"size": "203358196"
},
"windows-x86_64": {
"relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-11.7.4.91-archive.zip",
"sha256": "2827643399b92b87af858bf4b004b4a664bc7e838a18e2143258b93c019487b0",
"md5": "21c85acb7ffa3094b81eaee72ec3af5c",
"size": "170688099"
}
},
"libnpp": {
"name": "CUDA NPP",
"license": "CUDA Toolkit",
"version": "11.7.4.75",
"linux-x86_64": {
"relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-11.7.4.75-archive.tar.xz",
"sha256": "d90a30dd7e379d55cbc3b893e23c3bdf08b07293bdd2bd6957c4fc1e2ea998ef",
"md5": "49abdcebbefb9ab8ad8b6dac450c7b20",
"size": "182469720"
},
"linux-ppc64le": {
"relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-11.7.4.75-archive.tar.xz",
"sha256": "fb822e3c04e0fa1ff84dd236c9e9f5d84658c5b370d8d3ae235a241cc8445183",
"md5": "a320af153a4fb828b51552ca180bc866",
"size": "182956844"
},
"linux-sbsa": {
"relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-11.7.4.75-archive.tar.xz",
"sha256": "29499fe94220b91408487df21dc13a7c638482438e631df13cd5f1b28b68c48a",
"md5": "38989288b63a68b93d4fc414dbe3266a",
"size": "181639308"
},
"windows-x86_64": {
"relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-11.7.4.75-archive.zip",
"sha256": "dca9b5ee0021802f02a164f3ea6bd44e552b84bbe1896bebb21e625b811c7006",
"md5": "e61b5f9a59be9fe37141168726e3151e",
"size": "137990727"
}
},
"libnvidia_nscq": {
"name": "NVIDIA NSCQ API",
"license": "NVIDIA Driver",
"version": "515.65.01",
"linux-x86_64": {
"relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-515.65.01-archive.tar.xz",
"sha256": "588b0a5ce467992ba926ada4d36ccf6741c3cfcc3fa8f03c6f68290a3f2c2a3b",
"md5": "bd1d2193708b89158a5a40711cf60bcd",
"size": "334740"
},
"linux-sbsa": {
"relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-515.65.01-archive.tar.xz",
"sha256": "fa37d0c15d79fe3ad1280f5d5946ad3c849592d89627339d1ecd90e4baeb73a1",
"md5": "44c788de578818dfcedb507ad76f3d65",
"size": "303936"
}
},
"libnvjpeg": {
"name": "CUDA nvJPEG",
"license": "CUDA Toolkit",
"version": "11.8.0.2",
"linux-x86_64": {
"relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-11.8.0.2-archive.tar.xz",
"sha256": "ae8877a59d8badf6ed6e61b0b6690dbe516997386061557f5c33ba49de6e7ac9",
"md5": "a743a968906c4300ab3dbbcef5f13182",
"size": "1956104"
},
"linux-ppc64le": {
"relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-11.8.0.2-archive.tar.xz",
"sha256": "ce1862c4db6726531d7b778b0911ac77b76d2cd4253295d5d6984b0f2bcc0adf",
"md5": "89eb5043e361f875872e4b5bf07b05b0",
"size": "1972884"
},
"linux-sbsa": {
"relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-11.8.0.2-archive.tar.xz",
"sha256": "d157fb48056c896e0474f5e07fd6f51580d27501844f8218135e233de3b927e8",
"md5": "43f15a462121e538acc36ac9cc68603c",
"size": "1763644"
},
"windows-x86_64": {
"relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-11.8.0.2-archive.zip",
"sha256": "3e3d88d6dc9d0f01d9c9261b9c055f3a93ddfd65bb8609a92bd57ea9bd9fe6f2",
"md5": "56463f5e7dbf2ecfb991a7f1a96553b5",
"size": "1858909"
}
},
"nsight_compute": {
"name": "Nsight Compute",
"license": "NVIDIA SLA",
"version": "2022.2.1.3",
"linux-x86_64": {
"relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2022.2.1.3-archive.tar.xz",
"sha256": "ba3c1ee8c6f7e3fae993a83678df6e7c6ff12f2d9ac0ab1b0f056405f3e0490a",
"md5": "fb9a27ef58aafc5d7aae9c54e364e636",
"size": "420206916"
},
"linux-ppc64le": {
"relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2022.2.1.3-archive.tar.xz",
"sha256": "cbfaf3e608d66f6f2b087b6cca4f9d2a63bf41be0997fafe30213c9feda76e22",
"md5": "68f714d5d9a82177e7d7b0b9d06e2b96",
"size": "126488268"
},
"linux-sbsa": {
"relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2022.2.1.3-archive.tar.xz",
"sha256": "2dbd112b3d89ed60b78f91912c41672165df9e8dac47e96de4e9416f8364d39f",
"md5": "495a7b1b2bcef47ff37ecee1e01fdf22",
"size": "245773972"
},
"windows-x86_64": {
"relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2022.2.1.3-archive.zip",
"sha256": "6b3c11cf07100ad0f4eac843aad877391b3ce4f24808a2a2efcba93da704d80b",
"md5": "63ffe69b1afc698d95017ec0e0edeca2",
"size": "353604503"
}
},
"nsight_nvtx": {
"name": "Nsight NVTX",
"license": "CUDA Toolkit",
"version": "1.21018621",
"windows-x86_64": {
"relative_path": "nsight_nvtx/windows-x86_64/nsight_nvtx-windows-x86_64-1.21018621-archive.zip",
"sha256": "d99b015bfb1308206f9d7c16ea401bf426fed3a5a99953b855fe4e68be5ed2d1",
"md5": "34ee04d45cfca1c4e3cbfba0ec8f6f80",
"size": "315692"
}
},
"nsight_systems": {
"name": "Nsight Systems",
"license": "NVIDIA SLA",
"version": "2022.1.3.3",
"linux-x86_64": {
"relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2022.1.3.3-archive.tar.xz",
"sha256": "bd95553d573f117be2e3b2bda6e79d14dbb038b136c12c6e5467bbd9a891681d",
"md5": "40d12d33aa2d496817d959a9551418aa",
"size": "166785296"
},
"linux-ppc64le": {
"relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2022.1.3.3-archive.tar.xz",
"sha256": "4c228bfbd38b80612afeb65a406cba829d2b2e2352ea4a810cd6a386d6190151",
"md5": "0d5da67cb5393a0e961509cd7dab98f1",
"size": "49700384"
},
"linux-sbsa": {
"relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2022.1.3.3-archive.tar.xz",
"sha256": "9025f56b9fe70288ee3f2d30477c9cfbe8c17a304b31f7f22caf7f78153d8d23",
"md5": "3559eeb8416d9a984012d2b397560740",
"size": "50415564"
},
"windows-x86_64": {
"relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2022.1.3.3-archive.zip",
"sha256": "294738ba0aa0621395740a6d039a490aa0bf5fceec449b1fd4135a97b81eda0f",
"md5": "91e316744714c168c1a75804c9a198c9",
"size": "315748009"
}
},
"nsight_vse": {
"name": "Nsight Visual Studio Edition (VSE)",
"license": "NVIDIA SLA",
"version": "2022.2.1.22136",
"windows-x86_64": {
"relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2022.2.1.22136-archive.zip",
"sha256": "b2afd0efaf6f1fab5a1aca71c536e34c29260f69d5c5d5c3aec41624de0be671",
"md5": "ab19e7dbec03a5f5a3fd42ca839c57ce",
"size": "459007868"
}
},
"nvidia_driver": {
"name": "NVIDIA Linux Driver",
"license": "NVIDIA Driver",
"version": "515.65.01",
"linux-x86_64": {
"relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-515.65.01-archive.tar.xz",
"sha256": "e7845a159bb870df2a7a74505611dd3db9501707c0e74668d7f21e32b8613282",
"md5": "38226ca31111cea5c75384ae791b8b81",
"size": "366714956"
},
"linux-ppc64le": {
"relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-515.65.01-archive.tar.xz",
"sha256": "a235b54c8349ac72474d9a1123b5c7c34cf7c9c6968196365282dc555120c3c9",
"md5": "3dbd9131e366f33b29c6e7798eb89fb2",
"size": "76861468"
},
"linux-sbsa": {
"relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-515.65.01-archive.tar.xz",
"sha256": "db1c9b31783b8af2929887f103f40db53463a83535c7b17c8eeb6adefa255ce0",
"md5": "8882f6df4d644fe76b83eab7d83a0ae5",
"size": "226280968"
}
},
"nvidia_fs": {
"name": "NVIDIA filesystem",
"license": "CUDA Toolkit",
"version": "2.12.8",
"linux-x86_64": {
"relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.12.8-archive.tar.xz",
"sha256": "71830b69b8a31fe46bf07329c0986b61cf557c5d6ac51c1a9cbc7017dfa3f767",
"md5": "ee40e41ec4349fc6e408ff15fd42a800",
"size": "67356"
}
},
"visual_studio_integration": {
"name": "CUDA Visual Studio Integration",
"license": "CUDA Toolkit",
"version": "11.7.91",
"windows-x86_64": {
"relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-11.7.91-archive.zip",
"sha256": "46f31c50d34869b79d85e030016b09c0286428374f07688f8ef1bb133ab41391",
"md5": "3d6a962dc19be4ee995a51621a88e77e",
"size": "517028"
}
}
}

0
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.8.0.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_11.8.0.json
View File

1
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_12.0.1.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_12.0.1.json
View File

@ -1125,4 +1125,3 @@
}
}
}

0
pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_12.1.1.json → pkgs/development/cuda-modules/cuda/manifests/redistrib_12.1.1.json
View File

1151
pkgs/development/cuda-modules/cuda/manifests/redistrib_12.2.2.json Normal file
View File

File diff suppressed because it is too large Load Diff

971
pkgs/development/cuda-modules/cuda/manifests/redistrib_12.3.0.json Normal file
View File

@ -0,0 +1,971 @@
{
"release_date": "2023-10-19",
"release_label": "12.3.0",
"release_product": "cuda",
"cuda_cccl": {
"name": "CXX Core Compute Libraries",
"license": "CUDA Toolkit",
"license_path": "cuda_cccl/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "659f8f8fd58eb7f5bc8ba171712147a007a2c8c92f30b21d135cf2d12f80226d",
"md5": "e97f283762e4cc26a91368b545445888",
"size": "1148140"
},
"linux-ppc64le": {
"relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "1a188bc279ba32d910259bdf9b7106accacba163ce9ef92989af18ca8a50a6ea",
"md5": "a2c10d1037efe99ff2bd840a552500a0",
"size": "1148584"
},
"linux-sbsa": {
"relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "96b5465af73b77447c3997d923916f7aea0939ffd0d8be42bc197ee8d8965fca",
"md5": "7b33cb50efd7d589bc1da8fd292179b6",
"size": "1147616"
},
"windows-x86_64": {
"relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.3.52-archive.zip",
"sha256": "074c26ca05bd305ee23fdc56c3e8115d21c7843c5778fb75052791d66ee73711",
"md5": "ac1857b6c543c5489c126fb6a1ef0b10",
"size": "3041533"
}
},
"cuda_cudart": {
"name": "CUDA Runtime (cudart)",
"license": "CUDA Toolkit",
"license_path": "cuda_cudart/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "0dcd864fcef10b7d4591cc545330c411f589b27b12c98c30ac6e3d5e14eb2ee4",
"md5": "d0857c0c2b568ca05aac12dc67a6871b",
"size": "1090372"
},
"linux-ppc64le": {
"relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "354d1ffdd1ce2da61ec2c3fb1b15cdf65270804aba78863d235cc0d69a9c9eec",
"md5": "8abeb75f2d60efe9f69eb3ae3266ae45",
"size": "1068716"
},
"linux-sbsa": {
"relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "4789a039df340581d7a71f5da6af9f222baa2265e8de8ce00365a31ac645adca",
"md5": "abe7432e966b61c9d6272ef5f0d889f0",
"size": "1079100"
},
"windows-x86_64": {
"relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.3.52-archive.zip",
"sha256": "a01396eeb88b52137dd1878e1278a1608f848194a1bb7faa02d6b147894d17a9",
"md5": "5731383d0884a47d93e52772c0815042",
"size": "2462899"
}
},
"cuda_cuobjdump": {
"name": "cuobjdump",
"license": "CUDA Toolkit",
"license_path": "cuda_cuobjdump/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "cfedfd2e64aedec65793240c2814bc94463eaafe508bb34776b5d7bee783c899",
"md5": "9de85c598e48234db4ec743b2984205a",
"size": "171908"
},
"linux-ppc64le": {
"relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "33bbf67fbf5cfa5e1a451c3325330fc032a0e58ed31748839993ecb94711a9a0",
"md5": "d628a4c6ae76e52cec8bcb976a30edea",
"size": "215840"
},
"linux-sbsa": {
"relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "cce91131e57a901463ce1dc86577fe67db0bf6a17f8aefe3e269fff98689151d",
"md5": "c390408c5973d68eb7d292678dc201b8",
"size": "181628"
},
"windows-x86_64": {
"relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.3.52-archive.zip",
"sha256": "90f583b64f97bd600d0f6d81026bee6cfd2712d5b4905d238b0b6ab21a0709c3",
"md5": "f789a23aa0fe7e38f5c874be8612502f",
"size": "4013028"
}
},
"cuda_cupti": {
"name": "CUPTI",
"license": "CUDA Toolkit",
"license_path": "cuda_cupti/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "f51ae93f02378d88b5f53b66abad675f0b2e8b4444192b4705a550b1d083de79",
"md5": "2ad99522a4e6a6aab309fb44b611e607",
"size": "19651160"
},
"linux-ppc64le": {
"relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "8dead100bec1dd9b02f56e34dfeae91381422cbf858ce1c9fd1a45fdde946a16",
"md5": "dbc7e027e4e2f1d9f2a59db6ec20b2f0",
"size": "10918684"
},
"linux-sbsa": {
"relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "39f07116b64d8b3b9bf17c65c45d97bf19886eb41847e30c6606751455cbb284",
"md5": "c701206a376dab8f82aae89c9d3d4085",
"size": "10086868"
},
"windows-x86_64": {
"relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.3.52-archive.zip",
"sha256": "c177c59124f4ae41d46950999548931905f6097de57f88df7d2af62dffbdf249",
"md5": "4402839a83f9daed16007ba93fa528ec",
"size": "13149248"
}
},
"cuda_cuxxfilt": {
"name": "CUDA cuxxfilt (demangler)",
"license": "CUDA Toolkit",
"license_path": "cuda_cuxxfilt/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "932ef5f2f607b5fcb5a84b4489d562cd1239ef7cebfaf862070f9953d02e6cce",
"md5": "b1d37d6dd3a6f6218b73c8310cafbd12",
"size": "188368"
},
"linux-ppc64le": {
"relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "dc0490f0881ee51f803bfcd93fcd448216776fa347712d43823c09e687f013b1",
"md5": "7eadb41329c74d76212f2e830232e854",
"size": "180568"
},
"linux-sbsa": {
"relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "5a9c4d613a8120b21c1f44a9e48f2908bd429e2059f8aaabf4cb67bd5c468e04",
"md5": "755a801e5f34f090bda0139f32432e21",
"size": "174576"
},
"windows-x86_64": {
"relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.3.52-archive.zip",
"sha256": "d7b94c8fa3198764e0664709543a9ee5820a004df9afa70af69c84d2cfca5bc4",
"md5": "ad52248ba90cc66a4f73e1914ef3b090",
"size": "170310"
}
},
"cuda_demo_suite": {
"name": "CUDA Demo Suite",
"license": "CUDA Toolkit",
"license_path": "cuda_demo_suite/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "ed9dd4e1b5fad1c21cfdab9df2d9c80c6360513f4ebd4dd1bc71d518c0a5f2d2",
"md5": "a18e17098bfc19e966e36152c7417b01",
"size": "4000328"
},
"windows-x86_64": {
"relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.3.52-archive.zip",
"sha256": "a93c7712d3b2782964172c1677868684a4145f8bc8cb18b9173e4abb640ee353",
"md5": "17adbdccd94580c1b821ed6ea9a856cf",
"size": "5061022"
}
},
"cuda_documentation": {
"name": "CUDA Documentation",
"license": "CUDA Toolkit",
"license_path": "cuda_documentation/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "b2bea4ca04808c88fc34ce3da98457f789f6087effe9c12ec5c7cadc583f8c2e",
"md5": "6c898f430b8cc9f89c3acc2ecb3587c7",
"size": "67052"
},
"linux-ppc64le": {
"relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "ac53d750359c4c0bf92111ee46c0dc4ffc4e78c480e8319c48c6097697712847",
"md5": "870aa50e6b0d5627e44152dbbe28d100",
"size": "67156"
},
"linux-sbsa": {
"relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "2e95ef6bee1b78068d6a8a854effec0e31aed07cf6d81f48021cee213fd01c26",
"md5": "076cebe3b4f8f76c4e66b5369566ea8a",
"size": "67044"
},
"windows-x86_64": {
"relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.3.52-archive.zip",
"sha256": "57f074a8fd407f9848fccbe6fb728d649938f315b3135ca0070682fa326df466",
"md5": "b6d4e19b1239e1f63856ce91bf058b38",
"size": "105364"
}
},
"cuda_gdb": {
"name": "CUDA GDB",
"license": "CUDA Toolkit",
"license_path": "cuda_gdb/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "597b1429d311e338023763c6e414f8b826f254c139a4422214f6f8d4f9af90f7",
"md5": "f6d3aa7856abf88e5c0c4e5cebf5af8e",
"size": "65762552"
},
"linux-ppc64le": {
"relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "2738151a55fcc13f01195722a5cd316eb3b2e49fc6ab4da066bdc13a1e2c98af",
"md5": "9940939654686fd3da00d1fa281e212c",
"size": "65482616"
},
"linux-sbsa": {
"relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "8eb60a57eec17d837aa4be481f4399aa6288262ae61990cedf8f202a5b2329f4",
"md5": "80a1a0127fff32fa4aadd6e7074303f9",
"size": "65463172"
}
},
"cuda_nsight": {
"name": "Nsight Eclipse Edition Plugin",
"license": "CUDA Toolkit",
"license_path": "cuda_nsight/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "7e96029a8a730c799d7e85d283d4d3f21601448e50e3af407ff54f4344a30847",
"md5": "6a688c24dd28528970f028f62763e907",
"size": "118689728"
},
"linux-ppc64le": {
"relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "8121c2f187e3bfc1542e155d52c69283ada1f5d8c17e4779306e095926856d6e",
"md5": "3dae1d37c213a1e76cd0f571214b1bc3",
"size": "118689712"
}
},
"cuda_nvcc": {
"name": "CUDA NVCC",
"license": "CUDA Toolkit",
"license_path": "cuda_nvcc/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "32302154a7ec122defdbb49f1c7cc8777f204c3199d9222f013046be256f72d6",
"md5": "858c4eea2da82037bae9b6eef47747ed",
"size": "47698868"
},
"linux-ppc64le": {
"relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "f7c647b74f2f85f5d9c42d951d810cb7130288b11d25ef7308fb489e1150232f",
"md5": "c19a78d3e11fde996b83e2ac21252199",
"size": "42947524"
},
"linux-sbsa": {
"relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "98940f1719b2ab1af943293601307b9e87ea71e30809d429fd7dc2e59b294c68",
"md5": "e47ff4a9f6d35fa01efc7c5f64ebf1e8",
"size": "41816996"
},
"windows-x86_64": {
"relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.3.52-archive.zip",
"sha256": "1c9e275d10ce496f75efc2337284ab7b6b8c7deb2abc148ea90b0a7ac9ebd9fd",
"md5": "5a3765f447771c6a983b7a90ca2f5396",
"size": "62734155"
}
},
"cuda_nvdisasm": {
"name": "CUDA nvdisasm",
"license": "CUDA Toolkit",
"license_path": "cuda_nvdisasm/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "dfaa7c1bea5e4e833374da2f80156998bc303e8787a6e88d6a9c97fdead6e9a9",
"md5": "a800e8d833020a5794310c74b54e73c4",
"size": "49879928"
},
"linux-ppc64le": {
"relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "06e9e4ba698d9b29f0d36e732264e8f1ce920cbe9b4014227104280f665674f6",
"md5": "a59901cdbd2c583cd59053e863b673a0",
"size": "49879940"
},
"linux-sbsa": {
"relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "3d9b4e99966f9e9305b54a55991a64b59d85d804dc3876f0881b538cff09c84c",
"md5": "cb93fd227f8eb20df6b39176801d144f",
"size": "49820084"
},
"windows-x86_64": {
"relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.3.52-archive.zip",
"sha256": "59f237756aa152cd1f18ee49e30cc9138ad6b0b451e338b467684f8c1b512117",
"md5": "860e10f6ffcf7312709cefcfa6067047",
"size": "50139397"
}
},
"cuda_nvml_dev": {
"name": "CUDA NVML Headers",
"license": "CUDA Toolkit",
"license_path": "cuda_nvml_dev/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "37537d1946513d41a0b4b350ee93d4722a52fd56293c66f3dbdb33bf96d799f8",
"md5": "691e15a41db1eac40f9ba96c3b702852",
"size": "87052"
},
"linux-ppc64le": {
"relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "eb107e7c12c89c221f34f700fd838d2788d40febb43df45a387653c677a38027",
"md5": "5ed3d7b3a60abef4f8e038976a8c4304",
"size": "85620"
},
"linux-sbsa": {
"relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "4cee78d3354f268730e40c04626abb38bfb7329a06feb9ab0ab4fc53b2ffe09a",
"md5": "5a2b431c55f26240d3b2806ffc92ad30",
"size": "86308"
},
"windows-x86_64": {
"relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.3.52-archive.zip",
"sha256": "26309a28f1ea2ad58c8eac6725e39210889d8310e5eecd234fe385056ea4b4cf",
"md5": "c79c8a619506364c791aa5e7d0d354ac",
"size": "120977"
}
},
"cuda_nvprof": {
"name": "CUDA nvprof",
"license": "CUDA Toolkit",
"license_path": "cuda_nvprof/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "b4683cee4e0837e19d22a93d2b944a740de4837049ab4f7a4ac97f35a554c3b9",
"md5": "7ed9fe37b9fd3b84a24c4fcc04e500b8",
"size": "2441540"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "38c9c81e0913cbce002d094b504c5c94418b8968cf951a3764919439957e5894",
"md5": "af1ea66babdfe389194447e65b4885b7",
"size": "2120596"
},
"windows-x86_64": {
"relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.3.52-archive.zip",
"sha256": "4b82430be0be570dfbe9fb0b3aa316b413757444f7b7a36fb70de81b58cb61c3",
"md5": "d5bd756383bda6676c9c1e41793bd948",
"size": "1700913"
}
},
"cuda_nvprune": {
"name": "CUDA nvprune",
"license": "CUDA Toolkit",
"license_path": "cuda_nvprune/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "1ba95b8a3c0b44a91ab7f1c5c52a23bad56cd2ca651e4f9c6a820d666ade24e3",
"md5": "253cbe9af015b13868e88540530ac206",
"size": "56212"
},
"linux-ppc64le": {
"relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "66b8e6c69ca9e6368d5e6753bc3a38f51c43d58d3e1fa30fc41cab5af2d58bf0",
"md5": "b3a6f87df7d2288b5d01e31caab131e5",
"size": "57240"
},
"linux-sbsa": {
"relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "8161576c8b9b4eeb23fdb3def3373e17a82f3bf9ee75422c16ffc30f9a9bcec7",
"md5": "fa4958bdca0f2188508fcdf8790dd291",
"size": "48436"
},
"windows-x86_64": {
"relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.3.52-archive.zip",
"sha256": "17b5efeaf20298ef51ecea0969e8013481717c1d73bb2df5c6a3c994546f9944",
"md5": "dcc3362f5b55bf3fc088a591a647ff2f",
"size": "146052"
}
},
"cuda_nvrtc": {
"name": "CUDA NVRTC",
"license": "CUDA Toolkit",
"license_path": "cuda_nvrtc/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "6d549612a9c61caf7356d8a13d99a85cfa644269ed856192bea13c7e5f8ce234",
"md5": "68aa875913caefbe11de5fded4df7ac9",
"size": "31333156"
},
"linux-ppc64le": {
"relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "0e12e3bc044d6b1d0440493e086d7b7ca8c31eafe79e4fe7fbada6dd209d5d57",
"md5": "5d64fbfc312afa6c0259de98917e447a",
"size": "28575620"
},
"linux-sbsa": {
"relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "8c1aa8bb711a31d50f613d8594103cfeaf062e9a422094dcf6d18646ecd99f17",
"md5": "f879465dd1304b83b82a8b895a37d7b2",
"size": "28661256"
},
"windows-x86_64": {
"relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.3.52-archive.zip",
"sha256": "3dabf99c94d8cadd4efc5163fb53207f8c011e553b08c41cb760d18bbf2e3f0b",
"md5": "1fb1e8d9668177ce740a9e5f24d568c9",
"size": "102259575"
}
},
"cuda_nvtx": {
"name": "CUDA NVTX",
"license": "CUDA Toolkit",
"license_path": "cuda_nvtx/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "090068726f299ac218f125fe15fb845bef5670ce48eccb95e752479b40361771",
"md5": "59b253c005d1829560b740a1f83bdc04",
"size": "48388"
},
"linux-ppc64le": {
"relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "2c3a6c1f84139e706c1a329b80dc7afaf2b687cc2e65111a37eb90419cd9ffe5",
"md5": "90d934de07f3a1d297509c21ac7c0908",
"size": "48400"
},
"linux-sbsa": {
"relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "d28d0be121286f5fb3e55e2e358bbda18c0eedf16d37347806601cc90ebff789",
"md5": "157223166a9249869b0df211073ed11a",
"size": "49044"
},
"windows-x86_64": {
"relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.3.52-archive.zip",
"sha256": "92e840d1b5a2f6a5e6f7328de3e99554fbe3d6acfe917010597135c3e69a104b",
"md5": "868895cecfa12a9fc5204a673403fcf4",
"size": "65690"
}
},
"cuda_nvvp": {
"name": "CUDA NVVP",
"license": "CUDA Toolkit",
"license_path": "cuda_nvvp/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "54871072910527bae22af3337163a873cd92ad08ece6ed26e9ca48b6e28ce7f9",
"md5": "4dfddacbbeb2b335d678a620848af6bd",
"size": "117759232"
},
"linux-ppc64le": {
"relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "7aacfde343022de7e13792d87bcc4f9d7826e9a4f5c11ea11949730098024b3e",
"md5": "15bb39a8a7ed622c640112aa5d9ec93f",
"size": "111830320"
},
"windows-x86_64": {
"relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.3.52-archive.zip",
"sha256": "40919592c0f3b71264cd4d3de4674bcf775d16ea81209fb4d41fb74673b8d21c",
"md5": "efd029d36d6edd6ca074416d98ad68e9",
"size": "120340815"
}
},
"cuda_opencl": {
"name": "CUDA OpenCL",
"license": "CUDA Toolkit",
"license_path": "cuda_opencl/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "8e270a6369947e711b5df48c4dbaebcbfdf7245cc4ddb098cfad69f85efa626e",
"md5": "94e8d0efc5bf057cff8a55349956371a",
"size": "75540"
},
"windows-x86_64": {
"relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.3.52-archive.zip",
"sha256": "92d4b713626add42437aae1a044cebb1b80c7c47d343963150e5c182f8e3c9a3",
"md5": "2288f81210af58bf38f4be7ee29492bc",
"size": "114719"
}
},
"cuda_profiler_api": {
"name": "CUDA Profiler API",
"license": "CUDA Toolkit",
"license_path": "cuda_profiler_api/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "4ab0f21627156b9e0f681863d4adcfe8924b07eb1a40a6381ef807ff588a6d47",
"md5": "e96e1c532cfff9287e0ed7b38e3a3ad2",
"size": "16048"
},
"linux-ppc64le": {
"relative_path": "cuda_profiler_api/linux-ppc64le/cuda_profiler_api-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "186094548cb3603f167cac03777bd31c6c02d794dc5312f31b8874e25a515b06",
"md5": "7ba4e575eaaaf0ffd39f59eeac156491",
"size": "16056"
},
"linux-sbsa": {
"relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "2c1b04b719e6cbccef1e140c4371c1fb119c66b8e788adf3e10313fdb456ba87",
"md5": "c2ec9b80c3abf4d404f4da6e934be1c8",
"size": "16060"
},
"windows-x86_64": {
"relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.3.52-archive.zip",
"sha256": "a339bb2448d39b74e895a1b5321c58cd235d9c7719fe343f8a2cb00c7f5877d4",
"md5": "67ebaa93beb345ed1ba5f56c08090568",
"size": "20075"
}
},
"cuda_sanitizer_api": {
"name": "CUDA Compute Sanitizer API",
"license": "CUDA Toolkit",
"license_path": "cuda_sanitizer_api/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "9dbebdd45130df33685213d8d5c6443ef45b34b9a23cee08d1c8eb54ab662cf9",
"md5": "198b805f7dbd3e04bbca139cdd2810b2",
"size": "8204808"
},
"linux-ppc64le": {
"relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "8a5bd354931778eb18c0ab118c38748c6a5bafa553cf84fee79d07839763c13e",
"md5": "9f9fe626f4f84fec7ee206faa7872f69",
"size": "7772948"
},
"linux-sbsa": {
"relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "a301c71de5f8d786b675c4258a8dd4fdc6533468c81f946b327e1a7f1ae859c2",
"md5": "37712b47eff245ce1e1dcdf0f685f6d4",
"size": "6519848"
},
"windows-x86_64": {
"relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.3.52-archive.zip",
"sha256": "9d7abb0c7df2b9104888ea11539055117023cf7354d6859789c233e6e5df14b8",
"md5": "53e6bdc5e662ceb0efd8b2c1f0704a29",
"size": "14116642"
}
},
"fabricmanager": {
"name": "NVIDIA Fabric Manager",
"license": "NVIDIA Driver",
"license_path": "fabricmanager/LICENSE.txt",
"version": "545.23.06",
"linux-x86_64": {
"relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-545.23.06-archive.tar.xz",
"sha256": "3c0e848f554b33cf941e54ce1775f4f11198dbbc0275e261082f8fca0d0a28d9",
"md5": "3a04213dcd349cc2964eb29cce4c6bcc",
"size": "5088924"
},
"linux-sbsa": {
"relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-545.23.06-archive.tar.xz",
"sha256": "ffe93591af3d1075177ff598ae02c7067db5b2edde8bb016356c8d2ea549eb6d",
"md5": "0c73afa460eaa469bb51e7c3fba8fa38",
"size": "4649044"
}
},
"libcublas": {
"name": "CUDA cuBLAS",
"license": "CUDA Toolkit",
"license_path": "libcublas/LICENSE.txt",
"version": "12.3.2.9",
"linux-x86_64": {
"relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.3.2.9-archive.tar.xz",
"sha256": "793fb630ffeac7aabd241e43cd41d5209fb93e9505cb7937bdd318188d47551f",
"md5": "7b3a5411eeb85a061e48ce77b6f1e695",
"size": "504998132"
},
"linux-ppc64le": {
"relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-12.3.2.9-archive.tar.xz",
"sha256": "c6b00cf18831527543f93a2e35d98f3b297d7a5b6896a598995eb4a3fa47f39c",
"md5": "7842b3f6de4312b21b7910b85f56587e",
"size": "401263304"
},
"linux-sbsa": {
"relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.3.2.9-archive.tar.xz",
"sha256": "bb83278da1007847a72e8f8ad40186c70a2ead7e48bf9eb387aeda94a8b63672",
"md5": "2dadf0b64c0f1781b606bda508e1d8b8",
"size": "496892884"
},
"windows-x86_64": {
"relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.3.2.9-archive.zip",
"sha256": "35c177357715c9c326ee50fa87192dee6b9c25944725ec3107f63675d10df4cf",
"md5": "7f1b5517f09170f46bc97812b0c81b13",
"size": "443868444"
}
},
"libcufft": {
"name": "CUDA cuFFT",
"license": "CUDA Toolkit",
"license_path": "libcufft/LICENSE.txt",
"version": "11.0.11.19",
"linux-x86_64": {
"relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.0.11.19-archive.tar.xz",
"sha256": "f84d33026cc59f6bdfe4ce446b78912499fc4447e8b7b4e3f1617bb0dae2a27e",
"md5": "9becd4989c7b92bc2f7fa4429c613fd1",
"size": "172050036"
},
"linux-ppc64le": {
"relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-11.0.11.19-archive.tar.xz",
"sha256": "45a7f4bef97846374cc11c637b4b6b635b8e6abd0a45555ebb3ef5afc3c9c159",
"md5": "76a2f1431da7985b8deaea7355a6f3cf",
"size": "173409752"
},
"linux-sbsa": {
"relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.0.11.19-archive.tar.xz",
"sha256": "c6867258f4347557435b2dfb7d7e05405cd6a21c954f9ab82a22a1280e93173c",
"md5": "78655b8a9b6d32d76bc5cff2e1e735d6",
"size": "172359036"
},
"windows-x86_64": {
"relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.0.11.19-archive.zip",
"sha256": "df838d3a085f3741410f86c90a3da8dc57b38d69d830b198473b04fb0e8cfe06",
"md5": "420b784f259ccafe210c04fef0edd1e6",
"size": "96307613"
}
},
"libcufile": {
"name": "CUDA cuFile",
"license": "CUDA Toolkit",
"license_path": "libcufile/LICENSE.txt",
"version": "1.8.0.34",
"linux-x86_64": {
"relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.8.0.34-archive.tar.xz",
"sha256": "16d9810a414354f084820b3dacd59baa0dcbdc1c951519803fa10784d1f43ec4",
"md5": "9a27732eee2556fe72009fbdb9007342",
"size": "41857344"
},
"linux-sbsa": {
"relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.8.0.34-archive.tar.xz",
"sha256": "733c02066ac5b026337da0a6adfc0ce3c71a677cfac9528c4e22443f0cd615bc",
"md5": "f67ac3f54ba73bbd69411237fba00c87",
"size": "41296760"
}
},
"libcurand": {
"name": "CUDA cuRAND",
"license": "CUDA Toolkit",
"license_path": "libcurand/LICENSE.txt",
"version": "10.3.4.52",
"linux-x86_64": {
"relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.4.52-archive.tar.xz",
"sha256": "8ac8ca5b1ab22e13cbd474ea5dfe24a2d6d1ff02dc5ed06b07648066c7ea34fc",
"md5": "04779769c4d217ee94e034f60d0a0e43",
"size": "81714596"
},
"linux-ppc64le": {
"relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.3.4.52-archive.tar.xz",
"sha256": "8de3fee960f55895af53a2817835086c4d0c260628a32120d2987ae4e1b48e9f",
"md5": "9a2900df6914baf192eff7fd886be734",
"size": "81766484"
},
"linux-sbsa": {
"relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.4.52-archive.tar.xz",
"sha256": "2923351205c6d078a0678857f507f57e0aeaab9570946faad2ade97362abafc7",
"md5": "c3064fc74451401d864c811588d7447d",
"size": "81702812"
},
"windows-x86_64": {
"relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.4.52-archive.zip",
"sha256": "e3634e5eb0d9133e92909c525775e43ebc9597b4f6dda1f95d09bea18e4f4c51",
"md5": "19e696cffbaa7acb889b8c0092ae7db4",
"size": "55099171"
}
},
"libcusolver": {
"name": "CUDA cuSOLVER",
"license": "CUDA Toolkit",
"license_path": "libcusolver/LICENSE.txt",
"version": "11.5.3.52",
"linux-x86_64": {
"relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.5.3.52-archive.tar.xz",
"sha256": "334470e66d74102fa7a80e7eeb9ab5b80fe4939204a67d4ef64d369fe254cae2",
"md5": "8430c15911f35fcbf2108820df8ddcff",
"size": "123465076"
},
"linux-ppc64le": {
"relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.5.3.52-archive.tar.xz",
"sha256": "a71dcef7bccd565003120bb5d18cf8adb0ed4428b3a122f1869f4849827234a1",
"md5": "f4997ae343547742e63fcd819cd02bad",
"size": "123579460"
},
"linux-sbsa": {
"relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.5.3.52-archive.tar.xz",
"sha256": "3de3b43a6576a10adac99ac34984c3c623ad6666699aa0531ca239d9d27beee5",
"md5": "2c2ae3936e81a9338fab1f3f723eedc9",
"size": "122842492"
},
"windows-x86_64": {
"relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.5.3.52-archive.zip",
"sha256": "73251d1b23faed1a04a84801beeb643161a1d10c6cdccd5f321a7dda7b105290",
"md5": "d088b48c66d39651cc05952529d308c7",
"size": "120934003"
}
},
"libcusparse": {
"name": "CUDA cuSPARSE",
"license": "CUDA Toolkit",
"license_path": "libcusparse/LICENSE.txt",
"version": "12.1.3.153",
"linux-x86_64": {
"relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.1.3.153-archive.tar.xz",
"sha256": "62b091161967b830cb20cdd73ceb77da28bd88a33db9b734644531f36f3556f6",
"md5": "f6685c2b0e80052f77210a451daf5fb6",
"size": "212909260"
},
"linux-ppc64le": {
"relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-12.1.3.153-archive.tar.xz",
"sha256": "b086126226b919f6fcacbf1ef547045ea848bbc739bd6524a6bd2aee46110f61",
"md5": "0df5916c88513e489a47a83b58dc9444",
"size": "212929864"
},
"linux-sbsa": {
"relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.1.3.153-archive.tar.xz",
"sha256": "9f61ff29dc5aa272b771ba0691565d73f167ffe544b3d10f42c3f84ae9aa510a",
"md5": "5f4a30593348a87234f612dd3dd7b204",
"size": "212557236"
},
"windows-x86_64": {
"relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.1.3.153-archive.zip",
"sha256": "ae79b3b756a1c2ba848c2931bf0c9ae62746ab7755d110d68a280392999a0b45",
"md5": "9c1caa26adc1cc51728c632f89e38fa7",
"size": "192897620"
}
},
"libnpp": {
"name": "CUDA NPP",
"license": "CUDA Toolkit",
"license_path": "libnpp/LICENSE.txt",
"version": "12.2.2.32",
"linux-x86_64": {
"relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.2.2.32-archive.tar.xz",
"sha256": "1f8f47aedb988eea8611eabe085e6f9e177981b4d942e4d45185d90f752eed3e",
"md5": "194a625a46f20799e8e0dc1ed7148a7a",
"size": "183688252"
},
"linux-ppc64le": {
"relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-12.2.2.32-archive.tar.xz",
"sha256": "00f2a26ea9ce3f4090ac72a3e2659faba6ab000afa1f22f50eeabe72ed4bf5b1",
"md5": "b916512ad551b21fff9b2ec88e2b5658",
"size": "184496636"
},
"linux-sbsa": {
"relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.2.2.32-archive.tar.xz",
"sha256": "d2f5e784d4486663e4a0851e3bedd7fab769cf7960a4d37bfb07c2feb43ca4b7",
"md5": "8d4fd6cc3e070a263f527b3a2e4ec516",
"size": "183572808"
},
"windows-x86_64": {
"relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.2.2.32-archive.zip",
"sha256": "5b35180d336cb4cdc8d3ee362b91aef986de292bcbdbe1a71dc544dc3bae3b6a",
"md5": "0890caecbe7fdd94fbf82fe3f40fda6e",
"size": "153321627"
}
},
"libnvidia_nscq": {
"name": "NVIDIA NSCQ API",
"license": "NVIDIA Driver",
"license_path": "libnvidia_nscq/LICENSE.txt",
"version": "545.23.06",
"linux-x86_64": {
"relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-545.23.06-archive.tar.xz",
"sha256": "66abb1ec36f5e67f0c32c7f7fdd7b264a628528684d3b3647674eef914330926",
"md5": "ef4d098fb8d226b6e8b3197d54255eb5",
"size": "352880"
},
"linux-sbsa": {
"relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-545.23.06-archive.tar.xz",
"sha256": "4d60d9022c2228ef9f32705ffbc5aa72b5ce44e9e4aad859f8bf7aa2915dc8a7",
"md5": "3c48b4a62438026ac4a5bf563fead503",
"size": "319880"
}
},
"libnvjitlink": {
"name": "NVIDIA compiler library for JIT LTO functionality",
"license": "CUDA Toolkit",
"license_path": "libnvjitlink/LICENSE.txt",
"version": "12.3.52",
"linux-x86_64": {
"relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.3.52-archive.tar.xz",
"sha256": "92f21102652a22ec735bac9ab236dae1b69d808d1391a96ba379bfa4dd83e6b8",
"md5": "107a984b8eb5712b3997cf3b56779356",
"size": "26483580"
},
"linux-ppc64le": {
"relative_path": "libnvjitlink/linux-ppc64le/libnvjitlink-linux-ppc64le-12.3.52-archive.tar.xz",
"sha256": "2802ed389e9c246415a6fc0dc8f8f5bc6cf9f43bcf53f30a921b6e5d80b1e314",
"md5": "b595ce0b4ac917063b9d3e417e1c0847",
"size": "24029696"
},
"linux-sbsa": {
"relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.3.52-archive.tar.xz",
"sha256": "afcd59beb68d68115d0b020bca49e75ff3b407a9469d5578c25309e5ef83442e",
"md5": "4a4629c069aad8a564927990c167b01b",
"size": "24067300"
},
"windows-x86_64": {
"relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.3.52-archive.zip",
"sha256": "117ba27dc4086f895bade8d6314d5a2bd835342a6d46fef471b9932807e59e1e",
"md5": "ee72bcd855f46ad652acbe8a06457e59",
"size": "90900374"
}
},
"libnvjpeg": {
"name": "CUDA nvJPEG",
"license": "CUDA Toolkit",
"license_path": "libnvjpeg/LICENSE.txt",
"version": "12.2.3.32",
"linux-x86_64": {
"relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.2.3.32-archive.tar.xz",
"sha256": "19e7dedaaa07c451a84cc607711a22a6f852043559f5bd11cd8e50683628a590",
"md5": "8195a125d8dc67b9769ba4151f28b471",
"size": "2564332"
},
"linux-ppc64le": {
"relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-12.2.3.32-archive.tar.xz",
"sha256": "cb77d773e261c0fb298da405036728e18be11f21f45c3ac474b9e3a69ad2ff46",
"md5": "e8323f5f3b00f3703b834a72171863ad",
"size": "2589976"
},
"linux-sbsa": {
"relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.2.3.32-archive.tar.xz",
"sha256": "a4c7a739905f42dce324845b5d27cb8402ec84c0d48a7e50b6426891ae62d429",
"md5": "fee67a165abdc83440788932cccf113b",
"size": "2390916"
},
"windows-x86_64": {
"relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.2.3.32-archive.zip",
"sha256": "dd931eb75934550421884d548d1e6c4504a11d4f71df07f1c088158b7b7466b7",
"md5": "5741a278df23d62f0e97be4d1013ddd2",
"size": "2829977"
}
},
"nsight_compute": {
"name": "Nsight Compute",
"license": "NVIDIA SLA",
"license_path": "nsight_compute/LICENSE.txt",
"version": "2023.3.0.12",
"linux-x86_64": {
"relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2023.3.0.12-archive.tar.xz",
"sha256": "12c96010d723f48702a342d7ae6dfa18e96154fc69225de0398c907fdd655499",
"md5": "40e9f41957a580680f88e7edce40e49a",
"size": "736137868"
},
"linux-ppc64le": {
"relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2023.3.0.12-archive.tar.xz",
"sha256": "d2003f65ec46ded90db0639990efa2a2b5e3acebafbc2f47f8b8d47c4624c85d",
"md5": "29eac226551bfeeadb394f6b2215765e",
"size": "139988468"
},
"linux-sbsa": {
"relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2023.3.0.12-archive.tar.xz",
"sha256": "e4e809260462a313c1ecb5705b535558289e60507d26e77495cd456a9e1cd85b",
"md5": "bc6d08cb6d6e485cc94939940d0feb50",
"size": "358992716"
},
"windows-x86_64": {
"relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2023.3.0.12-archive.zip",
"sha256": "97959a668e6c4732b34a294bd997ce37f8f08ab5714c47af426a5d00313eb435",
"md5": "a23e3d5e577624f95e35738e7507ded1",
"size": "674363811"
}
},
"nsight_systems": {
"name": "Nsight Systems",
"license": "NVIDIA SLA",
"license_path": "nsight_systems/LICENSE.txt",
"version": "2023.3.3.42",
"linux-x86_64": {
"relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2023.3.3.42-archive.tar.xz",
"sha256": "dafded1be045abea2804697646178a66bec4a5eebb1b28b2637a37c2f22c7b93",
"md5": "34208b6d0c71444babf10a9bfeac86b0",
"size": "227696524"
},
"linux-ppc64le": {
"relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2023.3.3.42-archive.tar.xz",
"sha256": "5095fc2a432267c002fa84d14f8c09985c7ba17becb6095699d7407fcbe3234d",
"md5": "8f873649a9686b23c71ab4f5c575bf74",
"size": "67233156"
},
"linux-sbsa": {
"relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2023.3.3.42-archive.tar.xz",
"sha256": "93976454c75ca4dc6da28c7e8cc886cc21ec513d4e0f294f56b9afad245e4071",
"md5": "98e172f249dfa5da3eaa564a86179601",
"size": "198960916"
},
"windows-x86_64": {
"relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2023.3.3.42-archive.zip",
"sha256": "9049d2bd0f17d967f7c84f33eee04b83c6b65349e3b12f97a3a9211d411e0009",
"md5": "54e49f657acf7b5e337c77f94b9d0943",
"size": "348461444"
}
},
"nsight_vse": {
"name": "Nsight Visual Studio Edition (VSE)",
"license": "NVIDIA SLA",
"license_path": "nsight_vse/LICENSE.txt",
"version": "2023.3.0.23248",
"windows-x86_64": {
"relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2023.3.0.23248-archive.zip",
"sha256": "10518927226a8a60c47bd1040e4be8b0396d37738ba1f11ba6bc918115e231a0",
"md5": "c2aba6d4604b9005b2a322dc68ce5534",
"size": "527217651"
}
},
"nvidia_driver": {
"name": "NVIDIA Linux Driver",
"license": "NVIDIA Driver",
"license_path": "nvidia_driver/LICENSE.txt",
"version": "545.23.06",
"linux-x86_64": {
"relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-545.23.06-archive.tar.xz",
"sha256": "e799421bdfee93a16c2bfd0b7622875ae1e993cc1955383d92a57f36a2ce47db",
"md5": "4c17b86e90fd601d9f787b2777949bfd",
"size": "371993760"
},
"linux-ppc64le": {
"relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-545.23.06-archive.tar.xz",
"sha256": "09e8790c9c79419acf74dc3d3f20c812d073e156001e617a8a4af9fe11713a36",
"md5": "f9734bc55548492a4d3e2d991419b446",
"size": "100061728"
},
"linux-sbsa": {
"relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-545.23.06-archive.tar.xz",
"sha256": "6d0bf7e1adb49c0bcd968c9a4eb9ee324ebffa7683b34d92fd25f4ff2f99dbd1",
"md5": "9fe92968de77c9809d579582d5266b0a",
"size": "288683672"
}
},
"nvidia_fs": {
"name": "NVIDIA filesystem",
"license": "CUDA Toolkit",
"license_path": "nvidia_fs/LICENSE.txt",
"version": "2.18.3",
"linux-x86_64": {
"relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.18.3-archive.tar.xz",
"sha256": "4b2b045c932c1449f28be246b3b28658981e81507825d73a35e11e9450774ac4",
"md5": "74135e8f97454338505b58bbcc5483a5",
"size": "58448"
},
"linux-sbsa": {
"relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.18.3-archive.tar.xz",
"sha256": "80bae8ef6f977e2aeecb392c00e056e579657632abb02eb75e86bbf306db6f50",
"md5": "f88dd5297012268400192de8877f4606",
"size": "58460"
}
},
"visual_studio_integration": {
"name": "CUDA Visual Studio Integration",
"license": "CUDA Toolkit",
"license_path": "visual_studio_integration/LICENSE.txt",
"version": "12.3.52",
"windows-x86_64": {
"relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.3.52-archive.zip",
"sha256": "b801075f82c789ac8014223ca3437ef87e9e0ee700b7b617f4495bcc273b788a",
"md5": "f456d7ab05e574cd8c2a20d8f1efd4e0",
"size": "518070"
}
}
}

129
pkgs/development/cuda-modules/cuda/overrides.nix Normal file
View File

@ -0,0 +1,129 @@
{cudaVersion, lib}:
let
inherit (lib) attrsets lists strings;
# cudaVersionOlder : Version -> Boolean
cudaVersionOlder = strings.versionOlder cudaVersion;
# cudaVersionAtLeast : Version -> Boolean
cudaVersionAtLeast = strings.versionAtLeast cudaVersion;
addBuildInputs =
drv: buildInputs:
drv.overrideAttrs (prevAttrs: {buildInputs = prevAttrs.buildInputs ++ buildInputs;});
in
# NOTE: Filter out attributes that are not present in the previous version of
# the package set. This is necessary to prevent the appearance of attributes
# like `cuda_nvcc` in `cudaPackages_10_0, which predates redistributables.
final: prev:
attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
libcufile = prev.libcufile.overrideAttrs (
prevAttrs: {
buildInputs = prevAttrs.buildInputs ++ [
final.libcublas.lib
final.pkgs.numactl
final.pkgs.rdma-core
];
# Before 11.7 libcufile depends on itself for some reason.
env.autoPatchelfIgnoreMissingDeps =
prevAttrs.env.autoPatchelfIgnoreMissingDeps
+ strings.optionalString (cudaVersionOlder "11.7") " libcufile.so.0";
}
);
libcusolver = addBuildInputs prev.libcusolver (
# Always depends on this
[final.libcublas.lib]
# Dependency from 12.0 and on
++ lists.optionals (cudaVersionAtLeast "12.0") [final.libnvjitlink.lib]
# Dependency from 12.1 and on
++ lists.optionals (cudaVersionAtLeast "12.1") [final.libcusparse.lib]
);
libcusparse = addBuildInputs prev.libcusparse (
lists.optionals (cudaVersionAtLeast "12.0") [final.libnvjitlink.lib]
);
cuda_compat = prev.cuda_compat.overrideAttrs (
prevAttrs: {
env.autoPatchelfIgnoreMissingDeps =
prevAttrs.env.autoPatchelfIgnoreMissingDeps + " libnvrm_gpu.so libnvrm_mem.so";
# `cuda_compat` only works on aarch64-linux, and only when building for Jetson devices.
brokenConditions = prevAttrs.brokenConditions // {
"Trying to use cuda_compat on aarch64-linux targeting non-Jetson devices" =
!final.flags.isJetsonBuild;
};
}
);
cuda_gdb = addBuildInputs prev.cuda_gdb (
# x86_64 only needs gmp from 12.0 and on
lists.optionals (cudaVersionAtLeast "12.0") [final.pkgs.gmp]
);
cuda_nvcc = prev.cuda_nvcc.overrideAttrs (
oldAttrs: {
propagatedBuildInputs = [final.setupCudaHook];
meta = (oldAttrs.meta or {}) // {
mainProgram = "nvcc";
};
}
);
cuda_nvprof = prev.cuda_nvprof.overrideAttrs (
prevAttrs: {buildInputs = prevAttrs.buildInputs ++ [final.cuda_cupti.lib];}
);
cuda_demo_suite = addBuildInputs prev.cuda_demo_suite [
final.pkgs.freeglut
final.pkgs.libGLU
final.pkgs.libglvnd
final.pkgs.mesa
final.libcufft.lib
final.libcurand.lib
];
nsight_compute = prev.nsight_compute.overrideAttrs (
prevAttrs: {
nativeBuildInputs =
prevAttrs.nativeBuildInputs
++ (
if (strings.versionOlder prev.nsight_compute.version "2022.2.0") then
[final.pkgs.qt5.wrapQtAppsHook]
else
[final.pkgs.qt6.wrapQtAppsHook]
);
buildInputs =
prevAttrs.buildInputs
++ (
if (strings.versionOlder prev.nsight_compute.version "2022.2.0") then
[final.pkgs.qt5.qtwebview]
else
[final.pkgs.qt6.qtwebview]
);
}
);
nsight_systems = prev.nsight_systems.overrideAttrs (
prevAttrs: {
nativeBuildInputs = prevAttrs.nativeBuildInputs ++ [final.pkgs.qt5.wrapQtAppsHook];
buildInputs = prevAttrs.buildInputs ++ [
final.pkgs.alsa-lib
final.pkgs.e2fsprogs
final.pkgs.nss
final.pkgs.numactl
final.pkgs.pulseaudio
final.pkgs.wayland
final.pkgs.xorg.libXcursor
final.pkgs.xorg.libXdamage
final.pkgs.xorg.libXrandr
final.pkgs.xorg.libXtst
];
}
);
nvidia_driver = prev.nvidia_driver.overrideAttrs {
# No need to support this package as we have drivers already
# in linuxPackages.
meta.broken = true;
};
}

374
pkgs/development/cuda-modules/cudatoolkit/default.nix Normal file
View File

@ -0,0 +1,374 @@
{
cudaVersion,
runPatches ? [],
autoPatchelfHook,
autoAddOpenGLRunpathHook,
addOpenGLRunpath,
alsa-lib,
curlMinimal,
expat,
fetchurl,
fontconfig,
freetype,
gdk-pixbuf,
glib,
glibc,
gst_all_1,
gtk2,
lib,
libxkbcommon,
libkrb5,
krb5,
makeWrapper,
markForCudatoolkitRootHook,
ncurses5,
numactl,
nss,
patchelf,
perl,
python3, # FIXME: CUDAToolkit 10 may still need python27
pulseaudio,
setupCudaHook,
stdenv,
backendStdenv, # E.g. gcc11Stdenv, set in extension.nix
unixODBC,
wayland,
xorg,
zlib,
freeglut,
libGLU,
libsForQt5,
libtiff,
qt6Packages,
qt6,
rdma-core,
ucx,
rsync,
}:
let
# Version info for the classic cudatoolkit packages that contain everything that is in redist.
releases = builtins.import ./releases.nix;
release = releases.${cudaVersion};
in
backendStdenv.mkDerivation rec {
pname = "cudatoolkit";
inherit (release) version;
inherit runPatches;
dontPatchELF = true;
dontStrip = true;
src = fetchurl {inherit (release) url sha256;};
outputs = [
"out"
"lib"
"doc"
];
nativeBuildInputs =
[
perl
makeWrapper
rsync
addOpenGLRunpath
autoPatchelfHook
autoAddOpenGLRunpathHook
markForCudatoolkitRootHook
]
++ lib.optionals (lib.versionOlder version "11") [libsForQt5.wrapQtAppsHook]
++ lib.optionals (lib.versionAtLeast version "11.8") [qt6Packages.wrapQtAppsHook];
depsTargetTargetPropagated = [setupCudaHook];
buildInputs =
lib.optionals (lib.versionOlder version "11") [
libsForQt5.qt5.qtwebengine
freeglut
libGLU
]
++ [
# To get $GDK_PIXBUF_MODULE_FILE via setup-hook
gdk-pixbuf
# For autoPatchelf
ncurses5
expat
python3
zlib
glibc
xorg.libX11
xorg.libXext
xorg.libXrender
xorg.libXt
xorg.libXtst
xorg.libXi
xorg.libXext
xorg.libXdamage
xorg.libxcb
xorg.xcbutilimage
xorg.xcbutilrenderutil
xorg.xcbutilwm
xorg.xcbutilkeysyms
pulseaudio
libxkbcommon
libkrb5
krb5
gtk2
glib
fontconfig
freetype
numactl
nss
unixODBC
alsa-lib
wayland
]
++ lib.optionals (lib.versionAtLeast version "11.8") [
(lib.getLib libtiff)
qt6Packages.qtwayland
rdma-core
(ucx.override {enableCuda = false;}) # Avoid infinite recursion
xorg.libxshmfence
xorg.libxkbfile
]
++ (lib.optionals (lib.versionAtLeast version "12") (
map lib.getLib ([
# Used by `/target-linux-x64/CollectX/clx` and `/target-linux-x64/CollectX/libclx_api.so` for:
# - `libcurl.so.4`
curlMinimal
# Used by `/host-linux-x64/Scripts/WebRTCContainer/setup/neko/server/bin/neko`
gst_all_1.gstreamer
gst_all_1.gst-plugins-base
])
++ (
with qt6; [
qtmultimedia
qttools
qtpositioning
qtscxml
qtsvg
qtwebchannel
qtwebengine
]
)
));
# Prepended to runpaths by autoPatchelf.
# The order inherited from older rpath preFixup code
runtimeDependencies = [
(placeholder "lib")
(placeholder "out")
"${placeholder "out"}/nvvm"
# NOTE: use the same libstdc++ as the rest of nixpkgs, not from backendStdenv
"${lib.getLib stdenv.cc.cc}/lib64"
"${placeholder "out"}/jre/lib/amd64/jli"
"${placeholder "out"}/lib64"
"${placeholder "out"}/nvvm/lib64"
];
autoPatchelfIgnoreMissingDeps = [
# This is the hardware-dependent userspace driver that comes from
# nvidia_x11 package. It must be deployed at runtime in
# /run/opengl-driver/lib or pointed at by LD_LIBRARY_PATH variable, rather
# than pinned in runpath
"libcuda.so.1"
# The krb5 expression ships libcom_err.so.3 but cudatoolkit asks for the
# older
# This dependency is asked for by target-linux-x64/CollectX/RedHat/x86_64/libssl.so.10
# - do we even want to use nvidia-shipped libssl?
"libcom_err.so.2"
];
preFixup =
if lib.versionOlder version "11" then
''
${lib.getExe' patchelf "patchelf"} $out/targets/*/lib/libnvrtc.so --add-needed libnvrtc-builtins.so
''
else
''
${lib.getExe' patchelf "patchelf"} $out/lib64/libnvrtc.so --add-needed libnvrtc-builtins.so
'';
unpackPhase = ''
sh $src --keep --noexec
${lib.optionalString (lib.versionOlder version "10.1") ''
cd pkg/run_files
sh cuda-linux*.run --keep --noexec
sh cuda-samples*.run --keep --noexec
mv pkg ../../$(basename $src)
cd ../..
rm -rf pkg
for patch in $runPatches; do
sh $patch --keep --noexec
mv pkg $(basename $patch)
done
''}
'';
installPhase =
''
runHook preInstall
mkdir $out
${lib.optionalString (lib.versionOlder version "10.1") ''
cd $(basename $src)
export PERL5LIB=.
perl ./install-linux.pl --prefix="$out"
cd ..
for patch in $runPatches; do
cd $(basename $patch)
perl ./install_patch.pl --silent --accept-eula --installdir="$out"
cd ..
done
''}
${lib.optionalString (lib.versionAtLeast version "10.1" && lib.versionOlder version "11") ''
cd pkg/builds/cuda-toolkit
mv * $out/
''}
${lib.optionalString (lib.versionAtLeast version "11") ''
mkdir -p $out/bin $out/lib64 $out/include $doc
for dir in pkg/builds/* pkg/builds/cuda_nvcc/nvvm pkg/builds/cuda_cupti/extras/CUPTI; do
if [ -d $dir/bin ]; then
mv $dir/bin/* $out/bin
fi
if [ -d $dir/doc ]; then
(cd $dir/doc && find . -type d -exec mkdir -p $doc/\{} \;)
(cd $dir/doc && find . \( -type f -o -type l \) -exec mv \{} $doc/\{} \;)
fi
if [ -L $dir/include ] || [ -d $dir/include ]; then
(cd $dir/include && find . -type d -exec mkdir -p $out/include/\{} \;)
(cd $dir/include && find . \( -type f -o -type l \) -exec mv \{} $out/include/\{} \;)
fi
if [ -L $dir/lib64 ] || [ -d $dir/lib64 ]; then
(cd $dir/lib64 && find . -type d -exec mkdir -p $out/lib64/\{} \;)
(cd $dir/lib64 && find . \( -type f -o -type l \) -exec mv \{} $out/lib64/\{} \;)
fi
done
mv pkg/builds/cuda_nvcc/nvvm $out/nvvm
mv pkg/builds/cuda_sanitizer_api $out/cuda_sanitizer_api
ln -s $out/cuda_sanitizer_api/compute-sanitizer/compute-sanitizer $out/bin/compute-sanitizer
mv pkg/builds/nsight_systems/target-linux-x64 $out/target-linux-x64
mv pkg/builds/nsight_systems/host-linux-x64 $out/host-linux-x64
rm $out/host-linux-x64/libstdc++.so*
''}
${
lib.optionalString (lib.versionAtLeast version "11.8")
# error: auto-patchelf could not satisfy dependency libtiff.so.5 wanted by /nix/store/.......-cudatoolkit-12.0.1/host-linux-x64/Plugins/imageformats/libqtiff.so
# we only ship libtiff.so.6, so let's use qt plugins built by Nix.
# TODO: don't copy, come up with a symlink-based "merge"
''
rsync ${lib.getLib qt6Packages.qtimageformats}/lib/qt-6/plugins/ $out/host-linux-x64/Plugins/ -aP
''
}
rm -f $out/tools/CUDA_Occupancy_Calculator.xls # FIXME: why?
${lib.optionalString (lib.versionOlder version "10.1") ''
# let's remove the 32-bit libraries, they confuse the lib64->lib mover
rm -rf $out/lib
''}
${lib.optionalString (lib.versionAtLeast version "12.0") ''
rm $out/host-linux-x64/libQt6*
''}
# Remove some cruft.
${lib.optionalString ((lib.versionAtLeast version "7.0") && (lib.versionOlder version "10.1"))
"rm $out/bin/uninstall*"}
# Fixup path to samples (needed for cuda 6.5 or else nsight will not find them)
if [ -d "$out"/cuda-samples ]; then
mv "$out"/cuda-samples "$out"/samples
fi
# Change the #error on GCC > 4.9 to a #warning.
sed -i $out/include/host_config.h -e 's/#error\(.*unsupported GNU version\)/#warning\1/'
# Fix builds with newer glibc version
sed -i "1 i#define _BITS_FLOATN_H" "$out/include/host_defines.h"
''
+
# Point NVCC at a compatible compiler
# CUDA_TOOLKIT_ROOT_DIR is legacy,
# Cf. https://cmake.org/cmake/help/latest/module/FindCUDA.html#input-variables
''
mkdir -p $out/nix-support
cat <<EOF >> $out/nix-support/setup-hook
cmakeFlags+=' -DCUDA_TOOLKIT_ROOT_DIR=$out'
EOF
# Move some libraries to the lib output so that programs that
# depend on them don't pull in this entire monstrosity.
mkdir -p $lib/lib
mv -v $out/lib64/libcudart* $lib/lib/
# Remove OpenCL libraries as they are provided by ocl-icd and driver.
rm -f $out/lib64/libOpenCL*
${lib.optionalString (lib.versionAtLeast version "10.1" && (lib.versionOlder version "11")) ''
mv $out/lib64 $out/lib
mv $out/extras/CUPTI/lib64/libcupti* $out/lib
''}
# nvprof do not find any program to profile if LD_LIBRARY_PATH is not set
wrapProgram $out/bin/nvprof \
--prefix LD_LIBRARY_PATH : $out/lib
''
+ lib.optionalString (lib.versionOlder version "8.0") ''
# Hack to fix building against recent Glibc/GCC.
echo "NIX_CFLAGS_COMPILE+=' -D_FORCE_INLINES'" >> $out/nix-support/setup-hook
''
# 11.8 includes a broken symlink, include/include, pointing to targets/x86_64-linux/include
+ lib.optionalString (lib.versions.majorMinor version == "11.8") ''
rm $out/include/include
''
+ ''
runHook postInstall
'';
postInstall = ''
for b in nvvp ${lib.optionalString (lib.versionOlder version "11") "nsight"}; do
wrapProgram "$out/bin/$b" \
--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE"
done
'';
# cuda-gdb doesn't run correctly when not using sandboxing, so
# temporarily disabling the install check. This should be set to true
# when we figure out how to get `cuda-gdb --version` to run correctly
# when not using sandboxing.
doInstallCheck = false;
postInstallCheck = ''
# Smoke test binaries
pushd $out/bin
for f in *; do
case $f in
crt) continue;;
nvcc.profile) continue;;
nsight_ee_plugins_manage.sh) continue;;
uninstall_cuda_toolkit_6.5.pl) continue;;
computeprof|nvvp|nsight) continue;; # GUIs don't feature "--version"
*) echo "Executing '$f --version':"; ./$f --version;;
esac
done
popd
'';
passthru = {
inherit (backendStdenv) cc;
majorMinorVersion = lib.versions.majorMinor version;
majorVersion = lib.versions.majorMinor version;
};
meta = with lib; {
description = "A compiler for NVIDIA GPUs, math libraries, and tools";
homepage = "https://developer.nvidia.com/cuda-toolkit";
platforms = ["x86_64-linux"];
license = licenses.nvidiaCuda;
maintainers = teams.cuda.members;
};
}

108
pkgs/development/cuda-modules/cudatoolkit/releases.nix Normal file
View File

@ -0,0 +1,108 @@
# Type Aliases
# CudaVersion = String (two-component version, e.g. "10.0")
# Release = {
# version: String
# - The version of CUDA.
# url: String
# - The URL to download the CUDA installer from.
# sha256: String
# - The SHA256 checksum of the CUDA installer.
# }
# Releases = AttrSet CudaVersion Release
{
"10.0" = {
version = "10.0.130";
url = "https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux";
sha256 = "16p3bv1lwmyqpxil8r951h385sy9asc578afrc7lssa68c71ydcj";
};
"10.1" = {
version = "10.1.243";
url = "https://developer.download.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.243_418.87.00_linux.run";
sha256 = "0caxhlv2bdq863dfp6wj7nad66ml81vasq2ayf11psvq2b12vhp7";
};
"10.2" = {
version = "10.2.89";
url = "http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run";
sha256 = "04fasl9sjkb1jvchvqgaqxprnprcz7a8r52249zp2ijarzyhf3an";
};
"11.0" = {
version = "11.0.3";
url = "https://developer.download.nvidia.com/compute/cuda/11.0.3/local_installers/cuda_11.0.3_450.51.06_linux.run";
sha256 = "1h4c69nfrgm09jzv8xjnjcvpq8n4gnlii17v3wzqry5d13jc8ydh";
};
"11.1" = {
version = "11.1.1";
url = "https://developer.download.nvidia.com/compute/cuda/11.1.1/local_installers/cuda_11.1.1_455.32.00_linux.run";
sha256 = "13yxv2fgvdnqqbwh1zb80x4xhyfkbajfkwyfpdg9493010kngbiy";
};
"11.2" = {
version = "11.2.1";
url = "https://developer.download.nvidia.com/compute/cuda/11.2.1/local_installers/cuda_11.2.1_460.32.03_linux.run";
sha256 = "sha256-HamMuJfMX1inRFpKZspPaSaGdwbLOvWKZpzc2Nw9F8g=";
};
"11.3" = {
version = "11.3.1";
url = "https://developer.download.nvidia.com/compute/cuda/11.3.1/local_installers/cuda_11.3.1_465.19.01_linux.run";
sha256 = "0d19pwcqin76scbw1s5kgj8n0z1p4v1hyfldqmamilyfxycfm4xd";
};
"11.4" = {
version = "11.4.2";
url = "https://developer.download.nvidia.com/compute/cuda/11.4.2/local_installers/cuda_11.4.2_470.57.02_linux.run";
sha256 = "sha256-u9h8oOkT+DdFSnljZ0c1E83e9VUILk2G7Zo4ZZzIHwo=";
};
"11.5" = {
version = "11.5.0";
url = "https://developer.download.nvidia.com/compute/cuda/11.5.0/local_installers/cuda_11.5.0_495.29.05_linux.run";
sha256 = "sha256-rgoWk9lJfPPYHmlIlD43lGNpANtxyY1Y7v2sr38aHkw=";
};
"11.6" = {
version = "11.6.1";
url = "https://developer.download.nvidia.com/compute/cuda/11.6.1/local_installers/cuda_11.6.1_510.47.03_linux.run";
sha256 = "sha256-qyGa/OALdCABEyaYZvv/derQN7z8I1UagzjCaEyYTX4=";
};
"11.7" = {
version = "11.7.0";
url = "https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda_11.7.0_515.43.04_linux.run";
sha256 = "sha256-CH/fy7ofeVQ7H3jkOo39rF9tskLQQt3oIOFtwYWJLyY=";
};
"11.8" = {
version = "11.8.0";
url = "https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run";
sha256 = "sha256-kiPErzrr5Ke77Zq9mxY7A6GzS4VfvCtKDRtwasCaWhY=";
};
"12.0" = {
version = "12.0.1";
url = "https://developer.download.nvidia.com/compute/cuda/12.0.1/local_installers/cuda_12.0.1_525.85.12_linux.run";
sha256 = "sha256-GyBaBicvFGP0dydv2rkD8/ZmkXwGjlIHOAAeacehh1s=";
};
"12.1" = {
version = "12.1.1";
url = "https://developer.download.nvidia.com/compute/cuda/12.1.1/local_installers/cuda_12.1.1_530.30.02_linux.run";
sha256 = "sha256-10Ai1B2AEFMZ36Ib7qObd6W5kZU5wEh6BcqvJEbWpw4=";
};
"12.2" = {
version = "12.2.0";
url = "https://developer.download.nvidia.com/compute/cuda/12.2.0/local_installers/cuda_12.2.0_535.54.03_linux.run";
sha256 = "sha256-7PPSr63LrAKfD0UFeFgQ1S0AbkuHunn/P5hDNqK79Rg=";
};
"12.3" = {
version = "12.3.0";
url = "https://developer.download.nvidia.com/compute/cuda/12.3.0/local_installers/cuda_12.3.0_545.23.06_linux.run";
sha256 = "sha256-fBP6zjr2TW4WSNbjEB0xyBEedHFDrLAHfZc8FpCCBCI=";
};
}

69
pkgs/development/cuda-modules/cudnn/fixup.nix Normal file
View File

@ -0,0 +1,69 @@
{
cudaVersion,
fetchurl,
final,
lib,
package,
patchelf,
zlib,
...
}:
let
inherit (lib)
lists
maintainers
meta
strings
;
in
finalAttrs: prevAttrs: {
src = fetchurl {inherit (package) url hash;};
# Useful for inspecting why something went wrong.
brokenConditions =
let
cudaTooOld = strings.versionOlder cudaVersion package.minCudaVersion;
cudaTooNew =
(package.maxCudaVersion != null) && strings.versionOlder package.maxCudaVersion cudaVersion;
in
prevAttrs.brokenConditions
// {
"CUDA version is too old" = cudaTooOld;
"CUDA version is too new" = cudaTooNew;
};
buildInputs =
prevAttrs.buildInputs
++ [zlib]
++ lists.optionals finalAttrs.passthru.useCudatoolkitRunfile [final.cudatoolkit]
++ lists.optionals (!finalAttrs.passthru.useCudatoolkitRunfile) [final.libcublas.lib];
# Tell autoPatchelf about runtime dependencies.
# NOTE: Versions from CUDNN releases have four components.
postFixup = strings.optionalString (strings.versionAtLeast finalAttrs.version "8.0.5.0") ''
${meta.getExe' patchelf "patchelf"} $lib/lib/libcudnn.so --add-needed libcudnn_cnn_infer.so
${meta.getExe' patchelf "patchelf"} $lib/lib/libcudnn_ops_infer.so --add-needed libcublas.so --add-needed libcublasLt.so
'';
passthru.useCudatoolkitRunfile = strings.versionOlder cudaVersion "11.3.999";
meta = prevAttrs.meta // {
homepage = "https://developer.nvidia.com/cudnn";
maintainers =
prevAttrs.meta.maintainers
++ (
with maintainers; [
mdaiter
samuela
connorbaker
]
);
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;
redistributable = !finalAttrs.passthru.useCudatoolkitRunfile;
};
};
}

262
pkgs/development/cuda-modules/cudnn/releases.nix Normal file
View File

@ -0,0 +1,262 @@
# NOTE: Check https://docs.nvidia.com/deeplearning/cudnn/archives/index.html for support matrices.
# Version policy is to keep the latest minor release for each major release.
{
cudnn.releases = {
# jetson
linux-aarch64 = [
{
version = "8.9.5.30";
minCudaVersion = "12.0";
maxCudaVersion = "12.2";
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=";
}
];
# powerpc
linux-ppc64le = [];
# server-grade arm
linux-sbsa = [
{
version = "8.4.1.50";
minCudaVersion = "11.0";
maxCudaVersion = "11.7";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.4.1.50_cuda11.6-archive.tar.xz";
hash = "sha256-CxufrFt4l04v2qp0hD2xj2Ns6PPZmdYv8qYVuZePw2A=";
}
{
version = "8.5.0.96";
minCudaVersion = "11.0";
maxCudaVersion = "11.7";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.5.0.96_cuda11-archive.tar.xz";
hash = "sha256-hngKu+zUY05zY/rR0ACuI7eQWl+Dg73b9zMsaTR5Hd4=";
}
{
version = "8.6.0.163";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.6.0.163_cuda11-archive.tar.xz";
hash = "sha256-oCAieNPL1POtw/eBa/9gcWIcsEKwkDaYtHesrIkorAY=";
}
{
version = "8.7.0.84";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.7.0.84_cuda11-archive.tar.xz";
hash = "sha256-z5Z/eNv2wHUkPMg6oYdZ43DbN1SqFbEqChTov2ejqdQ=";
}
{
version = "8.8.1.3";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.8.1.3_cuda11-archive.tar.xz";
hash = "sha256-OzWq+aQkmIbZONmWSYyFoZzem3RldoXyJy7GVT6GM1k=";
}
{
version = "8.8.1.3";
minCudaVersion = "12.0";
maxCudaVersion = "12.0";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.8.1.3_cuda12-archive.tar.xz";
hash = "sha256-njl3qhudBuuGC1gqyJM2MGdaAkMCnCWb/sW7VpmGfSA=";
}
{
version = "8.9.6.50";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.6.50_cuda11-archive.tar.xz";
hash = "sha256-nlQWYSOJWci7o3wFGIuxrkoo8d3ddg4F2hU/qJySvBE=";
}
{
version = "8.9.6.50";
minCudaVersion = "12.0";
maxCudaVersion = "12.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-sbsa/cudnn-linux-sbsa-8.9.6.50_cuda12-archive.tar.xz";
hash = "sha256-L20O26RelmeynVfjohEADW3Vaj3VbFS2dTUadTKlXdg=";
}
];
# x86_64
linux-x86_64 = [
{
version = "7.4.2.24";
minCudaVersion = "10.0";
maxCudaVersion = "10.0";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v7.4.2/cudnn-10.0-linux-x64-v7.4.2.24.tgz";
hash = "sha256-Lt/IagK1DRfojEeJVaMy5qHoF05+U6NFi06lH68C2qM=";
}
{
version = "7.6.5.32";
minCudaVersion = "10.0";
maxCudaVersion = "10.0";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v7.6.5/cudnn-10.0-linux-x64-v7.6.5.32.tgz";
hash = "sha256-KDVeOV8LK5OsLIO2E2CzW6bNA3fkTni+GXtrYbS0kro=";
}
{
version = "7.6.5.32";
minCudaVersion = "10.1";
maxCudaVersion = "10.1";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v7.6.5/cudnn-10.1-linux-x64-v7.6.5.32.tgz";
hash = "sha256-fq7IA5osMKsLx1jTA1iHZ2k972v0myJIWiwAvy4TbLM=";
}
{
version = "7.6.5.32";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v7.6.5/cudnn-10.2-linux-x64-v7.6.5.32.tgz";
hash = "sha256-fq7IA5osMKsLx1jTA1iHZ2k972v0myJIWiwAvy4TbLN=";
}
{
version = "8.0.5.39";
minCudaVersion = "10.1";
maxCudaVersion = "10.1";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.0.5/cudnn-10.1-linux-x64-v8.0.5.39.tgz";
hash = "sha256-kJCElSmIlrM6qVBjo0cfk8NmJ9esAcF9w211xl7qSgA=";
}
{
version = "8.0.5.39";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.0.5/cudnn-10.2-linux-x64-v8.0.5.39.tgz";
hash = "sha256-IfhMBcZ78eyFnnfDjM1b8VSWT6HDCPRJlZvkw1bjgvM=";
}
{
version = "8.0.5.39";
minCudaVersion = "11.0";
maxCudaVersion = "11.0";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.0.5/cudnn-11.0-linux-x64-v8.0.5.39.tgz";
hash = "sha256-ThbueJXetKixwZS4ErpJWG730mkCBRQB03F1EYmKm3M=";
}
{
version = "8.0.5.39";
minCudaVersion = "11.1";
maxCudaVersion = "11.1";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.0.5/cudnn-11.1-linux-x64-v8.0.5.39.tgz";
hash = "sha256-HQRr+nk5navMb2yxUHkYdUQ5RC6gyp4Pvs3URvmwDM4=";
}
{
version = "8.1.1.33";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.1.1/cudnn-10.2-linux-x64-v8.1.1.33.tgz";
hash = "sha256-Kkp7mabpv6aQ6xm7QeSVU/KnpJGls6v8rpAOFmxbbr0=";
}
{
version = "8.1.1.33";
minCudaVersion = "11.0";
maxCudaVersion = "11.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.1.1/cudnn-11.2-linux-x64-v8.1.1.33.tgz";
hash = "sha256-mKh4TpKGLyABjSDCgbMNSgzZUfk2lPZDPM9K6cUCumo=";
}
{
version = "8.2.4.15";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.2.4/cudnn-10.2-linux-x64-v8.2.4.15.tgz";
hash = "sha256-0jyUoxFaHHcRamwSfZF1+/WfcjNkN08mo0aZB18yIvE=";
}
{
version = "8.2.4.15";
minCudaVersion = "11.0";
maxCudaVersion = "11.4";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.2.4/cudnn-11.4-linux-x64-v8.2.4.15.tgz";
hash = "sha256-Dl0t+JC5ln76ZhnaQhMQ2XMjVlp58FoajLm3Fluq0Nc=";
}
{
version = "8.3.3.40";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.3.3/local_installers/10.2/cudnn-linux-x86_64-8.3.3.40_cuda10.2-archive.tar.xz";
hash = "sha256-2FVPKzLmKV1fyPOsJeaPlAWLAYyAHaucFD42gS+JJqs=";
}
{
version = "8.3.3.40";
minCudaVersion = "11.0";
maxCudaVersion = "11.6";
url = "https://developer.download.nvidia.com/compute/redist/cudnn/v8.3.3/local_installers/11.5/cudnn-linux-x86_64-8.3.3.40_cuda11.5-archive.tar.xz";
hash = "sha256-6r6Wx1zwPqT1N5iU2RTx+K4UzqsSGYnoSwg22Sf7dzE=";
}
{
version = "8.4.1.50";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.4.1.50_cuda10.2-archive.tar.xz";
hash = "sha256-I88qMmU6lIiLVmaPuX7TTbisgTav839mssxUo3lQNjg=";
}
{
version = "8.4.1.50";
minCudaVersion = "11.0";
maxCudaVersion = "11.7";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.4.1.50_cuda11.6-archive.tar.xz";
hash = "sha256-7JbSN22B/KQr3T1MPXBambKaBlurV/kgVhx2PinGfQE=";
}
{
version = "8.5.0.96";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.5.0.96_cuda10-archive.tar.xz";
hash = "sha256-1mzhbbzR40WKkHnQLtJHhg0vYgf7G8a0OBcCwIOkJjM=";
}
{
version = "8.5.0.96";
minCudaVersion = "11.0";
maxCudaVersion = "11.7";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.5.0.96_cuda11-archive.tar.xz";
hash = "sha256-VFSm/ZTwCHKMqumtrZk8ToXvNjAuJrzkO+p9RYpee20=";
}
{
version = "8.6.0.163";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.6.0.163_cuda10-archive.tar.xz";
hash = "sha256-t4sr/GrFqqdxu2VhaJQk5K1Xm/0lU4chXG8hVL09R9k=";
}
{
version = "8.6.0.163";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.6.0.163_cuda11-archive.tar.xz";
hash = "sha256-u8OW30cpTGV+3AnGAGdNYIyxv8gLgtz0VHBgwhcRFZ4=";
}
{
version = "8.7.0.84";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.7.0.84_cuda10-archive.tar.xz";
hash = "sha256-bZhaqc8+GbPV2FQvvbbufd8VnEJgvfkICc2N3/gitRg=";
}
{
version = "8.7.0.84";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.7.0.84_cuda11-archive.tar.xz";
hash = "sha256-l2xMunIzyXrnQAavq1Fyl2MAukD1slCiH4z3H1nJ920=";
}
{
version = "8.8.1.3";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.8.1.3_cuda11-archive.tar.xz";
hash = "sha256-r3WEyuDMVSS1kT7wjCm6YVQRPGDrCjegWQqRtRWoqPk=";
}
{
version = "8.8.1.3";
minCudaVersion = "12.0";
maxCudaVersion = "12.0";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.8.1.3_cuda12-archive.tar.xz";
hash = "sha256-edd6dpx+cXWrx7XC7VxJQUjAYYqGQThyLIh/lcYjd3w=";
}
{
version = "8.9.6.50";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.6.50_cuda11-archive.tar.xz";
hash = "sha256-oOLvVemfTNZH99HaqlqkUE/6M1ujAYbVwyiPL0ffBX4=";
}
{
version = "8.9.6.50";
minCudaVersion = "12.0";
maxCudaVersion = "12.2";
url = "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/cudnn-linux-x86_64-8.9.6.50_cuda12-archive.tar.xz";
hash = "sha256-FyIlnblSZbs4E0OKWhxuzZed6JrkU2YDkEBC4STTAtU=";
}
];
};
}

13
pkgs/development/cuda-modules/cudnn/shims.nix Normal file
View File

@ -0,0 +1,13 @@
# Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix
{package, redistArch}:
{
featureRelease.${redistArch}.outputs = {
lib = true;
static = true;
dev = true;
};
redistribRelease = {
name = "NVIDIA CUDA Deep Neural Network library (cuDNN)";
inherit (package) version;
};
}

164
pkgs/development/cuda-modules/cutensor/extension.nix Normal file
View File

@ -0,0 +1,164 @@
# 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.
{
cudaVersion,
flags,
hostPlatform,
lib,
mkVersionedPackageName,
}:
let
inherit (lib)
attrsets
lists
modules
versions
strings
trivial
;
redistName = "cutensor";
pname = "libcutensor";
cutensorVersions = [
"1.3.3"
"1.4.0"
"1.5.0"
"1.6.2"
"1.7.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 cudaVersion 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:
#
# - 10.2
# - 11
# - 11.0
# - 12
# libPath :: String
libPath =
let
cudaMajorMinor = versions.majorMinor cudaVersion;
cudaMajor = versions.major cudaVersion;
in
if cudaMajorMinor == "10.2" then cudaMajorMinor else cudaMajor;
# 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.
redistArch = flags.getRedistArch hostPlatform.system;
# platformIsSupported :: Manifests -> Boolean
platformIsSupported =
{feature, ...}:
(attrsets.attrByPath
[
pname
redistArch
]
null
feature
) != null;
# TODO(@connorbaker): With an auxilliary 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, ...}: mkVersionedPackageName redistName 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};
};
fixedDrv = drv.overrideAttrs (
prevAttrs: {
buildInputs =
prevAttrs.buildInputs
++ lists.optionals (strings.versionOlder cudaVersion "11.4") [final.cudatoolkit]
++ lists.optionals (strings.versionAtLeast cudaVersion "11.4") (
[final.libcublas.lib]
# For some reason, the 1.4.x release of cuTENSOR requires the cudart library.
++ lists.optionals (strings.hasPrefix "1.4" redistrib.${pname}.version) [final.cuda_cudart.lib]
);
meta = prevAttrs.meta // {
description = "cuTENSOR: A High-Performance CUDA Library For Tensor Primitives";
homepage = "https://developer.nvidia.com/cutensor";
maintainers = prevAttrs.meta.maintainers ++ [lib.maintainers.obsidian-systems-maintenance];
license = lib.licenses.unfreeRedistributable // {
shortName = "cuTENSOR EULA";
name = "cuTENSOR SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS";
url = "https://docs.nvidia.com/cuda/cutensor/license.html";
};
};
}
);
in
attrsets.nameValuePair (computeName redistrib.${pname}) fixedDrv;
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

44
pkgs/development/cuda-modules/cutensor/manifests/feature_1.3.3.json Normal file
View File

@ -0,0 +1,44 @@
{
"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
}
}
}
}

44
pkgs/development/cuda-modules/cutensor/manifests/feature_1.4.0.json Normal file
View File

@ -0,0 +1,44 @@
{
"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
}
}
}
}

44
pkgs/development/cuda-modules/cutensor/manifests/feature_1.5.0.json Normal file
View File

@ -0,0 +1,44 @@
{
"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
}
}
}
}

44
pkgs/development/cuda-modules/cutensor/manifests/feature_1.6.2.json Normal file
View File

@ -0,0 +1,44 @@
{
"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
}
}
}
}

44
pkgs/development/cuda-modules/cutensor/manifests/feature_1.7.0.json Normal file
View File

@ -0,0 +1,44 @@
{
"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
}
}
}
}

32
pkgs/development/cuda-modules/cutensor/manifests/redistrib_1.3.3.json Normal file
View File

@ -0,0 +1,32 @@
{
"release_date": "2021-09-22",
"libcutensor": {
"name": "NVIDIA cuTENSOR",
"license": "cuTensor",
"version": "1.3.3.2",
"linux-x86_64": {
"relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-1.3.3.2-archive.tar.xz",
"sha256": "2e9517f31305872a7e496b6aa8ea329acda6b947b0c1eb1250790eaa2d4e2ecc",
"md5": "977699555cfcc8d2ffeff018a0f975b0",
"size": "201849628"
},
"linux-ppc64le": {
"relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-1.3.3.2-archive.tar.xz",
"sha256": "79f294c4a7933e5acee5f150145c526d6cd4df16eefb63f2d65df1dbc683cd68",
"md5": "1f632c9d33ffef9c819e10c95d69a134",
"size": "202541908"
},
"linux-sbsa": {
"relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-1.3.3.2-archive.tar.xz",
"sha256": "0b62d5305abfdfca4776290f16a1796c78c1fa83b203680c012f37d44706fcdb",
"md5": "e476675490aff0b154f2f38063f0c10b",
"size": "149059520"
},
"windows-x86_64": {
"relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-1.3.3.2-archive.zip",
"sha256": "3abeacbe7085af7026ca1399a77c681c219c10a1448a062964e97aaac2b05851",
"md5": "fe75f031c53260c00ad5f7c5d69d31e5",
"size": "374926147"
}
}
}

32
pkgs/development/cuda-modules/cutensor/manifests/redistrib_1.4.0.json Normal file
View File

@ -0,0 +1,32 @@
{
"release_date": "2021-11-19",
"libcutensor": {
"name": "NVIDIA cuTENSOR",
"license": "cuTensor",
"version": "1.4.0.6",
"linux-x86_64": {
"relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-1.4.0.6-archive.tar.xz",
"sha256": "467ba189195fcc4b868334fc16a0ae1e51574139605975cc8004cedebf595964",
"md5": "5d4009390be0226fc3ee75d225053123",
"size": "218277136"
},
"linux-ppc64le": {
"relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-1.4.0.6-archive.tar.xz",
"sha256": "5da44ff2562ab7b9286122653e54f28d2222c8aab4bb02e9bdd4cf7e4b7809be",
"md5": "6058c728485072c980f652c2de38b016",
"size": "218951992"
},
"linux-sbsa": {
"relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-1.4.0.6-archive.tar.xz",
"sha256": "6b06d63a5bc49c1660be8c307795f8a901c93dcde7b064455a6c81333c7327f4",
"md5": "a6f3fd515c052df43fbee9508ea87e1e",
"size": "163596044"
},
"windows-x86_64": {
"relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-1.4.0.6-archive.zip",
"sha256": "4f01a8aac2c25177e928c63381a80e3342f214ec86ad66965dcbfe81fc5c901d",
"md5": "d21e0d5f2bd8c29251ffacaa85f0d733",
"size": "431385567"
}
}
}

32
pkgs/development/cuda-modules/cutensor/manifests/redistrib_1.5.0.json Normal file
View File

@ -0,0 +1,32 @@
{
"release_date": "2022-03-08",
"libcutensor": {
"name": "NVIDIA cuTENSOR",
"license": "cuTensor",
"version": "1.5.0.3",
"linux-x86_64": {
"relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-1.5.0.3-archive.tar.xz",
"sha256": "4fdebe94f0ba3933a422cff3dd05a0ef7a18552ca274dd12564056993f55471d",
"md5": "7e1b1a613b819d6cf6ee7fbc70f16105",
"size": "208925360"
},
"linux-ppc64le": {
"relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-1.5.0.3-archive.tar.xz",
"sha256": "ad736acc94e88673b04a3156d7d3a408937cac32d083acdfbd8435582cbe15db",
"md5": "bcdafb6d493aceebfb9a420880f1486c",
"size": "208384668"
},
"linux-sbsa": {
"relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-1.5.0.3-archive.tar.xz",
"sha256": "5b9ac479b1dadaf40464ff3076e45f2ec92581c07df1258a155b5bcd142f6090",
"md5": "62149d726480d12c9a953d27edc208dc",
"size": "156512748"
},
"windows-x86_64": {
"relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-1.5.0.3-archive.zip",
"sha256": "de76f7d92600dda87a14ac756e9d0b5733cbceb88bcd20b3935a82c99342e6cd",
"md5": "66feef08de8c7fccf7269383e663fd06",
"size": "421810766"
}
}
}

32
pkgs/development/cuda-modules/cutensor/manifests/redistrib_1.6.2.json Normal file
View File

@ -0,0 +1,32 @@
{
"release_date": "2022-12-12",
"libcutensor": {
"name": "NVIDIA cuTENSOR",
"license": "cuTensor",
"version": "1.6.2.3",
"linux-x86_64": {
"relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-1.6.2.3-archive.tar.xz",
"sha256": "0f2745681b1d0556f9f46ff6af4937662793498d7367b5f8f6b8625ac051629e",
"md5": "b84a2f6712e39314f6c54b429152339f",
"size": "538838404"
},
"linux-ppc64le": {
"relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-1.6.2.3-archive.tar.xz",
"sha256": "558329fa05409f914ebbe218a1cf7c9ccffdb7aa2642b96db85fd78b5ad534d1",
"md5": "8d5d129aa7863312a95084ab5a27b7e7",
"size": "535585612"
},
"linux-sbsa": {
"relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-1.6.2.3-archive.tar.xz",
"sha256": "7d4d9088c892bb692ffd70750b49625d1ccbb85390f6eb7c70d6cf582df6d935",
"md5": "f6e0cce3a3b38ced736e55a19da587a3",
"size": "450705724"
},
"windows-x86_64": {
"relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-1.6.2.3-archive.zip",
"sha256": "07cb312d7cafc7bb2f33d775e1ef5fffd1703d5c6656e785a7a8f0f01939907e",
"md5": "5ae1c56bf4d457933dc1acb58a4ac995",
"size": "1063805254"
}
}
}

32
pkgs/development/cuda-modules/cutensor/manifests/redistrib_1.7.0.json Normal file
View File

@ -0,0 +1,32 @@
{
"release_date": "2023-03-16",
"libcutensor": {
"name": "NVIDIA cuTENSOR",
"license": "cuTensor",
"version": "1.7.0.1",
"linux-x86_64": {
"relative_path": "libcutensor/linux-x86_64/libcutensor-linux-x86_64-1.7.0.1-archive.tar.xz",
"sha256": "dd3557891371a19e73e7c955efe5383b0bee954aba6a30e4892b0e7acb9deb26",
"md5": "7c7e655e2ef1c57ede351f5f5c7c59be",
"size": "542970468"
},
"linux-ppc64le": {
"relative_path": "libcutensor/linux-ppc64le/libcutensor-linux-ppc64le-1.7.0.1-archive.tar.xz",
"sha256": "af4ad5e29dcb636f1bf941ed1fd7fc8053eeec4813fbc0b41581e114438e84c8",
"md5": "30739decf9f5267f2a5f28c7c1a1dc3d",
"size": "538487672"
},
"linux-sbsa": {
"relative_path": "libcutensor/linux-sbsa/libcutensor-linux-sbsa-1.7.0.1-archive.tar.xz",
"sha256": "c31f8e4386539434a5d1643ebfed74572011783b4e21b62be52003e3a9de3720",
"md5": "3185c17e8f32c9c54f591006b917365e",
"size": "454324456"
},
"windows-x86_64": {
"relative_path": "libcutensor/windows-x86_64/libcutensor-windows-x86_64-1.7.0.1-archive.zip",
"sha256": "cdbb53bcc1c7b20ee0aa2dee781644a324d2d5e8065944039024fe22d6b822ab",
"md5": "7d20a5823e94074e273525b0713f812b",
"size": "1070143817"
}
}
}

390
pkgs/development/cuda-modules/flags.nix Normal file
View File

@ -0,0 +1,390 @@
# Type aliases
# Gpu :: AttrSet
# - See the documentation in ./gpus.nix.
{
config,
cudaCapabilities ? (config.cudaCapabilities or []),
cudaForwardCompat ? (config.cudaForwardCompat or true),
lib,
cudaVersion,
hostPlatform,
# gpus :: List Gpu
gpus,
}:
let
inherit (lib)
asserts
attrsets
lists
strings
trivial
;
# Flags are determined based on your CUDA toolkit by default. You may benefit
# from improved performance, reduced file size, or greater hardware support by
# passing a configuration based on your specific GPU environment.
#
# cudaCapabilities :: List Capability
# List of hardware generations to build.
# E.g. [ "8.0" ]
# Currently, the last item is considered the optional forward-compatibility arch,
# but this may change in the future.
#
# cudaForwardCompat :: Bool
# Whether to include the forward compatibility gencode (+PTX)
# to support future GPU generations.
# E.g. true
#
# Please see the accompanying documentation or https://github.com/NixOS/nixpkgs/pull/205351
# isSupported :: Gpu -> Bool
isSupported =
gpu:
let
inherit (gpu) minCudaVersion maxCudaVersion;
lowerBoundSatisfied = strings.versionAtLeast cudaVersion minCudaVersion;
upperBoundSatisfied =
(maxCudaVersion == null) || !(strings.versionOlder maxCudaVersion cudaVersion);
in
lowerBoundSatisfied && upperBoundSatisfied;
# NOTE: Jetson is never built by default.
# isDefault :: Gpu -> Bool
isDefault =
gpu:
let
inherit (gpu) dontDefaultAfter isJetson;
newGpu = dontDefaultAfter == null;
recentGpu = newGpu || strings.versionAtLeast dontDefaultAfter cudaVersion;
in
recentGpu && !isJetson;
# supportedGpus :: List Gpu
# GPUs which are supported by the provided CUDA version.
supportedGpus = builtins.filter isSupported gpus;
# defaultGpus :: List Gpu
# GPUs which are supported by the provided CUDA version and we want to build for by default.
defaultGpus = builtins.filter isDefault supportedGpus;
# supportedCapabilities :: List Capability
supportedCapabilities = lists.map (gpu: gpu.computeCapability) supportedGpus;
# defaultCapabilities :: List Capability
# The default capabilities to target, if not overridden by the user.
defaultCapabilities = lists.map (gpu: gpu.computeCapability) defaultGpus;
# cudaArchNameToVersions :: AttrSet String (List String)
# Maps the name of a GPU architecture to different versions of that architecture.
# For example, "Ampere" maps to [ "8.0" "8.6" "8.7" ].
cudaArchNameToVersions =
lists.groupBy' (versions: gpu: versions ++ [gpu.computeCapability]) [] (gpu: gpu.archName)
supportedGpus;
# cudaComputeCapabilityToName :: AttrSet String String
# Maps the version of a GPU architecture to the name of that architecture.
# For example, "8.0" maps to "Ampere".
cudaComputeCapabilityToName = builtins.listToAttrs (
lists.map (gpu: attrsets.nameValuePair gpu.computeCapability gpu.archName) supportedGpus
);
# cudaComputeCapabilityToIsJetson :: AttrSet String Boolean
cudaComputeCapabilityToIsJetson = builtins.listToAttrs (
lists.map (attrs: attrsets.nameValuePair attrs.computeCapability attrs.isJetson) supportedGpus
);
# jetsonComputeCapabilities :: List String
jetsonComputeCapabilities = trivial.pipe cudaComputeCapabilityToIsJetson [
(attrsets.filterAttrs (_: isJetson: isJetson))
builtins.attrNames
];
# Find the intersection with the user-specified list of cudaCapabilities.
# NOTE: Jetson devices are never built by default because they cannot be targeted along with
# non-Jetson devices and require an aarch64 host platform. As such, if they're present anywhere,
# they must be in the user-specified cudaCapabilities.
# NOTE: We don't need to worry about mixes of Jetson and non-Jetson devices here -- there's
# sanity-checking for all that in below.
jetsonTargets = lists.intersectLists jetsonComputeCapabilities cudaCapabilities;
# dropDot :: String -> String
dropDot = ver: builtins.replaceStrings ["."] [""] ver;
# archMapper :: String -> List String -> List String
# Maps a feature across a list of architecture versions to produce a list of architectures.
# For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "sm_80" "sm_86" "sm_87" ].
archMapper = feat: lists.map (computeCapability: "${feat}_${dropDot computeCapability}");
# gencodeMapper :: String -> List String -> List String
# Maps a feature across a list of architecture versions to produce a list of gencode arguments.
# For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "-gencode=arch=compute_80,code=sm_80"
# "-gencode=arch=compute_86,code=sm_86" "-gencode=arch=compute_87,code=sm_87" ].
gencodeMapper =
feat:
lists.map (
computeCapability:
"-gencode=arch=compute_${dropDot computeCapability},code=${feat}_${dropDot computeCapability}"
);
# Maps Nix system to NVIDIA redist arch.
# 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.
# getRedistArch :: String -> String
getRedistArch =
nixSystem:
if nixSystem == "aarch64-linux" then
if jetsonTargets != [] then "linux-aarch64" else "linux-sbsa"
else if nixSystem == "x86_64-linux" then
"linux-x86_64"
else if nixSystem == "ppc64le-linux" then
"linux-ppc64le"
else if nixSystem == "x86_64-windows" then
"windows-x86_64"
else
builtins.throw "Unsupported Nix system: ${nixSystem}";
# Maps NVIDIA redist arch to Nix system.
# It is imperative that we include the boolean condition based on jetsonTargets to ensure
# we don't advertise availability of packages only available on server-grade ARM
# as being available for the Jetson, since both `linux-sbsa` and `linux-aarch64` are
# mapped to the Nix system `aarch64-linux`.
getNixSystem =
redistArch:
if redistArch == "linux-sbsa" && jetsonTargets == [] then
"aarch64-linux"
else if redistArch == "linux-aarch64" && jetsonTargets != [] then
"aarch64-linux"
else if redistArch == "linux-x86_64" then
"x86_64-linux"
else if redistArch == "linux-ppc64le" then
"ppc64le-linux"
else if redistArch == "windows-x86_64" then
"x86_64-windows"
else
builtins.throw "Unsupported NVIDIA redist arch: ${redistArch}";
formatCapabilities =
{
cudaCapabilities,
enableForwardCompat ? true,
}:
rec {
inherit cudaCapabilities enableForwardCompat;
# archNames :: List String
# E.g. [ "Turing" "Ampere" ]
archNames = lists.unique (
lists.map (cap: cudaComputeCapabilityToName.${cap} or (throw "missing cuda compute capability"))
cudaCapabilities
);
# realArches :: List String
# The real architectures are physical architectures supported by the CUDA version.
# E.g. [ "sm_75" "sm_86" ]
realArches = archMapper "sm" cudaCapabilities;
# virtualArches :: List String
# The virtual architectures are typically used for forward compatibility, when trying to support
# an architecture newer than the CUDA version allows.
# E.g. [ "compute_75" "compute_86" ]
virtualArches = archMapper "compute" cudaCapabilities;
# arches :: List String
# By default, build for all supported architectures and forward compatibility via a virtual
# architecture for the newest supported architecture.
# E.g. [ "sm_75" "sm_86" "compute_86" ]
arches = realArches ++ lists.optional enableForwardCompat (lists.last virtualArches);
# gencode :: List String
# A list of CUDA gencode arguments to pass to NVCC.
# E.g. [ "-gencode=arch=compute_75,code=sm_75" ... "-gencode=arch=compute_86,code=compute_86" ]
gencode =
let
base = gencodeMapper "sm" cudaCapabilities;
forward = gencodeMapper "compute" [(lists.last cudaCapabilities)];
in
base ++ lib.optionals enableForwardCompat forward;
# gencodeString :: String
# A space-separated string of CUDA gencode arguments to pass to NVCC.
# E.g. "-gencode=arch=compute_75,code=sm_75 ... -gencode=arch=compute_86,code=compute_86"
gencodeString = strings.concatStringsSep " " gencode;
# Jetson devices 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.
# isJetsonBuild :: Boolean
isJetsonBuild =
let
requestedJetsonDevices =
lists.filter (cap: cudaComputeCapabilityToIsJetson.${cap})
cudaCapabilities;
requestedNonJetsonDevices =
lists.filter (cap: !(builtins.elem cap requestedJetsonDevices))
cudaCapabilities;
jetsonBuildSufficientCondition = requestedJetsonDevices != [];
jetsonBuildNecessaryCondition = requestedNonJetsonDevices == [] && hostPlatform.isAarch64;
in
trivial.throwIf (jetsonBuildSufficientCondition && !jetsonBuildNecessaryCondition)
''
Jetson devices cannot be targeted with non-Jetson devices. Additionally, they require hostPlatform to be aarch64.
You requested ${builtins.toJSON cudaCapabilities} for host platform ${hostPlatform.system}.
Requested Jetson devices: ${builtins.toJSON requestedJetsonDevices}.
Requested non-Jetson devices: ${builtins.toJSON requestedNonJetsonDevices}.
Exactly one of the following must be true:
- All CUDA capabilities belong to Jetson devices and hostPlatform is aarch64.
- No CUDA capabilities belong to Jetson devices.
See ${./gpus.nix} for a list of architectures supported by this version of Nixpkgs.
''
jetsonBuildSufficientCondition
&& jetsonBuildNecessaryCondition;
};
in
# When changing names or formats: pause, validate, and update the assert
assert let
expected = {
cudaCapabilities = [
"7.5"
"8.6"
];
enableForwardCompat = true;
archNames = [
"Turing"
"Ampere"
];
realArches = [
"sm_75"
"sm_86"
];
virtualArches = [
"compute_75"
"compute_86"
];
arches = [
"sm_75"
"sm_86"
"compute_86"
];
gencode = [
"-gencode=arch=compute_75,code=sm_75"
"-gencode=arch=compute_86,code=sm_86"
"-gencode=arch=compute_86,code=compute_86"
];
gencodeString = "-gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_86,code=sm_86 -gencode=arch=compute_86,code=compute_86";
isJetsonBuild = false;
};
actual = formatCapabilities {
cudaCapabilities = [
"7.5"
"8.6"
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg ((strings.versionAtLeast cudaVersion "11.2") -> (expected == actualWrapped)) ''
This test should only fail when using a version of CUDA older than 11.2, the first to support
8.6.
Expected: ${builtins.toJSON expected}
Actual: ${builtins.toJSON actualWrapped}
'';
# Check mixed Jetson and non-Jetson devices
assert let
expected = false;
actual = formatCapabilities {
cudaCapabilities = [
"7.2"
"7.5"
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg (expected == actualWrapped) ''
Jetson devices capabilities cannot be mixed with non-jetson devices.
Capability 7.5 is non-Jetson and should not be allowed with Jetson 7.2.
Expected: ${builtins.toJSON expected}
Actual: ${builtins.toJSON actualWrapped}
'';
# Check Jetson-only
assert let
expected = {
cudaCapabilities = [
"6.2"
"7.2"
];
enableForwardCompat = true;
archNames = [
"Pascal"
"Volta"
];
realArches = [
"sm_62"
"sm_72"
];
virtualArches = [
"compute_62"
"compute_72"
];
arches = [
"sm_62"
"sm_72"
"compute_72"
];
gencode = [
"-gencode=arch=compute_62,code=sm_62"
"-gencode=arch=compute_72,code=sm_72"
"-gencode=arch=compute_72,code=compute_72"
];
gencodeString = "-gencode=arch=compute_62,code=sm_62 -gencode=arch=compute_72,code=sm_72 -gencode=arch=compute_72,code=compute_72";
isJetsonBuild = true;
};
actual = formatCapabilities {
cudaCapabilities = [
"6.2"
"7.2"
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg
# We can't do this test unless we're targeting aarch64
(hostPlatform.isAarch64 -> (expected == actualWrapped))
''
Jetson devices can only be built with other Jetson devices.
Both 6.2 and 7.2 are Jetson devices.
Expected: ${builtins.toJSON expected}
Actual: ${builtins.toJSON actualWrapped}
'';
{
# formatCapabilities :: { cudaCapabilities: List Capability, enableForwardCompat: Boolean } -> { ... }
inherit formatCapabilities;
# cudaArchNameToVersions :: String => String
inherit cudaArchNameToVersions;
# cudaComputeCapabilityToName :: String => String
inherit cudaComputeCapabilityToName;
# dropDot :: String -> String
inherit dropDot;
inherit
defaultCapabilities
supportedCapabilities
jetsonComputeCapabilities
jetsonTargets
getNixSystem
getRedistArch
;
}
// formatCapabilities {
cudaCapabilities = if cudaCapabilities == [] then defaultCapabilities else cudaCapabilities;
enableForwardCompat = cudaForwardCompat;
}

250
pkgs/development/cuda-modules/generic-builders/manifest.nix Normal file
View File

@ -0,0 +1,250 @@
{
# General callPackage-supplied arguments
autoAddOpenGLRunpathHook,
autoPatchelfHook,
backendStdenv,
fetchurl,
lib,
lndir,
markForCudatoolkitRootHook,
flags,
stdenv,
hostPlatform,
# 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,
}:
let
inherit (lib)
attrsets
lists
meta
strings
trivial
licenses
teams
sourceTypes
;
# Get the redist architectures for which package provides distributables.
# These are used by meta.platforms.
supportedRedistArchs = builtins.attrNames featureRelease;
redistArch = flags.getRedistArch hostPlatform.system;
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
[
redistArch
"outputs"
output
]
false
featureRelease;
# Order is important here so we use a list.
additionalOutputs = builtins.filter hasOutput [
"bin"
"lib"
"static"
"dev"
"doc"
"sample"
"python"
];
# 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 speficied in outputs;
# entries are skipped if they don't exist in outputs.
outputToPatterns = {
bin = ["bin"];
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 broken to
# booleans indicating whether that description is true.
brokenConditions = {};
src = fetchurl {
url = "https://developer.download.nvidia.com/compute/${redistName}/redist/${
redistribRelease.${redistArch}.relative_path
}";
inherit (redistribRelease.${redistArch}) sha256;
};
# 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
autoAddOpenGLRunpathHook
markForCudatoolkitRootHook
];
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
stdenv.cc.cc.lib
];
# 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) ''
if [[ ! -d "${libPath}" ]] ; then
echo "${finalAttrs.pname}: ${libPath} does not exist, only found:" >&2
find "$(dirname ${libPath})"/ -maxdepth 1 >&2
echo "This release might not support your CUDA version" >&2
exit 1
fi
mv "lib/${libPath}" 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)
# Post-install hook
+ ''
runHook postInstall
'';
# libcuda needs to be resolved during runtime
# NOTE: Due to the use of __structuredAttrs, we can't use a list for autoPatchelfIgnoreMissingDeps, since it
# will take only the first value. Instead, we produce a string with the values separated by spaces.
# Using the `env` attribute ensures that the value is representable as one of the primitives allowed by
# bash's environment variables.
env.autoPatchelfIgnoreMissingDeps = "libcuda.so libcuda.so.*";
# The out output leverages the same functionality which backs the `symlinkJoin` function in
# Nixpkgs:
# https://github.com/NixOS/nixpkgs/blob/d8b2a92df48f9b08d68b0132ce7adfbdbc1fbfac/pkgs/build-support/trivial-builders/default.nix#L510
#
# That should allow us to emulate "fat" default outputs without having to actually create them.
#
# It is important that this run after the autoPatchelfHook, otherwise the symlinks in out will reference libraries in lib, creating a circular dependency.
postPhases = ["postPatchelf"];
# For each output, create a symlink to it in the out output.
# NOTE: We must recreate the out output here, because the setup hook will have deleted it if it was empty.
postPatchelf = ''
mkdir -p "$out"
for output in $(getAllOutputNames); do
if [[ "$output" != "out" ]]; then
${meta.getExe lndir} "''${!output}" "$out"
fi
done
'';
# Make the CUDA-patched stdenv available
passthru.stdenv = backendStdenv;
# Setting propagatedBuildInputs to false will prevent outputs known to the multiple-outputs
# from depending on `out` by default.
# https://github.com/NixOS/nixpkgs/blob/2920b6fc16a9ed5d51429e94238b28306ceda79e/pkgs/build-support/setup-hooks/multiple-outputs.sh#L196
# Indeed, we want to do the opposite -- fat "out" outputs that contain all the other outputs.
propagatedBuildOutputs = false;
# By default, if the dev output exists it just uses that.
# However, because we disabled propagatedBuildOutputs, dev doesn't contain libraries or
# anything of the sort. To remedy this, we set outputSpecified to true, and use
# outputsToInstall, which tells Nix which outputs to use when the package name is used
# unqualified (that is, without an explicit output).
outputSpecified = true;
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];
platforms =
lists.concatMap
(
redistArch:
let
nixSystem = builtins.tryEval (flags.getNixSystem redistArch);
in
if nixSystem.success then [nixSystem.value] else []
)
supportedRedistArchs;
broken = lists.any trivial.id (attrsets.attrValues finalAttrs.brokenConditions);
license = licenses.unfree;
maintainers = teams.cuda.members;
# Force the use of the default, fat output by default (even though `dev` exists, which
# causes Nix to prefer that output over the others if outputSpecified isn't set).
outputsToInstall = ["out"];
};
}
)

131
pkgs/development/cuda-modules/generic-builders/multiplex.nix Normal file
View File

@ -0,0 +1,131 @@
{
# callPackage-provided arguments
lib,
cudaVersion,
flags,
hostPlatform,
# Expected to be passed by the caller
mkVersionedPackageName,
# pname :: String
pname,
# 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)
# and to determine the outputs of the package.
# shimFn :: {package, redistArch} -> AttrSet
shimsFn ? ({package, redistArch}: throw "shimsFn must be provided"),
# fixupFn :: Path
# A path (or nix expression) to be evaluated with callPackage and then
# provided to the package's overrideAttrs function.
# It must accept at least the following arguments:
# - final
# - cudaVersion
# - mkVersionedPackageName
# - package
fixupFn ? (
{
final,
cudaVersion,
mkVersionedPackageName,
package,
...
}:
throw "fixupFn must be provided"
),
}:
let
inherit (lib)
attrsets
lists
modules
strings
;
evaluatedModules = modules.evalModules {
modules = [
../modules
releasesModule
];
};
# NOTE: Important types:
# - Releases: ../modules/${pname}/releases/releases.nix
# - Package: ../modules/${pname}/releases/package.nix
# All releases across all platforms
# See ../modules/${pname}/releases/releases.nix
allReleases = evaluatedModules.config.${pname}.releases;
# 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, ...}: mkVersionedPackageName pname version;
# Check whether a package supports our CUDA version
# isSupported :: Package -> Bool
isSupported =
package:
strings.versionAtLeast cudaVersion package.minCudaVersion
&& strings.versionAtLeast package.maxCudaVersion cudaVersion;
# Get all of the packages for our given platform.
redistArch = flags.getRedistArch hostPlatform.system;
# All the supported packages we can build for our platform.
# supportedPackages :: List (AttrSet Packages)
supportedPackages = builtins.filter isSupported (allReleases.${redistArch} or []);
# newestToOldestSupportedPackage :: List (AttrSet Packages)
newestToOldestSupportedPackage = lists.reverseList supportedPackages;
nameOfNewest = computeName (builtins.head newestToOldestSupportedPackage);
# A function which takes the `final` overlay and the `package` being built and returns
# a function to be consumed via `overrideAttrs`.
overrideAttrsFixupFn =
final: package:
final.callPackage fixupFn {
inherit
final
cudaVersion
mkVersionedPackageName
package
;
};
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 redistArch;};
name = computeName package;
drv = final.callPackage ./manifest.nix {
inherit pname;
redistName = pname;
inherit (shims) redistribRelease featureRelease;
};
fixedDrv = drv.overrideAttrs (overrideAttrsFixupFn final package);
in
attrsets.nameValuePair name fixedDrv;
# versionedDerivations :: AttrSet Derivation
versionedDerivations = builtins.listToAttrs (lists.map buildPackage newestToOldestSupportedPackage);
defaultDerivation = attrsets.optionalAttrs (versionedDerivations != {}) {
${pname} = versionedDerivations.${nameOfNewest};
};
in
versionedDerivations // defaultDerivation;
in
extension

204
pkgs/development/cuda-modules/gpus.nix Normal file
View File

@ -0,0 +1,204 @@
# Type aliases
#
# Gpu = {
# archName: String
# - The name of the microarchitecture.
# computeCapability: String
# - The compute capability of the GPU.
# isJetson: Boolean
# - Whether a GPU is part of NVIDIA's line of Jetson embedded computers. This field is
# notable because it tells us what architecture to build for (as Jetson devices are
# aarch64).
# More on Jetson devices here:
# https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/
# NOTE: These architectures are only built upon request.
# minCudaVersion: String
# - The minimum (inclusive) CUDA version that supports this GPU.
# dontDefaultAfter: null | String
# - The CUDA version after which to exclude this GPU from the list of default capabilities
# we build. null means we always include this GPU in the default capabilities if it is
# supported.
# maxCudaVersion: null | String
# - The maximum (exclusive) CUDA version that supports this GPU. null means there is no
# maximum.
# }
#
# Many thanks to Arnon Shimoni for maintaining a list of these architectures and capabilities.
# Without your work, this would have been much more difficult.
# https://arnon.dk/matching-sm-architectures-arch-and-gencode-for-various-nvidia-cards/
[
{
# GeForce 700, GT-730
archName = "Kepler";
computeCapability = "3.0";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "10.2";
maxCudaVersion = "10.2";
}
{
archName = "Kepler";
computeCapability = "3.2";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "10.2";
maxCudaVersion = "10.2";
}
{
# Tesla K40
archName = "Kepler";
computeCapability = "3.5";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = "11.8";
}
{
# Tesla K80
archName = "Kepler";
computeCapability = "3.7";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = "11.8";
}
{
# Tesla/Quadro M series
archName = "Maxwell";
computeCapability = "5.0";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = null;
}
{
# Quadro M6000 , GeForce 900, GTX-970, GTX-980, GTX Titan X
archName = "Maxwell";
computeCapability = "5.2";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = "11.0";
maxCudaVersion = null;
}
{
# Tegra (Jetson) TX1 / Tegra X1, Drive CX, Drive PX, Jetson Nano
archName = "Maxwell";
computeCapability = "5.3";
isJetson = true;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# Quadro GP100, Tesla P100, DGX-1 (Generic Pascal)
archName = "Pascal";
computeCapability = "6.0";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# GTX 1080, GTX 1070, GTX 1060, GTX 1050, GTX 1030 (GP108), GT 1010 (GP108) Titan Xp, Tesla
# P40, Tesla P4, Discrete GPU on the NVIDIA Drive PX2
archName = "Pascal";
computeCapability = "6.1";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# Integrated GPU on the NVIDIA Drive PX2, Tegra (Jetson) TX2
archName = "Pascal";
computeCapability = "6.2";
isJetson = true;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# DGX-1 with Volta, Tesla V100, GTX 1180 (GV104), Titan V, Quadro GV100
archName = "Volta";
computeCapability = "7.0";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# Jetson AGX Xavier, Drive AGX Pegasus, Xavier NX
archName = "Volta";
computeCapability = "7.2";
isJetson = true;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# 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
archName = "Turing";
computeCapability = "7.5";
isJetson = false;
minCudaVersion = "10.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# NVIDIA A100 (the name “Tesla” has been dropped – GA100), NVIDIA DGX-A100
archName = "Ampere";
computeCapability = "8.0";
isJetson = false;
minCudaVersion = "11.2";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# Tesla GA10x cards, RTX Ampere – RTX 3080, GA102 – RTX 3090, RTX A2000, A3000, RTX A4000,
# A5000, A6000, NVIDIA A40, GA106 – RTX 3060, GA104 – RTX 3070, GA107 – RTX 3050, RTX A10, RTX
# A16, RTX A40, A2 Tensor Core GPU
archName = "Ampere";
computeCapability = "8.6";
isJetson = false;
minCudaVersion = "11.2";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# Jetson AGX Orin and Drive AGX Orin only
archName = "Ampere";
computeCapability = "8.7";
isJetson = true;
minCudaVersion = "11.5";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# NVIDIA GeForce RTX 4090, RTX 4080, RTX 6000, Tesla L40
archName = "Ada";
computeCapability = "8.9";
isJetson = false;
minCudaVersion = "11.8";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# NVIDIA H100 (GH100)
archName = "Hopper";
computeCapability = "9.0";
isJetson = false;
minCudaVersion = "11.8";
dontDefaultAfter = null;
maxCudaVersion = null;
}
{
# NVIDIA H100 (GH100) (Thor)
archName = "Hopper";
computeCapability = "9.0a";
isJetson = false;
minCudaVersion = "12.0";
dontDefaultAfter = null;
maxCudaVersion = null;
}
]

27
pkgs/development/cuda-modules/modules/README.md Normal file
View File

@ -0,0 +1,27 @@
# 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](./modules/cudnn/default.nix) is able to use the generic module for release expressions, while the [module for TensorRT](./modules/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`.

1
pkgs/development/cuda-modules/modules/cuda/default.nix Normal file
View File

@ -0,0 +1 @@
{options, ...}: {options.cuda.manifests = options.generic.manifests;}

12
pkgs/development/cuda-modules/modules/cudnn/default.nix Normal file
View File

@ -0,0 +1,12 @@
{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 = "The URL to download the tarball from";
# type = types.str;
# };
# }
}

1
pkgs/development/cuda-modules/modules/cutensor/default.nix Normal file
View File

@ -0,0 +1 @@
{options, ...}: {options.cutensor.manifests = options.generic.manifests;}

10
pkgs/development/cuda-modules/modules/default.nix Normal file
View File

@ -0,0 +1,10 @@
{
imports = [
./generic
# Always after generic
./cuda
./cudnn
./cutensor
./tensorrt
];
}

7
pkgs/development/cuda-modules/modules/generic/default.nix Normal file
View File

@ -0,0 +1,7 @@
{
imports = [
./types
./manifests
./releases
];
}

7
pkgs/development/cuda-modules/modules/generic/manifests/default.nix Normal file
View File

@ -0,0 +1,7 @@
{lib, config, ...}:
{
options.generic.manifests = {
feature = import ./feature/manifest.nix {inherit lib config;};
redistrib = import ./redistrib/manifest.nix {inherit lib;};
};
}

10
pkgs/development/cuda-modules/modules/generic/manifests/feature/manifest.nix Normal file
View File

@ -0,0 +1,10 @@
{lib, config, ...}:
let
inherit (lib) options trivial types;
Release = import ./release.nix {inherit lib config;};
in
options.mkOption {
description = "A feature manifest is an attribute set which includes a mapping from package name to release";
example = trivial.importJSON ../../../../cuda/manifests/feature_11.5.2.json;
type = types.attrsOf Release.type;
}

60
pkgs/development/cuda-modules/modules/generic/manifests/feature/outputs.nix Normal file
View File

@ -0,0 +1,60 @@
{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 = "A 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 = "A `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 = "A `lib` output requires that we have a non-empty lib directory containing at least one shared library.";
type = types.bool;
};
sample = options.mkOption {
description = "A `sample` output requires that we have a non-empty `samples` directory.";
type = types.bool;
};
static = options.mkOption {
description = "A `static` output requires that we have a non-empty lib directory containing at least one static library.";
type = types.bool;
};
};
};
}

10
pkgs/development/cuda-modules/modules/generic/manifests/feature/package.nix Normal file
View File

@ -0,0 +1,10 @@
{lib, ...}:
let
inherit (lib) options types;
Outputs = import ./outputs.nix {inherit lib;};
in
options.mkOption {
description = "A package in the manifest";
example = (import ./release.nix {inherit lib;}).linux-x86_64;
type = types.submodule {options.outputs = Outputs;};
}

10
pkgs/development/cuda-modules/modules/generic/manifests/feature/release.nix Normal file
View File

@ -0,0 +1,10 @@
{lib, config, ...}:
let
inherit (lib) options types;
Package = import ./package.nix {inherit lib config;};
in
options.mkOption {
description = "A 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;
}

33
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/manifest.nix Normal file
View File

@ -0,0 +1,33 @@
{lib, ...}:
let
inherit (lib) options trivial types;
Release = import ./release.nix {inherit lib;};
in
options.mkOption {
description = "A redistributable manifest is an attribute set which includes a mapping from package name to release";
example = trivial.importJSON ../../../../cuda/manifests/redistrib_11.5.2.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 = "The release date of the manifest";
type = types.nullOr types.str;
default = null;
example = "2023-08-29";
};
release_label = options.mkOption {
description = "The release label of the manifest";
type = types.nullOr types.str;
default = null;
example = "12.2.2";
};
release_product = options.mkOption {
example = "cuda";
description = "The release product of the manifest";
type = types.nullOr types.str;
default = null;
};
};
};
}

32
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/package.nix Normal file
View File

@ -0,0 +1,32 @@
{lib, ...}:
let
inherit (lib) options types;
in
options.mkOption {
description = "A package in the manifest";
example = (import ./release.nix {inherit lib;}).linux-x86_64;
type = types.submodule {
options = {
relative_path = options.mkOption {
description = "The 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 = "The sha256 hash of the package";
example = "bbe633d6603d5a96a214dcb9f3f6f6fd2fa04d62e53694af97ae0c7afe0121b0";
type = types.str;
};
md5 = options.mkOption {
description = "The md5 hash of the package";
example = "e5deef4f6cb71f14aac5be5d5745dafe";
type = types.str;
};
size = options.mkOption {
description = "The size of the package as a string";
type = types.str;
example = "960968";
};
};
};
}

36
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/release.nix Normal file
View File

@ -0,0 +1,36 @@
{lib, ...}:
let
inherit (lib) options types;
Package = import ./package.nix {inherit lib;};
in
options.mkOption {
description = "A 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 = "The full name of the package";
example = "CXX Core Compute Libraries";
type = types.str;
};
license = options.mkOption {
description = "The license of the package";
example = "CUDA Toolkit";
type = types.str;
};
license_path = options.mkOption {
description = "The path to the license of the package";
example = "cuda_cccl/LICENSE.txt";
default = null;
type = types.nullOr types.str;
};
version = options.mkOption {
description = "The version of the package";
example = "11.5.62";
type = types.str;
};
};
};
}

45
pkgs/development/cuda-modules/modules/generic/releases/default.nix Normal file
View File

@ -0,0 +1,45 @@
{lib, config, ...}:
let
inherit (config.generic.types) majorMinorVersion majorMinorPatchBuildVersion;
inherit (lib) options types;
in
{
options.generic.releases = options.mkOption {
description = "A collection of packages targeting different platforms";
type =
let
Package = options.mkOption {
description = "A 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 = "The version of the package";
type = majorMinorPatchBuildVersion;
};
minCudaVersion = options.mkOption {
description = "The minimum CUDA version supported";
type = majorMinorVersion;
};
maxCudaVersion = options.mkOption {
description = "The maximum CUDA version supported";
type = majorMinorVersion;
};
hash = options.mkOption {
description = "The hash of the tarball";
type = types.str;
};
};
};
};
in
types.attrsOf (types.listOf Package.type);
};
}

39
pkgs/development/cuda-modules/modules/generic/types/default.nix Normal file
View File

@ -0,0 +1,39 @@
{lib, ...}:
let
inherit (lib) options types;
in
{
options.generic.types = options.mkOption {
type = types.attrsOf types.optionType;
default = {};
description = "A set of generic types.";
};
config.generic.types = {
cudaArch = types.strMatching "^sm_[[:digit:]]+[a-z]?$" // {
name = "cudaArch";
description = "A 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 = "The name of a shared object file.";
};
majorMinorVersion = types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)$" // {
name = "majorMinorVersion";
description = "A version number with a major and minor component.";
};
majorMinorPatchVersion = types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)$" // {
name = "majorMinorPatchVersion";
description = "A version number with a major, minor, and patch component.";
};
majorMinorPatchBuildVersion =
types.strMatching "^([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)\\.([[:digit:]]+)$"
// {
name = "majorMinorPatchBuildVersion";
description = "A version number with a major, minor, patch, and build component.";
};
};
}

16
pkgs/development/cuda-modules/modules/tensorrt/default.nix Normal file
View File

@ -0,0 +1,16 @@
{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 = "The CUDNN version supported";
# type = types.nullOr majorMinorVersion;
# };
# filename = lib.options.mkOption {
# description = "The tarball name";
# type = types.str;
# };
# }
}

0
pkgs/development/libraries/science/math/nccl/tests.nix → pkgs/development/cuda-modules/nccl-tests/default.nix
View File

1
pkgs/development/libraries/science/math/nccl/default.nix → pkgs/development/cuda-modules/nccl/default.nix
View File

@ -11,7 +11,6 @@
gitUpdater,
}:
let
inherit (cudaPackages)
autoAddOpenGLRunpathHook
backendStdenv

124
pkgs/development/cuda-modules/nvcc-compatibilities.nix Normal file
View File

@ -0,0 +1,124 @@
# Taken from
# https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#host-compiler-support-policy
#
# NVCC performs a version check on the host compiler’s major version and so newer minor versions
# of the compilers listed below will be supported, but major versions falling outside the range
# will not be supported.
#
# NOTE: These constraints don't apply to Jetson, which uses something else.
# NOTE: NVIDIA can and will add support for newer compilers even during patch releases.
# E.g.: CUDA 12.2.1 maxxed out with support for Clang 15.0; 12.2.2 added support for Clang 16.0.
# NOTE: Because all platforms NVIDIA supports use GCC and Clang, we omit the architectures here.
# Type Aliases
# CudaVersion = String (two-part version number, e.g. "11.2")
# Platform = String (e.g. "x86_64-linux")
# CompilerCompatibilities = {
# clangMaxMajorVersion = String (e.g. "15")
# clangMinMajorVersion = String (e.g. "7")
# gccMaxMajorVersion = String (e.g. "11")
# gccMinMajorVersion = String (e.g. "6")
# }
let
# attrs :: AttrSet CudaVersion CompilerCompatibilities
attrs = {
# Our baseline
# https://docs.nvidia.com/cuda/archive/10.0/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features
"10.0" = {
clangMaxMajorVersion = "6";
clangMinMajorVersion = "6";
gccMaxMajorVersion = "7";
gccMinMajorVersion = "5";
};
# Added support for Clang 7 and GCC 8
# https://docs.nvidia.com/cuda/archive/10.1/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features
"10.1" = attrs."10.0" // {
clangMaxMajorVersion = "7";
gccMaxMajorVersion = "8";
};
# Added clang 8
# https://docs.nvidia.com/cuda/archive/10.2/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features
"10.2" = attrs."10.1" // {
clangMaxMajorVersion = "8";
};
# Added support for Clang 9 and GCC 9
# https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features
"11.0" = {
clangMaxMajorVersion = "9";
clangMinMajorVersion = "7";
gccMaxMajorVersion = "9";
gccMinMajorVersion = "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" = attrs."11.0" // {
clangMaxMajorVersion = "10";
gccMaxMajorVersion = "10";
};
# Added support for Clang 11
# https://docs.nvidia.com/cuda/archive/11.2.2/cuda-installation-guide-linux/index.html#system-requirements
"11.2" = attrs."11.1" // {
clangMaxMajorVersion = "11";
};
# No changes from 11.2 to 11.3
"11.3" = attrs."11.2";
# 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
"11.4" = attrs."11.3" // {
clangMaxMajorVersion = "12";
# 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
# gccMaxMajorVersion = "11";
};
# No changes from 11.4 to 11.5
"11.5" = attrs."11.4";
# No changes from 11.5 to 11.6
# However, as mentioned above, we add GCC 11 this release.
"11.6" = attrs."11.5" // {
gccMaxMajorVersion = "11";
};
# 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" = attrs."11.6" // {
clangMaxMajorVersion = "13";
};
# Added support for Clang 14
# https://docs.nvidia.com/cuda/archive/11.8.0/cuda-installation-guide-linux/index.html#system-requirements
"11.8" = attrs."11.7" // {
clangMaxMajorVersion = "14";
};
# Added support for GCC 12
# https://docs.nvidia.com/cuda/archive/12.0.1/cuda-installation-guide-linux/index.html#system-requirements
"12.0" = attrs."11.8" // {
gccMaxMajorVersion = "12";
};
# 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" = attrs."12.0" // {
clangMaxMajorVersion = "15";
};
# 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" = attrs."12.1" // {
clangMaxMajorVersion = "16";
};
# No changes from 12.2 to 12.3
"12.3" = attrs."12.2";
};
in
attrs

0
pkgs/development/compilers/cudatoolkit/saxpy/CMakeLists.txt → pkgs/development/cuda-modules/saxpy/CMakeLists.txt
View File

56
pkgs/development/cuda-modules/saxpy/default.nix Normal file
View File

@ -0,0 +1,56 @@
{
cmake,
cudaPackages,
lib,
}:
let
inherit (cudaPackages)
autoAddOpenGLRunpathHook
backendStdenv
cuda_cccl
cuda_cudart
cuda_nvcc
cudatoolkit
cudaVersion
flags
libcublas
;
in
backendStdenv.mkDerivation {
pname = "saxpy";
version = "unstable-2023-07-11";
src = ./.;
strictDeps = true;
nativeBuildInputs =
[
cmake
autoAddOpenGLRunpathHook
]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [cuda_nvcc];
buildInputs =
lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [
libcublas
cuda_cudart
]
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [cuda_cccl];
cmakeFlags = [
(lib.cmakeBool "CMAKE_VERBOSE_MAKEFILE" true)
(lib.cmakeFeature "CMAKE_CUDA_ARCHITECTURES" (
with flags; lib.concatStringsSep ";" (lib.lists.map dropDot cudaCapabilities)
))
];
meta = {
description = "A simple (Single-precision AX Plus Y) FindCUDAToolkit.cmake example for testing cross-compilation";
license = lib.licenses.mit;
maintainers = lib.teams.cuda.members;
platforms = lib.platforms.unix;
};
}

0
pkgs/development/compilers/cudatoolkit/saxpy/saxpy.cu → pkgs/development/cuda-modules/saxpy/saxpy.cu
View File

0
pkgs/development/compilers/cudatoolkit/auto-add-opengl-runpath-hook.sh → pkgs/development/cuda-modules/setup-hooks/auto-add-opengl-runpath-hook.sh
View File

47
pkgs/development/cuda-modules/setup-hooks/extension.nix Normal file
View File

@ -0,0 +1,47 @@
final: _: {
# Internal hook, used by cudatoolkit and cuda redist packages
# to accommodate automatic CUDAToolkit_ROOT construction
markForCudatoolkitRootHook =
final.callPackage
(
{makeSetupHook}:
makeSetupHook {name = "mark-for-cudatoolkit-root-hook";} ./mark-for-cudatoolkit-root-hook.sh
)
{};
# Currently propagated by cuda_nvcc or cudatoolkit, rather than used directly
setupCudaHook =
(final.callPackage
(
{makeSetupHook, backendStdenv}:
makeSetupHook
{
name = "setup-cuda-hook";
substitutions.setupCudaHook = placeholder "out";
# Point NVCC at a compatible compiler
substitutions.ccRoot = "${backendStdenv.cc}";
# Required in addition to ccRoot as otherwise bin/gcc is looked up
# when building CMakeCUDACompilerId.cu
substitutions.ccFullPath = "${backendStdenv.cc}/bin/${backendStdenv.cc.targetPrefix}c++";
}
./setup-cuda-hook.sh
)
{}
);
autoAddOpenGLRunpathHook =
final.callPackage
(
{addOpenGLRunpath, makeSetupHook}:
makeSetupHook
{
name = "auto-add-opengl-runpath-hook";
propagatedBuildInputs = [addOpenGLRunpath];
}
./auto-add-opengl-runpath-hook.sh
)
{};
}

0
pkgs/development/compilers/cudatoolkit/hooks/mark-for-cudatoolkit-root-hook.sh → pkgs/development/cuda-modules/setup-hooks/mark-for-cudatoolkit-root-hook.sh
View File

0
pkgs/development/compilers/cudatoolkit/hooks/setup-cuda-hook.sh → pkgs/development/cuda-modules/setup-hooks/setup-cuda-hook.sh
View File

113
pkgs/development/cuda-modules/tensorrt/fixup.nix Normal file
View File

@ -0,0 +1,113 @@
{
cudaVersion,
final,
hostPlatform,
lib,
mkVersionedPackageName,
package,
patchelf,
requireFile,
...
}:
let
inherit (lib)
maintainers
meta
strings
versions
;
in
finalAttrs: prevAttrs: {
# Useful for inspecting why something went wrong.
brokenConditions =
let
cudaTooOld = strings.versionOlder cudaVersion package.minCudaVersion;
cudaTooNew =
(package.maxCudaVersion != null) && strings.versionOlder package.maxCudaVersion cudaVersion;
cudnnVersionIsSpecified = package.cudnnVersion != null;
cudnnVersionSpecified = versions.majorMinor package.cudnnVersion;
cudnnVersionProvided = versions.majorMinor finalAttrs.passthru.cudnn.version;
cudnnTooOld =
cudnnVersionIsSpecified && (strings.versionOlder cudnnVersionProvided cudnnVersionSpecified);
cudnnTooNew =
cudnnVersionIsSpecified && (strings.versionOlder cudnnVersionSpecified cudnnVersionProvided);
in
prevAttrs.brokenConditions
// {
"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 = package.filename;
inherit (package) hash;
message = ''
To use the TensorRT derivation, you must join the NVIDIA Developer Program and
download the ${package.version} TAR package for CUDA ${cudaVersion} 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 ${package.filename}
'';
};
# We need to look inside the extracted output to get the files we need.
sourceRoot = "TensorRT-${finalAttrs.version}";
buildInputs = prevAttrs.buildInputs ++ [finalAttrs.passthru.cudnn.lib];
preInstall =
let
targetArch =
if hostPlatform.isx86_64 then
"x86_64-linux-gnu"
else if hostPlatform.isAarch64 then
"aarch64-linux-gnu"
else
throw "Unsupported architecture";
in
(prevAttrs.preInstall or "")
+ ''
# 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
'';
# 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 = {
useCudatoolkitRunfile = strings.versionOlder cudaVersion "11.3.999";
# 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 = mkVersionedPackageName "cudnn" package.cudnnVersion;
desiredIsAvailable = final ? desiredName;
in
if package.cudnnVersion == null || !desiredIsAvailable then final.cudnn else final.${desiredName};
};
meta = prevAttrs.meta // {
homepage = "https://developer.nvidia.com/tensorrt";
maintainers = prevAttrs.meta.maintainers ++ [maintainers.aidalgol];
};
}

130
pkgs/development/cuda-modules/tensorrt/releases.nix Normal file
View File

@ -0,0 +1,130 @@
# NOTE: Check https://developer.nvidia.com/nvidia-tensorrt-8x-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 = "8.2.5.1";
minCudaVersion = "11.4";
maxCudaVersion = "11.4";
cudnnVersion = "8.2";
filename = "TensorRT-8.2.5.1.Ubuntu-20.04.aarch64-gnu.cuda-11.4.cudnn8.2.tar.gz";
hash = "sha256-oWfQ3lq2aoMPv65THeotnMilTzP+QWqKeToLU8eO+qo=";
}
{
version = "8.4.3.1";
minCudaVersion = "11.6";
maxCudaVersion = "11.6";
cudnnVersion = "8.4";
filename = "TensorRT-8.4.3.1.Ubuntu-20.04.aarch64-gnu.cuda-11.6.cudnn8.4.tar.gz";
hash = "sha256-9tLlrB8cKYFvN2xF0Pol5CZs06iuuI5mq+6jpzD8wWI=";
}
{
version = "8.5.3.1";
minCudaVersion = "11.8";
maxCudaVersion = "11.8";
cudnnVersion = "8.6";
filename = "TensorRT-8.5.3.1.Ubuntu-20.04.aarch64-gnu.cuda-11.8.cudnn8.6.tar.gz";
hash = "sha256-GW//mX0brvN/waHo9Wd07xerOEz3X/H/HAW2ZehYtTA=";
}
{
version = "8.6.1.6";
minCudaVersion = "12.0";
maxCudaVersion = "12.0";
cudnnVersion = null;
filename = "TensorRT-8.6.1.6.Ubuntu-20.04.aarch64-gnu.cuda-12.0.tar.gz";
hash = "sha256-Lc4+v/yBr17VlecCSFMLUDlXMTYV68MGExwnUjGme5E=";
}
];
# x86_64
linux-x86_64 = [
{
version = "8.0.3.4";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
cudnnVersion = "8.2";
filename = "TensorRT-8.0.3.4.Linux.x86_64-gnu.cuda-10.2.cudnn8.2.tar.gz";
hash = "sha256-LxcXgwe1OCRfwDsEsNLIkeNsOcx3KuF5Sj+g2dY6WD0=";
}
{
version = "8.0.3.4";
minCudaVersion = "11.0";
maxCudaVersion = "11.3";
cudnnVersion = "8.2";
filename = "TensorRT-8.0.3.4.Linux.x86_64-gnu.cuda-11.3.cudnn8.2.tar.gz";
hash = "sha256-MXdDUCT/SqWm26jB7QarEcwOG/O7cS36Y6Q0IvQTE/M=";
}
{
version = "8.2.5.1";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
cudnnVersion = "8.2";
filename = "TensorRT-8.2.5.1.Linux.x86_64-gnu.cuda-10.2.cudnn8.2.tar.gz";
hash = "sha256-XV2Bf2LH8OM2GEMjV80MDweb1hSVF/wFUcaW3KP2m8Q=";
}
{
# The docs claim this supports through 11.5 despite the file name indicating 11.4.
version = "8.2.5.1";
minCudaVersion = "11.0";
maxCudaVersion = "11.5";
cudnnVersion = "8.2";
filename = "TensorRT-8.2.5.1.Linux.x86_64-gnu.cuda-11.4.cudnn8.2.tar.gz";
hash = "sha256-LcNpYvDiT7AavqzK1MRlijo2qDN7jznigeS77US713E=";
}
{
version = "8.4.3.1";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
cudnnVersion = "8.4";
filename = "TensorRT-8.4.3.1.Linux.x86_64-gnu.cuda-10.2.cudnn8.4.tar.gz";
hash = "sha256-2c3Zzt93FBWWQtrSIvpbzzS6BT9s0NzALzdwXGLOZEU=";
}
{
# The docs claim this supports through 11.7 despite the file name indicating 11.6.
version = "8.4.3.1";
minCudaVersion = "11.0";
maxCudaVersion = "11.7";
cudnnVersion = "8.4";
filename = "TensorRT-8.4.3.1.Linux.x86_64-gnu.cuda-11.6.cudnn8.4.tar.gz";
hash = "sha256-jXwghcFjncxzh1BIwjWYqFJs4wiRNoduMdkCWOSeT2E=";
}
{
version = "8.5.3.1";
minCudaVersion = "10.2";
maxCudaVersion = "10.2";
cudnnVersion = "8.6";
filename = "TensorRT-8.5.3.1.Linux.x86_64-gnu.cuda-10.2.cudnn8.6.tar.gz";
hash = "sha256-WCt6yfOmFbrjqdYCj6AE2+s2uFpISwk6urP+2I0BnGQ=";
}
{
version = "8.5.3.1";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
cudnnVersion = "8.6";
filename = "TensorRT-8.5.3.1.Linux.x86_64-gnu.cuda-11.8.cudnn8.6.tar.gz";
hash = "sha256-BNeuOYvPTUAfGxI0DVsNrX6Z/FAB28+SE0ptuGu7YDY=";
}
{
version = "8.6.1.6";
minCudaVersion = "11.0";
maxCudaVersion = "11.8";
cudnnVersion = "8.9";
filename = "TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-11.8.tar.gz";
hash = "sha256-Fb/mBT1F/uxF7McSOpEGB2sLQ/oENfJC2J3KB3gzd1k=";
}
{
version = "8.6.1.6";
minCudaVersion = "12.0";
maxCudaVersion = "12.1";
cudnnVersion = "8.9";
filename = "TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-12.0.tar.gz";
hash = "sha256-D4FXpfxTKZQ7M4uJNZE3M1CvqQyoEjnNrddYDNHrolQ=";
}
];
};
}

16
pkgs/development/cuda-modules/tensorrt/shims.nix Normal file
View File

@ -0,0 +1,16 @@
# Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix
{package, redistArch}:
{
featureRelease.${redistArch}.outputs = {
bin = true;
lib = true;
static = true;
dev = true;
sample = true;
python = true;
};
redistribRelease = {
name = "TensorRT: a high-performance deep learning interface";
inherit (package) version;
};
}

Some files were not shown because too many files have changed in this diff Show More