commit c5dad2886a5623fc5e41054ab9ed9ff8e5f7ac91 · pyrox.dev/nixpkgs

+2 -2

doc/languages-frameworks/cuda.section.md

···

       115
       115
        
       

     

       116
       116
        
       ### Updating supported compilers and GPUs {#updating-supported-compilers-and-gpus}

     

       117
       117
        
       

     

       118
       118
       -
       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.

     

       119
       119
       -
       2. Update `gpus.nix` in `pkgs/development/cuda-modules/` to include any new GPUs supported by the new release of CUDA.

     

       118
       118
       +
       1. Update `nvccCompatibilities` in `pkgs/development/cuda-modules/lib/data/nvcc.nix` to include the newest release of NVCC, as well as any newly supported host compilers.

     

       119
       119
       +
       2. Update `cudaCapabilityToInfo` in `pkgs/development/cuda-modules/lib/data/cuda.nix` to include any new GPUs supported by the new release of CUDA.

     

       120
       120
        
       

     

       121
       121
        
       ### Updating the CUDA Toolkit runfile installer {#updating-the-cuda-toolkit}

     

       122
       122

-3

pkgs/development/cuda-modules/README.md

···

       16
       16
        
       

     

       17
       17
        
       - `backend-stdenv.nix`: Standard environment for CUDA packages.

     

       18
       18
        
       - `flags.nix`: Flags set, or consumed by, NVCC in order to build packages.

     

       19
       19
       -
       - `gpus.nix`: A list of supported NVIDIA GPUs.

     

       20
       20
       -
       - `nvcc-compatibilities.nix`: NVCC releases and the version range of GCC/Clang

     

       21
       21
       -
           they support.

     

       22
       19
        
       

     

       23
       20
        
       ## Top-level directories

     

       24
       21

+3 -2

pkgs/development/cuda-modules/aliases.nix

···

       1
       1
        
       # Packages which have been deprecated or removed from cudaPackages

     

       2
       2
       -
       final: _:

     

       2
       2
       +
       { lib }:

     

       3
       3
        
       let

     

       4
       4
        
         mkRenamed =

     

       5
       5
        
           oldName:

     

       6
       6
        
           { path, package }:

     

       7
       7
       -
           final.lib.warn "cudaPackages.${oldName} is deprecated, use ${path} instead" package;

     

       7
       7
       +
           lib.warn "cudaPackages.${oldName} is deprecated, use ${path} instead" package;

     

       8
       8
        
       in

     

       9
       9
       +
       final: _:

     

       9
       10
        
       builtins.mapAttrs mkRenamed {

     

       10
       11
        
         # A comment to prevent empty { } from collapsing into a single line

     

       11
       12

+1 -1

pkgs/development/cuda-modules/cuda/extension.nix

···

       43
       43
        
         };

     

       44
       44
        
       

     

       45
       45
        
         # Generally we prefer to do things involving getting attribute names with feature_manifest instead

     

       46
       46
       -
         # of redistrib_manifest because the feature manifest will have *only* the redist architecture

     

       46
       46
       +
         # of redistrib_manifest because the feature manifest will have *only* the redist system

     

       47
       47
        
         # names as the keys, whereas the redistrib manifest will also have things like version, name, license,

     

       48
       48
        
         # and license_path.

     

       49
       49
        
         featureManifest = evaluatedModules.config.cuda.manifests.feature;

+3 -3

pkgs/development/cuda-modules/cudnn/shims.nix

···

       1
       1
        
       # Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix

     

       2
       2
        
       {

     

       3
       3
        
         package,

     

       4
       4
       -
         # redistArch :: String

     

       4
       4
       +
         # redistSystem :: String

     

       5
       5
        
         # String is "unsupported" if the given architecture is unsupported.

     

       6
       6
       -
         redistArch,

     

       6
       6
       +
         redistSystem,

     

       7
       7
        
       }:

     

       8
       8
        
       {

     

       9
       9
        
         featureRelease = {

     

       10
       10
        
           inherit (package) minCudaVersion maxCudaVersion;

     

       11
       11
       -
           ${redistArch}.outputs = {

     

       11
       11
       +
           ${redistSystem}.outputs = {

     

       12
       12
        
             lib = true;

     

       13
       13
        
             static = true;

     

       14
       14
        
             dev = true;

+5 -13

pkgs/development/cuda-modules/cusparselt/extension.nix

···

       1
       1
        
       # Support matrix can be found at

     

       2
       2
        
       # https://docs.nvidia.com/deeplearning/cudnn/archives/cudnn-880/support-matrix/index.html

     

       3
       3
        
       {

     

       4
       4
       +
         cudaLib,

     

       4
       5
        
         lib,

     

       5
       5
       -
         stdenv,

     

       6
       6
       -
         cudaMajorMinorVersion,

     

       7
       7
       -
         flags,

     

       8
       8
       -
         mkVersionedPackageName,

     

       6
       6
       +
         redistSystem,

     

       9
       7
        
       }:

     

       10
       8
        
       let

     

       11
       9
        
         inherit (lib)

     
···

       14
       12
        
           modules

     

       15
       13
        
           trivial

     

       16
       14
        
           ;

     

       17
       17
       -
       

     

       18
       18
       -
         inherit (stdenv) hostPlatform;

     

       19
       15
        
       

     

       20
       16
        
         redistName = "cusparselt";

     

       21
       17
        
         pname = "libcusparse_lt";

     
···

       54
       50
        
             releaseGrabber

     

       55
       51
        
           ]) cusparseltVersions;

     

       56
       52
        
       

     

       57
       57
       -
         # A release is supported if it has a libPath that matches our CUDA version for our platform.

     

       58
       58
       -
         # LibPath are not constant across the same release -- one platform may support fewer

     

       59
       59
       -
         # CUDA versions than another.

     

       60
       60
       -
         # redistArch :: String

     

       61
       61
       -
         redistArch = flags.getRedistArch hostPlatform.system;

     

       62
       53
        
         # platformIsSupported :: Manifests -> Boolean

     

       63
       54
        
         platformIsSupported =

     

       64
       55
        
           { feature, redistrib, ... }:

     

       65
       56
        
           (attrsets.attrByPath [

     

       66
       57
        
             pname

     

       67
       67
       -
             redistArch

     

       58
       58
       +
             redistSystem

     

       68
       59
        
           ] null feature) != null;

     

       69
       60
        
       

     

       70
       61
        
         # TODO(@connorbaker): With an auxiliary file keeping track of the CUDA versions each release supports,

     
···

       77
       68
        
         # Compute versioned attribute name to be used in this package set

     

       78
       69
        
         # Patch version changes should not break the build, so we only use major and minor

     

       79
       70
        
         # computeName :: RedistribRelease -> String

     

       80
       80
       -
         computeName = { version, ... }: mkVersionedPackageName redistName version;

     

       71
       71
       +
         computeName =

     

       72
       72
       +
           { version, ... }: cudaLib.utils.mkVersionedName redistName (lib.versions.majorMinor version);

     

       81
       73
        
       in

     

       82
       74
        
       final: _:

     

       83
       75
        
       let

+5 -9

pkgs/development/cuda-modules/cutensor/extension.nix

···

       13
       13
        
       # - Instead of providing different releases for each version of CUDA, CuTensor has multiple subdirectories in `lib`

     

       14
       14
        
       #   -- one for each version of CUDA.

     

       15
       15
        
       {

     

       16
       16
       +
         cudaLib,

     

       16
       17
        
         cudaMajorMinorVersion,

     

       17
       17
       -
         flags,

     

       18
       18
        
         lib,

     

       19
       19
       -
         mkVersionedPackageName,

     

       20
       20
       -
         stdenv,

     

       19
       19
       +
         redistSystem,

     

       21
       20
        
       }:

     

       22
       21
        
       let

     

       23
       22
        
         inherit (lib)

     
···

       27
       26
        
           versions

     

       28
       27
        
           trivial

     

       29
       28
        
           ;

     

       30
       30
       -
       

     

       31
       31
       -
         inherit (stdenv) hostPlatform;

     

       32
       29
        
       

     

       33
       30
        
         redistName = "cutensor";

     

       34
       31
        
         pname = "libcutensor";

     
···

       92
       89
        
         # A release is supported if it has a libPath that matches our CUDA version for our platform.

     

       93
       90
        
         # LibPath are not constant across the same release -- one platform may support fewer

     

       94
       91
        
         # CUDA versions than another.

     

       95
       95
       -
         # redistArch :: String

     

       96
       96
       -
         redistArch = flags.getRedistArch hostPlatform.system;

     

       97
       92
        
         # platformIsSupported :: Manifests -> Boolean

     

       98
       93
        
         platformIsSupported =

     

       99
       94
        
           { feature, redistrib, ... }:

     

       100
       95
        
           (attrsets.attrByPath [

     

       101
       96
        
             pname

     

       102
       102
       -
             redistArch

     

       97
       97
       +
             redistSystem

     

       103
       98
        
           ] null feature) != null;

     

       104
       99
        
       

     

       105
       100
        
         # TODO(@connorbaker): With an auxiliary file keeping track of the CUDA versions each release supports,

     
···

       112
       107
        
         # Compute versioned attribute name to be used in this package set

     

       113
       108
        
         # Patch version changes should not break the build, so we only use major and minor

     

       114
       109
        
         # computeName :: RedistribRelease -> String

     

       115
       115
       -
         computeName = { version, ... }: mkVersionedPackageName redistName version;

     

       110
       110
       +
         computeName =

     

       111
       111
       +
           { version, ... }: cudaLib.utils.mkVersionedName redistName (lib.versions.majorMinor version);

     

       116
       112
        
       in

     

       117
       113
        
       final: _:

     

       118
       114
        
       let

+4 -2

pkgs/development/cuda-modules/fixups/tensorrt.nix

···

       1
       1
        
       {

     

       2
       2
       +
         cudaLib,

     

       2
       3
        
         cudaOlder,

     

       3
       4
        
         cudaPackages,

     

       4
       5
        
         cudaMajorMinorVersion,

     

       5
       6
        
         lib,

     

       6
       6
       -
         mkVersionedPackageName,

     

       7
       7
        
         patchelf,

     

       8
       8
        
         requireFile,

     

       9
       9
        
         stdenv,

     
···

       103
       103
        
           # unless it is not available, in which case the default cudnn derivation will be used.

     

       104
       104
        
           cudnn =

     

       105
       105
        
             let

     

       106
       106
       -
               desiredName = mkVersionedPackageName "cudnn" finalAttrs.passthru.featureRelease.cudnnVersion;

     

       106
       106
       +
               desiredName = cudaLib.utils.mkVersionedName "cudnn" (

     

       107
       107
       +
                 lib.versions.majorMinor finalAttrs.passthru.featureRelease.cudnnVersion

     

       108
       108
       +
               );

     

       107
       109
        
             in

     

       108
       110
        
             if finalAttrs.passthru.featureRelease.cudnnVersion == null || (cudaPackages ? desiredName) then

     

       109
       111
        
               cudaPackages.cudnn

-399

pkgs/development/cuda-modules/flags.nix

···

       1
       1
       -
       # Type aliases

     

       2
       2
       -
       # Gpu :: AttrSet

     

       3
       3
       -
       #   - See the documentation in ./gpus.nix.

     

       4
       4
       -
       {

     

       5
       5
       -
         config,

     

       6
       6
       -
         cudaCapabilities ? (config.cudaCapabilities or [ ]),

     

       7
       7
       -
         cudaForwardCompat ? (config.cudaForwardCompat or true),

     

       8
       8
       -
         lib,

     

       9
       9
       -
         cudaMajorMinorVersion,

     

       10
       10
       -
         stdenv,

     

       11
       11
       -
         # gpus :: List Gpu

     

       12
       12
       -
         gpus,

     

       13
       13
       -
       }:

     

       14
       14
       -
       let

     

       15
       15
       -
         inherit (lib)

     

       16
       16
       -
           asserts

     

       17
       17
       -
           attrsets

     

       18
       18
       -
           lists

     

       19
       19
       -
           strings

     

       20
       20
       -
           trivial

     

       21
       21
       -
           ;

     

       22
       22
       -
       

     

       23
       23
       -
         inherit (stdenv) hostPlatform;

     

       24
       24
       -
       

     

       25
       25
       -
         # Flags are determined based on your CUDA toolkit by default.  You may benefit

     

       26
       26
       -
         # from improved performance, reduced file size, or greater hardware support by

     

       27
       27
       -
         # passing a configuration based on your specific GPU environment.

     

       28
       28
       -
         #

     

       29
       29
       -
         # cudaCapabilities :: List Capability

     

       30
       30
       -
         # List of hardware generations to build.

     

       31
       31
       -
         # E.g. [ "8.0" ]

     

       32
       32
       -
         # Currently, the last item is considered the optional forward-compatibility arch,

     

       33
       33
       -
         # but this may change in the future.

     

       34
       34
       -
         #

     

       35
       35
       -
         # cudaForwardCompat :: Bool

     

       36
       36
       -
         # Whether to include the forward compatibility gencode (+PTX)

     

       37
       37
       -
         # to support future GPU generations.

     

       38
       38
       -
         # E.g. true

     

       39
       39
       -
         #

     

       40
       40
       -
         # Please see the accompanying documentation or https://github.com/NixOS/nixpkgs/pull/205351

     

       41
       41
       -
       

     

       42
       42
       -
         # isSupported :: Gpu -> Bool

     

       43
       43
       -
         isSupported =

     

       44
       44
       -
           gpu:

     

       45
       45
       -
           let

     

       46
       46
       -
             inherit (gpu) minCudaVersion maxCudaVersion;

     

       47
       47
       -
             lowerBoundSatisfied = strings.versionAtLeast cudaMajorMinorVersion minCudaVersion;

     

       48
       48
       -
             upperBoundSatisfied =

     

       49
       49
       -
               (maxCudaVersion == null) || !(strings.versionOlder maxCudaVersion cudaMajorMinorVersion);

     

       50
       50
       -
           in

     

       51
       51
       -
           lowerBoundSatisfied && upperBoundSatisfied;

     

       52
       52
       -
       

     

       53
       53
       -
         # NOTE: Jetson is never built by default.

     

       54
       54
       -
         # isDefault :: Gpu -> Bool

     

       55
       55
       -
         isDefault =

     

       56
       56
       -
           gpu:

     

       57
       57
       -
           let

     

       58
       58
       -
             inherit (gpu) dontDefaultAfter isJetson;

     

       59
       59
       -
             newGpu = dontDefaultAfter == null;

     

       60
       60
       -
             recentGpu = newGpu || strings.versionAtLeast dontDefaultAfter cudaMajorMinorVersion;

     

       61
       61
       -
           in

     

       62
       62
       -
           recentGpu && !isJetson;

     

       63
       63
       -
       

     

       64
       64
       -
         # supportedGpus :: List Gpu

     

       65
       65
       -
         # GPUs which are supported by the provided CUDA version.

     

       66
       66
       -
         supportedGpus = builtins.filter isSupported gpus;

     

       67
       67
       -
       

     

       68
       68
       -
         # defaultGpus :: List Gpu

     

       69
       69
       -
         # GPUs which are supported by the provided CUDA version and we want to build for by default.

     

       70
       70
       -
         defaultGpus = builtins.filter isDefault supportedGpus;

     

       71
       71
       -
       

     

       72
       72
       -
         # supportedCapabilities :: List Capability

     

       73
       73
       -
         supportedCapabilities = lists.map (gpu: gpu.computeCapability) supportedGpus;

     

       74
       74
       -
       

     

       75
       75
       -
         # defaultCapabilities :: List Capability

     

       76
       76
       -
         # The default capabilities to target, if not overridden by the user.

     

       77
       77
       -
         defaultCapabilities = lists.map (gpu: gpu.computeCapability) defaultGpus;

     

       78
       78
       -
       

     

       79
       79
       -
         # cudaArchNameToVersions :: AttrSet String (List String)

     

       80
       80
       -
         # Maps the name of a GPU architecture to different versions of that architecture.

     

       81
       81
       -
         # For example, "Ampere" maps to [ "8.0" "8.6" "8.7" ].

     

       82
       82
       -
         cudaArchNameToVersions = lists.groupBy' (versions: gpu: versions ++ [ gpu.computeCapability ]) [ ] (

     

       83
       83
       -
           gpu: gpu.archName

     

       84
       84
       -
         ) supportedGpus;

     

       85
       85
       -
       

     

       86
       86
       -
         # cudaComputeCapabilityToName :: AttrSet String String

     

       87
       87
       -
         # Maps the version of a GPU architecture to the name of that architecture.

     

       88
       88
       -
         # For example, "8.0" maps to "Ampere".

     

       89
       89
       -
         cudaComputeCapabilityToName = builtins.listToAttrs (

     

       90
       90
       -
           lists.map (gpu: attrsets.nameValuePair gpu.computeCapability gpu.archName) supportedGpus

     

       91
       91
       -
         );

     

       92
       92
       -
       

     

       93
       93
       -
         # cudaComputeCapabilityToIsJetson :: AttrSet String Boolean

     

       94
       94
       -
         cudaComputeCapabilityToIsJetson = builtins.listToAttrs (

     

       95
       95
       -
           lists.map (attrs: attrsets.nameValuePair attrs.computeCapability attrs.isJetson) supportedGpus

     

       96
       96
       -
         );

     

       97
       97
       -
       

     

       98
       98
       -
         # jetsonComputeCapabilities :: List String

     

       99
       99
       -
         jetsonComputeCapabilities = trivial.pipe cudaComputeCapabilityToIsJetson [

     

       100
       100
       -
           (attrsets.filterAttrs (_: isJetson: isJetson))

     

       101
       101
       -
           builtins.attrNames

     

       102
       102
       -
         ];

     

       103
       103
       -
       

     

       104
       104
       -
         # Find the intersection with the user-specified list of cudaCapabilities.

     

       105
       105
       -
         # NOTE: Jetson devices are never built by default because they cannot be targeted along with

     

       106
       106
       -
         # non-Jetson devices and require an aarch64 host platform. As such, if they're present anywhere,

     

       107
       107
       -
         # they must be in the user-specified cudaCapabilities.

     

       108
       108
       -
         # NOTE: We don't need to worry about mixes of Jetson and non-Jetson devices here -- there's

     

       109
       109
       -
         # sanity-checking for all that in below.

     

       110
       110
       -
         jetsonTargets = lists.intersectLists jetsonComputeCapabilities cudaCapabilities;

     

       111
       111
       -
       

     

       112
       112
       -
         # dropDot :: String -> String

     

       113
       113
       -
         dropDot = ver: builtins.replaceStrings [ "." ] [ "" ] ver;

     

       114
       114
       -
       

     

       115
       115
       -
         # archMapper :: String -> List String -> List String

     

       116
       116
       -
         # Maps a feature across a list of architecture versions to produce a list of architectures.

     

       117
       117
       -
         # For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "sm_80" "sm_86" "sm_87" ].

     

       118
       118
       -
         archMapper = feat: lists.map (computeCapability: "${feat}_${dropDot computeCapability}");

     

       119
       119
       -
       

     

       120
       120
       -
         # gencodeMapper :: String -> List String -> List String

     

       121
       121
       -
         # Maps a feature across a list of architecture versions to produce a list of gencode arguments.

     

       122
       122
       -
         # For example, "sm" and [ "8.0" "8.6" "8.7" ] produces [ "-gencode=arch=compute_80,code=sm_80"

     

       123
       123
       -
         # "-gencode=arch=compute_86,code=sm_86" "-gencode=arch=compute_87,code=sm_87" ].

     

       124
       124
       -
         gencodeMapper =

     

       125
       125
       -
           feat:

     

       126
       126
       -
           lists.map (

     

       127
       127
       -
             computeCapability:

     

       128
       128
       -
             "-gencode=arch=compute_${dropDot computeCapability},code=${feat}_${dropDot computeCapability}"

     

       129
       129
       -
           );

     

       130
       130
       -
       

     

       131
       131
       -
         # Maps Nix system to NVIDIA redist arch.

     

       132
       132
       -
         # NOTE: We swap out the default `linux-sbsa` redist (for server-grade ARM chips) with the

     

       133
       133
       -
         # `linux-aarch64` redist (which is for Jetson devices) if we're building any Jetson devices.

     

       134
       134
       -
         # Since both are based on aarch64, we can only have one or the other, otherwise there's an

     

       135
       135
       -
         # ambiguity as to which should be used.

     

       136
       136
       -
         # NOTE: This function *will* be called by unsupported systems because `cudaPackages` is part of

     

       137
       137
       -
         # `all-packages.nix`, which is evaluated on all systems. As such, we need to handle unsupported

     

       138
       138
       -
         # systems gracefully.

     

       139
       139
       -
         # getRedistArch :: String -> String

     

       140
       140
       -
         getRedistArch =

     

       141
       141
       -
           nixSystem:

     

       142
       142
       -
           attrsets.attrByPath [ nixSystem ] "unsupported" {

     

       143
       143
       -
             aarch64-linux = if jetsonTargets != [ ] then "linux-aarch64" else "linux-sbsa";

     

       144
       144
       -
             x86_64-linux = "linux-x86_64";

     

       145
       145
       -
             ppc64le-linux = "linux-ppc64le";

     

       146
       146
       -
             x86_64-windows = "windows-x86_64";

     

       147
       147
       -
           };

     

       148
       148
       -
       

     

       149
       149
       -
         # Maps NVIDIA redist arch to Nix system.

     

       150
       150
       -
         # NOTE: This function *will* be called by unsupported systems because `cudaPackages` is part of

     

       151
       151
       -
         # `all-packages.nix`, which is evaluated on all systems. As such, we need to handle unsupported

     

       152
       152
       -
         # systems gracefully.

     

       153
       153
       -
         # getNixSystem :: String -> String

     

       154
       154
       -
         getNixSystem =

     

       155
       155
       -
           redistArch:

     

       156
       156
       -
           attrsets.attrByPath [ redistArch ] "unsupported-${redistArch}" {

     

       157
       157
       -
             linux-sbsa = "aarch64-linux";

     

       158
       158
       -
             linux-aarch64 = "aarch64-linux";

     

       159
       159
       -
             linux-x86_64 = "x86_64-linux";

     

       160
       160
       -
             linux-ppc64le = "ppc64le-linux";

     

       161
       161
       -
             windows-x86_64 = "x86_64-windows";

     

       162
       162
       -
           };

     

       163
       163
       -
       

     

       164
       164
       -
         formatCapabilities =

     

       165
       165
       -
           {

     

       166
       166
       -
             cudaCapabilities,

     

       167
       167
       -
             enableForwardCompat ? true,

     

       168
       168
       -
           }:

     

       169
       169
       -
           rec {

     

       170
       170
       -
             inherit cudaCapabilities enableForwardCompat;

     

       171
       171
       -
       

     

       172
       172
       -
             # archNames :: List String

     

       173
       173
       -
             # E.g. [ "Turing" "Ampere" ]

     

       174
       174
       -
             #

     

       175
       175
       -
             # Unknown architectures are rendered as sm_XX gencode flags.

     

       176
       176
       -
             archNames = lists.unique (

     

       177
       177
       -
               lists.map (cap: cudaComputeCapabilityToName.${cap} or "sm_${dropDot cap}") cudaCapabilities

     

       178
       178
       -
             );

     

       179
       179
       -
       

     

       180
       180
       -
             # realArches :: List String

     

       181
       181
       -
             # The real architectures are physical architectures supported by the CUDA version.

     

       182
       182
       -
             # E.g. [ "sm_75" "sm_86" ]

     

       183
       183
       -
             realArches = archMapper "sm" cudaCapabilities;

     

       184
       184
       -
       

     

       185
       185
       -
             # virtualArches :: List String

     

       186
       186
       -
             # The virtual architectures are typically used for forward compatibility, when trying to support

     

       187
       187
       -
             # an architecture newer than the CUDA version allows.

     

       188
       188
       -
             # E.g. [ "compute_75" "compute_86" ]

     

       189
       189
       -
             virtualArches = archMapper "compute" cudaCapabilities;

     

       190
       190
       -
       

     

       191
       191
       -
             # arches :: List String

     

       192
       192
       -
             # By default, build for all supported architectures and forward compatibility via a virtual

     

       193
       193
       -
             # architecture for the newest supported architecture.

     

       194
       194
       -
             # E.g. [ "sm_75" "sm_86" "compute_86" ]

     

       195
       195
       -
             arches = realArches ++ lists.optional enableForwardCompat (lists.last virtualArches);

     

       196
       196
       -
       

     

       197
       197
       -
             # gencode :: List String

     

       198
       198
       -
             # A list of CUDA gencode arguments to pass to NVCC.

     

       199
       199
       -
             # E.g. [ "-gencode=arch=compute_75,code=sm_75" ... "-gencode=arch=compute_86,code=compute_86" ]

     

       200
       200
       -
             gencode =

     

       201
       201
       -
               let

     

       202
       202
       -
                 base = gencodeMapper "sm" cudaCapabilities;

     

       203
       203
       -
                 forward = gencodeMapper "compute" [ (lists.last cudaCapabilities) ];

     

       204
       204
       -
               in

     

       205
       205
       -
               base ++ lib.optionals enableForwardCompat forward;

     

       206
       206
       -
       

     

       207
       207
       -
             # gencodeString :: String

     

       208
       208
       -
             # A space-separated string of CUDA gencode arguments to pass to NVCC.

     

       209
       209
       -
             # E.g. "-gencode=arch=compute_75,code=sm_75 ... -gencode=arch=compute_86,code=compute_86"

     

       210
       210
       -
             gencodeString = strings.concatStringsSep " " gencode;

     

       211
       211
       -
       

     

       212
       212
       -
             # cmakeCudaArchitecturesString :: String

     

       213
       213
       -
             # A semicolon-separated string of CUDA capabilities without dots, suitable for passing to CMake.

     

       214
       214
       -
             # E.g. "75;86"

     

       215
       215
       -
             cmakeCudaArchitecturesString = strings.concatMapStringsSep ";" dropDot cudaCapabilities;

     

       216
       216
       -
       

     

       217
       217
       -
             # Jetson devices cannot be targeted by the same binaries which target non-Jetson devices. While

     

       218
       218
       -
             # NVIDIA provides both `linux-aarch64` and `linux-sbsa` packages, which both target `aarch64`,

     

       219
       219
       -
             # they are built with different settings and cannot be mixed.

     

       220
       220
       -
             # isJetsonBuild :: Boolean

     

       221
       221
       -
             isJetsonBuild =

     

       222
       222
       -
               let

     

       223
       223
       -
                 requestedJetsonDevices = lists.filter (

     

       224
       224
       -
                   cap: cudaComputeCapabilityToIsJetson.${cap} or false

     

       225
       225
       -
                 ) cudaCapabilities;

     

       226
       226
       -
                 requestedNonJetsonDevices = lists.filter (

     

       227
       227
       -
                   cap: !(builtins.elem cap requestedJetsonDevices)

     

       228
       228
       -
                 ) cudaCapabilities;

     

       229
       229
       -
                 jetsonBuildSufficientCondition = requestedJetsonDevices != [ ];

     

       230
       230
       -
                 jetsonBuildNecessaryCondition = requestedNonJetsonDevices == [ ] && hostPlatform.isAarch64;

     

       231
       231
       -
               in

     

       232
       232
       -
               trivial.throwIf (jetsonBuildSufficientCondition && !jetsonBuildNecessaryCondition) ''

     

       233
       233
       -
                 Jetson devices cannot be targeted with non-Jetson devices. Additionally, they require hostPlatform to be aarch64.

     

       234
       234
       -
                 You requested ${builtins.toJSON cudaCapabilities} for host platform ${hostPlatform.system}.

     

       235
       235
       -
                 Requested Jetson devices: ${builtins.toJSON requestedJetsonDevices}.

     

       236
       236
       -
                 Requested non-Jetson devices: ${builtins.toJSON requestedNonJetsonDevices}.

     

       237
       237
       -
                 Exactly one of the following must be true:

     

       238
       238
       -
                 - All CUDA capabilities belong to Jetson devices and hostPlatform is aarch64.

     

       239
       239
       -
                 - No CUDA capabilities belong to Jetson devices.

     

       240
       240
       -
                 See ${./gpus.nix} for a list of architectures supported by this version of Nixpkgs.

     

       241
       241
       -
               '' jetsonBuildSufficientCondition

     

       242
       242
       -
               && jetsonBuildNecessaryCondition;

     

       243
       243
       -
           };

     

       244
       244
       -
       in

     

       245
       245
       -
       # When changing names or formats: pause, validate, and update the assert

     

       246
       246
       -
       assert

     

       247
       247
       -
         let

     

       248
       248
       -
           expected = {

     

       249
       249
       -
             cudaCapabilities = [

     

       250
       250
       -
               "7.5"

     

       251
       251
       -
               "8.6"

     

       252
       252
       -
             ];

     

       253
       253
       -
             enableForwardCompat = true;

     

       254
       254
       -
       

     

       255
       255
       -
             archNames = [

     

       256
       256
       -
               "Turing"

     

       257
       257
       -
               "Ampere"

     

       258
       258
       -
             ];

     

       259
       259
       -
             realArches = [

     

       260
       260
       -
               "sm_75"

     

       261
       261
       -
               "sm_86"

     

       262
       262
       -
             ];

     

       263
       263
       -
             virtualArches = [

     

       264
       264
       -
               "compute_75"

     

       265
       265
       -
               "compute_86"

     

       266
       266
       -
             ];

     

       267
       267
       -
             arches = [

     

       268
       268
       -
               "sm_75"

     

       269
       269
       -
               "sm_86"

     

       270
       270
       -
               "compute_86"

     

       271
       271
       -
             ];

     

       272
       272
       -
       

     

       273
       273
       -
             gencode = [

     

       274
       274
       -
               "-gencode=arch=compute_75,code=sm_75"

     

       275
       275
       -
               "-gencode=arch=compute_86,code=sm_86"

     

       276
       276
       -
               "-gencode=arch=compute_86,code=compute_86"

     

       277
       277
       -
             ];

     

       278
       278
       -
             gencodeString = "-gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_86,code=sm_86 -gencode=arch=compute_86,code=compute_86";

     

       279
       279
       -
       

     

       280
       280
       -
             cmakeCudaArchitecturesString = "75;86";

     

       281
       281
       -
       

     

       282
       282
       -
             isJetsonBuild = false;

     

       283
       283
       -
           };

     

       284
       284
       -
           actual = formatCapabilities {

     

       285
       285
       -
             cudaCapabilities = [

     

       286
       286
       -
               "7.5"

     

       287
       287
       -
               "8.6"

     

       288
       288
       -
             ];

     

       289
       289
       -
           };

     

       290
       290
       -
           actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;

     

       291
       291
       -
         in

     

       292
       292
       -
         asserts.assertMsg

     

       293
       293
       -
           ((strings.versionAtLeast cudaMajorMinorVersion "11.2") -> (expected == actualWrapped))

     

       294
       294
       -
           ''

     

       295
       295
       -
             This test should only fail when using a version of CUDA older than 11.2, the first to support

     

       296
       296
       -
             8.6.

     

       297
       297
       -
             Expected: ${builtins.toJSON expected}

     

       298
       298
       -
             Actual: ${builtins.toJSON actualWrapped}

     

       299
       299
       -
           '';

     

       300
       300
       -
       # Check mixed Jetson and non-Jetson devices

     

       301
       301
       -
       assert

     

       302
       302
       -
         let

     

       303
       303
       -
           expected = false;

     

       304
       304
       -
           actual = formatCapabilities {

     

       305
       305
       -
             cudaCapabilities = [

     

       306
       306
       -
               "7.2"

     

       307
       307
       -
               "7.5"

     

       308
       308
       -
             ];

     

       309
       309
       -
           };

     

       310
       310
       -
           actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;

     

       311
       311
       -
         in

     

       312
       312
       -
         asserts.assertMsg (expected == actualWrapped) ''

     

       313
       313
       -
           Jetson devices capabilities cannot be mixed with non-jetson devices.

     

       314
       314
       -
           Capability 7.5 is non-Jetson and should not be allowed with Jetson 7.2.

     

       315
       315
       -
           Expected: ${builtins.toJSON expected}

     

       316
       316
       -
           Actual: ${builtins.toJSON actualWrapped}

     

       317
       317
       -
         '';

     

       318
       318
       -
       # Check Jetson-only

     

       319
       319
       -
       assert

     

       320
       320
       -
         let

     

       321
       321
       -
           expected = {

     

       322
       322
       -
             cudaCapabilities = [

     

       323
       323
       -
               "6.2"

     

       324
       324
       -
               "7.2"

     

       325
       325
       -
             ];

     

       326
       326
       -
             enableForwardCompat = true;

     

       327
       327
       -
       

     

       328
       328
       -
             archNames = [

     

       329
       329
       -
               "Pascal"

     

       330
       330
       -
               "Volta"

     

       331
       331
       -
             ];

     

       332
       332
       -
             realArches = [

     

       333
       333
       -
               "sm_62"

     

       334
       334
       -
               "sm_72"

     

       335
       335
       -
             ];

     

       336
       336
       -
             virtualArches = [

     

       337
       337
       -
               "compute_62"

     

       338
       338
       -
               "compute_72"

     

       339
       339
       -
             ];

     

       340
       340
       -
             arches = [

     

       341
       341
       -
               "sm_62"

     

       342
       342
       -
               "sm_72"

     

       343
       343
       -
               "compute_72"

     

       344
       344
       -
             ];

     

       345
       345
       -
       

     

       346
       346
       -
             gencode = [

     

       347
       347
       -
               "-gencode=arch=compute_62,code=sm_62"

     

       348
       348
       -
               "-gencode=arch=compute_72,code=sm_72"

     

       349
       349
       -
               "-gencode=arch=compute_72,code=compute_72"

     

       350
       350
       -
             ];

     

       351
       351
       -
             gencodeString = "-gencode=arch=compute_62,code=sm_62 -gencode=arch=compute_72,code=sm_72 -gencode=arch=compute_72,code=compute_72";

     

       352
       352
       -
       

     

       353
       353
       -
             cmakeCudaArchitecturesString = "62;72";

     

       354
       354
       -
       

     

       355
       355
       -
             isJetsonBuild = true;

     

       356
       356
       -
           };

     

       357
       357
       -
           actual = formatCapabilities {

     

       358
       358
       -
             cudaCapabilities = [

     

       359
       359
       -
               "6.2"

     

       360
       360
       -
               "7.2"

     

       361
       361
       -
             ];

     

       362
       362
       -
           };

     

       363
       363
       -
           actualWrapped = (builtins.tryEval (builtins.deepSeq actual actual)).value;

     

       364
       364
       -
         in

     

       365
       365
       -
         asserts.assertMsg

     

       366
       366
       -
           # We can't do this test unless we're targeting aarch64

     

       367
       367
       -
           (hostPlatform.isAarch64 -> (expected == actualWrapped))

     

       368
       368
       -
           ''

     

       369
       369
       -
             Jetson devices can only be built with other Jetson devices.

     

       370
       370
       -
             Both 6.2 and 7.2 are Jetson devices.

     

       371
       371
       -
             Expected: ${builtins.toJSON expected}

     

       372
       372
       -
             Actual: ${builtins.toJSON actualWrapped}

     

       373
       373
       -
           '';

     

       374
       374
       -
       {

     

       375
       375
       -
         # formatCapabilities :: { cudaCapabilities: List Capability, enableForwardCompat: Boolean } ->  { ... }

     

       376
       376
       -
         inherit formatCapabilities;

     

       377
       377
       -
       

     

       378
       378
       -
         # cudaArchNameToVersions :: String => String

     

       379
       379
       -
         inherit cudaArchNameToVersions;

     

       380
       380
       -
       

     

       381
       381
       -
         # cudaComputeCapabilityToName :: String => String

     

       382
       382
       -
         inherit cudaComputeCapabilityToName;

     

       383
       383
       -
       

     

       384
       384
       -
         # dropDot :: String -> String

     

       385
       385
       -
         inherit dropDot;

     

       386
       386
       -
       

     

       387
       387
       -
         inherit

     

       388
       388
       -
           defaultCapabilities

     

       389
       389
       -
           supportedCapabilities

     

       390
       390
       -
           jetsonComputeCapabilities

     

       391
       391
       -
           jetsonTargets

     

       392
       392
       -
           getNixSystem

     

       393
       393
       -
           getRedistArch

     

       394
       394
       -
           ;

     

       395
       395
       -
       }

     

       396
       396
       -
       // formatCapabilities {

     

       397
       397
       -
         cudaCapabilities = if cudaCapabilities == [ ] then defaultCapabilities else cudaCapabilities;

     

       398
       398
       -
         enableForwardCompat = cudaForwardCompat;

     

       399
       399
       -
       }

+23 -17

pkgs/development/cuda-modules/generic-builders/manifest.nix

···

       5
       5
        
         autoPatchelfHook,

     

       6
       6
        
         backendStdenv,

     

       7
       7
        
         callPackage,

     

       8
       8
       +
         cudaLib,

     

       8
       9
        
         fetchurl,

     

       9
       10
        
         fixups,

     

       10
       11
        
         lib,

     
···

       47
       48
        
         maybeFixup = fixups.${pname} or null;

     

       48
       49
        
         fixup = if maybeFixup != null then callPackage maybeFixup { } else { };

     

       49
       50
        
       

     

       50
       50
       -
         # Get the redist architectures for which package provides distributables.

     

       51
       51
       +
         # Get the redist systems for which package provides distributables.

     

       51
       52
        
         # These are used by meta.platforms.

     

       52
       52
       -
         supportedRedistArchs = builtins.attrNames featureRelease;

     

       53
       53
       -
         # redistArch :: String

     

       54
       54
       -
         # The redistArch is the name of the architecture for which the redistributable is built.

     

       55
       55
       -
         # It is `"unsupported"` if the redistributable is not supported on the target platform.

     

       56
       56
       -
         redistArch = flags.getRedistArch hostPlatform.system;

     

       53
       53
       +
         supportedRedistSystems = builtins.attrNames featureRelease;

     

       54
       54
       +
         # redistSystem :: String

     

       55
       55
       +
         # The redistSystem is the name of the system for which the redistributable is built.

     

       56
       56
       +
         # It is `"unsupported"` if the redistributable is not supported on the target system.

     

       57
       57
       +
         redistSystem = cudaLib.utils.getRedistSystem backendStdenv.hasJetsonCudaCapability hostPlatform.system;

     

       57
       58
        
       

     

       58
       58
       -
         sourceMatchesHost = flags.getNixSystem redistArch == hostPlatform.system;

     

       59
       59
       +
         sourceMatchesHost = lib.elem hostPlatform.system (cudaLib.utils.getNixSystems redistSystem);

     

       59
       60
        
       in

     

       60
       61
        
       (backendStdenv.mkDerivation (finalAttrs: {

     

       61
       62
        
         # NOTE: Even though there's no actual buildPhase going on here, the derivations of the

     
···

       81
       82
        
             hasOutput =

     

       82
       83
        
               output:

     

       83
       84
        
               attrsets.attrByPath [

     

       84
       84
       -
                 redistArch

     

       85
       85
       +
                 redistSystem

     

       85
       86
        
                 "outputs"

     

       86
       87
        
                 output

     

       87
       88
        
               ] false featureRelease;

     
···

       99
       100
        
             # NOTE: In the case the redistributable isn't supported on the target platform,

     

       100
       101
        
             # we will have `outputs = [ "out" ] ++ possibleOutputs`. This is of note because platforms which

     

       101
       102
        
             # aren't supported would otherwise have evaluation errors when trying to access outputs other than `out`.

     

       102
       102
       -
             # The alternative would be to have `outputs = [ "out" ]` when`redistArch = "unsupported"`, but that would

     

       103
       103
       +
             # The alternative would be to have `outputs = [ "out" ]` when`redistSystem = "unsupported"`, but that would

     

       103
       104
        
             # require adding guards throughout the entirety of the CUDA package set to ensure `cudaSupport` is true --

     

       104
       105
        
             # recall that OfBorg will evaluate packages marked as broken and that `cudaPackages` will be evaluated with

     

       105
       106
        
             # `cudaSupport = false`!

     

       106
       107
        
             additionalOutputs =

     

       107
       107
       -
               if redistArch == "unsupported" then possibleOutputs else builtins.filter hasOutput possibleOutputs;

     

       108
       108
       +
               if redistSystem == "unsupported" then

     

       109
       109
       +
                 possibleOutputs

     

       110
       110
       +
               else

     

       111
       111
       +
                 builtins.filter hasOutput possibleOutputs;

     

       108
       112
        
             # The out output is special -- it's the default output and we always include it.

     

       109
       113
        
             outputs = [ "out" ] ++ additionalOutputs;

     

       110
       114
        
           in

     
···

       155
       159
        
         };

     

       156
       160
        
       

     

       157
       161
        
         # src :: Optional Derivation

     

       158
       158
       -
         # If redistArch doesn't exist in redistribRelease, return null.

     

       162
       162
       +
         # If redistSystem doesn't exist in redistribRelease, return null.

     

       159
       163
        
         src = trivial.mapNullable (

     

       160
       164
        
           { relative_path, sha256, ... }:

     

       161
       165
        
           fetchurl {

     

       162
       166
        
             url = "https://developer.download.nvidia.com/compute/${redistName}/redist/${relative_path}";

     

       163
       167
        
             inherit sha256;

     

       164
       168
        
           }

     

       165
       165
       -
         ) (redistribRelease.${redistArch} or null);

     

       169
       169
       +
         ) (redistribRelease.${redistSystem} or null);

     

       166
       170
        
       

     

       167
       171
        
         postPatch =

     

       168
       172
        
           # Pkg-config's setup hook expects configuration files in $out/share/pkgconfig

     
···

       321
       325
        
           description = "${redistribRelease.name}. By downloading and using the packages you accept the terms and conditions of the ${finalAttrs.meta.license.shortName}";

     

       322
       326
        
           sourceProvenance = [ sourceTypes.binaryNativeCode ];

     

       323
       327
        
           broken = lists.any trivial.id (attrsets.attrValues finalAttrs.brokenConditions);

     

       324
       324
       -
           platforms = trivial.pipe supportedRedistArchs [

     

       325
       325
       -
             # Map each redist arch to the equivalent nix system or null if there is no equivalent.

     

       326
       326
       -
             (builtins.map flags.getNixSystem)

     

       327
       327
       -
             # Filter out unsupported systems

     

       328
       328
       -
             (builtins.filter (nixSystem: !(strings.hasPrefix "unsupported-" nixSystem)))

     

       328
       328
       +
           platforms = trivial.pipe supportedRedistSystems [

     

       329
       329
       +
             # Map each redist system to the equivalent nix systems.

     

       330
       330
       +
             (lib.concatMap cudaLib.utils.getNixSystems)

     

       331
       331
       +
             # Take all the unique values.

     

       332
       332
       +
             lib.unique

     

       333
       333
       +
             # Sort the list.

     

       334
       334
       +
             lib.naturalSort

     

       329
       335
        
           ];

     

       330
       336
        
           badPlatforms =

     

       331
       337
        
             let

+8 -13

pkgs/development/cuda-modules/generic-builders/multiplex.nix

···

       1
       1
        
       {

     

       2
       2
       -
         # callPackage-provided arguments

     

       3
       2
        
         lib,

     

       3
       3
       +
         cudaLib,

     

       4
       4
        
         cudaMajorMinorVersion,

     

       5
       5
       -
         flags,

     

       5
       5
       +
         redistSystem,

     

       6
       6
        
         stdenv,

     

       7
       7
       -
         # Expected to be passed by the caller

     

       8
       8
       -
         mkVersionedPackageName,

     

       9
       7
        
         # Builder-specific arguments

     

       10
       8
        
         # Short package name (e.g., "cuda_cccl")

     

       11
       9
        
         # pname : String

     
···

       26
       24
        
         # The featureRelease is used to populate meta.platforms (by way of looking at the attribute names), determine the

     

       27
       25
        
         # outputs of the package, and provide additional package-specific constraints (e.g., min/max supported CUDA versions,

     

       28
       26
        
         # required versions of other packages, etc.).

     

       29
       29
       -
         # shimFn :: {package, redistArch} -> AttrSet

     

       27
       27
       +
         # shimFn :: {package, redistSystem} -> AttrSet

     

       30
       28
        
         shimsFn ? (throw "shimsFn must be provided"),

     

       31
       29
        
       }:

     

       32
       30
        
       let

     
···

       41
       39
        
         # - Releases: ../modules/${pname}/releases/releases.nix

     

       42
       40
        
         # - Package: ../modules/${pname}/releases/package.nix

     

       43
       41
        
       

     

       44
       44
       -
         # redistArch :: String

     

       45
       45
       -
         # Value is `"unsupported"` if the platform is not supported.

     

       46
       46
       -
         redistArch = flags.getRedistArch stdenv.hostPlatform.system;

     

       47
       47
       -
       

     

       48
       42
        
         # Check whether a package supports our CUDA version.

     

       49
       43
        
         # satisfiesCudaVersion :: Package -> Bool

     

       50
       44
        
         satisfiesCudaVersion =

     
···

       53
       47
        
           && lib.versionAtLeast package.maxCudaVersion cudaMajorMinorVersion;

     

       54
       48
        
       

     

       55
       49
        
         # FIXME: do this at the module system level

     

       56
       56
       -
         propagatePlatforms = lib.mapAttrs (redistArch: lib.map (p: { inherit redistArch; } // p));

     

       50
       50
       +
         propagatePlatforms = lib.mapAttrs (redistSystem: lib.map (p: { inherit redistSystem; } // p));

     

       57
       51
        
       

     

       58
       52
        
         # Releases for all platforms and all CUDA versions.

     

       59
       53
        
         allReleases = propagatePlatforms evaluatedModules.config.${pname}.releases;

     
···

       65
       59
        
         allPackages = lib.concatLists (lib.attrValues allReleases');

     

       66
       60
        
       

     

       67
       61
        
         packageOlder = p1: p2: lib.versionOlder p1.version p2.version;

     

       68
       68
       -
         packageSupportedPlatform = p: p.redistArch == redistArch;

     

       62
       62
       +
         packageSupportedPlatform = p: p.redistSystem == redistSystem;

     

       69
       63
        
       

     

       70
       64
        
         # Compute versioned attribute name to be used in this package set

     

       71
       65
        
         # Patch version changes should not break the build, so we only use major and minor

     

       72
       66
        
         # computeName :: Package -> String

     

       73
       73
       -
         computeName = package: mkVersionedPackageName pname package.version;

     

       67
       67
       +
         computeName =

     

       68
       68
       +
           { version, ... }: cudaLib.utils.mkVersionedName pname (lib.versions.majorMinor version);

     

       74
       69
        
       

     

       75
       70
        
         # The newest package for each major-minor version, with newest first.

     

       76
       71
        
         # newestPackages :: List Package

     
···

       113
       108
        
             buildPackage =

     

       114
       109
        
               package:

     

       115
       110
        
               let

     

       116
       116
       -
                 shims = final.callPackage shimsFn { inherit package redistArch; };

     

       111
       111
       +
                 shims = final.callPackage shimsFn { inherit package redistSystem; };

     

       117
       112
        
                 name = computeName package;

     

       118
       113
        
                 drv = final.callPackage ./manifest.nix {

     

       119
       114
        
                   inherit pname redistName;

-244

pkgs/development/cuda-modules/gpus.nix

···

       1
       1
       -
       # Type aliases

     

       2
       2
       -
       #

     

       3
       3
       -
       # Gpu = {

     

       4
       4
       -
       #   archName: String

     

       5
       5
       -
       #     - The name of the microarchitecture.

     

       6
       6
       -
       #   computeCapability: String

     

       7
       7
       -
       #     - The compute capability of the GPU.

     

       8
       8
       -
       #   isJetson: Boolean

     

       9
       9
       -
       #     - Whether a GPU is part of NVIDIA's line of Jetson embedded computers. This field is

     

       10
       10
       -
       #       notable because it tells us what architecture to build for (as Jetson devices are

     

       11
       11
       -
       #       aarch64).

     

       12
       12
       -
       #       More on Jetson devices here:

     

       13
       13
       -
       #       https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/

     

       14
       14
       -
       #       NOTE: These architectures are only built upon request.

     

       15
       15
       -
       #   minCudaVersion: String

     

       16
       16
       -
       #     - The minimum (inclusive) CUDA version that supports this GPU.

     

       17
       17
       -
       #   dontDefaultAfter: null | String

     

       18
       18
       -
       #     - The CUDA version after which to exclude this GPU from the list of default capabilities

     

       19
       19
       -
       #       we build. null means we always include this GPU in the default capabilities if it is

     

       20
       20
       -
       #       supported.

     

       21
       21
       -
       #   maxCudaVersion: null | String

     

       22
       22
       -
       #     - The maximum (exclusive) CUDA version that supports this GPU. null means there is no

     

       23
       23
       -
       #       maximum.

     

       24
       24
       -
       # }

     

       25
       25
       -
       #

     

       26
       26
       -
       # Many thanks to Arnon Shimoni for maintaining a list of these architectures and capabilities.

     

       27
       27
       -
       # Without your work, this would have been much more difficult.

     

       28
       28
       -
       # https://arnon.dk/matching-sm-architectures-arch-and-gencode-for-various-nvidia-cards/

     

       29
       29
       -
       #

     

       30
       30
       -
       # https://en.wikipedia.org/wiki/CUDA#GPUs_supported

     

       31
       31
       -
       

     

       32
       32
       -
       [

     

       33
       33
       -
         {

     

       34
       34
       -
           # Tesla K40

     

       35
       35
       -
           archName = "Kepler";

     

       36
       36
       -
           computeCapability = "3.5";

     

       37
       37
       -
           isJetson = false;

     

       38
       38
       -
           minCudaVersion = "10.0";

     

       39
       39
       -
           dontDefaultAfter = "11.0";

     

       40
       40
       -
           maxCudaVersion = "11.8";

     

       41
       41
       -
         }

     

       42
       42
       -
         {

     

       43
       43
       -
           # Tesla K80

     

       44
       44
       -
           archName = "Kepler";

     

       45
       45
       -
           computeCapability = "3.7";

     

       46
       46
       -
           isJetson = false;

     

       47
       47
       -
           minCudaVersion = "10.0";

     

       48
       48
       -
           dontDefaultAfter = "11.0";

     

       49
       49
       -
           maxCudaVersion = "11.8";

     

       50
       50
       -
         }

     

       51
       51
       -
         {

     

       52
       52
       -
           # Tesla/Quadro M series

     

       53
       53
       -
           archName = "Maxwell";

     

       54
       54
       -
           computeCapability = "5.0";

     

       55
       55
       -
           isJetson = false;

     

       56
       56
       -
           minCudaVersion = "10.0";

     

       57
       57
       -
           dontDefaultAfter = "11.0";

     

       58
       58
       -
           maxCudaVersion = null;

     

       59
       59
       -
         }

     

       60
       60
       -
         {

     

       61
       61
       -
           # Quadro M6000, GeForce 900, GTX-970, GTX-980, GTX Titan X

     

       62
       62
       -
           archName = "Maxwell";

     

       63
       63
       -
           computeCapability = "5.2";

     

       64
       64
       -
           isJetson = false;

     

       65
       65
       -
           minCudaVersion = "10.0";

     

       66
       66
       -
           dontDefaultAfter = "11.0";

     

       67
       67
       -
           maxCudaVersion = null;

     

       68
       68
       -
         }

     

       69
       69
       -
         {

     

       70
       70
       -
           # Tegra (Jetson) TX1 / Tegra X1, Drive CX, Drive PX, Jetson Nano

     

       71
       71
       -
           archName = "Maxwell";

     

       72
       72
       -
           computeCapability = "5.3";

     

       73
       73
       -
           isJetson = true;

     

       74
       74
       -
           minCudaVersion = "10.0";

     

       75
       75
       -
           dontDefaultAfter = null;

     

       76
       76
       -
           maxCudaVersion = null;

     

       77
       77
       -
         }

     

       78
       78
       -
         {

     

       79
       79
       -
           # Quadro GP100, Tesla P100, DGX-1 (Generic Pascal)

     

       80
       80
       -
           archName = "Pascal";

     

       81
       81
       -
           computeCapability = "6.0";

     

       82
       82
       -
           isJetson = false;

     

       83
       83
       -
           minCudaVersion = "10.0";

     

       84
       84
       -
           dontDefaultAfter = null;

     

       85
       85
       -
           maxCudaVersion = null;

     

       86
       86
       -
         }

     

       87
       87
       -
         {

     

       88
       88
       -
           # GTX 1080, GTX 1070, GTX 1060, GTX 1050, GTX 1030 (GP108), GT 1010 (GP108) Titan Xp, Tesla

     

       89
       89
       -
           # P40, Tesla P4, Discrete GPU on the NVIDIA Drive PX2

     

       90
       90
       -
           archName = "Pascal";

     

       91
       91
       -
           computeCapability = "6.1";

     

       92
       92
       -
           isJetson = false;

     

       93
       93
       -
           minCudaVersion = "10.0";

     

       94
       94
       -
           dontDefaultAfter = null;

     

       95
       95
       -
           maxCudaVersion = null;

     

       96
       96
       -
         }

     

       97
       97
       -
         {

     

       98
       98
       -
           # Integrated GPU on the NVIDIA Drive PX2, Tegra (Jetson) TX2

     

       99
       99
       -
           archName = "Pascal";

     

       100
       100
       -
           computeCapability = "6.2";

     

       101
       101
       -
           isJetson = true;

     

       102
       102
       -
           minCudaVersion = "10.0";

     

       103
       103
       -
           dontDefaultAfter = null;

     

       104
       104
       -
           maxCudaVersion = null;

     

       105
       105
       -
         }

     

       106
       106
       -
         {

     

       107
       107
       -
           # DGX-1 with Volta, Tesla V100, GTX 1180 (GV104), Titan V, Quadro GV100

     

       108
       108
       -
           archName = "Volta";

     

       109
       109
       -
           computeCapability = "7.0";

     

       110
       110
       -
           isJetson = false;

     

       111
       111
       -
           minCudaVersion = "10.0";

     

       112
       112
       -
           dontDefaultAfter = null;

     

       113
       113
       -
           maxCudaVersion = null;

     

       114
       114
       -
         }

     

       115
       115
       -
         {

     

       116
       116
       -
           # Jetson AGX Xavier, Drive AGX Pegasus, Xavier NX

     

       117
       117
       -
           archName = "Volta";

     

       118
       118
       -
           computeCapability = "7.2";

     

       119
       119
       -
           isJetson = true;

     

       120
       120
       -
           minCudaVersion = "10.0";

     

       121
       121
       -
           dontDefaultAfter = null;

     

       122
       122
       -
           maxCudaVersion = null;

     

       123
       123
       -
         }

     

       124
       124
       -
         {

     

       125
       125
       -
           # GTX/RTX Turing – GTX 1660 Ti, RTX 2060, RTX 2070, RTX 2080, Titan RTX, Quadro RTX 4000,

     

       126
       126
       -
           # Quadro RTX 5000, Quadro RTX 6000, Quadro RTX 8000, Quadro T1000/T2000, Tesla T4

     

       127
       127
       -
           archName = "Turing";

     

       128
       128
       -
           computeCapability = "7.5";

     

       129
       129
       -
           isJetson = false;

     

       130
       130
       -
           minCudaVersion = "10.0";

     

       131
       131
       -
           dontDefaultAfter = null;

     

       132
       132
       -
           maxCudaVersion = null;

     

       133
       133
       -
         }

     

       134
       134
       -
         {

     

       135
       135
       -
           # NVIDIA A100 (the name “Tesla” has been dropped – GA100), NVIDIA DGX-A100

     

       136
       136
       -
           archName = "Ampere";

     

       137
       137
       -
           computeCapability = "8.0";

     

       138
       138
       -
           isJetson = false;

     

       139
       139
       -
           minCudaVersion = "11.2";

     

       140
       140
       -
           dontDefaultAfter = null;

     

       141
       141
       -
           maxCudaVersion = null;

     

       142
       142
       -
         }

     

       143
       143
       -
         {

     

       144
       144
       -
           # Tesla GA10x cards, RTX Ampere – RTX 3080, GA102 – RTX 3090, RTX A2000, A3000, RTX A4000,

     

       145
       145
       -
           # A5000, A6000, NVIDIA A40, GA106 – RTX 3060, GA104 – RTX 3070, GA107 – RTX 3050, RTX A10, RTX

     

       146
       146
       -
           # A16, RTX A40, A2 Tensor Core GPU

     

       147
       147
       -
           archName = "Ampere";

     

       148
       148
       -
           computeCapability = "8.6";

     

       149
       149
       -
           isJetson = false;

     

       150
       150
       -
           minCudaVersion = "11.2";

     

       151
       151
       -
           dontDefaultAfter = null;

     

       152
       152
       -
           maxCudaVersion = null;

     

       153
       153
       -
         }

     

       154
       154
       -
         {

     

       155
       155
       -
           # Jetson AGX Orin and Drive AGX Orin only

     

       156
       156
       -
           archName = "Ampere";

     

       157
       157
       -
           computeCapability = "8.7";

     

       158
       158
       -
           isJetson = true;

     

       159
       159
       -
           minCudaVersion = "11.5";

     

       160
       160
       -
           dontDefaultAfter = null;

     

       161
       161
       -
           maxCudaVersion = null;

     

       162
       162
       -
         }

     

       163
       163
       -
         {

     

       164
       164
       -
           # NVIDIA GeForce RTX 4090, RTX 4080, RTX 6000, Tesla L40

     

       165
       165
       -
           archName = "Ada";

     

       166
       166
       -
           computeCapability = "8.9";

     

       167
       167
       -
           isJetson = false;

     

       168
       168
       -
           minCudaVersion = "11.8";

     

       169
       169
       -
           dontDefaultAfter = null;

     

       170
       170
       -
           maxCudaVersion = null;

     

       171
       171
       -
         }

     

       172
       172
       -
         {

     

       173
       173
       -
           # NVIDIA H100 (GH100)

     

       174
       174
       -
           archName = "Hopper";

     

       175
       175
       -
           computeCapability = "9.0";

     

       176
       176
       -
           isJetson = false;

     

       177
       177
       -
           minCudaVersion = "11.8";

     

       178
       178
       -
           dontDefaultAfter = null;

     

       179
       179
       -
           maxCudaVersion = null;

     

       180
       180
       -
         }

     

       181
       181
       -
         {

     

       182
       182
       -
           # NVIDIA H100 (GH100) (Thor)

     

       183
       183
       -
           archName = "Hopper";

     

       184
       184
       -
           computeCapability = "9.0a";

     

       185
       185
       -
           isJetson = false;

     

       186
       186
       -
           minCudaVersion = "12.0";

     

       187
       187
       -
           dontDefaultAfter = null;

     

       188
       188
       -
           maxCudaVersion = null;

     

       189
       189
       -
         }

     

       190
       190
       -
         {

     

       191
       191
       -
           # NVIDIA B100

     

       192
       192
       -
           archName = "Blackwell";

     

       193
       193
       -
           computeCapability = "10.0";

     

       194
       194
       -
           isJetson = false;

     

       195
       195
       -
           minCudaVersion = "12.8";

     

       196
       196
       -
           dontDefaultAfter = null;

     

       197
       197
       -
           maxCudaVersion = null;

     

       198
       198
       -
         }

     

       199
       199
       -
         {

     

       200
       200
       -
           # NVIDIA B100 Accelerated

     

       201
       201
       -
           archName = "Blackwell";

     

       202
       202
       -
           computeCapability = "10.0a";

     

       203
       203
       -
           isJetson = false;

     

       204
       204
       -
           minCudaVersion = "12.8";

     

       205
       205
       -
           dontDefaultAfter = "12.0"; # disable to reduce size of OnnxRuntime and Torch CUDA binaries

     

       206
       206
       -
           maxCudaVersion = null;

     

       207
       207
       -
         }

     

       208
       208
       -
         {

     

       209
       209
       -
           # NVIDIA Blackwell

     

       210
       210
       -
           archName = "Blackwell";

     

       211
       211
       -
           computeCapability = "10.1";

     

       212
       212
       -
           isJetson = false;

     

       213
       213
       -
           minCudaVersion = "12.8";

     

       214
       214
       -
           dontDefaultAfter = "12.0"; # disable to reduce size of OnnxRuntime and Torch CUDA binaries

     

       215
       215
       -
           maxCudaVersion = null;

     

       216
       216
       -
         }

     

       217
       217
       -
         {

     

       218
       218
       -
           # NVIDIA Blackwell Accelerated

     

       219
       219
       -
           archName = "Blackwell";

     

       220
       220
       -
           computeCapability = "10.1a";

     

       221
       221
       -
           isJetson = false;

     

       222
       222
       -
           minCudaVersion = "12.8";

     

       223
       223
       -
           dontDefaultAfter = "12.0"; # disable to reduce size of OnnxRuntime and Torch CUDA binaries

     

       224
       224
       -
           maxCudaVersion = null;

     

       225
       225
       -
         }

     

       226
       226
       -
         {

     

       227
       227
       -
           # NVIDIA GeForce RTX 5090 (GB202), RTX 5080 (GB203), RTX 5070 (GB205)

     

       228
       228
       -
           archName = "Blackwell";

     

       229
       229
       -
           computeCapability = "12.0";

     

       230
       230
       -
           isJetson = false;

     

       231
       231
       -
           minCudaVersion = "12.8";

     

       232
       232
       -
           dontDefaultAfter = null;

     

       233
       233
       -
           maxCudaVersion = null;

     

       234
       234
       -
         }

     

       235
       235
       -
         {

     

       236
       236
       -
           # NVIDIA Blackwell Accelerated

     

       237
       237
       -
           archName = "Blackwell";

     

       238
       238
       -
           computeCapability = "12.0a";

     

       239
       239
       -
           isJetson = false;

     

       240
       240
       -
           minCudaVersion = "12.8";

     

       241
       241
       -
           dontDefaultAfter = "12.0"; # disable to reduce size of OnnxRuntime and Torch CUDA binaries

     

       242
       242
       -
           maxCudaVersion = null;

     

       243
       243
       -
         }

     

       244
       244
       -
       ]

-125

pkgs/development/cuda-modules/nvcc-compatibilities.nix

···

       1
       1
       -
       # Taken from

     

       2
       2
       -
       # https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#host-compiler-support-policy

     

       3
       3
       -
       #

     

       4
       4
       -
       #   NVCC performs a version check on the host compiler’s major version and so newer minor versions

     

       5
       5
       -
       #   of the compilers listed below will be supported, but major versions falling outside the range

     

       6
       6
       -
       #   will not be supported.

     

       7
       7
       -
       #

     

       8
       8
       -
       # NOTE: These constraints don't apply to Jetson, which uses something else.

     

       9
       9
       -
       # NOTE: NVIDIA can and will add support for newer compilers even during patch releases.

     

       10
       10
       -
       # E.g.: CUDA 12.2.1 maxxed out with support for Clang 15.0; 12.2.2 added support for Clang 16.0.

     

       11
       11
       -
       # NOTE: Because all platforms NVIDIA supports use GCC and Clang, we omit the architectures here.

     

       12
       12
       -
       # Type Aliases

     

       13
       13
       -
       # CudaVersion = String (two-part version number, e.g. "11.2")

     

       14
       14
       -
       # Platform = String (e.g. "x86_64-linux")

     

       15
       15
       -
       # CompilerCompatibilities = {

     

       16
       16
       -
       #  clangMaxMajorVersion = String (e.g. "15")

     

       17
       17
       -
       #  clangMinMajorVersion = String (e.g. "7")

     

       18
       18
       -
       #  gccMaxMajorVersion = String (e.g. "11")

     

       19
       19
       -
       #  gccMinMajorVersion = String (e.g. "6")

     

       20
       20
       -
       # }

     

       21
       21
       -
       let

     

       22
       22
       -
         # attrs :: AttrSet CudaVersion CompilerCompatibilities

     

       23
       23
       -
         attrs = {

     

       24
       24
       -
           # Our baseline

     

       25
       25
       -
           # https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features

     

       26
       26
       -
           "11.0" = {

     

       27
       27
       -
             clangMaxMajorVersion = "9";

     

       28
       28
       -
             clangMinMajorVersion = "7";

     

       29
       29
       -
             gccMaxMajorVersion = "9";

     

       30
       30
       -
             gccMinMajorVersion = "6";

     

       31
       31
       -
           };

     

       32
       32
       -
       

     

       33
       33
       -
           # Added support for Clang 10 and GCC 10

     

       34
       34
       -
           # https://docs.nvidia.com/cuda/archive/11.1.1/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features

     

       35
       35
       -
           "11.1" = attrs."11.0" // {

     

       36
       36
       -
             clangMaxMajorVersion = "10";

     

       37
       37
       -
             gccMaxMajorVersion = "10";

     

       38
       38
       -
           };

     

       39
       39
       -
       

     

       40
       40
       -
           # Added support for Clang 11

     

       41
       41
       -
           # https://docs.nvidia.com/cuda/archive/11.2.2/cuda-installation-guide-linux/index.html#system-requirements

     

       42
       42
       -
           "11.2" = attrs."11.1" // {

     

       43
       43
       -
             clangMaxMajorVersion = "11";

     

       44
       44
       -
           };

     

       45
       45
       -
       

     

       46
       46
       -
           # No changes from 11.2 to 11.3

     

       47
       47
       -
           "11.3" = attrs."11.2";

     

       48
       48
       -
       

     

       49
       49
       -
           # Added support for Clang 12 and GCC 11

     

       50
       50
       -
           # https://docs.nvidia.com/cuda/archive/11.4.4/cuda-toolkit-release-notes/index.html#cuda-general-new-features

     

       51
       51
       -
           "11.4" = attrs."11.3" // {

     

       52
       52
       -
             clangMaxMajorVersion = "12";

     

       53
       53
       -
             # NOTE: There is a bug in the version of GLIBC that GCC 11 uses which causes it to fail to compile some CUDA

     

       54
       54
       -
             # code. As such, we skip it for this release, and do the bump in 11.6 (skipping 11.5).

     

       55
       55
       -
             # https://forums.developer.nvidia.com/t/cuda-11-5-samples-throw-multiple-error-attribute-malloc-does-not-take-arguments/192750/15

     

       56
       56
       -
             # gccMaxMajorVersion = "11";

     

       57
       57
       -
           };

     

       58
       58
       -
       

     

       59
       59
       -
           # No changes from 11.4 to 11.5

     

       60
       60
       -
           "11.5" = attrs."11.4";

     

       61
       61
       -
       

     

       62
       62
       -
           # No changes from 11.5 to 11.6

     

       63
       63
       -
           # However, as mentioned above, we add GCC 11 this release.

     

       64
       64
       -
           "11.6" = attrs."11.5" // {

     

       65
       65
       -
             gccMaxMajorVersion = "11";

     

       66
       66
       -
           };

     

       67
       67
       -
       

     

       68
       68
       -
           # Added support for Clang 13

     

       69
       69
       -
           # https://docs.nvidia.com/cuda/archive/11.7.1/cuda-toolkit-release-notes/index.html#cuda-compiler-new-features

     

       70
       70
       -
           "11.7" = attrs."11.6" // {

     

       71
       71
       -
             clangMaxMajorVersion = "13";

     

       72
       72
       -
           };

     

       73
       73
       -
       

     

       74
       74
       -
           # Added support for Clang 14

     

       75
       75
       -
           # https://docs.nvidia.com/cuda/archive/11.8.0/cuda-installation-guide-linux/index.html#system-requirements

     

       76
       76
       -
           "11.8" = attrs."11.7" // {

     

       77
       77
       -
             clangMaxMajorVersion = "14";

     

       78
       78
       -
           };

     

       79
       79
       -
       

     

       80
       80
       -
           # Added support for GCC 12

     

       81
       81
       -
           # https://docs.nvidia.com/cuda/archive/12.0.1/cuda-installation-guide-linux/index.html#system-requirements

     

       82
       82
       -
           "12.0" = attrs."11.8" // {

     

       83
       83
       -
             gccMaxMajorVersion = "12";

     

       84
       84
       -
           };

     

       85
       85
       -
       

     

       86
       86
       -
           # Added support for Clang 15

     

       87
       87
       -
           # https://docs.nvidia.com/cuda/archive/12.1.1/cuda-toolkit-release-notes/index.html#cuda-compilers-new-features

     

       88
       88
       -
           "12.1" = attrs."12.0" // {

     

       89
       89
       -
             clangMaxMajorVersion = "15";

     

       90
       90
       -
           };

     

       91
       91
       -
       

     

       92
       92
       -
           # Added support for Clang 16

     

       93
       93
       -
           # https://docs.nvidia.com/cuda/archive/12.2.2/cuda-installation-guide-linux/index.html#host-compiler-support-policy

     

       94
       94
       -
           "12.2" = attrs."12.1" // {

     

       95
       95
       -
             clangMaxMajorVersion = "16";

     

       96
       96
       -
           };

     

       97
       97
       -
       

     

       98
       98
       -
           # No changes from 12.2 to 12.3

     

       99
       99
       -
           "12.3" = attrs."12.2";

     

       100
       100
       -
       

     

       101
       101
       -
           # Added support for Clang 17 and GCC 13

     

       102
       102
       -
           # https://docs.nvidia.com/cuda/archive/12.4.0/cuda-installation-guide-linux/index.html#host-compiler-support-policy

     

       103
       103
       -
           "12.4" = attrs."12.3" // {

     

       104
       104
       -
             clangMaxMajorVersion = "17";

     

       105
       105
       -
             gccMaxMajorVersion = "13";

     

       106
       106
       -
           };

     

       107
       107
       -
       

     

       108
       108
       -
           # No changes from 12.4 to 12.5

     

       109
       109
       -
           "12.5" = attrs."12.4";

     

       110
       110
       -
       

     

       111
       111
       -
           # Added support for Clang 18

     

       112
       112
       -
           # https://docs.nvidia.com/cuda/archive/12.6.0/cuda-installation-guide-linux/index.html#host-compiler-support-policy

     

       113
       113
       -
           "12.6" = attrs."12.4" // {

     

       114
       114
       -
             clangMaxMajorVersion = "18";

     

       115
       115
       -
           };

     

       116
       116
       -
       

     

       117
       117
       -
           # Added support for Clang 19 and GCC 14

     

       118
       118
       -
           # https://docs.nvidia.com/cuda/archive/12.8.0/cuda-installation-guide-linux/index.html#host-compiler-support-policy

     

       119
       119
       -
           "12.8" = attrs."12.6" // {

     

       120
       120
       -
             clangMaxMajorVersion = "19";

     

       121
       121
       -
             gccMaxMajorVersion = "14";

     

       122
       122
       -
           };

     

       123
       123
       -
         };

     

       124
       124
       -
       in

     

       125
       125
       -
       attrs

+3 -3

pkgs/development/cuda-modules/tensorrt/shims.nix

···

       1
       1
        
       # Shims to mimic the shape of ../modules/generic/manifests/{feature,redistrib}/release.nix

     

       2
       2
        
       {

     

       3
       3
        
         package,

     

       4
       4
       -
         # redistArch :: String

     

       4
       4
       +
         # redistSystem :: String

     

       5
       5
        
         # String is `"unsupported"` if the given architecture is unsupported.

     

       6
       6
       -
         redistArch,

     

       6
       6
       +
         redistSystem,

     

       7
       7
        
       }:

     

       8
       8
        
       {

     

       9
       9
        
         featureRelease = {

     

       10
       10
        
           inherit (package) cudnnVersion minCudaVersion maxCudaVersion;

     

       11
       11
       -
           ${redistArch}.outputs = {

     

       11
       11
       +
           ${redistSystem}.outputs = {

     

       12
       12
        
             bin = true;

     

       13
       13
        
             lib = true;

     

       14
       14
        
             static = true;

+78

pkgs/development/cuda-modules/tests/flags.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         cudaLib,

     

       3
       3
       +
         cudaNamePrefix,

     

       4
       4
       +
         lib,

     

       5
       5
       +
         runCommand,

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         inherit (builtins) deepSeq toJSON tryEval;

     

       9
       9
       +
         inherit (cudaLib.data) cudaCapabilityToInfo;

     

       10
       10
       +
         inherit (cudaLib.utils) formatCapabilities;

     

       11
       11
       +
         inherit (lib.asserts) assertMsg;

     

       12
       12
       +
       in

     

       13
       13
       +
       # When changing names or formats: pause, validate, and update the assert

     

       14
       14
       +
       assert assertMsg (

     

       15
       15
       +
         cudaCapabilityToInfo ? "7.5" && cudaCapabilityToInfo ? "8.6"

     

       16
       16
       +
       ) "The following test requires both 7.5 and 8.6 be known CUDA capabilities";

     

       17
       17
       +
       assert

     

       18
       18
       +
         let

     

       19
       19
       +
           expected = {

     

       20
       20
       +
             cudaCapabilities = [

     

       21
       21
       +
               "7.5"

     

       22
       22
       +
               "8.6"

     

       23
       23
       +
             ];

     

       24
       24
       +
             cudaForwardCompat = true;

     

       25
       25
       +
       

     

       26
       26
       +
             # Sorted alphabetically

     

       27
       27
       +
             archNames = [

     

       28
       28
       +
               "Ampere"

     

       29
       29
       +
               "Turing"

     

       30
       30
       +
             ];

     

       31
       31
       +
       

     

       32
       32
       +
             realArches = [

     

       33
       33
       +
               "sm_75"

     

       34
       34
       +
               "sm_86"

     

       35
       35
       +
             ];

     

       36
       36
       +
       

     

       37
       37
       +
             virtualArches = [

     

       38
       38
       +
               "compute_75"

     

       39
       39
       +
               "compute_86"

     

       40
       40
       +
             ];

     

       41
       41
       +
       

     

       42
       42
       +
             arches = [

     

       43
       43
       +
               "sm_75"

     

       44
       44
       +
               "sm_86"

     

       45
       45
       +
               "compute_86"

     

       46
       46
       +
             ];

     

       47
       47
       +
       

     

       48
       48
       +
             gencode = [

     

       49
       49
       +
               "-gencode=arch=compute_75,code=sm_75"

     

       50
       50
       +
               "-gencode=arch=compute_86,code=sm_86"

     

       51
       51
       +
               "-gencode=arch=compute_86,code=compute_86"

     

       52
       52
       +
             ];

     

       53
       53
       +
       

     

       54
       54
       +
             gencodeString = "-gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_86,code=sm_86 -gencode=arch=compute_86,code=compute_86";

     

       55
       55
       +
       

     

       56
       56
       +
             cmakeCudaArchitecturesString = "75;86";

     

       57
       57
       +
           };

     

       58
       58
       +
           actual = formatCapabilities {

     

       59
       59
       +
             inherit cudaCapabilityToInfo;

     

       60
       60
       +
             cudaCapabilities = [

     

       61
       61
       +
               "7.5"

     

       62
       62
       +
               "8.6"

     

       63
       63
       +
             ];

     

       64
       64
       +
           };

     

       65
       65
       +
           actualWrapped = (tryEval (deepSeq actual actual)).value;

     

       66
       66
       +
         in

     

       67
       67
       +
         assertMsg (expected == actualWrapped) ''

     

       68
       68
       +
           Expected: ${toJSON expected}

     

       69
       69
       +
           Actual: ${toJSON actualWrapped}

     

       70
       70
       +
         '';

     

       71
       71
       +
       runCommand "${cudaNamePrefix}-tests-flags"

     

       72
       72
       +
         {

     

       73
       73
       +
           __structuredAttrs = true;

     

       74
       74
       +
           strictDeps = true;

     

       75
       75
       +
         }

     

       76
       76
       +
         ''

     

       77
       77
       +
           touch "$out"

     

       78
       78
       +
         ''

+49 -33

pkgs/top-level/cuda-packages.nix

···

       22
       22
        
       # I've (@connorbaker) attempted to do that, though I'm unsure of how this will interact with overrides.

     

       23
       23
        
       {

     

       24
       24
        
         config,

     

       25
       25
       +
         cudaLib,

     

       25
       26
        
         cudaMajorMinorVersion,

     

       26
       27
        
         lib,

     

       27
       28
        
         newScope,

     
···

       37
       38
        
           strings

     

       38
       39
        
           versions

     

       39
       40
        
           ;

     

       41
       41
       +
       

     

       40
       42
        
         # MUST be defined outside fix-point (cf. "NAMESET STRICTNESS" above)

     

       41
       43
        
         fixups = import ../development/cuda-modules/fixups { inherit lib; };

     

       42
       42
       -
         gpus = import ../development/cuda-modules/gpus.nix;

     

       43
       43
       -
         nvccCompatibilities = import ../development/cuda-modules/nvcc-compatibilities.nix;

     

       44
       44
       -
         flags = import ../development/cuda-modules/flags.nix {

     

       45
       45
       -
           inherit

     

       46
       46
       -
             config

     

       47
       47
       -
             cudaMajorMinorVersion

     

       48
       48
       -
             gpus

     

       49
       49
       -
             lib

     

       50
       50
       -
             stdenv

     

       51
       51
       -
             ;

     

       52
       52
       -
         };

     

       53
       44
        
       

     

       54
       54
       -
         mkVersionedPackageName =

     

       55
       55
       -
           name: version: name + "_" + strings.replaceStrings [ "." ] [ "_" ] (versions.majorMinor version);

     

       45
       45
       +
         # Since Jetson capabilities are never built by default, we can check if any of them were requested

     

       46
       46
       +
         # through final.config.cudaCapabilities and use that to determine if we should change some manifest versions.

     

       47
       47
       +
         # Copied from backendStdenv.

     

       48
       48
       +
         jetsonCudaCapabilities = lib.filter (

     

       49
       49
       +
           cudaCapability: cudaLib.data.cudaCapabilityToInfo.${cudaCapability}.isJetson

     

       50
       50
       +
         ) cudaLib.data.allSortedCudaCapabilities;

     

       51
       51
       +
         hasJetsonCudaCapability =

     

       52
       52
       +
           lib.intersectLists jetsonCudaCapabilities (config.cudaCapabilities or [ ]) != [ ];

     

       53
       53
       +
         redistSystem = cudaLib.utils.getRedistSystem hasJetsonCudaCapability stdenv.hostPlatform.system;

     

       56
       54
        
       

     

       57
       55
        
         passthruFunction = final: {

     

       56
       56
       +
           # NOTE:

     

       57
       57
       +
           # It is important that cudaLib (and fixups, which will be addressed later) are not part of the package set

     

       58
       58
       +
           # fixed-point.

     

       59
       59
       +
           # As described by @SomeoneSerge:

     

       60
       60
       +
           # > The layering should be: configuration -> (identifies/is part of) cudaPackages -> (is built using) cudaLib.

     

       61
       61
       +
           # > No arrows should point in the reverse directions.

     

       62
       62
       +
           # That is to say that cudaLib should only know about package sets and configurations, because it implements

     

       63
       63
       +
           # functionality for interpreting configurations, resolving them against data, and constructing package sets.

     

       58
       64
        
           inherit

     

       59
       65
        
             cudaMajorMinorVersion

     

       60
       66
        
             fixups

     

       61
       61
       -
             flags

     

       62
       62
       -
             gpus

     

       63
       67
        
             lib

     

       64
       64
       -
             nvccCompatibilities

     

       65
       68
        
             pkgs

     

       66
       69
        
             ;

     

       67
       70
        
       

     
···

       71
       74
        
           cudaOlder = strings.versionOlder cudaMajorMinorVersion;

     

       72
       75
        
           cudaAtLeast = strings.versionAtLeast cudaMajorMinorVersion;

     

       73
       76
        
       

     

       74
       74
       -
           # NOTE: mkVersionedPackageName is an internal, implementation detail and should not be relied on by outside consumers.

     

       75
       75
       -
           # It may be removed in the future.

     

       76
       76
       -
           inherit mkVersionedPackageName;

     

       77
       77
       -
       

     

       78
       77
        
           # Maintain a reference to the final cudaPackages.

     

       79
       78
        
           # Without this, if we use `final.callPackage` and a package accepts `cudaPackages` as an

     

       80
       79
        
           # argument, it's provided with `cudaPackages` from the top-level scope, which is not what we

     
···

       85
       84
        
             __attrsFailEvaluation = true;

     

       86
       85
        
           };

     

       87
       86
        
       

     

       87
       87
       +
           flags =

     

       88
       88
       +
             cudaLib.utils.formatCapabilities {

     

       89
       89
       +
               inherit (final.backendStdenv) cudaCapabilities cudaForwardCompat;

     

       90
       90
       +
               inherit (cudaLib.data) cudaCapabilityToInfo;

     

       91
       91
       +
             }

     

       92
       92
       +
             # TODO(@connorbaker): Enable the corresponding warnings in `../development/cuda-modules/aliases.nix` after some

     

       93
       93
       +
             # time to allow users to migrate to cudaLib and backendStdenv.

     

       94
       94
       +
             // {

     

       95
       95
       +
               inherit (cudaLib.utils) dropDots;

     

       96
       96
       +
               cudaComputeCapabilityToName =

     

       97
       97
       +
                 cudaCapability: cudaLib.data.cudaCapabilityToInfo.${cudaCapability}.archName;

     

       98
       98
       +
               dropDot = cudaLib.utils.dropDots;

     

       99
       99
       +
               isJetsonBuild = final.backendStdenv.hasJetsonCudaCapability;

     

       100
       100
       +
             };

     

       101
       101
       +
       

     

       88
       102
        
           # Loose packages

     

       89
       103
        
           # Barring packages which share a home (e.g., cudatoolkit and cudatoolkit-legacy-runfile), new packages

     

       90
       104
        
           # should be added to ../development/cuda-modules/packages in "by-name" style, where they will be automatically

     
···

       131
       145
        
                   value = final.callPackage ../development/cuda-modules/tests/opencv-and-torch config;

     

       132
       146
        
                 };

     

       133
       147
        
             in

     

       134
       134
       -
             attrsets.listToAttrs (attrsets.mapCartesianProduct builder configs);

     

       148
       148
       +
             attrsets.listToAttrs (attrsets.mapCartesianProduct builder configs)

     

       149
       149
       +
             // {

     

       150
       150
       +
               flags = final.callPackage ../development/cuda-modules/tests/flags.nix { };

     

       151
       151
       +
             };

     

       135
       152
        
         };

     

       136
       153
        
       

     

       137
       154
        
         composedExtension = fixedPoints.composeManyExtensions (

     
···

       146
       163
        
             (import ../development/cuda-modules/cuda/extension.nix { inherit cudaMajorMinorVersion lib; })

     

       147
       164
        
             (import ../development/cuda-modules/generic-builders/multiplex.nix {

     

       148
       165
        
               inherit

     

       166
       166
       +
                 cudaLib

     

       149
       167
        
                 cudaMajorMinorVersion

     

       150
       150
       -
                 flags

     

       151
       168
        
                 lib

     

       152
       152
       -
                 mkVersionedPackageName

     

       169
       169
       +
                 redistSystem

     

       153
       170
        
                 stdenv

     

       154
       171
        
                 ;

     

       155
       172
        
               pname = "cudnn";

     
···

       159
       176
        
             })

     

       160
       177
        
             (import ../development/cuda-modules/cutensor/extension.nix {

     

       161
       178
        
               inherit

     

       179
       179
       +
                 cudaLib

     

       162
       180
        
                 cudaMajorMinorVersion

     

       163
       163
       -
                 flags

     

       164
       181
        
                 lib

     

       165
       165
       -
                 mkVersionedPackageName

     

       166
       166
       -
                 stdenv

     

       182
       182
       +
                 redistSystem

     

       167
       183
        
                 ;

     

       168
       184
        
             })

     

       169
       185
        
             (import ../development/cuda-modules/cusparselt/extension.nix {

     

       170
       186
        
               inherit

     

       171
       171
       -
                 cudaMajorMinorVersion

     

       172
       172
       -
                 flags

     

       187
       187
       +
                 cudaLib

     

       173
       188
        
                 lib

     

       174
       174
       -
                 mkVersionedPackageName

     

       175
       175
       -
                 stdenv

     

       189
       189
       +
                 redistSystem

     

       176
       190
        
                 ;

     

       177
       191
        
             })

     

       178
       192
        
             (import ../development/cuda-modules/generic-builders/multiplex.nix {

     

       179
       193
        
               inherit

     

       194
       194
       +
                 cudaLib

     

       180
       195
        
                 cudaMajorMinorVersion

     

       181
       181
       -
                 flags

     

       182
       196
        
                 lib

     

       183
       183
       -
                 mkVersionedPackageName

     

       197
       197
       +
                 redistSystem

     

       184
       198
        
                 stdenv

     

       185
       199
        
                 ;

     

       186
       200
        
               pname = "tensorrt";

     
···

       193
       207
        
             })

     

       194
       208
        
             (import ../development/cuda-modules/cuda-library-samples/extension.nix { inherit lib stdenv; })

     

       195
       209
        
           ]

     

       196
       196
       -
           ++ lib.optionals config.allowAliases [ (import ../development/cuda-modules/aliases.nix) ]

     

       210
       210
       +
           ++ lib.optionals config.allowAliases [

     

       211
       211
       +
             (import ../development/cuda-modules/aliases.nix { inherit lib; })

     

       212
       212
       +
           ]

     

       197
       213
        
         );

     

       198
       214
        
       

     

       199
       215
        
         cudaPackages = customisation.makeScope newScope (

+2 -15

pkgs/top-level/release-cuda.nix

···

       14
       14
        
       

     

       15
       15
        
       let

     

       16
       16
        
         lib = import ../../lib;

     

       17
       17
       -
         ensureList = x: if builtins.isList x then x else [ x ];

     

       18
       18
       -
         allowUnfreePredicate =

     

       19
       19
       -
           p:

     

       20
       20
       -
           builtins.all (

     

       21
       21
       -
             license:

     

       22
       22
       -
             license.free

     

       23
       23
       -
             || builtins.elem license.shortName [

     

       24
       24
       -
               "CUDA EULA"

     

       25
       25
       -
               "cuDNN EULA"

     

       26
       26
       -
               "cuSPARSELt EULA"

     

       27
       27
       -
               "cuTENSOR EULA"

     

       28
       28
       -
               "NVidia OptiX EULA"

     

       29
       29
       -
             ]

     

       30
       30
       -
           ) (ensureList p.meta.license);

     

       17
       17
       +
         cudaLib = import ../development/cuda-modules/lib;

     

       31
       18
        
       in

     

       32
       19
        
       

     

       33
       20
        
       {

     
···

       40
       27
        
         # Attributes passed to nixpkgs.

     

       41
       28
        
         nixpkgsArgs ? {

     

       42
       29
        
           config = {

     

       43
       43
       -
             inherit allowUnfreePredicate;

     

       30
       30
       +
             allowUnfreePredicate = cudaLib.utils.allowUnfreeCudaPredicate;

     

       44
       31
        
             "${variant}Support" = true;

     

       45
       32
        
             inHydra = true;

     

       46
       33