commit 0ac3a73b6a997ea5e05067577a17c613ecddcd7d · pyrox.dev/nixpkgs

+357

pkgs/development/cuda-modules/lib/data/cuda.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           All CUDA capabilities, sorted by version.

     

       5
       5
       +
       

     

       6
       6
       +
           NOTE: Since the capabilities are sorted by version and architecture/family-specific features are

     

       7
       7
       +
           appended to the minor version component, the sorted list groups capabilities by baseline feature

     

       8
       8
       +
           set.

     

       9
       9
       +
       

     

       10
       10
       +
           # Type

     

       11
       11
       +
       

     

       12
       12
       +
           ```

     

       13
       13
       +
           allSortedCudaCapabilities :: [CudaCapability]

     

       14
       14
       +
           ```

     

       15
       15
       +
       

     

       16
       16
       +
           # Example

     

       17
       17
       +
       

     

       18
       18
       +
           ```

     

       19
       19
       +
           allSortedCudaCapabilities = [

     

       20
       20
       +
             "5.0"

     

       21
       21
       +
             "5.2"

     

       22
       22
       +
             "6.0"

     

       23
       23
       +
             "6.1"

     

       24
       24
       +
             "7.0"

     

       25
       25
       +
             "7.2"

     

       26
       26
       +
             "7.5"

     

       27
       27
       +
             "8.0"

     

       28
       28
       +
             "8.6"

     

       29
       29
       +
             "8.7"

     

       30
       30
       +
             "8.9"

     

       31
       31
       +
             "9.0"

     

       32
       32
       +
             "9.0a"

     

       33
       33
       +
             "10.0"

     

       34
       34
       +
             "10.0a"

     

       35
       35
       +
             "10.0f"

     

       36
       36
       +
             "10.1"

     

       37
       37
       +
             "10.1a"

     

       38
       38
       +
             "10.1f"

     

       39
       39
       +
             "10.3"

     

       40
       40
       +
             "10.3a"

     

       41
       41
       +
             "10.3f"

     

       42
       42
       +
           ];

     

       43
       43
       +
           ```

     

       44
       44
       +
         */

     

       45
       45
       +
         allSortedCudaCapabilities = lib.sort lib.versionOlder (

     

       46
       46
       +
           lib.attrNames cudaLib.data.cudaCapabilityToInfo

     

       47
       47
       +
         );

     

       48
       48
       +
       

     

       49
       49
       +
         /**

     

       50
       50
       +
           Mapping of CUDA micro-architecture name to capabilities belonging to that micro-architecture.

     

       51
       51
       +
       

     

       52
       52
       +
           # Type

     

       53
       53
       +
       

     

       54
       54
       +
           ```

     

       55
       55
       +
           cudaArchNameToCapabilities :: AttrSet NonEmptyStr (NonEmptyListOf CudaCapability)

     

       56
       56
       +
           ```

     

       57
       57
       +
         */

     

       58
       58
       +
         cudaArchNameToCapabilities = lib.groupBy (

     

       59
       59
       +
           cudaCapability: cudaLib.data.cudaCapabilityToInfo.${cudaCapability}.archName

     

       60
       60
       +
         ) cudaLib.data.allSortedCudaCapabilities;

     

       61
       61
       +
       

     

       62
       62
       +
         /**

     

       63
       63
       +
           Attribute set of supported CUDA capability mapped to information about that capability.

     

       64
       64
       +
       

     

       65
       65
       +
           NOTE: For more on baseline, architecture-specific, and family-specific feature sets, see

     

       66
       66
       +
           https://developer.nvidia.com/blog/nvidia-blackwell-and-nvidia-cuda-12-9-introduce-family-specific-architecture-features.

     

       67
       67
       +
       

     

       68
       68
       +
           NOTE: For information on when support for a given architecture was added, see

     

       69
       69
       +
           https://docs.nvidia.com/cuda/parallel-thread-execution/#release-notes

     

       70
       70
       +
       

     

       71
       71
       +
           NOTE: For baseline feature sets, `dontDefaultAfterCudaMajorMinorVersion` is generally set to the CUDA release

     

       72
       72
       +
           immediately prior to TensorRT removing support for that architecture.

     

       73
       73
       +
       

     

       74
       74
       +
           Many thanks to Arnon Shimoni for maintaining a list of these architectures and capabilities.

     

       75
       75
       +
           Without your work, this would have been much more difficult.

     

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

     

       77
       77
       +
       

     

       78
       78
       +
           # Type

     

       79
       79
       +
       

     

       80
       80
       +
           ```

     

       81
       81
       +
           cudaCapabilityToInfo ::

     

       82
       82
       +
             AttrSet

     

       83
       83
       +
               CudaCapability

     

       84
       84
       +
               { archName :: String

     

       85
       85
       +
               , cudaCapability :: CudaCapability

     

       86
       86
       +
               , isJetson :: Bool

     

       87
       87
       +
               , isArchitectureSpecific :: Bool

     

       88
       88
       +
               , isFamilySpecific :: Bool

     

       89
       89
       +
               , minCudaMajorMinorVersion :: MajorMinorVersion

     

       90
       90
       +
               , maxCudaMajorMinorVersion :: MajorMinorVersion

     

       91
       91
       +
               , dontDefaultAfterCudaMajorMinorVersion :: Null | MajorMinorVersion

     

       92
       92
       +
               }

     

       93
       93
       +
           ```

     

       94
       94
       +
       

     

       95
       95
       +
           `archName`

     

       96
       96
       +
       

     

       97
       97
       +
           : The name of the microarchitecture

     

       98
       98
       +
       

     

       99
       99
       +
           `cudaCapability`

     

       100
       100
       +
       

     

       101
       101
       +
           : The CUDA capability

     

       102
       102
       +
       

     

       103
       103
       +
           `isJetson`

     

       104
       104
       +
       

     

       105
       105
       +
           : Whether this capability is part of NVIDIA's line of Jetson embedded computers. This field is notable

     

       106
       106
       +
             because it tells us what architecture to build for (as Jetson devices are aarch64).

     

       107
       107
       +
             More on Jetson devices here: https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/

     

       108
       108
       +
             NOTE: These architectures are only built upon request.

     

       109
       109
       +
       

     

       110
       110
       +
           `isArchitectureSpecific`

     

       111
       111
       +
       

     

       112
       112
       +
           : Whether this capability is an architecture-specific feature set.

     

       113
       113
       +
             NOTE: These architectures are only built upon request.

     

       114
       114
       +
       

     

       115
       115
       +
           `isFamilySpecific`

     

       116
       116
       +
       

     

       117
       117
       +
           : Whether this capability is a family-specific feature set.

     

       118
       118
       +
             NOTE: These architectures are only built upon request.

     

       119
       119
       +
       

     

       120
       120
       +
           `minCudaMajorMinorVersion`

     

       121
       121
       +
       

     

       122
       122
       +
           : The minimum (inclusive) CUDA version that supports this capability.

     

       123
       123
       +
       

     

       124
       124
       +
           `maxCudaMajorMinorVersion`

     

       125
       125
       +
       

     

       126
       126
       +
           : The maximum (exclusive) CUDA version that supports this capability.

     

       127
       127
       +
             `null` means there is no maximum.

     

       128
       128
       +
       

     

       129
       129
       +
           `dontDefaultAfterCudaMajorMinorVersion`

     

       130
       130
       +
       

     

       131
       131
       +
           : The CUDA version after which to exclude this capability from the list of default capabilities we build.

     

       132
       132
       +
         */

     

       133
       133
       +
         cudaCapabilityToInfo =

     

       134
       134
       +
           lib.mapAttrs

     

       135
       135
       +
             (

     

       136
       136
       +
               cudaCapability:

     

       137
       137
       +
               # Supplies default values.

     

       138
       138
       +
               {

     

       139
       139
       +
                 archName,

     

       140
       140
       +
                 isJetson ? false,

     

       141
       141
       +
                 isArchitectureSpecific ? (lib.hasSuffix "a" cudaCapability),

     

       142
       142
       +
                 isFamilySpecific ? (lib.hasSuffix "f" cudaCapability),

     

       143
       143
       +
                 minCudaMajorMinorVersion,

     

       144
       144
       +
                 maxCudaMajorMinorVersion ? null,

     

       145
       145
       +
                 dontDefaultAfterCudaMajorMinorVersion ? null,

     

       146
       146
       +
               }:

     

       147
       147
       +
               {

     

       148
       148
       +
                 inherit

     

       149
       149
       +
                   archName

     

       150
       150
       +
                   cudaCapability

     

       151
       151
       +
                   isJetson

     

       152
       152
       +
                   isArchitectureSpecific

     

       153
       153
       +
                   isFamilySpecific

     

       154
       154
       +
                   minCudaMajorMinorVersion

     

       155
       155
       +
                   maxCudaMajorMinorVersion

     

       156
       156
       +
                   dontDefaultAfterCudaMajorMinorVersion

     

       157
       157
       +
                   ;

     

       158
       158
       +
               }

     

       159
       159
       +
             )

     

       160
       160
       +
             {

     

       161
       161
       +
               # Tesla K40

     

       162
       162
       +
               "3.5" = {

     

       163
       163
       +
                 archName = "Kepler";

     

       164
       164
       +
                 minCudaMajorMinorVersion = "10.0";

     

       165
       165
       +
                 dontDefaultAfterCudaMajorMinorVersion = "11.0";

     

       166
       166
       +
                 maxCudaMajorMinorVersion = "11.8";

     

       167
       167
       +
               };

     

       168
       168
       +
       

     

       169
       169
       +
               # Tesla K80

     

       170
       170
       +
               "3.7" = {

     

       171
       171
       +
                 archName = "Kepler";

     

       172
       172
       +
                 minCudaMajorMinorVersion = "10.0";

     

       173
       173
       +
                 dontDefaultAfterCudaMajorMinorVersion = "11.0";

     

       174
       174
       +
                 maxCudaMajorMinorVersion = "11.8";

     

       175
       175
       +
               };

     

       176
       176
       +
       

     

       177
       177
       +
               # Tesla/Quadro M series

     

       178
       178
       +
               "5.0" = {

     

       179
       179
       +
                 archName = "Maxwell";

     

       180
       180
       +
                 minCudaMajorMinorVersion = "10.0";

     

       181
       181
       +
                 dontDefaultAfterCudaMajorMinorVersion = "11.0";

     

       182
       182
       +
               };

     

       183
       183
       +
       

     

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

     

       185
       185
       +
               "5.2" = {

     

       186
       186
       +
                 archName = "Maxwell";

     

       187
       187
       +
                 minCudaMajorMinorVersion = "10.0";

     

       188
       188
       +
                 dontDefaultAfterCudaMajorMinorVersion = "11.0";

     

       189
       189
       +
               };

     

       190
       190
       +
       

     

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

     

       192
       192
       +
               "6.0" = {

     

       193
       193
       +
                 archName = "Pascal";

     

       194
       194
       +
                 minCudaMajorMinorVersion = "10.0";

     

       195
       195
       +
                 # Removed from TensorRT 10.0, which corresponds to CUDA 12.4 release.

     

       196
       196
       +
                 # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1001/support-matrix/index.html

     

       197
       197
       +
                 dontDefaultAfterCudaMajorMinorVersion = "12.3";

     

       198
       198
       +
               };

     

       199
       199
       +
       

     

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

     

       201
       201
       +
               # P40, Tesla P4, Discrete GPU on the NVIDIA Drive PX2

     

       202
       202
       +
               "6.1" = {

     

       203
       203
       +
                 archName = "Pascal";

     

       204
       204
       +
                 minCudaMajorMinorVersion = "10.0";

     

       205
       205
       +
                 # Removed from TensorRT 10.0, which corresponds to CUDA 12.4 release.

     

       206
       206
       +
                 # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1001/support-matrix/index.html

     

       207
       207
       +
                 dontDefaultAfterCudaMajorMinorVersion = "12.3";

     

       208
       208
       +
               };

     

       209
       209
       +
       

     

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

     

       211
       211
       +
               "7.0" = {

     

       212
       212
       +
                 archName = "Volta";

     

       213
       213
       +
                 minCudaMajorMinorVersion = "10.0";

     

       214
       214
       +
                 # Removed from TensorRT 10.5, which corresponds to CUDA 12.6 release.

     

       215
       215
       +
                 # https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-1050/support-matrix/index.html

     

       216
       216
       +
                 dontDefaultAfterCudaMajorMinorVersion = "12.5";

     

       217
       217
       +
               };

     

       218
       218
       +
       

     

       219
       219
       +
               # Jetson AGX Xavier, Drive AGX Pegasus, Xavier NX

     

       220
       220
       +
               "7.2" = {

     

       221
       221
       +
                 archName = "Volta";

     

       222
       222
       +
                 minCudaMajorMinorVersion = "10.0";

     

       223
       223
       +
                 # Note: without `cuda_compat`, maxCudaMajorMinorVersion is 11.8

     

       224
       224
       +
                 # https://docs.nvidia.com/cuda/cuda-for-tegra-appnote/index.html#deployment-considerations-for-cuda-upgrade-package

     

       225
       225
       +
                 maxCudaMajorMinorVersion = "12.2";

     

       226
       226
       +
                 isJetson = true;

     

       227
       227
       +
               };

     

       228
       228
       +
       

     

       229
       229
       +
               # GTX/RTX Turing – GTX 1660 Ti, RTX 2060, RTX 2070, RTX 2080, Titan RTX, Quadro RTX 4000,

     

       230
       230
       +
               # Quadro RTX 5000, Quadro RTX 6000, Quadro RTX 8000, Quadro T1000/T2000, Tesla T4

     

       231
       231
       +
               "7.5" = {

     

       232
       232
       +
                 archName = "Turing";

     

       233
       233
       +
                 minCudaMajorMinorVersion = "10.0";

     

       234
       234
       +
               };

     

       235
       235
       +
       

     

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

     

       237
       237
       +
               "8.0" = {

     

       238
       238
       +
                 archName = "Ampere";

     

       239
       239
       +
                 minCudaMajorMinorVersion = "11.2";

     

       240
       240
       +
               };

     

       241
       241
       +
       

     

       242
       242
       +
               # Tesla GA10x cards, RTX Ampere – RTX 3080, GA102 – RTX 3090, RTX A2000, A3000, RTX A4000,

     

       243
       243
       +
               # A5000, A6000, NVIDIA A40, GA106 – RTX 3060, GA104 – RTX 3070, GA107 – RTX 3050, RTX A10, RTX

     

       244
       244
       +
               # A16, RTX A40, A2 Tensor Core GPU

     

       245
       245
       +
               "8.6" = {

     

       246
       246
       +
                 archName = "Ampere";

     

       247
       247
       +
                 minCudaMajorMinorVersion = "11.2";

     

       248
       248
       +
               };

     

       249
       249
       +
       

     

       250
       250
       +
               # Jetson AGX Orin and Drive AGX Orin only

     

       251
       251
       +
               "8.7" = {

     

       252
       252
       +
                 archName = "Ampere";

     

       253
       253
       +
                 minCudaMajorMinorVersion = "11.5";

     

       254
       254
       +
                 isJetson = true;

     

       255
       255
       +
               };

     

       256
       256
       +
       

     

       257
       257
       +
               # NVIDIA GeForce RTX 4090, RTX 4080, RTX 6000, Tesla L40

     

       258
       258
       +
               "8.9" = {

     

       259
       259
       +
                 archName = "Ada";

     

       260
       260
       +
                 minCudaMajorMinorVersion = "11.8";

     

       261
       261
       +
               };

     

       262
       262
       +
       

     

       263
       263
       +
               # NVIDIA H100 (GH100)

     

       264
       264
       +
               "9.0" = {

     

       265
       265
       +
                 archName = "Hopper";

     

       266
       266
       +
                 minCudaMajorMinorVersion = "11.8";

     

       267
       267
       +
               };

     

       268
       268
       +
       

     

       269
       269
       +
               "9.0a" = {

     

       270
       270
       +
                 archName = "Hopper";

     

       271
       271
       +
                 minCudaMajorMinorVersion = "12.0";

     

       272
       272
       +
               };

     

       273
       273
       +
       

     

       274
       274
       +
               # NVIDIA B100

     

       275
       275
       +
               "10.0" = {

     

       276
       276
       +
                 archName = "Blackwell";

     

       277
       277
       +
                 minCudaMajorMinorVersion = "12.7";

     

       278
       278
       +
               };

     

       279
       279
       +
       

     

       280
       280
       +
               "10.0a" = {

     

       281
       281
       +
                 archName = "Blackwell";

     

       282
       282
       +
                 minCudaMajorMinorVersion = "12.7";

     

       283
       283
       +
               };

     

       284
       284
       +
       

     

       285
       285
       +
               "10.0f" = {

     

       286
       286
       +
                 archName = "Blackwell";

     

       287
       287
       +
                 minCudaMajorMinorVersion = "12.9";

     

       288
       288
       +
               };

     

       289
       289
       +
       

     

       290
       290
       +
               # NVIDIA Jetson Thor Blackwell

     

       291
       291
       +
               "10.1" = {

     

       292
       292
       +
                 archName = "Blackwell";

     

       293
       293
       +
                 minCudaMajorMinorVersion = "12.7";

     

       294
       294
       +
                 isJetson = true;

     

       295
       295
       +
               };

     

       296
       296
       +
       

     

       297
       297
       +
               "10.1a" = {

     

       298
       298
       +
                 archName = "Blackwell";

     

       299
       299
       +
                 minCudaMajorMinorVersion = "12.7";

     

       300
       300
       +
                 isJetson = true;

     

       301
       301
       +
               };

     

       302
       302
       +
       

     

       303
       303
       +
               "10.1f" = {

     

       304
       304
       +
                 archName = "Blackwell";

     

       305
       305
       +
                 minCudaMajorMinorVersion = "12.9";

     

       306
       306
       +
                 isJetson = true;

     

       307
       307
       +
               };

     

       308
       308
       +
       

     

       309
       309
       +
               # NVIDIA ???

     

       310
       310
       +
               "10.3" = {

     

       311
       311
       +
                 archName = "Blackwell";

     

       312
       312
       +
                 minCudaMajorMinorVersion = "12.9";

     

       313
       313
       +
               };

     

       314
       314
       +
       

     

       315
       315
       +
               "10.3a" = {

     

       316
       316
       +
                 archName = "Blackwell";

     

       317
       317
       +
                 minCudaMajorMinorVersion = "12.9";

     

       318
       318
       +
               };

     

       319
       319
       +
       

     

       320
       320
       +
               "10.3f" = {

     

       321
       321
       +
                 archName = "Blackwell";

     

       322
       322
       +
                 minCudaMajorMinorVersion = "12.9";

     

       323
       323
       +
               };

     

       324
       324
       +
       

     

       325
       325
       +
               # NVIDIA GeForce RTX 5090 (GB202) etc.

     

       326
       326
       +
               "12.0" = {

     

       327
       327
       +
                 archName = "Blackwell";

     

       328
       328
       +
                 minCudaMajorMinorVersion = "12.8";

     

       329
       329
       +
               };

     

       330
       330
       +
       

     

       331
       331
       +
               "12.0a" = {

     

       332
       332
       +
                 archName = "Blackwell";

     

       333
       333
       +
                 minCudaMajorMinorVersion = "12.8";

     

       334
       334
       +
               };

     

       335
       335
       +
       

     

       336
       336
       +
               "12.0f" = {

     

       337
       337
       +
                 archName = "Blackwell";

     

       338
       338
       +
                 minCudaMajorMinorVersion = "12.9";

     

       339
       339
       +
               };

     

       340
       340
       +
       

     

       341
       341
       +
               # NVIDIA ???

     

       342
       342
       +
               "12.1" = {

     

       343
       343
       +
                 archName = "Blackwell";

     

       344
       344
       +
                 minCudaMajorMinorVersion = "12.9";

     

       345
       345
       +
               };

     

       346
       346
       +
       

     

       347
       347
       +
               "12.1a" = {

     

       348
       348
       +
                 archName = "Blackwell";

     

       349
       349
       +
                 minCudaMajorMinorVersion = "12.9";

     

       350
       350
       +
               };

     

       351
       351
       +
       

     

       352
       352
       +
               "12.1f" = {

     

       353
       353
       +
                 archName = "Blackwell";

     

       354
       354
       +
                 minCudaMajorMinorVersion = "12.9";

     

       355
       355
       +
               };

     

       356
       356
       +
             };

     

       357
       357
       +
       }

+32

pkgs/development/cuda-modules/lib/data/default.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         # See ./cuda.nix for documentation.

     

       4
       4
       +
         inherit (import ./cuda.nix { inherit cudaLib lib; })

     

       5
       5
       +
           allSortedCudaCapabilities

     

       6
       6
       +
           cudaArchNameToCapabilities

     

       7
       7
       +
           cudaCapabilityToInfo

     

       8
       8
       +
           ;

     

       9
       9
       +
       

     

       10
       10
       +
         # See ./nvcc.nix for documentation.

     

       11
       11
       +
         inherit (import ./nvcc.nix)

     

       12
       12
       +
           nvccCompatibilities

     

       13
       13
       +
           ;

     

       14
       14
       +
       

     

       15
       15
       +
         # See ./redist.nix for documentation.

     

       16
       16
       +
         inherit (import ./redist.nix)

     

       17
       17
       +
           redistNames

     

       18
       18
       +
           redistSystems

     

       19
       19
       +
           redistUrlPrefix

     

       20
       20
       +
           ;

     

       21
       21
       +
       

     

       22
       22
       +
         /**

     

       23
       23
       +
           The path to the CUDA packages root directory, for use with `callPackage` to create new package sets.

     

       24
       24
       +
       

     

       25
       25
       +
           # Type

     

       26
       26
       +
       

     

       27
       27
       +
           ```

     

       28
       28
       +
           cudaPackagesPath :: Path

     

       29
       29
       +
           ```

     

       30
       30
       +
         */

     

       31
       31
       +
         cudaPackagesPath = ./..;

     

       32
       32
       +
       }

+268

pkgs/development/cuda-modules/lib/data/nvcc.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         /**

     

       3
       3
       +
             Mapping of CUDA versions to NVCC compatibilities

     

       4
       4
       +
       

     

       5
       5
       +
             Taken from

     

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

     

       7
       7
       +
       

     

       8
       8
       +
               NVCC performs a version check on the host compiler's major version and so newer minor versions

     

       9
       9
       +
               of the compilers listed below will be supported, but major versions falling outside the range

     

       10
       10
       +
               will not be supported.

     

       11
       11
       +
       

     

       12
       12
       +
             NOTE: These constraints don't apply to Jetson, which uses something else.

     

       13
       13
       +
       

     

       14
       14
       +
             NOTE: NVIDIA can and will add support for newer compilers even during patch releases.

     

       15
       15
       +
             E.g.: CUDA 12.2.1 maxxed out with support for Clang 15.0; 12.2.2 added support for Clang 16.0.

     

       16
       16
       +
       

     

       17
       17
       +
             NOTE: Because all platforms NVIDIA supports use GCC and Clang, we omit the architectures here.

     

       18
       18
       +
       

     

       19
       19
       +
             # Type

     

       20
       20
       +
       

     

       21
       21
       +
             ```

     

       22
       22
       +
             nvccCompatibilities ::

     

       23
       23
       +
               AttrSet

     

       24
       24
       +
                 String

     

       25
       25
       +
                 { clang :: { maxMajorVersion :: String, minMajorVersion :: String }

     

       26
       26
       +
                 , gcc :: { maxMajorVersion :: String, minMajorVersion :: String }

     

       27
       27
       +
                 }

     

       28
       28
       +
             ```

     

       29
       29
       +
         */

     

       30
       30
       +
         nvccCompatibilities = {

     

       31
       31
       +
           # Our baseline

     

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

     

       33
       33
       +
           "11.0" = {

     

       34
       34
       +
             clang = {

     

       35
       35
       +
               maxMajorVersion = "9";

     

       36
       36
       +
               minMajorVersion = "7";

     

       37
       37
       +
             };

     

       38
       38
       +
             gcc = {

     

       39
       39
       +
               maxMajorVersion = "9";

     

       40
       40
       +
               minMajorVersion = "6";

     

       41
       41
       +
             };

     

       42
       42
       +
           };

     

       43
       43
       +
       

     

       44
       44
       +
           # Added support for Clang 10 and GCC 10

     

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

     

       46
       46
       +
           "11.1" = {

     

       47
       47
       +
             clang = {

     

       48
       48
       +
               maxMajorVersion = "10";

     

       49
       49
       +
               minMajorVersion = "7";

     

       50
       50
       +
             };

     

       51
       51
       +
             gcc = {

     

       52
       52
       +
               maxMajorVersion = "10";

     

       53
       53
       +
               minMajorVersion = "6";

     

       54
       54
       +
             };

     

       55
       55
       +
           };

     

       56
       56
       +
       

     

       57
       57
       +
           # Added support for Clang 11

     

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

     

       59
       59
       +
           "11.2" = {

     

       60
       60
       +
             clang = {

     

       61
       61
       +
               maxMajorVersion = "11";

     

       62
       62
       +
               minMajorVersion = "7";

     

       63
       63
       +
             };

     

       64
       64
       +
             gcc = {

     

       65
       65
       +
               maxMajorVersion = "10";

     

       66
       66
       +
               minMajorVersion = "6";

     

       67
       67
       +
             };

     

       68
       68
       +
           };

     

       69
       69
       +
       

     

       70
       70
       +
           # No changes from 11.2 to 11.3

     

       71
       71
       +
           "11.3" = {

     

       72
       72
       +
             clang = {

     

       73
       73
       +
               maxMajorVersion = "11";

     

       74
       74
       +
               minMajorVersion = "7";

     

       75
       75
       +
             };

     

       76
       76
       +
             gcc = {

     

       77
       77
       +
               maxMajorVersion = "10";

     

       78
       78
       +
               minMajorVersion = "6";

     

       79
       79
       +
             };

     

       80
       80
       +
           };

     

       81
       81
       +
       

     

       82
       82
       +
           # Added support for Clang 12 and GCC 11

     

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

     

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

     

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

     

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

     

       87
       87
       +
           "11.4" = {

     

       88
       88
       +
             clang = {

     

       89
       89
       +
               maxMajorVersion = "12";

     

       90
       90
       +
               minMajorVersion = "7";

     

       91
       91
       +
             };

     

       92
       92
       +
             gcc = {

     

       93
       93
       +
               maxMajorVersion = "10";

     

       94
       94
       +
               minMajorVersion = "6";

     

       95
       95
       +
             };

     

       96
       96
       +
           };

     

       97
       97
       +
       

     

       98
       98
       +
           # No changes from 11.4 to 11.5

     

       99
       99
       +
           "11.5" = {

     

       100
       100
       +
             clang = {

     

       101
       101
       +
               maxMajorVersion = "12";

     

       102
       102
       +
               minMajorVersion = "7";

     

       103
       103
       +
             };

     

       104
       104
       +
             gcc = {

     

       105
       105
       +
               maxMajorVersion = "10";

     

       106
       106
       +
               minMajorVersion = "6";

     

       107
       107
       +
             };

     

       108
       108
       +
           };

     

       109
       109
       +
       

     

       110
       110
       +
           # No changes from 11.5 to 11.6

     

       111
       111
       +
           # However, as mentioned above, we add GCC 11 this release.

     

       112
       112
       +
           "11.6" = {

     

       113
       113
       +
             clang = {

     

       114
       114
       +
               maxMajorVersion = "12";

     

       115
       115
       +
               minMajorVersion = "7";

     

       116
       116
       +
             };

     

       117
       117
       +
             gcc = {

     

       118
       118
       +
               maxMajorVersion = "11";

     

       119
       119
       +
               minMajorVersion = "6";

     

       120
       120
       +
             };

     

       121
       121
       +
           };

     

       122
       122
       +
       

     

       123
       123
       +
           # Added support for Clang 13

     

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

     

       125
       125
       +
           "11.7" = {

     

       126
       126
       +
             clang = {

     

       127
       127
       +
               maxMajorVersion = "13";

     

       128
       128
       +
               minMajorVersion = "7";

     

       129
       129
       +
             };

     

       130
       130
       +
             gcc = {

     

       131
       131
       +
               maxMajorVersion = "11";

     

       132
       132
       +
               minMajorVersion = "6";

     

       133
       133
       +
             };

     

       134
       134
       +
           };

     

       135
       135
       +
       

     

       136
       136
       +
           # Added support for Clang 14

     

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

     

       138
       138
       +
           "11.8" = {

     

       139
       139
       +
             clang = {

     

       140
       140
       +
               maxMajorVersion = "14";

     

       141
       141
       +
               minMajorVersion = "7";

     

       142
       142
       +
             };

     

       143
       143
       +
             gcc = {

     

       144
       144
       +
               maxMajorVersion = "11";

     

       145
       145
       +
               minMajorVersion = "6";

     

       146
       146
       +
             };

     

       147
       147
       +
           };

     

       148
       148
       +
       

     

       149
       149
       +
           # Added support for GCC 12

     

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

     

       151
       151
       +
           "12.0" = {

     

       152
       152
       +
             clang = {

     

       153
       153
       +
               maxMajorVersion = "14";

     

       154
       154
       +
               minMajorVersion = "7";

     

       155
       155
       +
             };

     

       156
       156
       +
             gcc = {

     

       157
       157
       +
               maxMajorVersion = "12";

     

       158
       158
       +
               minMajorVersion = "6";

     

       159
       159
       +
             };

     

       160
       160
       +
           };

     

       161
       161
       +
       

     

       162
       162
       +
           # Added support for Clang 15

     

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

     

       164
       164
       +
           "12.1" = {

     

       165
       165
       +
             clang = {

     

       166
       166
       +
               maxMajorVersion = "15";

     

       167
       167
       +
               minMajorVersion = "7";

     

       168
       168
       +
             };

     

       169
       169
       +
             gcc = {

     

       170
       170
       +
               maxMajorVersion = "12";

     

       171
       171
       +
               minMajorVersion = "6";

     

       172
       172
       +
             };

     

       173
       173
       +
           };

     

       174
       174
       +
       

     

       175
       175
       +
           # Added support for Clang 16

     

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

     

       177
       177
       +
           "12.2" = {

     

       178
       178
       +
             clang = {

     

       179
       179
       +
               maxMajorVersion = "16";

     

       180
       180
       +
               minMajorVersion = "7";

     

       181
       181
       +
             };

     

       182
       182
       +
             gcc = {

     

       183
       183
       +
               maxMajorVersion = "12";

     

       184
       184
       +
               minMajorVersion = "6";

     

       185
       185
       +
             };

     

       186
       186
       +
           };

     

       187
       187
       +
       

     

       188
       188
       +
           # No changes from 12.2 to 12.3

     

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

     

       190
       190
       +
           "12.3" = {

     

       191
       191
       +
             clang = {

     

       192
       192
       +
               maxMajorVersion = "16";

     

       193
       193
       +
               minMajorVersion = "7";

     

       194
       194
       +
             };

     

       195
       195
       +
             gcc = {

     

       196
       196
       +
               maxMajorVersion = "12";

     

       197
       197
       +
               minMajorVersion = "6";

     

       198
       198
       +
             };

     

       199
       199
       +
           };

     

       200
       200
       +
       

     

       201
       201
       +
           # Maximum Clang version is 17

     

       202
       202
       +
           # Minimum GCC version is still 6, but all versions prior to GCC 7.3 are deprecated.

     

       203
       203
       +
           # Maximum GCC version is 13.2

     

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

     

       205
       205
       +
           "12.4" = {

     

       206
       206
       +
             clang = {

     

       207
       207
       +
               maxMajorVersion = "17";

     

       208
       208
       +
               minMajorVersion = "7";

     

       209
       209
       +
             };

     

       210
       210
       +
             gcc = {

     

       211
       211
       +
               maxMajorVersion = "13";

     

       212
       212
       +
               minMajorVersion = "6";

     

       213
       213
       +
             };

     

       214
       214
       +
           };

     

       215
       215
       +
       

     

       216
       216
       +
           # No changes from 12.4 to 12.5

     

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

     

       218
       218
       +
           "12.5" = {

     

       219
       219
       +
             clang = {

     

       220
       220
       +
               maxMajorVersion = "17";

     

       221
       221
       +
               minMajorVersion = "7";

     

       222
       222
       +
             };

     

       223
       223
       +
             gcc = {

     

       224
       224
       +
               maxMajorVersion = "13";

     

       225
       225
       +
               minMajorVersion = "6";

     

       226
       226
       +
             };

     

       227
       227
       +
           };

     

       228
       228
       +
       

     

       229
       229
       +
           # Maximum Clang version is 18

     

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

     

       231
       231
       +
           "12.6" = {

     

       232
       232
       +
             clang = {

     

       233
       233
       +
               maxMajorVersion = "18";

     

       234
       234
       +
               minMajorVersion = "7";

     

       235
       235
       +
             };

     

       236
       236
       +
             gcc = {

     

       237
       237
       +
               maxMajorVersion = "13";

     

       238
       238
       +
               minMajorVersion = "6";

     

       239
       239
       +
             };

     

       240
       240
       +
           };

     

       241
       241
       +
       

     

       242
       242
       +
           # Maximum Clang version is 19, maximum GCC version is 14

     

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

     

       244
       244
       +
           "12.8" = {

     

       245
       245
       +
             clang = {

     

       246
       246
       +
               maxMajorVersion = "19";

     

       247
       247
       +
               minMajorVersion = "7";

     

       248
       248
       +
             };

     

       249
       249
       +
             gcc = {

     

       250
       250
       +
               maxMajorVersion = "14";

     

       251
       251
       +
               minMajorVersion = "6";

     

       252
       252
       +
             };

     

       253
       253
       +
           };

     

       254
       254
       +
       

     

       255
       255
       +
           # No changes from 12.8 to 12.9

     

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

     

       257
       257
       +
           "12.9" = {

     

       258
       258
       +
             clang = {

     

       259
       259
       +
               maxMajorVersion = "19";

     

       260
       260
       +
               minMajorVersion = "7";

     

       261
       261
       +
             };

     

       262
       262
       +
             gcc = {

     

       263
       263
       +
               maxMajorVersion = "14";

     

       264
       264
       +
               minMajorVersion = "6";

     

       265
       265
       +
             };

     

       266
       266
       +
           };

     

       267
       267
       +
         };

     

       268
       268
       +
       }

+56

pkgs/development/cuda-modules/lib/data/redist.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         /**

     

       3
       3
       +
           A list of redistributable names to use in creation of the `redistName` option type.

     

       4
       4
       +
       

     

       5
       5
       +
           # Type

     

       6
       6
       +
       

     

       7
       7
       +
           ```

     

       8
       8
       +
           redistNames :: [String]

     

       9
       9
       +
           ```

     

       10
       10
       +
         */

     

       11
       11
       +
         redistNames = [

     

       12
       12
       +
           "cublasmp"

     

       13
       13
       +
           "cuda"

     

       14
       14
       +
           "cudnn"

     

       15
       15
       +
           "cudss"

     

       16
       16
       +
           "cuquantum"

     

       17
       17
       +
           "cusolvermp"

     

       18
       18
       +
           "cusparselt"

     

       19
       19
       +
           "cutensor"

     

       20
       20
       +
           "nppplus"

     

       21
       21
       +
           "nvcomp"

     

       22
       22
       +
           # "nvidia-driver",  # NOTE: Some of the earlier manifests don't follow our scheme.

     

       23
       23
       +
           "nvjpeg2000"

     

       24
       24
       +
           "nvpl"

     

       25
       25
       +
           "nvtiff"

     

       26
       26
       +
           "tensorrt" # NOTE: not truly a redist; uses different naming convention

     

       27
       27
       +
         ];

     

       28
       28
       +
       

     

       29
       29
       +
         /**

     

       30
       30
       +
           A list of redistributable systems to use in creation of the `redistSystem` option type.

     

       31
       31
       +
       

     

       32
       32
       +
           # Type

     

       33
       33
       +
       

     

       34
       34
       +
           ```

     

       35
       35
       +
           redistSystems :: [String]

     

       36
       36
       +
           ```

     

       37
       37
       +
         */

     

       38
       38
       +
         redistSystems = [

     

       39
       39
       +
           "linux-aarch64"

     

       40
       40
       +
           "linux-all" # Taken to mean all other linux systems

     

       41
       41
       +
           "linux-sbsa"

     

       42
       42
       +
           "linux-x86_64"

     

       43
       43
       +
           "source" # Source-agnostic platform

     

       44
       44
       +
         ];

     

       45
       45
       +
       

     

       46
       46
       +
         /**

     

       47
       47
       +
           The prefix of the URL for redistributable files.

     

       48
       48
       +
       

     

       49
       49
       +
           # Type

     

       50
       50
       +
       

     

       51
       51
       +
           ```

     

       52
       52
       +
           redistUrlPrefix :: String

     

       53
       53
       +
           ```

     

       54
       54
       +
         */

     

       55
       55
       +
         redistUrlPrefix = "https://developer.download.nvidia.com/compute";

     

       56
       56
       +
       }

+13

pkgs/development/cuda-modules/lib/default.nix

···

       1
       1
       +
       let

     

       2
       2
       +
         lib = import ../../../../lib;

     

       3
       3
       +
       in

     

       4
       4
       +
       lib.fixedPoints.makeExtensible (final: {

     

       5
       5
       +
         data = import ./data {

     

       6
       6
       +
           inherit lib;

     

       7
       7
       +
           cudaLib = final;

     

       8
       8
       +
         };

     

       9
       9
       +
         utils = import ./utils {

     

       10
       10
       +
           inherit lib;

     

       11
       11
       +
           cudaLib = final;

     

       12
       12
       +
         };

     

       13
       13
       +
       })

+139

pkgs/development/cuda-modules/lib/utils/assertions.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Evaluate assertions and add error context to return value.

     

       5
       5
       +
       

     

       6
       6
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       7
       7
       +
       

     

       8
       8
       +
           # Type

     

       9
       9
       +
       

     

       10
       10
       +
           ```

     

       11
       11
       +
           _evaluateAssertions

     

       12
       12
       +
             :: (assertions :: List { assertion :: Bool, message :: String })

     

       13
       13
       +
             -> Bool

     

       14
       14
       +
           ```

     

       15
       15
       +
         */

     

       16
       16
       +
         _evaluateAssertions =

     

       17
       17
       +
           assertions:

     

       18
       18
       +
           let

     

       19
       19
       +
             failedAssertionsString = cudaLib.utils._mkFailedAssertionsString assertions;

     

       20
       20
       +
           in

     

       21
       21
       +
           if failedAssertionsString == "" then

     

       22
       22
       +
             true

     

       23
       23
       +
           else

     

       24
       24
       +
             lib.addErrorContext "with failed assertions:${failedAssertionsString}" false;

     

       25
       25
       +
       

     

       26
       26
       +
         /**

     

       27
       27
       +
           Function to generate a string of failed assertions.

     

       28
       28
       +
       

     

       29
       29
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       30
       30
       +
       

     

       31
       31
       +
           # Type

     

       32
       32
       +
       

     

       33
       33
       +
           ```

     

       34
       34
       +
           _mkFailedAssertionsString

     

       35
       35
       +
             :: (assertions :: List { assertion :: Bool, message :: String })

     

       36
       36
       +
             -> String

     

       37
       37
       +
           ```

     

       38
       38
       +
       

     

       39
       39
       +
           # Inputs

     

       40
       40
       +
       

     

       41
       41
       +
           `assertions`

     

       42
       42
       +
       

     

       43
       43
       +
           : A list of assertions to evaluate

     

       44
       44
       +
       

     

       45
       45
       +
           # Examples

     

       46
       46
       +
       

     

       47
       47
       +
           :::{.example}

     

       48
       48
       +
           ## `cudaLib.utils._mkFailedAssertionsString` usage examples

     

       49
       49
       +
       

     

       50
       50
       +
           ```nix

     

       51
       51
       +
           _mkFailedAssertionsString [

     

       52
       52
       +
             { assertion = false; message = "Assertion 1 failed"; }

     

       53
       53
       +
             { assertion = true; message = "Assertion 2 failed"; }

     

       54
       54
       +
           ]

     

       55
       55
       +
           => "\n- Assertion 1 failed"

     

       56
       56
       +
           ```

     

       57
       57
       +
       

     

       58
       58
       +
           ```nix

     

       59
       59
       +
           _mkFailedAssertionsString [

     

       60
       60
       +
             { assertion = false; message = "Assertion 1 failed"; }

     

       61
       61
       +
             { assertion = false; message = "Assertion 2 failed"; }

     

       62
       62
       +
           ]

     

       63
       63
       +
           => "\n- Assertion 1 failed\n- Assertion 2 failed"

     

       64
       64
       +
           ```

     

       65
       65
       +
           :::

     

       66
       66
       +
         */

     

       67
       67
       +
         _mkFailedAssertionsString = lib.foldl' (

     

       68
       68
       +
           failedAssertionsString:

     

       69
       69
       +
           { assertion, message }:

     

       70
       70
       +
           failedAssertionsString + lib.optionalString (!assertion) ("\n- " + message)

     

       71
       71
       +
         ) "";

     

       72
       72
       +
       

     

       73
       73
       +
         /**

     

       74
       74
       +
           Utility function to generate assertions for missing packages.

     

       75
       75
       +
       

     

       76
       76
       +
           Used to mark a package as unsupported if any of its required packages are missing (null).

     

       77
       77
       +
       

     

       78
       78
       +
           Expects a set of attributes.

     

       79
       79
       +
       

     

       80
       80
       +
           Most commonly used in overrides files on a callPackage-provided attribute set of packages.

     

       81
       81
       +
       

     

       82
       82
       +
           NOTE: We typically use platfromAssertions instead of brokenAssertions because the presence of packages set to null

     

       83
       83
       +
           means evaluation will fail if package attributes are accessed without checking for null first. OfBorg evaluation

     

       84
       84
       +
           sets allowBroken to true, which means we can't rely on brokenAssertions to prevent evaluation of a package with

     

       85
       85
       +
           missing dependencies.

     

       86
       86
       +
       

     

       87
       87
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       88
       88
       +
       

     

       89
       89
       +
           # Type

     

       90
       90
       +
       

     

       91
       91
       +
           ```

     

       92
       92
       +
           _mkMissingPackagesAssertions

     

       93
       93
       +
             :: (attrs :: AttrSet)

     

       94
       94
       +
             -> (assertions :: List { assertion :: Bool, message :: String })

     

       95
       95
       +
           ```

     

       96
       96
       +
       

     

       97
       97
       +
           # Inputs

     

       98
       98
       +
       

     

       99
       99
       +
           `attrs`

     

       100
       100
       +
       

     

       101
       101
       +
           : The attributes to check for null

     

       102
       102
       +
       

     

       103
       103
       +
           # Examples

     

       104
       104
       +
       

     

       105
       105
       +
           :::{.example}

     

       106
       106
       +
           ## `cudaLib.utils._mkMissingPackagesAssertions` usage examples

     

       107
       107
       +
       

     

       108
       108
       +
           ```nix

     

       109
       109
       +
           {

     

       110
       110
       +
             lib,

     

       111
       111
       +
             libcal ? null,

     

       112
       112
       +
             libcublas,

     

       113
       113
       +
             utils,

     

       114
       114
       +
           }:

     

       115
       115
       +
           let

     

       116
       116
       +
             inherit (lib.attrsets) recursiveUpdate;

     

       117
       117
       +
             inherit (cudaLib.utils) _mkMissingPackagesAssertions;

     

       118
       118
       +
           in

     

       119
       119
       +
           prevAttrs: {

     

       120
       120
       +
             passthru = prevAttrs.passthru or { } // {

     

       121
       121
       +
               platformAssertions =

     

       122
       122
       +
                 prevAttrs.passthru.platformAssertions or [ ]

     

       123
       123
       +
                 ++ _mkMissingPackagesAssertions { inherit libcal; };

     

       124
       124
       +
             };

     

       125
       125
       +
           }

     

       126
       126
       +
           ```

     

       127
       127
       +
           :::

     

       128
       128
       +
         */

     

       129
       129
       +
         _mkMissingPackagesAssertions = lib.flip lib.pipe [

     

       130
       130
       +
           # Take the attributes that are null.

     

       131
       131
       +
           (lib.filterAttrs (_: value: value == null))

     

       132
       132
       +
           lib.attrNames

     

       133
       133
       +
           # Map them to assertions.

     

       134
       134
       +
           (lib.map (name: {

     

       135
       135
       +
             message = "${name} is available";

     

       136
       136
       +
             assertion = false;

     

       137
       137
       +
           }))

     

       138
       138
       +
         ];

     

       139
       139
       +
       }

+129

pkgs/development/cuda-modules/lib/utils/cuda.nix

···

       1
       1
       +
       { lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Returns whether a capability should be built by default for a particular CUDA version.

     

       5
       5
       +
       

     

       6
       6
       +
           Capabilities built by default are baseline, non-Jetson capabilities with relatively recent CUDA support.

     

       7
       7
       +
       

     

       8
       8
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       9
       9
       +
       

     

       10
       10
       +
           # Type

     

       11
       11
       +
       

     

       12
       12
       +
           ```

     

       13
       13
       +
           _cudaCapabilityIsDefault

     

       14
       14
       +
             :: (cudaMajorMinorVersion :: Version)

     

       15
       15
       +
             -> (cudaCapabilityInfo :: CudaCapabilityInfo)

     

       16
       16
       +
             -> Bool

     

       17
       17
       +
           ```

     

       18
       18
       +
       

     

       19
       19
       +
           # Inputs

     

       20
       20
       +
       

     

       21
       21
       +
           `cudaMajorMinorVersion`

     

       22
       22
       +
       

     

       23
       23
       +
           : The CUDA version to check

     

       24
       24
       +
       

     

       25
       25
       +
           `cudaCapabilityInfo`

     

       26
       26
       +
       

     

       27
       27
       +
           : The capability information to check

     

       28
       28
       +
         */

     

       29
       29
       +
         _cudaCapabilityIsDefault =

     

       30
       30
       +
           cudaMajorMinorVersion: cudaCapabilityInfo:

     

       31
       31
       +
           let

     

       32
       32
       +
             recentCapability =

     

       33
       33
       +
               cudaCapabilityInfo.dontDefaultAfterCudaMajorMinorVersion == null

     

       34
       34
       +
               || lib.versionAtLeast cudaCapabilityInfo.dontDefaultAfterCudaMajorMinorVersion cudaMajorMinorVersion;

     

       35
       35
       +
           in

     

       36
       36
       +
           recentCapability

     

       37
       37
       +
           && !cudaCapabilityInfo.isJetson

     

       38
       38
       +
           && !cudaCapabilityInfo.isArchitectureSpecific

     

       39
       39
       +
           && !cudaCapabilityInfo.isFamilySpecific;

     

       40
       40
       +
       

     

       41
       41
       +
         /**

     

       42
       42
       +
           Returns whether a capability is supported for a particular CUDA version.

     

       43
       43
       +
       

     

       44
       44
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       45
       45
       +
       

     

       46
       46
       +
           # Type

     

       47
       47
       +
       

     

       48
       48
       +
           ```

     

       49
       49
       +
           _cudaCapabilityIsSupported

     

       50
       50
       +
             :: (cudaMajorMinorVersion :: Version)

     

       51
       51
       +
             -> (cudaCapabilityInfo :: CudaCapabilityInfo)

     

       52
       52
       +
             -> Bool

     

       53
       53
       +
           ```

     

       54
       54
       +
       

     

       55
       55
       +
           # Inputs

     

       56
       56
       +
       

     

       57
       57
       +
           `cudaMajorMinorVersion`

     

       58
       58
       +
       

     

       59
       59
       +
           : The CUDA version to check

     

       60
       60
       +
       

     

       61
       61
       +
           `cudaCapabilityInfo`

     

       62
       62
       +
       

     

       63
       63
       +
           : The capability information to check

     

       64
       64
       +
         */

     

       65
       65
       +
         _cudaCapabilityIsSupported =

     

       66
       66
       +
           cudaMajorMinorVersion: cudaCapabilityInfo:

     

       67
       67
       +
           let

     

       68
       68
       +
             lowerBoundSatisfied = lib.versionAtLeast cudaMajorMinorVersion cudaCapabilityInfo.minCudaMajorMinorVersion;

     

       69
       69
       +
             upperBoundSatisfied =

     

       70
       70
       +
               cudaCapabilityInfo.maxCudaMajorMinorVersion == null

     

       71
       71
       +
               || lib.versionAtLeast cudaCapabilityInfo.maxCudaMajorMinorVersion cudaMajorMinorVersion;

     

       72
       72
       +
           in

     

       73
       73
       +
           lowerBoundSatisfied && upperBoundSatisfied;

     

       74
       74
       +
       

     

       75
       75
       +
         /**

     

       76
       76
       +
           Generates a CUDA variant name from a version.

     

       77
       77
       +
       

     

       78
       78
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       79
       79
       +
       

     

       80
       80
       +
           # Type

     

       81
       81
       +
       

     

       82
       82
       +
           ```

     

       83
       83
       +
           _mkCudaVariant :: (version :: String) -> String

     

       84
       84
       +
           ```

     

       85
       85
       +
       

     

       86
       86
       +
           # Inputs

     

       87
       87
       +
       

     

       88
       88
       +
           `version`

     

       89
       89
       +
       

     

       90
       90
       +
           : The version string

     

       91
       91
       +
       

     

       92
       92
       +
           # Examples

     

       93
       93
       +
       

     

       94
       94
       +
           :::{.example}

     

       95
       95
       +
           ## `cudaLib.utils._mkCudaVariant` usage examples

     

       96
       96
       +
       

     

       97
       97
       +
           ```nix

     

       98
       98
       +
           _mkCudaVariant "11.0"

     

       99
       99
       +
           => "cuda11"

     

       100
       100
       +
           ```

     

       101
       101
       +
           :::

     

       102
       102
       +
         */

     

       103
       103
       +
         _mkCudaVariant = version: "cuda${lib.versions.major version}";

     

       104
       104
       +
       

     

       105
       105
       +
         /**

     

       106
       106
       +
           A predicate which, given a package, returns true if the package has a free license or one of NVIDIA's licenses.

     

       107
       107
       +
       

     

       108
       108
       +
           This function is intended to be provided as `config.allowUnfreePredicate` when `import`-ing Nixpkgs.

     

       109
       109
       +
       

     

       110
       110
       +
           # Type

     

       111
       111
       +
       

     

       112
       112
       +
           ```

     

       113
       113
       +
           allowUnfreeCudaPredicate :: (package :: Package) -> Bool

     

       114
       114
       +
           ```

     

       115
       115
       +
         */

     

       116
       116
       +
         allowUnfreeCudaPredicate =

     

       117
       117
       +
           package:

     

       118
       118
       +
           lib.all (

     

       119
       119
       +
             license:

     

       120
       120
       +
             license.free

     

       121
       121
       +
             || lib.elem license.shortName [

     

       122
       122
       +
               "CUDA EULA"

     

       123
       123
       +
               "cuDNN EULA"

     

       124
       124
       +
               "cuSPARSELt EULA"

     

       125
       125
       +
               "cuTENSOR EULA"

     

       126
       126
       +
               "NVidia OptiX EULA"

     

       127
       127
       +
             ]

     

       128
       128
       +
           ) (lib.toList package.meta.license);

     

       129
       129
       +
       }

+49

pkgs/development/cuda-modules/lib/utils/default.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         # See ./assertions.nix for documentation.

     

       4
       4
       +
         inherit (import ./assertions.nix { inherit cudaLib lib; })

     

       5
       5
       +
           _evaluateAssertions

     

       6
       6
       +
           _mkFailedAssertionsString

     

       7
       7
       +
           _mkMissingPackagesAssertions

     

       8
       8
       +
           ;

     

       9
       9
       +
       

     

       10
       10
       +
         # See ./cuda.nix for documentation.

     

       11
       11
       +
         inherit (import ./cuda.nix { inherit lib; })

     

       12
       12
       +
           _cudaCapabilityIsDefault

     

       13
       13
       +
           _cudaCapabilityIsSupported

     

       14
       14
       +
           _mkCudaVariant

     

       15
       15
       +
           allowUnfreeCudaPredicate

     

       16
       16
       +
           ;

     

       17
       17
       +
       

     

       18
       18
       +
         # See ./meta.nix for documentation.

     

       19
       19
       +
         inherit (import ./meta.nix { inherit cudaLib lib; })

     

       20
       20
       +
           _mkMetaBadPlatforms

     

       21
       21
       +
           _mkMetaBroken

     

       22
       22
       +
           ;

     

       23
       23
       +
       

     

       24
       24
       +
         # See ./redist.nix for documentation.

     

       25
       25
       +
         inherit (import ./redist.nix { inherit cudaLib lib; })

     

       26
       26
       +
           _redistSystemIsSupported

     

       27
       27
       +
           getNixSystems

     

       28
       28
       +
           getRedistSystem

     

       29
       29
       +
           mkRedistUrl

     

       30
       30
       +
           ;

     

       31
       31
       +
       

     

       32
       32
       +
         # See ./strings.nix for documentation.

     

       33
       33
       +
         inherit (import ./strings.nix { inherit cudaLib lib; })

     

       34
       34
       +
           dotsToUnderscores

     

       35
       35
       +
           dropDots

     

       36
       36
       +
           formatCapabilities

     

       37
       37
       +
           mkCmakeCudaArchitecturesString

     

       38
       38
       +
           mkGencodeFlag

     

       39
       39
       +
           mkRealArchitecture

     

       40
       40
       +
           mkVersionedName

     

       41
       41
       +
           mkVirtualArchitecture

     

       42
       42
       +
           ;

     

       43
       43
       +
       

     

       44
       44
       +
         # See ./versions.nix for documentation.

     

       45
       45
       +
         inherit (import ./versions.nix { inherit cudaLib lib; })

     

       46
       46
       +
           majorMinorPatch

     

       47
       47
       +
           trimComponents

     

       48
       48
       +
           ;

     

       49
       49
       +
       }

+71

pkgs/development/cuda-modules/lib/utils/meta.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Returns a list of bad platforms for a given package if assertsions in `finalAttrs.passthru.platformAssertions`

     

       5
       5
       +
           fail, optionally logging evaluation warnings for each reason.

     

       6
       6
       +
       

     

       7
       7
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       8
       8
       +
       

     

       9
       9
       +
           NOTE: This function requires `finalAttrs.passthru.platformAssertions` to be a list of assertions and

     

       10
       10
       +
           `finalAttrs.finalPackage.name` and `finalAttrs.finalPackage.stdenv` to be available.

     

       11
       11
       +
       

     

       12
       12
       +
           # Type

     

       13
       13
       +
       

     

       14
       14
       +
           ```

     

       15
       15
       +
           _mkMetaBadPlatforms :: (warn :: Bool) -> (finalAttrs :: AttrSet) -> List String

     

       16
       16
       +
           ```

     

       17
       17
       +
         */

     

       18
       18
       +
         _mkMetaBadPlatforms =

     

       19
       19
       +
           warn: finalAttrs:

     

       20
       20
       +
           let

     

       21
       21
       +
             failedAssertionsString = cudaLib.utils._mkFailedAssertionsString finalAttrs.passthru.platformAssertions;

     

       22
       22
       +
             hasFailedAssertions = failedAssertionsString != "";

     

       23
       23
       +
             finalStdenv = finalAttrs.finalPackage.stdenv;

     

       24
       24
       +
           in

     

       25
       25
       +
           lib.warnIf (warn && hasFailedAssertions)

     

       26
       26
       +
             "Package ${finalAttrs.finalPackage.name} is unsupported on this platform due to the following failed assertions:${failedAssertionsString}"

     

       27
       27
       +
             (

     

       28
       28
       +
               lib.optionals hasFailedAssertions (

     

       29
       29
       +
                 lib.unique [

     

       30
       30
       +
                   finalStdenv.buildPlatform.system

     

       31
       31
       +
                   finalStdenv.hostPlatform.system

     

       32
       32
       +
                   finalStdenv.targetPlatform.system

     

       33
       33
       +
                 ]

     

       34
       34
       +
               )

     

       35
       35
       +
             );

     

       36
       36
       +
       

     

       37
       37
       +
         /**

     

       38
       38
       +
           Returns a boolean indicating whether the package is broken as a result of `finalAttrs.passthru.brokenAssertions`,

     

       39
       39
       +
           optionally logging evaluation warnings for each reason.

     

       40
       40
       +
       

     

       41
       41
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       42
       42
       +
       

     

       43
       43
       +
           NOTE: This function requires `finalAttrs.passthru.brokenAssertions` to be a list of assertions and

     

       44
       44
       +
           `finalAttrs.finalPackage.name` to be available.

     

       45
       45
       +
       

     

       46
       46
       +
           # Type

     

       47
       47
       +
       

     

       48
       48
       +
           ```

     

       49
       49
       +
           _mkMetaBroken :: (warn :: Bool) -> (finalAttrs :: AttrSet) -> Bool

     

       50
       50
       +
           ```

     

       51
       51
       +
       

     

       52
       52
       +
           # Inputs

     

       53
       53
       +
       

     

       54
       54
       +
           `warn`

     

       55
       55
       +
       

     

       56
       56
       +
           : A boolean indicating whether to log warnings

     

       57
       57
       +
       

     

       58
       58
       +
           `finalAttrs`

     

       59
       59
       +
       

     

       60
       60
       +
           : The final attributes of the package

     

       61
       61
       +
         */

     

       62
       62
       +
         _mkMetaBroken =

     

       63
       63
       +
           warn: finalAttrs:

     

       64
       64
       +
           let

     

       65
       65
       +
             failedAssertionsString = cudaLib.utils._mkFailedAssertionsString finalAttrs.passthru.brokenAssertions;

     

       66
       66
       +
             hasFailedAssertions = failedAssertionsString != "";

     

       67
       67
       +
           in

     

       68
       68
       +
           lib.warnIf (warn && hasFailedAssertions)

     

       69
       69
       +
             "Package ${finalAttrs.finalPackage.name} is marked as broken due to the following failed assertions:${failedAssertionsString}"

     

       70
       70
       +
             hasFailedAssertions;

     

       71
       71
       +
       }

+196

pkgs/development/cuda-modules/lib/utils/redist.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Returns a boolean indicating whether the provided redist system is supported by any of the provided redist systems.

     

       5
       5
       +
       

     

       6
       6
       +
           NOTE: No guarantees are made about this function's stability. You may use it at your own risk.

     

       7
       7
       +
       

     

       8
       8
       +
           # Type

     

       9
       9
       +
       

     

       10
       10
       +
           ```

     

       11
       11
       +
           _redistSystemIsSupported

     

       12
       12
       +
             :: (redistSystem :: RedistSystem)

     

       13
       13
       +
             -> (redistSystems :: List RedistSystem)

     

       14
       14
       +
             -> Bool

     

       15
       15
       +
           ```

     

       16
       16
       +
       

     

       17
       17
       +
           # Inputs

     

       18
       18
       +
       

     

       19
       19
       +
           `redistSystem`

     

       20
       20
       +
       

     

       21
       21
       +
           : The redist system to check

     

       22
       22
       +
       

     

       23
       23
       +
           `redistSystems`

     

       24
       24
       +
       

     

       25
       25
       +
           : The list of redist systems to check against

     

       26
       26
       +
       

     

       27
       27
       +
           # Examples

     

       28
       28
       +
       

     

       29
       29
       +
           :::{.example}

     

       30
       30
       +
           ## `cudaLib.utils._redistSystemIsSupported` usage examples

     

       31
       31
       +
       

     

       32
       32
       +
           ```nix

     

       33
       33
       +
           _redistSystemIsSupported "linux-x86_64" [ "linux-x86_64" ]

     

       34
       34
       +
           => true

     

       35
       35
       +
           ```

     

       36
       36
       +
       

     

       37
       37
       +
           ```nix

     

       38
       38
       +
           _redistSystemIsSupported "linux-x86_64" [ "linux-aarch64" ]

     

       39
       39
       +
           => false

     

       40
       40
       +
           ```

     

       41
       41
       +
       

     

       42
       42
       +
           ```nix

     

       43
       43
       +
           _redistSystemIsSupported "linux-x86_64" [ "linux-aarch64" "linux-x86_64" ]

     

       44
       44
       +
           => true

     

       45
       45
       +
           ```

     

       46
       46
       +
       

     

       47
       47
       +
           ```nix

     

       48
       48
       +
           _redistSystemIsSupported "linux-x86_64" [ "linux-aarch64" "linux-all" ]

     

       49
       49
       +
           => true

     

       50
       50
       +
           ```

     

       51
       51
       +
           :::

     

       52
       52
       +
         */

     

       53
       53
       +
         _redistSystemIsSupported =

     

       54
       54
       +
           redistSystem: redistSystems:

     

       55
       55
       +
           lib.findFirst (

     

       56
       56
       +
             redistSystem':

     

       57
       57
       +
             redistSystem' == redistSystem || redistSystem' == "linux-all" || redistSystem' == "source"

     

       58
       58
       +
           ) null redistSystems != null;

     

       59
       59
       +
       

     

       60
       60
       +
         /**

     

       61
       61
       +
           Maps a NVIDIA redistributable system to Nix systems.

     

       62
       62
       +
       

     

       63
       63
       +
           NOTE: This function returns a list of systems because the redistributable systems `"linux-all"` and `"source"` can

     

       64
       64
       +
           be built on multiple systems.

     

       65
       65
       +
       

     

       66
       66
       +
           NOTE: This function *will* be called by unsupported systems because `cudaPackages` is evaluated on all systems. As

     

       67
       67
       +
           such, we need to handle unsupported systems gracefully.

     

       68
       68
       +
       

     

       69
       69
       +
           # Type

     

       70
       70
       +
       

     

       71
       71
       +
           ```

     

       72
       72
       +
           getNixSystems :: (redistSystem :: RedistSystem) -> [String]

     

       73
       73
       +
           ```

     

       74
       74
       +
       

     

       75
       75
       +
           # Inputs

     

       76
       76
       +
       

     

       77
       77
       +
           `redistSystem`

     

       78
       78
       +
       

     

       79
       79
       +
           : The NVIDIA redistributable system

     

       80
       80
       +
       

     

       81
       81
       +
           # Examples

     

       82
       82
       +
       

     

       83
       83
       +
           :::{.example}

     

       84
       84
       +
           ## `cudaLib.utils.getNixSystems` usage examples

     

       85
       85
       +
       

     

       86
       86
       +
           ```nix

     

       87
       87
       +
           getNixSystems "linux-sbsa"

     

       88
       88
       +
           => [ "aarch64-linux" ]

     

       89
       89
       +
           ```

     

       90
       90
       +
       

     

       91
       91
       +
           ```nix

     

       92
       92
       +
           getNixSystems "linux-aarch64"

     

       93
       93
       +
           => [ "aarch64-linux" ]

     

       94
       94
       +
           ```

     

       95
       95
       +
           :::

     

       96
       96
       +
         */

     

       97
       97
       +
         getNixSystems =

     

       98
       98
       +
           redistSystem:

     

       99
       99
       +
           if redistSystem == "linux-x86_64" then

     

       100
       100
       +
             [ "x86_64-linux" ]

     

       101
       101
       +
           else if redistSystem == "linux-sbsa" || redistSystem == "linux-aarch64" then

     

       102
       102
       +
             [ "aarch64-linux" ]

     

       103
       103
       +
           else if redistSystem == "linux-all" || redistSystem == "source" then

     

       104
       104
       +
             [

     

       105
       105
       +
               "aarch64-linux"

     

       106
       106
       +
               "x86_64-linux"

     

       107
       107
       +
             ]

     

       108
       108
       +
           else

     

       109
       109
       +
             [ ];

     

       110
       110
       +
       

     

       111
       111
       +
         /**

     

       112
       112
       +
           Maps a Nix system to a NVIDIA redistributable system.

     

       113
       113
       +
       

     

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

     

       115
       115
       +
           (which is for Jetson devices) if we're building any Jetson devices. Since both are based on aarch64, we can only

     

       116
       116
       +
           have one or the other, otherwise there's an ambiguity as to which should be used.

     

       117
       117
       +
       

     

       118
       118
       +
           NOTE: This function *will* be called by unsupported systems because `cudaPackages` is evaluated on all systems. As

     

       119
       119
       +
           such, we need to handle unsupported systems gracefully.

     

       120
       120
       +
       

     

       121
       121
       +
           # Type

     

       122
       122
       +
       

     

       123
       123
       +
           ```

     

       124
       124
       +
           getRedistSystem :: (hasJetsonCudaCapability :: Bool) -> (nixSystem :: String) -> String

     

       125
       125
       +
           ```

     

       126
       126
       +
       

     

       127
       127
       +
           # Inputs

     

       128
       128
       +
       

     

       129
       129
       +
           `hasJetsonCudaCapability`

     

       130
       130
       +
       

     

       131
       131
       +
           : If configured for a Jetson device

     

       132
       132
       +
       

     

       133
       133
       +
           `nixSystem`

     

       134
       134
       +
       

     

       135
       135
       +
           : The Nix system

     

       136
       136
       +
       

     

       137
       137
       +
           # Examples

     

       138
       138
       +
       

     

       139
       139
       +
           :::{.example}

     

       140
       140
       +
           ## `cudaLib.utils.getRedistSystem` usage examples

     

       141
       141
       +
       

     

       142
       142
       +
           ```nix

     

       143
       143
       +
           getRedistSystem true "aarch64-linux"

     

       144
       144
       +
           => "linux-aarch64"

     

       145
       145
       +
           ```

     

       146
       146
       +
       

     

       147
       147
       +
           ```nix

     

       148
       148
       +
           getRedistSystem false "aarch64-linux"

     

       149
       149
       +
           => "linux-sbsa"

     

       150
       150
       +
           ```

     

       151
       151
       +
           :::

     

       152
       152
       +
         */

     

       153
       153
       +
         getRedistSystem =

     

       154
       154
       +
           hasJetsonCudaCapability: nixSystem:

     

       155
       155
       +
           if nixSystem == "x86_64-linux" then

     

       156
       156
       +
             "linux-x86_64"

     

       157
       157
       +
           else if nixSystem == "aarch64-linux" then

     

       158
       158
       +
             if hasJetsonCudaCapability then "linux-aarch64" else "linux-sbsa"

     

       159
       159
       +
           else

     

       160
       160
       +
             "unsupported";

     

       161
       161
       +
       

     

       162
       162
       +
         /**

     

       163
       163
       +
           Function to generate a URL for something in the redistributable tree.

     

       164
       164
       +
       

     

       165
       165
       +
           # Type

     

       166
       166
       +
       

     

       167
       167
       +
           ```

     

       168
       168
       +
           mkRedistUrl :: (redistName :: RedistName) -> (relativePath :: NonEmptyStr) -> RedistUrl

     

       169
       169
       +
           ```

     

       170
       170
       +
       

     

       171
       171
       +
           # Inputs

     

       172
       172
       +
       

     

       173
       173
       +
           `redistName`

     

       174
       174
       +
       

     

       175
       175
       +
           : The name of the redistributable

     

       176
       176
       +
       

     

       177
       177
       +
           `relativePath`

     

       178
       178
       +
       

     

       179
       179
       +
           : The relative path to a file in the redistributable tree

     

       180
       180
       +
         */

     

       181
       181
       +
         mkRedistUrl =

     

       182
       182
       +
           redistName: relativePath:

     

       183
       183
       +
           lib.concatStringsSep "/" (

     

       184
       184
       +
             [ cudaLib.data.redistUrlPrefix ]

     

       185
       185
       +
             ++ (

     

       186
       186
       +
               if redistName != "tensorrt" then

     

       187
       187
       +
                 [

     

       188
       188
       +
                   redistName

     

       189
       189
       +
                   "redist"

     

       190
       190
       +
                 ]

     

       191
       191
       +
               else

     

       192
       192
       +
                 [ "machine-learning" ]

     

       193
       193
       +
             )

     

       194
       194
       +
             ++ [ relativePath ]

     

       195
       195
       +
           );

     

       196
       196
       +
       }

+379

pkgs/development/cuda-modules/lib/utils/strings.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Replaces dots in a string with underscores.

     

       5
       5
       +
       

     

       6
       6
       +
           # Type

     

       7
       7
       +
       

     

       8
       8
       +
           ```

     

       9
       9
       +
           dotsToUnderscores :: (str :: String) -> String

     

       10
       10
       +
           ```

     

       11
       11
       +
       

     

       12
       12
       +
           # Inputs

     

       13
       13
       +
       

     

       14
       14
       +
           `str`

     

       15
       15
       +
       

     

       16
       16
       +
           : The string for which dots shall be replaced by underscores

     

       17
       17
       +
       

     

       18
       18
       +
           # Examples

     

       19
       19
       +
       

     

       20
       20
       +
           :::{.example}

     

       21
       21
       +
           ## `cudaLib.utils.dotsToUnderscores` usage examples

     

       22
       22
       +
       

     

       23
       23
       +
           ```nix

     

       24
       24
       +
           dotsToUnderscores "1.2.3"

     

       25
       25
       +
           => "1_2_3"

     

       26
       26
       +
           ```

     

       27
       27
       +
           :::

     

       28
       28
       +
         */

     

       29
       29
       +
         dotsToUnderscores = lib.replaceStrings [ "." ] [ "_" ];

     

       30
       30
       +
       

     

       31
       31
       +
         /**

     

       32
       32
       +
           Removes the dots from a string.

     

       33
       33
       +
       

     

       34
       34
       +
           # Type

     

       35
       35
       +
       

     

       36
       36
       +
           ```

     

       37
       37
       +
           dropDots :: (str :: String) -> String

     

       38
       38
       +
           ```

     

       39
       39
       +
       

     

       40
       40
       +
           # Inputs

     

       41
       41
       +
       

     

       42
       42
       +
           `str`

     

       43
       43
       +
       

     

       44
       44
       +
           : The string to remove dots from

     

       45
       45
       +
       

     

       46
       46
       +
           # Examples

     

       47
       47
       +
       

     

       48
       48
       +
           :::{.example}

     

       49
       49
       +
           ## `cudaLib.utils.dropDots` usage examples

     

       50
       50
       +
       

     

       51
       51
       +
           ```nix

     

       52
       52
       +
           dropDots "1.2.3"

     

       53
       53
       +
           => "123"

     

       54
       54
       +
           ```

     

       55
       55
       +
           :::

     

       56
       56
       +
         */

     

       57
       57
       +
         dropDots = lib.replaceStrings [ "." ] [ "" ];

     

       58
       58
       +
       

     

       59
       59
       +
         /**

     

       60
       60
       +
           Produces an attribute set of useful data and functionality for packaging CUDA software within Nixpkgs.

     

       61
       61
       +
       

     

       62
       62
       +
           # Type

     

       63
       63
       +
       

     

       64
       64
       +
           ```

     

       65
       65
       +
           formatCapabilities

     

       66
       66
       +
             :: { cudaCapabilityToInfo :: AttrSet CudaCapability CudaCapabilityInfo

     

       67
       67
       +
                , cudaCapabilities :: List CudaCapability

     

       68
       68
       +
                , cudaForwardCompat :: Bool

     

       69
       69
       +
                }

     

       70
       70
       +
             -> { cudaCapabilities :: List CudaCapability

     

       71
       71
       +
                , cudaForwardCompat :: Bool

     

       72
       72
       +
                , gencode :: List String

     

       73
       73
       +
                , realArches :: List String

     

       74
       74
       +
                , virtualArches :: List String

     

       75
       75
       +
                , archNames :: List String

     

       76
       76
       +
                , arches :: List String

     

       77
       77
       +
                , gencodeString :: String

     

       78
       78
       +
                , cmakeCudaArchitecturesString :: String

     

       79
       79
       +
                }

     

       80
       80
       +
           ```

     

       81
       81
       +
       

     

       82
       82
       +
           # Inputs

     

       83
       83
       +
       

     

       84
       84
       +
           `cudaCapabilityToInfo`

     

       85
       85
       +
       

     

       86
       86
       +
           : A mapping of CUDA capabilities to their information

     

       87
       87
       +
       

     

       88
       88
       +
           `cudaCapabilities`

     

       89
       89
       +
       

     

       90
       90
       +
           : A list of CUDA capabilities to use

     

       91
       91
       +
       

     

       92
       92
       +
           `cudaForwardCompat`

     

       93
       93
       +
       

     

       94
       94
       +
           : A boolean indicating whether to include the forward compatibility gencode (+PTX) to support future GPU

     

       95
       95
       +
             generations

     

       96
       96
       +
         */

     

       97
       97
       +
         formatCapabilities =

     

       98
       98
       +
           {

     

       99
       99
       +
             cudaCapabilityToInfo,

     

       100
       100
       +
             cudaCapabilities,

     

       101
       101
       +
             cudaForwardCompat,

     

       102
       102
       +
           }:

     

       103
       103
       +
           let

     

       104
       104
       +
             /**

     

       105
       105
       +
               The real architectures for the given CUDA capabilities.

     

       106
       106
       +
       

     

       107
       107
       +
               # Type

     

       108
       108
       +
       

     

       109
       109
       +
               ```

     

       110
       110
       +
               realArches :: List String

     

       111
       111
       +
               ```

     

       112
       112
       +
             */

     

       113
       113
       +
             realArches = lib.map cudaLib.utils.mkRealArchitecture cudaCapabilities;

     

       114
       114
       +
       

     

       115
       115
       +
             /**

     

       116
       116
       +
               The virtual architectures for the given CUDA capabilities.

     

       117
       117
       +
       

     

       118
       118
       +
               These are typically used for forward compatibility, when trying to support an architecture newer than the CUDA

     

       119
       119
       +
               version allows.

     

       120
       120
       +
       

     

       121
       121
       +
               # Type

     

       122
       122
       +
       

     

       123
       123
       +
               ```

     

       124
       124
       +
               virtualArches :: List String

     

       125
       125
       +
               ```

     

       126
       126
       +
             */

     

       127
       127
       +
             virtualArches = lib.map cudaLib.utils.mkVirtualArchitecture cudaCapabilities;

     

       128
       128
       +
       

     

       129
       129
       +
             /**

     

       130
       130
       +
               The gencode flags for the given CUDA capabilities.

     

       131
       131
       +
       

     

       132
       132
       +
               # Type

     

       133
       133
       +
       

     

       134
       134
       +
               ```

     

       135
       135
       +
               gencode :: List String

     

       136
       136
       +
               ```

     

       137
       137
       +
             */

     

       138
       138
       +
             gencode =

     

       139
       139
       +
               let

     

       140
       140
       +
                 base = lib.map (cudaLib.utils.mkGencodeFlag "sm") cudaCapabilities;

     

       141
       141
       +
                 forward = cudaLib.utils.mkGencodeFlag "compute" (lib.last cudaCapabilities);

     

       142
       142
       +
               in

     

       143
       143
       +
               base ++ lib.optionals cudaForwardCompat [ forward ];

     

       144
       144
       +
           in

     

       145
       145
       +
           {

     

       146
       146
       +
             inherit

     

       147
       147
       +
               cudaCapabilities

     

       148
       148
       +
               cudaForwardCompat

     

       149
       149
       +
               gencode

     

       150
       150
       +
               realArches

     

       151
       151
       +
               virtualArches

     

       152
       152
       +
               ;

     

       153
       153
       +
       

     

       154
       154
       +
             /**

     

       155
       155
       +
               The architecture names for the given CUDA capabilities.

     

       156
       156
       +
       

     

       157
       157
       +
               # Type

     

       158
       158
       +
       

     

       159
       159
       +
               ```

     

       160
       160
       +
               archNames :: List String

     

       161
       161
       +
               ```

     

       162
       162
       +
             */

     

       163
       163
       +
             # E.g. [ "Ampere" "Turing" ]

     

       164
       164
       +
             archNames = lib.pipe cudaCapabilities [

     

       165
       165
       +
               (lib.map (cudaCapability: cudaCapabilityToInfo.${cudaCapability}.archName))

     

       166
       166
       +
               lib.unique

     

       167
       167
       +
               lib.naturalSort

     

       168
       168
       +
             ];

     

       169
       169
       +
       

     

       170
       170
       +
             /**

     

       171
       171
       +
               The architectures for the given CUDA capabilities, including both real and virtual architectures.

     

       172
       172
       +
       

     

       173
       173
       +
               When `cudaForwardCompat` is enabled, the last architecture in the list is used as the forward compatibility architecture.

     

       174
       174
       +
       

     

       175
       175
       +
               # Type

     

       176
       176
       +
       

     

       177
       177
       +
               ```

     

       178
       178
       +
               arches :: List String

     

       179
       179
       +
               ```

     

       180
       180
       +
             */

     

       181
       181
       +
             # E.g. [ "sm_75" "sm_86" "compute_86" ]

     

       182
       182
       +
             arches = realArches ++ lib.optionals cudaForwardCompat [ (lib.last virtualArches) ];

     

       183
       183
       +
       

     

       184
       184
       +
             /**

     

       185
       185
       +
               The CMake-compatible CUDA architectures string for the given CUDA capabilities.

     

       186
       186
       +
       

     

       187
       187
       +
               # Type

     

       188
       188
       +
       

     

       189
       189
       +
               ```

     

       190
       190
       +
               cmakeCudaArchitecturesString :: String

     

       191
       191
       +
               ```

     

       192
       192
       +
             */

     

       193
       193
       +
             cmakeCudaArchitecturesString = cudaLib.utils.mkCmakeCudaArchitecturesString cudaCapabilities;

     

       194
       194
       +
       

     

       195
       195
       +
             /**

     

       196
       196
       +
               The gencode string for the given CUDA capabilities.

     

       197
       197
       +
       

     

       198
       198
       +
               # Type

     

       199
       199
       +
       

     

       200
       200
       +
               ```

     

       201
       201
       +
               gencodeString :: String

     

       202
       202
       +
               ```

     

       203
       203
       +
             */

     

       204
       204
       +
             gencodeString = lib.concatStringsSep " " gencode;

     

       205
       205
       +
           };

     

       206
       206
       +
       

     

       207
       207
       +
         /**

     

       208
       208
       +
           Produces a CMake-compatible CUDA architecture string from a list of CUDA capabilities.

     

       209
       209
       +
       

     

       210
       210
       +
           # Type

     

       211
       211
       +
       

     

       212
       212
       +
           ```

     

       213
       213
       +
           mkCmakeCudaArchitecturesString :: (cudaCapabilities :: List String) -> String

     

       214
       214
       +
           ```

     

       215
       215
       +
       

     

       216
       216
       +
           # Inputs

     

       217
       217
       +
       

     

       218
       218
       +
           `cudaCapabilities`

     

       219
       219
       +
       

     

       220
       220
       +
           : The CUDA capabilities to convert

     

       221
       221
       +
       

     

       222
       222
       +
           # Examples

     

       223
       223
       +
       

     

       224
       224
       +
           :::{.example}

     

       225
       225
       +
           ## `cudaLib.utils.mkCmakeCudaArchitecturesString` usage examples

     

       226
       226
       +
       

     

       227
       227
       +
           ```nix

     

       228
       228
       +
           mkCmakeCudaArchitecturesString [ "8.9" "10.0a" ]

     

       229
       229
       +
           => "89;100a"

     

       230
       230
       +
           ```

     

       231
       231
       +
           :::

     

       232
       232
       +
         */

     

       233
       233
       +
         mkCmakeCudaArchitecturesString = lib.concatMapStringsSep ";" cudaLib.utils.dropDots;

     

       234
       234
       +
       

     

       235
       235
       +
         /**

     

       236
       236
       +
           Produces a gencode flag from a CUDA capability.

     

       237
       237
       +
       

     

       238
       238
       +
           # Type

     

       239
       239
       +
       

     

       240
       240
       +
           ```

     

       241
       241
       +
           mkGencodeFlag :: (archPrefix :: String) -> (cudaCapability :: String) -> String

     

       242
       242
       +
           ```

     

       243
       243
       +
       

     

       244
       244
       +
           # Inputs

     

       245
       245
       +
       

     

       246
       246
       +
           `archPrefix`

     

       247
       247
       +
       

     

       248
       248
       +
           : The architecture prefix to use for the `code` field

     

       249
       249
       +
       

     

       250
       250
       +
           `cudaCapability`

     

       251
       251
       +
       

     

       252
       252
       +
           : The CUDA capability to convert

     

       253
       253
       +
       

     

       254
       254
       +
           # Examples

     

       255
       255
       +
       

     

       256
       256
       +
           :::{.example}

     

       257
       257
       +
           ## `cudaLib.utils.mkGencodeFlag` usage examples

     

       258
       258
       +
       

     

       259
       259
       +
           ```nix

     

       260
       260
       +
           mkGencodeFlag "sm" "8.9"

     

       261
       261
       +
           => "-gencode=arch=compute_89,code=sm_89"

     

       262
       262
       +
           ```

     

       263
       263
       +
       

     

       264
       264
       +
           ```nix

     

       265
       265
       +
           mkGencodeFlag "compute" "10.0a"

     

       266
       266
       +
           => "-gencode=arch=compute_100a,code=compute_100a"

     

       267
       267
       +
           ```

     

       268
       268
       +
           :::

     

       269
       269
       +
         */

     

       270
       270
       +
         mkGencodeFlag =

     

       271
       271
       +
           archPrefix: cudaCapability:

     

       272
       272
       +
           let

     

       273
       273
       +
             cap = cudaLib.utils.dropDots cudaCapability;

     

       274
       274
       +
           in

     

       275
       275
       +
           "-gencode=arch=compute_${cap},code=${archPrefix}_${cap}";

     

       276
       276
       +
       

     

       277
       277
       +
         /**

     

       278
       278
       +
           Produces a real architecture string from a CUDA capability.

     

       279
       279
       +
       

     

       280
       280
       +
           # Type

     

       281
       281
       +
       

     

       282
       282
       +
           ```

     

       283
       283
       +
           mkRealArchitecture :: (cudaCapability :: String) -> String

     

       284
       284
       +
           ```

     

       285
       285
       +
       

     

       286
       286
       +
           # Inputs

     

       287
       287
       +
       

     

       288
       288
       +
           `cudaCapability`

     

       289
       289
       +
       

     

       290
       290
       +
           : The CUDA capability to convert

     

       291
       291
       +
       

     

       292
       292
       +
           # Examples

     

       293
       293
       +
       

     

       294
       294
       +
           :::{.example}

     

       295
       295
       +
           ## `cudaLib.utils.mkRealArchitecture` usage examples

     

       296
       296
       +
       

     

       297
       297
       +
           ```nix

     

       298
       298
       +
           mkRealArchitecture "8.9"

     

       299
       299
       +
           => "sm_89"

     

       300
       300
       +
           ```

     

       301
       301
       +
       

     

       302
       302
       +
           ```nix

     

       303
       303
       +
           mkRealArchitecture "10.0a"

     

       304
       304
       +
           => "sm_100a"

     

       305
       305
       +
           ```

     

       306
       306
       +
           :::

     

       307
       307
       +
         */

     

       308
       308
       +
         mkRealArchitecture = cudaCapability: "sm_" + cudaLib.utils.dropDots cudaCapability;

     

       309
       309
       +
       

     

       310
       310
       +
         /**

     

       311
       311
       +
           Create a versioned attribute name from a version by replacing dots with underscores.

     

       312
       312
       +
       

     

       313
       313
       +
           # Type

     

       314
       314
       +
       

     

       315
       315
       +
           ```

     

       316
       316
       +
           mkVersionedName :: (name :: String) -> (version :: Version) -> String

     

       317
       317
       +
           ```

     

       318
       318
       +
       

     

       319
       319
       +
           # Inputs

     

       320
       320
       +
       

     

       321
       321
       +
           `name`

     

       322
       322
       +
       

     

       323
       323
       +
           : The name to use

     

       324
       324
       +
       

     

       325
       325
       +
           `version`

     

       326
       326
       +
       

     

       327
       327
       +
           : The version to use

     

       328
       328
       +
       

     

       329
       329
       +
           # Examples

     

       330
       330
       +
       

     

       331
       331
       +
           :::{.example}

     

       332
       332
       +
           ## `cudaLib.utils.mkVersionedName` usage examples

     

       333
       333
       +
       

     

       334
       334
       +
           ```nix

     

       335
       335
       +
           mkVersionedName "hello" "1.2.3"

     

       336
       336
       +
           => "hello_1_2_3"

     

       337
       337
       +
           ```

     

       338
       338
       +
       

     

       339
       339
       +
           ```nix

     

       340
       340
       +
           mkVersionedName "cudaPackages" "12.8"

     

       341
       341
       +
           => "cudaPackages_12_8"

     

       342
       342
       +
           ```

     

       343
       343
       +
           :::

     

       344
       344
       +
         */

     

       345
       345
       +
         mkVersionedName = name: version: "${name}_${cudaLib.utils.dotsToUnderscores version}";

     

       346
       346
       +
       

     

       347
       347
       +
         /**

     

       348
       348
       +
           Produces a virtual architecture string from a CUDA capability.

     

       349
       349
       +
       

     

       350
       350
       +
           # Type

     

       351
       351
       +
       

     

       352
       352
       +
           ```

     

       353
       353
       +
           mkVirtualArchitecture :: (cudaCapability :: String) -> String

     

       354
       354
       +
           ```

     

       355
       355
       +
       

     

       356
       356
       +
           # Inputs

     

       357
       357
       +
       

     

       358
       358
       +
           `cudaCapability`

     

       359
       359
       +
       

     

       360
       360
       +
           : The CUDA capability to convert

     

       361
       361
       +
       

     

       362
       362
       +
           # Examples

     

       363
       363
       +
       

     

       364
       364
       +
           :::{.example}

     

       365
       365
       +
           ## `cudaLib.utils.mkVirtualArchitecture` usage examples

     

       366
       366
       +
       

     

       367
       367
       +
           ```nix

     

       368
       368
       +
           mkVirtualArchitecture "8.9"

     

       369
       369
       +
           => "compute_89"

     

       370
       370
       +
           ```

     

       371
       371
       +
       

     

       372
       372
       +
           ```nix

     

       373
       373
       +
           mkVirtualArchitecture "10.0a"

     

       374
       374
       +
           => "compute_100a"

     

       375
       375
       +
           ```

     

       376
       376
       +
           :::

     

       377
       377
       +
         */

     

       378
       378
       +
         mkVirtualArchitecture = cudaCapability: "compute_" + cudaLib.utils.dropDots cudaCapability;

     

       379
       379
       +
       }

+76

pkgs/development/cuda-modules/lib/utils/versions.nix

···

       1
       1
       +
       { cudaLib, lib }:

     

       2
       2
       +
       {

     

       3
       3
       +
         /**

     

       4
       4
       +
           Extracts the major, minor, and patch version from a string.

     

       5
       5
       +
       

     

       6
       6
       +
           # Type

     

       7
       7
       +
       

     

       8
       8
       +
           ```

     

       9
       9
       +
           majorMinorPatch :: (version :: String) -> String

     

       10
       10
       +
           ```

     

       11
       11
       +
       

     

       12
       12
       +
           # Inputs

     

       13
       13
       +
       

     

       14
       14
       +
           `version`

     

       15
       15
       +
       

     

       16
       16
       +
           : The version string

     

       17
       17
       +
       

     

       18
       18
       +
           # Examples

     

       19
       19
       +
       

     

       20
       20
       +
           :::{.example}

     

       21
       21
       +
           ## `cudaLib.utils.majorMinorPatch` usage examples

     

       22
       22
       +
       

     

       23
       23
       +
           ```nix

     

       24
       24
       +
           majorMinorPatch "11.0.3.4"

     

       25
       25
       +
           => "11.0.3"

     

       26
       26
       +
           ```

     

       27
       27
       +
           :::

     

       28
       28
       +
         */

     

       29
       29
       +
         majorMinorPatch = cudaLib.utils.trimComponents 3;

     

       30
       30
       +
       

     

       31
       31
       +
         /**

     

       32
       32
       +
           Get a version string with no more than than the specified number of components.

     

       33
       33
       +
       

     

       34
       34
       +
           # Type

     

       35
       35
       +
       

     

       36
       36
       +
           ```

     

       37
       37
       +
           trimComponents :: (numComponents :: Integer) -> (version :: String) -> String

     

       38
       38
       +
           ```

     

       39
       39
       +
       

     

       40
       40
       +
           # Inputs

     

       41
       41
       +
       

     

       42
       42
       +
           `numComponents`

     

       43
       43
       +
           : A positive integer corresponding to the maximum number of components to keep

     

       44
       44
       +
       

     

       45
       45
       +
           `version`

     

       46
       46
       +
           : A version string

     

       47
       47
       +
       

     

       48
       48
       +
           # Examples

     

       49
       49
       +
       

     

       50
       50
       +
           :::{.example}

     

       51
       51
       +
           ## `cudaLib.utils.trimComponents` usage examples

     

       52
       52
       +
       

     

       53
       53
       +
           ```nix

     

       54
       54
       +
           trimComponents 1 "1.2.3.4"

     

       55
       55
       +
           => "1"

     

       56
       56
       +
           ```

     

       57
       57
       +
       

     

       58
       58
       +
           ```nix

     

       59
       59
       +
           trimComponents 3 "1.2.3.4"

     

       60
       60
       +
           => "1.2.3"

     

       61
       61
       +
           ```

     

       62
       62
       +
       

     

       63
       63
       +
           ```nix

     

       64
       64
       +
           trimComponents 9 "1.2.3.4"

     

       65
       65
       +
           => "1.2.3.4"

     

       66
       66
       +
           ```

     

       67
       67
       +
           :::

     

       68
       68
       +
         */

     

       69
       69
       +
         trimComponents =

     

       70
       70
       +
           n: v:

     

       71
       71
       +
           lib.pipe v [

     

       72
       72
       +
             lib.splitVersion

     

       73
       73
       +
             (lib.take n)

     

       74
       74
       +
             (lib.concatStringsSep ".")

     

       75
       75
       +
           ];

     

       76
       76
       +
       }

pkgs/top-level/all-packages.nix

···

       2719
       2719
        
       

     

       2720
       2720
        
         cron = isc-cron;

     

       2721
       2721
        
       

     

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

     

       2723
       2723
       +
       

     

       2722
       2724
        
         cudaPackages_11_0 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "11.0"; };

     

       2723
       2725
        
         cudaPackages_11_1 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "11.1"; };

     

       2724
       2726
        
         cudaPackages_11_2 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "11.2"; };