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

Merge pull request #299578 from ConnorBaker/fix/treewide-cuda-reformat-nixfmt-rfc-style-2024-03-01

Browse Source 
treewide: CUDA reformat with `nixfmt-rfc-style`
This commit is contained in:
Silvan Mosberger
2024-04-02 20:57:36 +02:00
committed by GitHub
parent bdcc3e8830 d94495d5bc
commit 073542a19e
36 changed files with 1027 additions and 994 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.git-blame-ignore-revs
View File

@@ -102,3 +102,6 @@ fb0e5be84331188a69b3edd31679ca6576edb75a
# systemd: break too long lines of Nix code
67643f8ec84bef1482204709073e417c9f07eb87
# {pkgs/development/cuda-modules,pkgs/test/cuda,pkgs/top-level/cuda-packages.nix}: reformat all CUDA files with nixfmt-rfc-style 2023-03-01
802a1b4d3338f24cbc4efd704616654456d75a94

50
.github/workflows/check-nix-format.yml vendored Normal file
View File

@@ -0,0 +1,50 @@
# This file was copied mostly from check-maintainers-sorted.yaml.
# NOTE: Formatting with the RFC-style nixfmt command is not yet stable. See
# https://github.com/NixOS/rfcs/pull/166.
# Because of this, this action is not yet enabled for all files -- only for
# those who have opted in.
name: Check that Nix files are formatted
on:
pull_request_target:
permissions:
contents: read
jobs:
nixos:
runs-on: ubuntu-latest
if: github.repository_owner == 'NixOS'
steps:
- uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 # v4.1.2
with:
# pull_request_target checks out the base branch by default
ref: refs/pull/${{ github.event.pull_request.number }}/merge
- uses: cachix/install-nix-action@8887e596b4ee1134dae06b98d573bd674693f47c # v26
with:
# explicitly enable sandbox
extra_nix_config: sandbox = true
- name: Install nixfmt
run: nix-env -f default.nix -iAP nixfmt-rfc-style
- name: Check that Nix files are formatted according to the RFC style
# Each environment variable beginning with NIX_FMT_PATHS_ is a list of
# paths to check with nixfmt.
env:
# Format paths related to the Nixpkgs CUDA ecosystem.
NIX_FMT_PATHS_CUDA: |
pkgs/development/cuda-modules
pkgs/test/cuda
pkgs/top-level/cuda-packages.nix
# Iterate over all environment variables beginning with NIX_FMT_PATHS_.
run: |
for env_var in "${!NIX_FMT_PATHS_@}"; do
readarray -t paths <<< "${!env_var}"
if [[ "${paths[*]}" == "" ]]; then
echo "Error: $env_var is empty."
exit 1
fi
echo "Checking paths: ${paths[@]}"
if ! nixfmt --check "${paths[@]}"; then
echo "Error: nixfmt failed."
exit 1
fi
done

2
pkgs/development/cuda-modules/backend-stdenv.nix
View File

@@ -21,6 +21,6 @@ let
assertCondition = true;
in
/* TODO: Consider testing whether we in fact use the newer libstdc++ */
# TODO: Consider testing whether we in fact use the newer libstdc++
lib.extendDerivation assertCondition passthruExtra cudaStdenv

4
pkgs/development/cuda-modules/cuda-library-samples/extension.nix
View File

@@ -1,4 +1,4 @@
{hostPlatform, lib}:
{ hostPlatform, lib }:
let
# Samples are built around the CUDA Toolkit, which is not available for
# aarch64. Check for both CUDA version and platform.
@@ -8,7 +8,7 @@ let
extension =
final: _:
lib.attrsets.optionalAttrs platformIsSupported {
cuda-library-samples = final.callPackage ./generic.nix {};
cuda-library-samples = final.callPackage ./generic.nix { };
};
in
extension

8
pkgs/development/cuda-modules/cuda-library-samples/generic.nix
View File

@@ -22,7 +22,7 @@ let
cmake
addOpenGLRunpath
];
buildInputs = [cudatoolkit];
buildInputs = [ cudatoolkit ];
postFixup = ''
for exe in $out/bin/*; do
addOpenGLRunpath $exe
@@ -36,7 +36,7 @@ let
cuSPARSE, cuSOLVER, cuFFT, cuRAND, NPP and nvJPEG.
'';
license = lib.licenses.bsd3;
maintainers = with lib.maintainers; [obsidian-systems-maintenance] ++ lib.teams.cuda.members;
maintainers = with lib.maintainers; [ obsidian-systems-maintenance ] ++ lib.teams.cuda.members;
};
};
in
@@ -69,9 +69,9 @@ in
src = "${src}/cuTENSOR";
buildInputs = [cutensor];
buildInputs = [ cutensor ];
cmakeFlags = ["-DCUTENSOR_EXAMPLE_BINARY_INSTALL_DIR=${builtins.placeholder "out"}/bin"];
cmakeFlags = [ "-DCUTENSOR_EXAMPLE_BINARY_INSTALL_DIR=${builtins.placeholder "out"}/bin" ];
# CUTENSOR_ROOT is double escaped
postPatch = ''

10
pkgs/development/cuda-modules/cuda-samples/generic.nix
View File

@@ -15,8 +15,7 @@
let
inherit (lib) lists strings;
in
backendStdenv.mkDerivation (
finalAttrs: {
backendStdenv.mkDerivation (finalAttrs: {
strictDeps = true;
pname = "cuda-samples";
@@ -37,7 +36,7 @@ backendStdenv.mkDerivation (
# CMake has to run as a native, build-time dependency for libNVVM samples.
# However, it's not the primary build tool -- that's still make.
# As such, we disable CMake's build system.
++ lists.optionals (strings.versionAtLeast finalAttrs.version "12.2") [cmake];
++ lists.optionals (strings.versionAtLeast finalAttrs.version "12.2") [ cmake ];
dontUseCmakeConfigure = true;
@@ -73,7 +72,6 @@ backendStdenv.mkDerivation (
description = "Samples for CUDA Developers which demonstrates features in CUDA Toolkit";
# CUDA itself is proprietary, but these sample apps are not.
license = lib.licenses.bsd3;
maintainers = with lib.maintainers; [obsidian-systems-maintenance] ++ lib.teams.cuda.members;
maintainers = with lib.maintainers; [ obsidian-systems-maintenance ] ++ lib.teams.cuda.members;
};
}
)
})

10
pkgs/development/cuda-modules/cuda/extension.nix
View File

@@ -1,4 +1,4 @@
{cudaVersion, lib}:
{ cudaVersion, lib }:
let
inherit (lib) attrsets modules trivial;
redistName = "cuda";
@@ -63,8 +63,7 @@ let
featureRelease
;
}).overrideAttrs
(
prevAttrs: {
(prevAttrs: {
# Add the package-specific license.
meta = prevAttrs.meta // {
license =
@@ -76,10 +75,9 @@ let
"${pname}/LICENSE.txt";
url = "https://developer.download.nvidia.com/compute/cuda/redist/${licensePath}";
in
lib.licenses.nvidiaCudaRedist // {inherit url;};
lib.licenses.nvidiaCudaRedist // { inherit url; };
};
}
);
});
in
drv;

58
pkgs/development/cuda-modules/cuda/overrides.nix
View File

@@ -1,4 +1,8 @@
{cudaVersion, lib, addDriverRunpath}:
{
cudaVersion,
lib,
addDriverRunpath,
}:
let
inherit (lib) attrsets lists strings;
# cudaVersionOlder : Version -> Boolean
@@ -8,15 +12,16 @@ let
addBuildInputs =
drv: buildInputs:
drv.overrideAttrs (prevAttrs: {buildInputs = prevAttrs.buildInputs ++ 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: {
libcufile = prev.libcufile.overrideAttrs (prevAttrs: {
buildInputs = prevAttrs.buildInputs ++ [
final.libcublas.lib
final.pkgs.numactl
@@ -26,24 +31,22 @@ attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
autoPatchelfIgnoreMissingDeps =
prevAttrs.autoPatchelfIgnoreMissingDeps
++ lists.optionals (cudaVersionOlder "11.7") [ "libcufile.so.0" ];
}
);
});
libcusolver = addBuildInputs prev.libcusolver (
# Always depends on this
[final.libcublas.lib]
[ final.libcublas.lib ]
# Dependency from 12.0 and on
++ lists.optionals (cudaVersionAtLeast "12.0") [final.libnvjitlink.lib]
++ lists.optionals (cudaVersionAtLeast "12.0") [ final.libnvjitlink.lib ]
# Dependency from 12.1 and on
++ lists.optionals (cudaVersionAtLeast "12.1") [final.libcusparse.lib]
++ lists.optionals (cudaVersionAtLeast "12.1") [ final.libcusparse.lib ]
);
libcusparse = addBuildInputs prev.libcusparse (
lists.optionals (cudaVersionAtLeast "12.0") [final.libnvjitlink.lib]
lists.optionals (cudaVersionAtLeast "12.0") [ final.libnvjitlink.lib ]
);
cuda_cudart = prev.cuda_cudart.overrideAttrs (
prevAttrs: {
cuda_cudart = prev.cuda_cudart.overrideAttrs (prevAttrs: {
# Remove once cuda-find-redist-features has a special case for libcuda
outputs =
prevAttrs.outputs
@@ -77,11 +80,9 @@ attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
ln -s "$stubs"/lib/stubs/* "$stubs"/lib/
ln -s "$stubs"/lib/stubs "''${!outputLib}/lib/stubs"
'';
}
);
});
cuda_compat = prev.cuda_compat.overrideAttrs (
prevAttrs: {
cuda_compat = prev.cuda_compat.overrideAttrs (prevAttrs: {
autoPatchelfIgnoreMissingDeps = prevAttrs.autoPatchelfIgnoreMissingDeps ++ [
"libnvrm_gpu.so"
"libnvrm_mem.so"
@@ -92,12 +93,11 @@ attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
"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]
lists.optionals (cudaVersionAtLeast "12.0") [ final.pkgs.gmp ]
);
cuda_nvcc = prev.cuda_nvcc.overrideAttrs (
@@ -176,9 +176,9 @@ attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
}
);
cuda_nvprof = prev.cuda_nvprof.overrideAttrs (
prevAttrs: {buildInputs = prevAttrs.buildInputs ++ [final.cuda_cupti.lib];}
);
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
@@ -189,26 +189,24 @@ attrsets.filterAttrs (attr: _: (builtins.hasAttr attr prev)) {
final.libcurand.lib
];
nsight_compute = prev.nsight_compute.overrideAttrs (
prevAttrs: {
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]
[ final.pkgs.qt5.wrapQtAppsHook ]
else
[final.pkgs.qt6.wrapQtAppsHook]
[ final.pkgs.qt6.wrapQtAppsHook ]
);
buildInputs =
prevAttrs.buildInputs
++ (
if (strings.versionOlder prev.nsight_compute.version "2022.2.0") then
[final.pkgs.qt5.qtwebview]
[ final.pkgs.qt5.qtwebview ]
else
[final.pkgs.qt6.qtwebview]
);
}
[ final.pkgs.qt6.qtwebview ]
);
});
nsight_systems = prev.nsight_systems.overrideAttrs (
prevAttrs:

43
pkgs/development/cuda-modules/cudatoolkit/default.nix
View File

@@ -1,6 +1,6 @@
{
cudaVersion,
runPatches ? [],
runPatches ? [ ],
autoPatchelfHook,
autoAddDriverRunpath,
addOpenGLRunpath,
@@ -61,7 +61,7 @@ backendStdenv.mkDerivation rec {
dontPatchELF = true;
dontStrip = true;
src = fetchurl {inherit (release) url sha256;};
src = fetchurl { inherit (release) url sha256; };
outputs = [
"out"
@@ -79,9 +79,9 @@ backendStdenv.mkDerivation rec {
autoAddDriverRunpath
markForCudatoolkitRootHook
]
++ lib.optionals (lib.versionOlder version "11") [libsForQt5.wrapQtAppsHook]
++ lib.optionals (lib.versionAtLeast version "11.8") [qt6Packages.wrapQtAppsHook];
propagatedBuildInputs = [setupCudaHook];
++ lib.optionals (lib.versionOlder version "11") [ libsForQt5.wrapQtAppsHook ]
++ lib.optionals (lib.versionAtLeast version "11.8") [ qt6Packages.wrapQtAppsHook ];
propagatedBuildInputs = [ setupCudaHook ];
buildInputs =
lib.optionals (lib.versionOlder version "11") [
libsForQt5.qt5.qtwebengine
@@ -130,7 +130,7 @@ backendStdenv.mkDerivation rec {
(lib.getLib libtiff)
qt6Packages.qtwayland
rdma-core
(ucx.override {enableCuda = false;}) # Avoid infinite recursion
(ucx.override { enableCuda = false; }) # Avoid infinite recursion
xorg.libxshmfence
xorg.libxkbfile
]
@@ -144,8 +144,7 @@ backendStdenv.mkDerivation rec {
gst_all_1.gstreamer
gst_all_1.gst-plugins-base
])
++ (
with qt6; [
++ (with qt6; [
qtmultimedia
qttools
qtpositioning
@@ -153,8 +152,7 @@ backendStdenv.mkDerivation rec {
qtsvg
qtwebchannel
qtwebengine
]
)
])
));
# Prepended to runpaths by autoPatchelf.
@@ -170,7 +168,8 @@ backendStdenv.mkDerivation rec {
"${placeholder "out"}/nvvm/lib64"
];
autoPatchelfIgnoreMissingDeps = [
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
@@ -182,7 +181,8 @@ backendStdenv.mkDerivation rec {
# 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"
] ++ lib.optionals (lib.versionOlder version "10.1") [
]
++ lib.optionals (lib.versionOlder version "10.1") [
# For Cuda 10.0, nVidia also shipped a jre implementation which needed
# two old versions of ffmpeg which are not available in nixpkgs
"libavcodec.so.54"
@@ -282,7 +282,14 @@ backendStdenv.mkDerivation rec {
for qtlib in $out/host-linux-x64/Plugins/*/libq*.so; do
qtdir=$(basename $(dirname $qtlib))
filename=$(basename $qtlib)
for qtpkgdir in ${lib.concatMapStringsSep " " (x: qt6Packages.${x}) ["qtbase" "qtimageformats" "qtsvg" "qtwayland"]}; do
for qtpkgdir in ${
lib.concatMapStringsSep " " (x: qt6Packages.${x}) [
"qtbase"
"qtimageformats"
"qtsvg"
"qtwayland"
]
}; do
if [ -e $qtpkgdir/lib/qt-6/plugins/$qtdir/$filename ]; then
ln -snf $qtpkgdir/lib/qt-6/plugins/$qtdir/$filename $qtlib
fi
@@ -303,8 +310,9 @@ backendStdenv.mkDerivation rec {
''}
# Remove some cruft.
${lib.optionalString ((lib.versionAtLeast version "7.0") && (lib.versionOlder version "10.1"))
"rm $out/bin/uninstall*"}
${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
@@ -360,8 +368,7 @@ backendStdenv.mkDerivation rec {
wrapProgram "$out/bin/$b" \
--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE"
done
${
lib.optionalString (lib.versionAtLeast version "12")
${lib.optionalString (lib.versionAtLeast version "12")
# Check we don't have any lurking vendored qt libraries that weren't
# replaced during installPhase
''
@@ -405,7 +412,7 @@ backendStdenv.mkDerivation rec {
meta = with lib; {
description = "A compiler for NVIDIA GPUs, math libraries, and tools";
homepage = "https://developer.nvidia.com/cuda-toolkit";
platforms = ["x86_64-linux"];
platforms = [ "x86_64-linux" ];
license = licenses.nvidiaCuda;
maintainers = teams.cuda.members;
};

14
pkgs/development/cuda-modules/cudnn/fixup.nix
View File

@@ -17,7 +17,7 @@ let
;
in
finalAttrs: prevAttrs: {
src = fetchurl {inherit (package) url hash;};
src = fetchurl { inherit (package) url hash; };
# Useful for inspecting why something went wrong.
brokenConditions =
@@ -34,9 +34,9 @@ finalAttrs: prevAttrs: {
buildInputs =
prevAttrs.buildInputs
++ [zlib]
++ lists.optionals finalAttrs.passthru.useCudatoolkitRunfile [final.cudatoolkit]
++ lists.optionals (!finalAttrs.passthru.useCudatoolkitRunfile) [final.libcublas.lib];
++ [ 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.
@@ -51,13 +51,11 @@ finalAttrs: prevAttrs: {
homepage = "https://developer.nvidia.com/cudnn";
maintainers =
prevAttrs.meta.maintainers
++ (
with maintainers; [
++ (with maintainers; [
mdaiter
samuela
connorbaker
]
);
]);
license = {
shortName = "cuDNN EULA";
fullName = "NVIDIA cuDNN Software License Agreement (EULA)";

2
pkgs/development/cuda-modules/cudnn/releases.nix
View File

@@ -13,7 +13,7 @@
}
];
# powerpc
linux-ppc64le = [];
linux-ppc64le = [ ];
# server-grade arm
linux-sbsa = [
{

36
pkgs/development/cuda-modules/cutensor/extension.nix
View File

@@ -65,12 +65,10 @@ let
# Un-nest the manifests attribute set.
releaseGrabber = evaluatedModules: evaluatedModules.config.cutensor.manifests;
in
lists.map
(trivial.flip trivial.pipe [
lists.map (trivial.flip trivial.pipe [
configEvaluator
releaseGrabber
])
cutensorVersions;
]) 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.
@@ -96,15 +94,11 @@ let
redistArch = flags.getRedistArch hostPlatform.system;
# platformIsSupported :: Manifests -> Boolean
platformIsSupported =
{feature, ...}:
(attrsets.attrByPath
[
{ feature, ... }:
(attrsets.attrByPath [
pname
redistArch
]
null
feature
) != null;
] 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.
@@ -116,41 +110,39 @@ let
# 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;
computeName = { version, ... }: mkVersionedPackageName redistName version;
in
final: _:
let
# buildCutensorPackage :: Manifests -> AttrSet Derivation
buildCutensorPackage =
{redistrib, feature}:
{ redistrib, feature }:
let
drv = final.callPackage ../generic-builders/manifest.nix {
inherit pname redistName libPath;
redistribRelease = redistrib.${pname};
featureRelease = feature.${pname};
};
fixedDrv = drv.overrideAttrs (
prevAttrs: {
fixedDrv = drv.overrideAttrs (prevAttrs: {
buildInputs =
prevAttrs.buildInputs
++ lists.optionals (strings.versionOlder cudaVersion "11.4") [final.cudatoolkit]
++ lists.optionals (strings.versionOlder cudaVersion "11.4") [ final.cudatoolkit ]
++ lists.optionals (strings.versionAtLeast cudaVersion "11.4") (
[final.libcublas.lib]
[ 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]
++ 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];
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;
@@ -158,7 +150,7 @@ let
let
nameOfNewest = computeName (lists.last supportedManifests).redistrib.${pname};
drvs = builtins.listToAttrs (lists.map buildCutensorPackage supportedManifests);
containsDefault = attrsets.optionalAttrs (drvs != {}) {cutensor = drvs.${nameOfNewest};};
containsDefault = attrsets.optionalAttrs (drvs != { }) { cutensor = drvs.${nameOfNewest}; };
in
drvs // containsDefault;
in

71
pkgs/development/cuda-modules/flags.nix
View File

@@ -3,7 +3,7 @@
# - See the documentation in ./gpus.nix.
{
config,
cudaCapabilities ? (config.cudaCapabilities or []),
cudaCapabilities ? (config.cudaCapabilities or [ ]),
cudaForwardCompat ? (config.cudaForwardCompat or true),
lib,
cudaVersion,
@@ -77,9 +77,9 @@ let
# 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;
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.
@@ -108,7 +108,7 @@ let
jetsonTargets = lists.intersectLists jetsonComputeCapabilities cudaCapabilities;
# dropDot :: String -> String
dropDot = ver: builtins.replaceStrings ["."] [""] ver;
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.
@@ -135,8 +135,10 @@ let
# `all-packages.nix`, which is evaluated on all systems. As such, we need to handle unsupported
# systems gracefully.
# getRedistArch :: String -> String
getRedistArch = nixSystem: attrsets.attrByPath [ nixSystem ] "unsupported" {
aarch64-linux = if jetsonTargets != [] then "linux-aarch64" else "linux-sbsa";
getRedistArch =
nixSystem:
attrsets.attrByPath [ nixSystem ] "unsupported" {
aarch64-linux = if jetsonTargets != [ ] then "linux-aarch64" else "linux-sbsa";
x86_64-linux = "linux-x86_64";
ppc64le-linux = "linux-ppc64le";
x86_64-windows = "windows-x86_64";
@@ -147,7 +149,9 @@ let
# `all-packages.nix`, which is evaluated on all systems. As such, we need to handle unsupported
# systems gracefully.
# getNixSystem :: String -> String
getNixSystem = redistArch: attrsets.attrByPath [ redistArch ] "unsupported-${redistArch}" {
getNixSystem =
redistArch:
attrsets.attrByPath [ redistArch ] "unsupported-${redistArch}" {
linux-sbsa = "aarch64-linux";
linux-aarch64 = "aarch64-linux";
linux-x86_64 = "x86_64-linux";
@@ -194,7 +198,7 @@ let
gencode =
let
base = gencodeMapper "sm" cudaCapabilities;
forward = gencodeMapper "compute" [(lists.last cudaCapabilities)];
forward = gencodeMapper "compute" [ (lists.last cudaCapabilities) ];
in
base ++ lib.optionals enableForwardCompat forward;
@@ -209,17 +213,16 @@ let
# isJetsonBuild :: Boolean
isJetsonBuild =
let
requestedJetsonDevices =
lists.filter (cap: cudaComputeCapabilityToIsJetson.${cap} or false)
cudaCapabilities;
requestedNonJetsonDevices =
lists.filter (cap: !(builtins.elem cap requestedJetsonDevices))
cudaCapabilities;
jetsonBuildSufficientCondition = requestedJetsonDevices != [];
jetsonBuildNecessaryCondition = requestedNonJetsonDevices == [] && hostPlatform.isAarch64;
requestedJetsonDevices = lists.filter (
cap: cudaComputeCapabilityToIsJetson.${cap} or false
) cudaCapabilities;
requestedNonJetsonDevices = lists.filter (
cap: !(builtins.elem cap requestedJetsonDevices)
) cudaCapabilities;
jetsonBuildSufficientCondition = requestedJetsonDevices != [ ];
jetsonBuildNecessaryCondition = requestedNonJetsonDevices == [ ] && hostPlatform.isAarch64;
in
trivial.throwIf (jetsonBuildSufficientCondition && !jetsonBuildNecessaryCondition)
''
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}.
@@ -228,13 +231,13 @@ let
- 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
'' jetsonBuildSufficientCondition
&& jetsonBuildNecessaryCondition;
};
in
# When changing names or formats: pause, validate, and update the assert
assert let
assert
let
expected = {
cudaCapabilities = [
"7.5"
@@ -276,15 +279,16 @@ assert let
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg ((strings.versionAtLeast cudaVersion "11.2") -> (expected == actualWrapped)) ''
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
assert
let
expected = false;
actual = formatCapabilities {
cudaCapabilities = [
@@ -293,15 +297,16 @@ assert let
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg (expected == actualWrapped) ''
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
assert
let
expected = {
cudaCapabilities = [
"6.2"
@@ -343,8 +348,8 @@ assert let
];
};
actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;
in
asserts.assertMsg
in
asserts.assertMsg
# We can't do this test unless we're targeting aarch64
(hostPlatform.isAarch64 -> (expected == actualWrapped))
''
@@ -376,6 +381,6 @@ asserts.assertMsg
;
}
// formatCapabilities {
cudaCapabilities = if cudaCapabilities == [] then defaultCapabilities else cudaCapabilities;
cudaCapabilities = if cudaCapabilities == [ ] then defaultCapabilities else cudaCapabilities;
enableForwardCompat = cudaForwardCompat;
}

39
pkgs/development/cuda-modules/generic-builders/manifest.nix
View File

@@ -50,8 +50,7 @@ let
sourceMatchesHost = flags.getNixSystem redistArch == stdenv.hostPlatform.system;
in
backendStdenv.mkDerivation (
finalAttrs: {
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
@@ -74,14 +73,11 @@ backendStdenv.mkDerivation (
# Checks whether the redistributable provides an output.
hasOutput =
output:
attrsets.attrByPath
[
attrsets.attrByPath [
redistArch
"outputs"
output
]
false
featureRelease;
] false featureRelease;
# Order is important here so we use a list.
possibleOutputs = [
"bin"
@@ -101,9 +97,7 @@ backendStdenv.mkDerivation (
# recall that OfBorg will evaluate packages marked as broken and that `cudaPackages` will be evaluated with
# `cudaSupport = false`!
additionalOutputs =
if redistArch == "unsupported"
then possibleOutputs
else builtins.filter hasOutput possibleOutputs;
if redistArch == "unsupported" then possibleOutputs else builtins.filter hasOutput possibleOutputs;
# The out output is special -- it's the default output and we always include it.
outputs = [ "out" ] ++ additionalOutputs;
in
@@ -122,9 +116,9 @@ backendStdenv.mkDerivation (
"lib"
"lib64"
];
static = ["**/*.a"];
sample = ["samples"];
python = ["**/*.whl"];
static = [ "**/*.a" ];
sample = [ "samples" ];
python = [ "**/*.whl" ];
};
# Useful for introspecting why something went wrong. Maps descriptions of why the derivation would be marked as
@@ -187,7 +181,8 @@ backendStdenv.mkDerivation (
# We do need some other phases, like configurePhase, so the multiple-output setup hook works.
dontBuild = true;
nativeBuildInputs = [
nativeBuildInputs =
[
autoPatchelfHook
# This hook will make sure libcuda can be found
# in typically /lib/opengl-driver by adding that
@@ -205,8 +200,7 @@ backendStdenv.mkDerivation (
autoAddCudaCompatRunpath
];
buildInputs =
[
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
@@ -216,7 +210,7 @@ backendStdenv.mkDerivation (
# Picked up by autoPatchelf
# Needed e.g. for libnvrtc to locate (dlopen) libnvrtc-builtins
appendRunpaths = ["$ORIGIN"];
appendRunpaths = [ "$ORIGIN" ];
# NOTE: We don't need to check for dev or doc, because those outputs are handled by
# the multiple-outputs setup hook.
@@ -228,7 +222,7 @@ backendStdenv.mkDerivation (
output:
let
template = pattern: ''moveToOutput "${pattern}" "${"$" + output}"'';
patterns = finalAttrs.outputToPatterns.${output} or [];
patterns = finalAttrs.outputToPatterns.${output} or [ ];
in
strings.concatMapStringsSep "\n" template patterns;
in
@@ -292,7 +286,7 @@ backendStdenv.mkDerivation (
# 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"];
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.
@@ -323,7 +317,7 @@ backendStdenv.mkDerivation (
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];
sourceProvenance = [ sourceTypes.binaryNativeCode ];
broken = lists.any trivial.id (attrsets.attrValues finalAttrs.brokenConditions);
platforms = trivial.pipe supportedRedistArchs [
# Map each redist arch to the equivalent nix system or null if there is no equivalent.
@@ -340,7 +334,6 @@ backendStdenv.mkDerivation (
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"];
outputsToInstall = [ "out" ];
};
}
)
})

18
pkgs/development/cuda-modules/generic-builders/multiplex.nix
View File

@@ -52,7 +52,9 @@ let
# - Package: ../modules/${pname}/releases/package.nix
# FIXME: do this at the module system level
propagatePlatforms = lib.mapAttrs (redistArch: packages: map (p: { inherit redistArch; } // p) packages);
propagatePlatforms = lib.mapAttrs (
redistArch: packages: map (p: { inherit redistArch; } // p) packages
);
# All releases across all platforms
# See ../modules/${pname}/releases/releases.nix
@@ -61,7 +63,7 @@ let
# 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;
computeName = { version, ... }: mkVersionedPackageName pname version;
# Check whether a package supports our CUDA version and platform.
# isSupported :: Package -> Bool
@@ -81,8 +83,7 @@ let
# All the supported packages we can build for our platform.
# perSystemReleases :: List Package
allReleases = lib.pipe releaseSets
[
allReleases = lib.pipe releaseSets [
(lib.attrValues)
(lists.flatten)
(lib.groupBy (p: lib.versions.majorMinor p.version))
@@ -115,7 +116,10 @@ let
buildPackage =
package:
let
shims = final.callPackage shimsFn {inherit package; inherit (package) redistArch; };
shims = final.callPackage shimsFn {
inherit package;
inherit (package) redistArch;
};
name = computeName package;
drv = final.callPackage ./manifest.nix {
inherit pname;
@@ -129,7 +133,9 @@ let
# versionedDerivations :: AttrSet Derivation
versionedDerivations = builtins.listToAttrs (lists.map buildPackage allReleases);
defaultDerivation = { ${pname} = (buildPackage newest).value; };
defaultDerivation = {
${pname} = (buildPackage newest).value;
};
in
versionedDerivations // defaultDerivation;
in

5
pkgs/development/cuda-modules/modules/cuda/default.nix
View File

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

2
pkgs/development/cuda-modules/modules/cudnn/default.nix
View File

@@ -1,4 +1,4 @@
{options, ...}:
{ options, ... }:
{
options.cudnn.releases = options.generic.releases;
# TODO(@connorbaker): Figure out how to add additional options to the

5
pkgs/development/cuda-modules/modules/cutensor/default.nix
View File

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

6
pkgs/development/cuda-modules/modules/generic/manifests/default.nix
View File

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

4
pkgs/development/cuda-modules/modules/generic/manifests/feature/manifest.nix
View File

@@ -1,7 +1,7 @@
{lib, config, ...}:
{ lib, config, ... }:
let
inherit (lib) options trivial types;
Release = import ./release.nix {inherit lib config;};
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";

2
pkgs/development/cuda-modules/modules/generic/manifests/feature/outputs.nix
View File

@@ -1,4 +1,4 @@
{lib, ...}:
{ lib, ... }:
let
inherit (lib) options types;
in

8
pkgs/development/cuda-modules/modules/generic/manifests/feature/package.nix
View File

@@ -1,10 +1,10 @@
{lib, ...}:
{ lib, ... }:
let
inherit (lib) options types;
Outputs = import ./outputs.nix {inherit lib;};
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;};
example = (import ./release.nix { inherit lib; }).linux-x86_64;
type = types.submodule { options.outputs = Outputs; };
}

6
pkgs/development/cuda-modules/modules/generic/manifests/feature/release.nix
View File

@@ -1,10 +1,10 @@
{lib, config, ...}:
{ lib, config, ... }:
let
inherit (lib) options types;
Package = import ./package.nix {inherit lib config;};
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;
example = (import ./manifest.nix { inherit lib; }).cuda_cccl;
type = types.attrsOf Package.type;
}

4
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/manifest.nix
View File

@@ -1,7 +1,7 @@
{lib, ...}:
{ lib, ... }:
let
inherit (lib) options trivial types;
Release = import ./release.nix {inherit lib;};
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";

4
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/package.nix
View File

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

6
pkgs/development/cuda-modules/modules/generic/manifests/redistrib/release.nix
View File

@@ -1,11 +1,11 @@
{lib, ...}:
{ lib, ... }:
let
inherit (lib) options types;
Package = import ./package.nix {inherit lib;};
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;
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;

2
pkgs/development/cuda-modules/modules/generic/releases/default.nix
View File

@@ -1,4 +1,4 @@
{lib, config, ...}:
{ lib, config, ... }:
let
inherit (config.generic.types) majorMinorVersion majorMinorPatchBuildVersion;
inherit (lib) options types;

4
pkgs/development/cuda-modules/modules/generic/types/default.nix
View File

@@ -1,11 +1,11 @@
{lib, ...}:
{ lib, ... }:
let
inherit (lib) options types;
in
{
options.generic.types = options.mkOption {
type = types.attrsOf types.optionType;
default = {};
default = { };
description = "A set of generic types.";
};
config.generic.types = {

2
pkgs/development/cuda-modules/modules/tensorrt/default.nix
View File

@@ -1,4 +1,4 @@
{options, ...}:
{ options, ... }:
{
options.tensorrt.releases = options.generic.releases;
# TODO(@connorbaker): Figure out how to add additional options to the

28
pkgs/development/cuda-modules/nccl-tests/default.nix
View File

@@ -22,8 +22,7 @@ let
nccl
;
in
backendStdenv.mkDerivation (
finalAttrs: {
backendStdenv.mkDerivation (finalAttrs: {
pname = "nccl-tests";
version = "2.13.9";
@@ -38,13 +37,13 @@ backendStdenv.mkDerivation (
strictDeps = true;
nativeBuildInputs =
[which]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [cuda_nvcc];
[ which ]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [ cudatoolkit ]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [ cuda_nvcc ];
buildInputs =
[nccl]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
[ nccl ]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [ cudatoolkit ]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [
cuda_nvcc.dev # crt/host_config.h
cuda_cudart
@@ -52,13 +51,13 @@ backendStdenv.mkDerivation (
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [
cuda_cccl.dev # <nv/target>
]
++ lib.optionals mpiSupport [mpi];
++ lib.optionals mpiSupport [ mpi ];
makeFlags =
["NCCL_HOME=${nccl}"]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") ["CUDA_HOME=${cudatoolkit}"]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") ["CUDA_HOME=${cuda_nvcc}"]
++ lib.optionals mpiSupport ["MPI=1"];
[ "NCCL_HOME=${nccl}" ]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [ "CUDA_HOME=${cudatoolkit}" ]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [ "CUDA_HOME=${cuda_nvcc}" ]
++ lib.optionals mpiSupport [ "MPI=1" ];
enableParallelBuilding = true;
@@ -78,7 +77,6 @@ backendStdenv.mkDerivation (
platforms = platforms.linux;
license = licenses.bsd3;
broken = !config.cudaSupport || (mpiSupport && mpi == null);
maintainers = with maintainers; [jmillerpdt] ++ teams.cuda.members;
maintainers = with maintainers; [ jmillerpdt ] ++ teams.cuda.members;
};
}
)
})

18
pkgs/development/cuda-modules/nccl/default.nix
View File

@@ -22,8 +22,7 @@ let
cudaVersion
;
in
backendStdenv.mkDerivation (
finalAttrs: {
backendStdenv.mkDerivation (finalAttrs: {
pname = "nccl";
version = "2.20.5-1";
@@ -47,11 +46,11 @@ backendStdenv.mkDerivation (
autoAddDriverRunpath
python3
]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [cuda_nvcc];
++ 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.versionOlder cudaVersion "11.4") [ cudatoolkit ]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [
cuda_nvcc.dev # crt/host_config.h
cuda_cudart
@@ -60,9 +59,9 @@ backendStdenv.mkDerivation (
# against other version, like below, it's important that we use the same format. Otherwise,
# we'll get incorrect results.
# For example, lib.versionAtLeast "12.0" "12.0.0" == false.
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [cuda_cccl];
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [ cuda_cccl ];
env.NIX_CFLAGS_COMPILE = toString ["-Wno-unused-function"];
env.NIX_CFLAGS_COMPILE = toString [ "-Wno-unused-function" ];
preConfigure = ''
patchShebangs ./src/device/generate.py
@@ -72,7 +71,7 @@ backendStdenv.mkDerivation (
'';
makeFlags =
["PREFIX=$(out)"]
[ "PREFIX=$(out)" ]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [
"CUDA_HOME=${cudatoolkit}"
"CUDA_LIB=${lib.getLib cudatoolkit}/lib"
@@ -111,5 +110,4 @@ backendStdenv.mkDerivation (
]
++ teams.cuda.members;
};
}
)
})

8
pkgs/development/cuda-modules/saxpy/default.nix
View File

@@ -31,18 +31,18 @@ backendStdenv.mkDerivation {
cmake
autoAddDriverRunpath
]
++ lib.optionals (lib.versionOlder cudaVersion "11.4") [cudatoolkit]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [cuda_nvcc];
++ 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.versionOlder cudaVersion "11.4") [ cudatoolkit ]
++ lib.optionals (lib.versionAtLeast cudaVersion "11.4") [
(getDev libcublas)
(getLib libcublas)
(getOutput "static" libcublas)
cuda_cudart
]
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [cuda_cccl];
++ lib.optionals (lib.versionAtLeast cudaVersion "12.0") [ cuda_cccl ];
cmakeFlags = [
(lib.cmakeBool "CMAKE_VERBOSE_MAKEFILE" true)

82
pkgs/development/cuda-modules/setup-hooks/extension.nix
View File

@@ -2,35 +2,22 @@ final: _: {
# Helper hook used in both autoAddCudaCompatRunpath and
# autoAddDriverRunpath that applies a generic patching action to all elf
# files with a dynamic linking section.
autoFixElfFiles =
final.callPackage
(
{makeSetupHook}:
makeSetupHook
{
name = "auto-fix-elf-files";
}
./auto-fix-elf-files.sh
)
{};
autoFixElfFiles = final.callPackage (
{ makeSetupHook }: makeSetupHook { name = "auto-fix-elf-files"; } ./auto-fix-elf-files.sh
) { };
# 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
)
{};
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
{
setupCudaHook = (
final.callPackage (
{ makeSetupHook, backendStdenv }:
makeSetupHook {
name = "setup-cuda-hook";
substitutions.setupCudaHook = placeholder "out";
@@ -41,24 +28,24 @@ final: _: {
# 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
)
{}
} ./setup-cuda-hook.sh
) { }
);
autoAddDriverRunpath =
final.callPackage
(
{addDriverRunpath, autoFixElfFiles, makeSetupHook}:
makeSetupHook
autoAddDriverRunpath = final.callPackage (
{
addDriverRunpath,
autoFixElfFiles,
makeSetupHook,
}:
makeSetupHook {
name = "auto-add-opengl-runpath-hook";
propagatedBuildInputs = [addDriverRunpath autoFixElfFiles];
}
./auto-add-driver-runpath-hook.sh
)
{};
propagatedBuildInputs = [
addDriverRunpath
autoFixElfFiles
];
} ./auto-add-driver-runpath-hook.sh
) { };
# Deprecated: an alias kept for compatibility. Consider removing after 24.11
autoAddOpenGLRunpathHook = final.autoAddDriverRunpath;
@@ -68,14 +55,15 @@ final: _: {
# patched elf files, but `cuda_compat` path must take precedence (otherwise,
# it doesn't have any effect) and thus appear first. Meaning this hook must be
# executed last.
autoAddCudaCompatRunpath =
final.callPackage
(
{makeSetupHook, autoFixElfFiles, cuda_compat ? null }:
makeSetupHook
autoAddCudaCompatRunpath = final.callPackage (
{
makeSetupHook,
autoFixElfFiles,
cuda_compat ? null,
}:
makeSetupHook {
name = "auto-add-cuda-compat-runpath-hook";
propagatedBuildInputs = [autoFixElfFiles];
propagatedBuildInputs = [ autoFixElfFiles ];
substitutions = {
# Hotfix Ofborg evaluation
@@ -87,8 +75,6 @@ final: _: {
# Pre-cuda_compat CUDA release:
meta.badPlatforms = final.lib.optionals (cuda_compat == null) final.lib.platforms.all;
meta.platforms = cuda_compat.meta.platforms or [ ];
}
./auto-add-cuda-compat-runpath.sh
)
{};
} ./auto-add-cuda-compat-runpath.sh
) { };
}

2
pkgs/development/cuda-modules/tensorrt/fixup.nix
View File

@@ -108,6 +108,6 @@ finalAttrs: prevAttrs: {
prevAttrs.meta.badPlatforms or [ ]
++ lib.optionals (targetArch == "unsupported") [ hostPlatform.system ];
homepage = "https://developer.nvidia.com/tensorrt";
maintainers = prevAttrs.meta.maintainers ++ [maintainers.aidalgol];
maintainers = prevAttrs.meta.maintainers ++ [ maintainers.aidalgol ];
};
}

4
pkgs/development/cuda-modules/tensorrt/releases.nix
View File

@@ -3,9 +3,9 @@
{
tensorrt.releases = {
# jetson
linux-aarch64 = [];
linux-aarch64 = [ ];
# powerpc
linux-ppc64le = [];
linux-ppc64le = [ ];
# server-grade arm
linux-sbsa = [
{

39
pkgs/top-level/cuda-packages.nix
View File

@@ -40,11 +40,8 @@ let
# Backbone
gpus = builtins.import ../development/cuda-modules/gpus.nix;
nvccCompatibilities = builtins.import ../development/cuda-modules/nvcc-compatibilities.nix;
flags = callPackage ../development/cuda-modules/flags.nix {inherit cudaVersion gpus;};
passthruFunction =
final:
(
{
flags = callPackage ../development/cuda-modules/flags.nix { inherit cudaVersion gpus; };
passthruFunction = final: ({
inherit cudaVersion lib pkgs;
inherit gpus nvccCompatibilities flags;
cudaMajorVersion = versions.major cudaVersion;
@@ -69,27 +66,27 @@ let
# when linked with other C++ libraries.
# E.g. for cudaPackages_11_8 we use gcc11 with gcc12's libstdc++
# Cf. https://github.com/NixOS/nixpkgs/pull/218265 for context
backendStdenv = final.callPackage ../development/cuda-modules/backend-stdenv.nix {};
backendStdenv = final.callPackage ../development/cuda-modules/backend-stdenv.nix { };
# Loose packages
cudatoolkit = final.callPackage ../development/cuda-modules/cudatoolkit {};
saxpy = final.callPackage ../development/cuda-modules/saxpy {};
nccl = final.callPackage ../development/cuda-modules/nccl {};
nccl-tests = final.callPackage ../development/cuda-modules/nccl-tests {};
}
);
cudatoolkit = final.callPackage ../development/cuda-modules/cudatoolkit { };
saxpy = final.callPackage ../development/cuda-modules/saxpy { };
nccl = final.callPackage ../development/cuda-modules/nccl { };
nccl-tests = final.callPackage ../development/cuda-modules/nccl-tests { };
});
mkVersionedPackageName =
name: version:
strings.concatStringsSep "_" [
name
(strings.replaceStrings ["."] ["_"] (versions.majorMinor version))
(strings.replaceStrings [ "." ] [ "_" ] (versions.majorMinor version))
];
composedExtension = fixedPoints.composeManyExtensions ([
composedExtension = fixedPoints.composeManyExtensions (
[
(import ../development/cuda-modules/setup-hooks/extension.nix)
(callPackage ../development/cuda-modules/cuda/extension.nix {inherit cudaVersion;})
(callPackage ../development/cuda-modules/cuda/overrides.nix {inherit cudaVersion;})
(callPackage ../development/cuda-modules/cuda/extension.nix { inherit cudaVersion; })
(callPackage ../development/cuda-modules/cuda/overrides.nix { inherit cudaVersion; })
(callPackage ../development/cuda-modules/generic-builders/multiplex.nix {
inherit cudaVersion flags mkVersionedPackageName;
pname = "cudnn";
@@ -107,11 +104,11 @@ let
shimsFn = ../development/cuda-modules/tensorrt/shims.nix;
fixupFn = ../development/cuda-modules/tensorrt/fixup.nix;
})
(callPackage ../development/cuda-modules/cuda-samples/extension.nix {inherit cudaVersion;})
(callPackage ../development/cuda-modules/cuda-library-samples/extension.nix {})
] ++ lib.optionals config.allowAliases [
(import ../development/cuda-modules/aliases.nix)
]);
(callPackage ../development/cuda-modules/cuda-samples/extension.nix { inherit cudaVersion; })
(callPackage ../development/cuda-modules/cuda-library-samples/extension.nix { })
]
++ lib.optionals config.allowAliases [ (import ../development/cuda-modules/aliases.nix) ]
);
cudaPackages = customisation.makeScope newScope (
fixedPoints.extends composedExtension passthruFunction