···

       
115
       
115
       
 
       


     

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

     

       
117
       
117
       
 
       


     

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

     

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

     

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

     

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

     

       
120
       
120
       
 
       


     

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

     

       
122
       
122
       
 
       


     

···

       
1
       
1
       
+
       
{

     

       
2
       
2
       
+
       
  lib,

     

       
3
       
3
       
+
       
  bootstrapData,

     

       
4
       
4
       
+
       
  db,

     

       
5
       
5
       
+
       
}:

     

       
6
       
6
       
+
       


     

       
7
       
7
       
+
       
bootstrapData

     

       
8
       
8
       
+
       
// {

     

       
9
       
9
       
+
       
  /**

     

       
10
       
10
       
+
       
    All CUDA capabilities, sorted by version.

     

       
11
       
11
       
+
       


     

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

     

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

     

       
14
       
14
       
+
       
    set.

     

       
15
       
15
       
+
       


     

       
16
       
16
       
+
       
    # Type

     

       
17
       
17
       
+
       


     

       
18
       
18
       
+
       
    ```

     

       
19
       
19
       
+
       
    allSortedCudaCapabilities :: [CudaCapability]

     

       
20
       
20
       
+
       
    ```

     

       
21
       
21
       
+
       


     

       
22
       
22
       
+
       
    # Example

     

       
23
       
23
       
+
       


     

       
24
       
24
       
+
       
    ```

     

       
25
       
25
       
+
       
    allSortedCudaCapabilities = [

     

       
26
       
26
       
+
       
      "5.0"

     

       
27
       
27
       
+
       
      "5.2"

     

       
28
       
28
       
+
       
      "6.0"

     

       
29
       
29
       
+
       
      "6.1"

     

       
30
       
30
       
+
       
      "7.0"

     

       
31
       
31
       
+
       
      "7.2"

     

       
32
       
32
       
+
       
      "7.5"

     

       
33
       
33
       
+
       
      "8.0"

     

       
34
       
34
       
+
       
      "8.6"

     

       
35
       
35
       
+
       
      "8.7"

     

       
36
       
36
       
+
       
      "8.9"

     

       
37
       
37
       
+
       
      "9.0"

     

       
38
       
38
       
+
       
      "9.0a"

     

       
39
       
39
       
+
       
      "10.0"

     

       
40
       
40
       
+
       
      "10.0a"

     

       
41
       
41
       
+
       
      "10.0f"

     

       
42
       
42
       
+
       
      "10.1"

     

       
43
       
43
       
+
       
      "10.1a"

     

       
44
       
44
       
+
       
      "10.1f"

     

       
45
       
45
       
+
       
      "10.3"

     

       
46
       
46
       
+
       
      "10.3a"

     

       
47
       
47
       
+
       
      "10.3f"

     

       
48
       
48
       
+
       
    ];

     

       
49
       
49
       
+
       
    ```

     

       
50
       
50
       
+
       
  */

     

       
51
       
51
       
+
       
  allSortedCudaCapabilities = lib.sort lib.versionOlder (lib.attrNames db.cudaCapabilityToInfo);

     

       
52
       
52
       
+
       


     

       
53
       
53
       
+
       
  /**

     

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

     

       
55
       
55
       
+
       


     

       
56
       
56
       
+
       
    # Type

     

       
57
       
57
       
+
       


     

       
58
       
58
       
+
       
    ```

     

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

     

       
60
       
60
       
+
       
    ```

     

       
61
       
61
       
+
       
  */

     

       
62
       
62
       
+
       
  cudaArchNameToCapabilities = lib.groupBy (

     

       
63
       
63
       
+
       
    cudaCapability: db.cudaCapabilityToInfo.${cudaCapability}.archName

     

       
64
       
64
       
+
       
  ) db.allSortedCudaCapabilities;

     

       
65
       
65
       
+
       
}

     

···

       
1
       
1
       
+
       
# The _cuda attribute set is a fixed-point which contains the static functionality required to construct CUDA package

     

       
2
       
2
       
+
       
# sets. For example, `_cuda.cudaData` includes information about NVIDIA's redistributables (such as the names NVIDIA

     

       
3
       
3
       
+
       
# uses for different systems), `_cuda.cudaLib` contains utility functions like `formatCapabilities` (which generate

     

       
4
       
4
       
+
       
# common arguments passed to NVCC and `cmakeFlags`), and `_cuda.cudaFixups` contains `callPackage`-able functions

     

       
5
       
5
       
+
       
# which are provided to the corresponding package's `overrideAttrs` attribute to provide package-specific fixups

     

       
6
       
6
       
+
       
# out of scope of the generic redistributable builder.

     

       
7
       
7
       
+
       
#

     

       
8
       
8
       
+
       
# Since this attribute set is used to construct the CUDA package sets, it must exist outside the fixed point of the

     

       
9
       
9
       
+
       
# package sets. Make these attributes available directly in the package set construction could cause confusion if

     

       
10
       
10
       
+
       
# users override the attribute set with the expection that changes will be reflected in the enclosing CUDA package

     

       
11
       
11
       
+
       
# set. To avoid this, we declare `_cuda` and inherit its members here, at top-level. (This also allows us to benefit

     

       
12
       
12
       
+
       
# from import caching, as it should be evaluated once per system, rather than per-system and CUDA package set.)

     

       
13
       
13
       
+
       


     

       
14
       
14
       
+
       
let

     

       
15
       
15
       
+
       
  lib = import ../../../../lib;

     

       
16
       
16
       
+
       
in

     

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

     

       
18
       
18
       
+
       
  bootstrapData = import ./db/bootstrap {

     

       
19
       
19
       
+
       
    inherit lib;

     

       
20
       
20
       
+
       
  };

     

       
21
       
21
       
+
       
  db = import ./db {

     

       
22
       
22
       
+
       
    inherit (final) bootstrapData db;

     

       
23
       
23
       
+
       
    inherit lib;

     

       
24
       
24
       
+
       
  };

     

       
25
       
25
       
+
       
  fixups = import ./fixups { inherit lib; };

     

       
26
       
26
       
+
       
  lib = import ./lib {

     

       
27
       
27
       
+
       
    _cuda = final;

     

       
28
       
28
       
+
       
    inherit lib;

     

       
29
       
29
       
+
       
  };

     

       
30
       
30
       
+
       
})

     

···

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

     

       
70
       
70
       
 
       
  # computeName :: RedistribRelease -> String

     

       
71
       
71
       
 
       
  computeName =

     

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

     

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

     

       
73
       
73
       
 
       
in

     

       
74
       
74
       
 
       
final: _:

     

       
75
       
75
       
 
       
let

     

···

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

     

       
109
       
109
       
 
       
  # computeName :: RedistribRelease -> String

     

       
110
       
110
       
 
       
  computeName =

     

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

     

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

     

       
112
       
112
       
 
       
in

     

       
113
       
113
       
 
       
final: _:

     

       
114
       
114
       
 
       
let

     

···

       
1
       
1
       
-
       
let

     

       
2
       
2
       
-
       
  lib = import ../../../../lib;

     

       
3
       
3
       
-
       
in

     

       
1
       
1
       
+
       
{ lib }:

     

       
4
       
2
       
 
       
lib.concatMapAttrs (

     

       
5
       
3
       
 
       
  fileName: _type:

     

       
6
       
4
       
 
       
  let

     

···

       
1
       
1
       
 
       
{

     

       
2
       
2
       
-
       
  cudaLib,

     

       
2
       
2
       
+
       
  _cuda,

     

       
3
       
3
       
 
       
  cudaOlder,

     

       
4
       
4
       
 
       
  cudaPackages,

     

       
5
       
5
       
 
       
  cudaMajorMinorVersion,

     
···

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

     

       
104
       
104
       
 
       
    cudnn =

     

       
105
       
105
       
 
       
      let

     

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

     

       
106
       
106
       
+
       
        desiredName = _cuda.lib.mkVersionedName "cudnn" (

     

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

     

       
108
       
108
       
 
       
        );

     

       
109
       
109
       
 
       
      in

     

···

       
5
       
5
       
 
       
  autoPatchelfHook,

     

       
6
       
6
       
 
       
  backendStdenv,

     

       
7
       
7
       
 
       
  callPackage,

     

       
8
       
8
       
-
       
  cudaFixups,

     

       
9
       
9
       
-
       
  cudaLib,

     

       
8
       
8
       
+
       
  _cuda,

     

       
10
       
9
       
 
       
  fetchurl,

     

       
11
       
10
       
 
       
  lib,

     

       
12
       
11
       
 
       
  markForCudatoolkitRootHook,

     
···

       
45
       
44
       
 
       
  # Last step before returning control to `callPackage` (adds the `.override` method)

     

       
46
       
45
       
 
       
  # we'll apply (`overrideAttrs`) necessary package-specific "fixup" functions.

     

       
47
       
46
       
 
       
  # Order is significant.

     

       
48
       
48
       
-
       
  maybeFixup = cudaFixups.${pname} or null;

     

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

     

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

     

       
50
       
49
       
 
       


     

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

     
···

       
54
       
53
       
 
       
  # redistSystem :: String

     

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

     

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

     

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

     

       
56
       
56
       
+
       
  redistSystem = _cuda.lib.getRedistSystem backendStdenv.hasJetsonCudaCapability hostPlatform.system;

     

       
58
       
57
       
 
       


     

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

     

       
58
       
58
       
+
       
  sourceMatchesHost = lib.elem hostPlatform.system (_cuda.lib.getNixSystems redistSystem);

     

       
60
       
59
       
 
       
in

     

       
61
       
60
       
 
       
(backendStdenv.mkDerivation (finalAttrs: {

     

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

     
···

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

     

       
328
       
327
       
 
       
    platforms = trivial.pipe supportedRedistSystems [

     

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

     

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

     

       
329
       
329
       
+
       
      (lib.concatMap _cuda.lib.getNixSystems)

     

       
331
       
330
       
 
       
      # Take all the unique values.

     

       
332
       
331
       
 
       
      lib.unique

     

       
333
       
332
       
 
       
      # Sort the list.

     

···

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

     

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

     

       
66
       
66
       
 
       
  # computeName :: Package -> String

     

       
67
       
67
       
-
       
  computeName =

     

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

     

       
67
       
67
       
+
       
  computeName = { version, ... }: cudaLib.mkVersionedName pname (lib.versions.majorMinor version);

     

       
69
       
68
       
 
       


     

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

     

       
71
       
70
       
 
       
  # newestPackages :: List Package

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ 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
       
3
       
 
       


     

       
62
       
4
       
 
       
  /**

     

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

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ 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

     

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

     

       
7
       
5
       
 
       
    cudaCapabilityToInfo

     

       
8
       
6
       
 
       
    ;

     

       
9
       
7
       
 
       


     
···

       
28
       
26
       
 
       
    cudaPackagesPath :: Path

     

       
29
       
27
       
 
       
    ```

     

       
30
       
28
       
 
       
  */

     

       
31
       
31
       
-
       
  cudaPackagesPath = ./..;

     

       
29
       
29
       
+
       
  cudaPackagesPath = ./../../..;

     

       
32
       
30
       
 
       
}

     

···

       
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
       
-
       
})

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ _cuda, lib }:

     

       
2
       
2
       
 
       
{

     

       
3
       
3
       
 
       
  /**

     

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

     
···

       
16
       
16
       
 
       
  _evaluateAssertions =

     

       
17
       
17
       
 
       
    assertions:

     

       
18
       
18
       
 
       
    let

     

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

     

       
19
       
19
       
+
       
      failedAssertionsString = _cuda.lib._mkFailedAssertionsString assertions;

     

       
20
       
20
       
 
       
    in

     

       
21
       
21
       
 
       
    if failedAssertionsString == "" then

     

       
22
       
22
       
 
       
      true

     
···

       
45
       
45
       
 
       
    # Examples

     

       
46
       
46
       
 
       


     

       
47
       
47
       
 
       
    :::{.example}

     

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

     

       
48
       
48
       
+
       
    ## `_cuda.lib._mkFailedAssertionsString` usage examples

     

       
49
       
49
       
 
       


     

       
50
       
50
       
 
       
    ```nix

     

       
51
       
51
       
 
       
    _mkFailedAssertionsString [

     
···

       
103
       
103
       
 
       
    # Examples

     

       
104
       
104
       
 
       


     

       
105
       
105
       
 
       
    :::{.example}

     

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

     

       
106
       
106
       
+
       
    ## `_cuda.lib._mkMissingPackagesAssertions` usage examples

     

       
107
       
107
       
 
       


     

       
108
       
108
       
 
       
    ```nix

     

       
109
       
109
       
 
       
    {

     
···

       
114
       
114
       
 
       
    }:

     

       
115
       
115
       
 
       
    let

     

       
116
       
116
       
 
       
      inherit (lib.attrsets) recursiveUpdate;

     

       
117
       
117
       
-
       
      inherit (cudaLib.utils) _mkMissingPackagesAssertions;

     

       
117
       
117
       
+
       
      inherit (_cuda.lib) _mkMissingPackagesAssertions;

     

       
118
       
118
       
 
       
    in

     

       
119
       
119
       
 
       
    prevAttrs: {

     

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

     

···

       
92
       
92
       
 
       
    # Examples

     

       
93
       
93
       
 
       


     

       
94
       
94
       
 
       
    :::{.example}

     

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

     

       
95
       
95
       
+
       
    ## `_cuda.lib._mkCudaVariant` usage examples

     

       
96
       
96
       
 
       


     

       
97
       
97
       
 
       
    ```nix

     

       
98
       
98
       
 
       
    _mkCudaVariant "11.0"

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{

     

       
2
       
2
       
+
       
  _cuda,

     

       
3
       
3
       
+
       
  lib,

     

       
4
       
4
       
+
       
}:

     

       
2
       
5
       
 
       
{

     

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

     

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

     

       
7
       
7
       
+
       
  inherit (import ./assertions.nix { inherit _cuda lib; })

     

       
5
       
8
       
 
       
    _evaluateAssertions

     

       
6
       
9
       
 
       
    _mkFailedAssertionsString

     

       
7
       
10
       
 
       
    _mkMissingPackagesAssertions

     
···

       
16
       
19
       
 
       
    ;

     

       
17
       
20
       
 
       


     

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

     

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

     

       
22
       
22
       
+
       
  inherit (import ./meta.nix { inherit _cuda lib; })

     

       
20
       
23
       
 
       
    _mkMetaBadPlatforms

     

       
21
       
24
       
 
       
    _mkMetaBroken

     

       
22
       
25
       
 
       
    ;

     

       
23
       
26
       
 
       


     

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

     

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

     

       
28
       
28
       
+
       
  inherit (import ./redist.nix { inherit _cuda lib; })

     

       
26
       
29
       
 
       
    _redistSystemIsSupported

     

       
27
       
30
       
 
       
    getNixSystems

     

       
28
       
31
       
 
       
    getRedistSystem

     
···

       
30
       
33
       
 
       
    ;

     

       
31
       
34
       
 
       


     

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

     

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

     

       
36
       
36
       
+
       
  inherit (import ./strings.nix { inherit _cuda lib; })

     

       
34
       
37
       
 
       
    dotsToUnderscores

     

       
35
       
38
       
 
       
    dropDots

     

       
36
       
39
       
 
       
    formatCapabilities

     
···

       
42
       
45
       
 
       
    ;

     

       
43
       
46
       
 
       


     

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

     

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

     

       
48
       
48
       
+
       
  inherit (import ./versions.nix { inherit _cuda lib; })

     

       
46
       
49
       
 
       
    majorMinorPatch

     

       
47
       
50
       
 
       
    trimComponents

     

       
48
       
51
       
 
       
    ;

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ _cuda, lib }:

     

       
2
       
2
       
 
       
{

     

       
3
       
3
       
 
       
  /**

     

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

     
···

       
18
       
18
       
 
       
  _mkMetaBadPlatforms =

     

       
19
       
19
       
 
       
    warn: finalAttrs:

     

       
20
       
20
       
 
       
    let

     

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

     

       
21
       
21
       
+
       
      failedAssertionsString = _cuda.lib._mkFailedAssertionsString finalAttrs.passthru.platformAssertions;

     

       
22
       
22
       
 
       
      hasFailedAssertions = failedAssertionsString != "";

     

       
23
       
23
       
 
       
      finalStdenv = finalAttrs.finalPackage.stdenv;

     

       
24
       
24
       
 
       
    in

     
···

       
62
       
62
       
 
       
  _mkMetaBroken =

     

       
63
       
63
       
 
       
    warn: finalAttrs:

     

       
64
       
64
       
 
       
    let

     

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

     

       
65
       
65
       
+
       
      failedAssertionsString = _cuda.lib._mkFailedAssertionsString finalAttrs.passthru.brokenAssertions;

     

       
66
       
66
       
 
       
      hasFailedAssertions = failedAssertionsString != "";

     

       
67
       
67
       
 
       
    in

     

       
68
       
68
       
 
       
    lib.warnIf (warn && hasFailedAssertions)

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ _cuda, 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.

     
···

       
27
       
27
       
 
       
    # Examples

     

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
    :::{.example}

     

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

     

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

     

       
31
       
31
       
 
       


     

       
32
       
32
       
 
       
    ```nix

     

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

     
···

       
81
       
81
       
 
       
    # Examples

     

       
82
       
82
       
 
       


     

       
83
       
83
       
 
       
    :::{.example}

     

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

     

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

     

       
85
       
85
       
 
       


     

       
86
       
86
       
 
       
    ```nix

     

       
87
       
87
       
 
       
    getNixSystems "linux-sbsa"

     
···

       
137
       
137
       
 
       
    # Examples

     

       
138
       
138
       
 
       


     

       
139
       
139
       
 
       
    :::{.example}

     

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

     

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

     

       
141
       
141
       
 
       


     

       
142
       
142
       
 
       
    ```nix

     

       
143
       
143
       
 
       
    getRedistSystem true "aarch64-linux"

     
···

       
181
       
181
       
 
       
  mkRedistUrl =

     

       
182
       
182
       
 
       
    redistName: relativePath:

     

       
183
       
183
       
 
       
    lib.concatStringsSep "/" (

     

       
184
       
184
       
-
       
      [ cudaLib.data.redistUrlPrefix ]

     

       
184
       
184
       
+
       
      [ _cuda.db.redistUrlPrefix ]

     

       
185
       
185
       
 
       
      ++ (

     

       
186
       
186
       
 
       
        if redistName != "tensorrt" then

     

       
187
       
187
       
 
       
          [

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ _cuda, lib }:

     

       
2
       
2
       
+
       
let

     

       
3
       
3
       
+
       
  cudaLib = _cuda.lib;

     

       
4
       
4
       
+
       
in

     

       
2
       
5
       
 
       
{

     

       
3
       
6
       
 
       
  /**

     

       
4
       
7
       
 
       
    Replaces dots in a string with underscores.

     
···

       
18
       
21
       
 
       
    # Examples

     

       
19
       
22
       
 
       


     

       
20
       
23
       
 
       
    :::{.example}

     

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

     

       
24
       
24
       
+
       
    ## `cudaLib.dotsToUnderscores` usage examples

     

       
22
       
25
       
 
       


     

       
23
       
26
       
 
       
    ```nix

     

       
24
       
27
       
 
       
    dotsToUnderscores "1.2.3"

     
···

       
46
       
49
       
 
       
    # Examples

     

       
47
       
50
       
 
       


     

       
48
       
51
       
 
       
    :::{.example}

     

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

     

       
52
       
52
       
+
       
    ## `cudaLib.dropDots` usage examples

     

       
50
       
53
       
 
       


     

       
51
       
54
       
 
       
    ```nix

     

       
52
       
55
       
 
       
    dropDots "1.2.3"

     
···

       
110
       
113
       
 
       
        realArches :: List String

     

       
111
       
114
       
 
       
        ```

     

       
112
       
115
       
 
       
      */

     

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

     

       
116
       
116
       
+
       
      realArches = lib.map cudaLib.mkRealArchitecture cudaCapabilities;

     

       
114
       
117
       
 
       


     

       
115
       
118
       
 
       
      /**

     

       
116
       
119
       
 
       
        The virtual architectures for the given CUDA capabilities.

     
···

       
124
       
127
       
 
       
        virtualArches :: List String

     

       
125
       
128
       
 
       
        ```

     

       
126
       
129
       
 
       
      */

     

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

     

       
130
       
130
       
+
       
      virtualArches = lib.map cudaLib.mkVirtualArchitecture cudaCapabilities;

     

       
128
       
131
       
 
       


     

       
129
       
132
       
 
       
      /**

     

       
130
       
133
       
 
       
        The gencode flags for the given CUDA capabilities.

     
···

       
137
       
140
       
 
       
      */

     

       
138
       
141
       
 
       
      gencode =

     

       
139
       
142
       
 
       
        let

     

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

     

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

     

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

     

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

     

       
142
       
145
       
 
       
        in

     

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

     

       
144
       
147
       
 
       
    in

     
···

       
190
       
193
       
 
       
        cmakeCudaArchitecturesString :: String

     

       
191
       
194
       
 
       
        ```

     

       
192
       
195
       
 
       
      */

     

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

     

       
196
       
196
       
+
       
      cmakeCudaArchitecturesString = cudaLib.mkCmakeCudaArchitecturesString cudaCapabilities;

     

       
194
       
197
       
 
       


     

       
195
       
198
       
 
       
      /**

     

       
196
       
199
       
 
       
        The gencode string for the given CUDA capabilities.

     
···

       
222
       
225
       
 
       
    # Examples

     

       
223
       
226
       
 
       


     

       
224
       
227
       
 
       
    :::{.example}

     

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

     

       
228
       
228
       
+
       
    ## `cudaLib.mkCmakeCudaArchitecturesString` usage examples

     

       
226
       
229
       
 
       


     

       
227
       
230
       
 
       
    ```nix

     

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

     
···

       
230
       
233
       
 
       
    ```

     

       
231
       
234
       
 
       
    :::

     

       
232
       
235
       
 
       
  */

     

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

     

       
236
       
236
       
+
       
  mkCmakeCudaArchitecturesString = lib.concatMapStringsSep ";" cudaLib.dropDots;

     

       
234
       
237
       
 
       


     

       
235
       
238
       
 
       
  /**

     

       
236
       
239
       
 
       
    Produces a gencode flag from a CUDA capability.

     
···

       
254
       
257
       
 
       
    # Examples

     

       
255
       
258
       
 
       


     

       
256
       
259
       
 
       
    :::{.example}

     

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

     

       
260
       
260
       
+
       
    ## `cudaLib.mkGencodeFlag` usage examples

     

       
258
       
261
       
 
       


     

       
259
       
262
       
 
       
    ```nix

     

       
260
       
263
       
 
       
    mkGencodeFlag "sm" "8.9"

     
···

       
270
       
273
       
 
       
  mkGencodeFlag =

     

       
271
       
274
       
 
       
    archPrefix: cudaCapability:

     

       
272
       
275
       
 
       
    let

     

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

     

       
276
       
276
       
+
       
      cap = cudaLib.dropDots cudaCapability;

     

       
274
       
277
       
 
       
    in

     

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

     

       
276
       
279
       
 
       


     
···

       
292
       
295
       
 
       
    # Examples

     

       
293
       
296
       
 
       


     

       
294
       
297
       
 
       
    :::{.example}

     

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

     

       
298
       
298
       
+
       
    ## `cudaLib.mkRealArchitecture` usage examples

     

       
296
       
299
       
 
       


     

       
297
       
300
       
 
       
    ```nix

     

       
298
       
301
       
 
       
    mkRealArchitecture "8.9"

     
···

       
305
       
308
       
 
       
    ```

     

       
306
       
309
       
 
       
    :::

     

       
307
       
310
       
 
       
  */

     

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

     

       
311
       
311
       
+
       
  mkRealArchitecture = cudaCapability: "sm_" + cudaLib.dropDots cudaCapability;

     

       
309
       
312
       
 
       


     

       
310
       
313
       
 
       
  /**

     

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

     
···

       
329
       
332
       
 
       
    # Examples

     

       
330
       
333
       
 
       


     

       
331
       
334
       
 
       
    :::{.example}

     

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

     

       
335
       
335
       
+
       
    ## `cudaLib.mkVersionedName` usage examples

     

       
333
       
336
       
 
       


     

       
334
       
337
       
 
       
    ```nix

     

       
335
       
338
       
 
       
    mkVersionedName "hello" "1.2.3"

     
···

       
342
       
345
       
 
       
    ```

     

       
343
       
346
       
 
       
    :::

     

       
344
       
347
       
 
       
  */

     

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

     

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

     

       
346
       
349
       
 
       


     

       
347
       
350
       
 
       
  /**

     

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

     
···

       
362
       
365
       
 
       
    # Examples

     

       
363
       
366
       
 
       


     

       
364
       
367
       
 
       
    :::{.example}

     

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

     

       
368
       
368
       
+
       
    ## `cudaLib.mkVirtualArchitecture` usage examples

     

       
366
       
369
       
 
       


     

       
367
       
370
       
 
       
    ```nix

     

       
368
       
371
       
 
       
    mkVirtualArchitecture "8.9"

     
···

       
375
       
378
       
 
       
    ```

     

       
376
       
379
       
 
       
    :::

     

       
377
       
380
       
 
       
  */

     

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

     

       
381
       
381
       
+
       
  mkVirtualArchitecture = cudaCapability: "compute_" + cudaLib.dropDots cudaCapability;

     

       
379
       
382
       
 
       
}

     

···

       
1
       
1
       
-
       
{ cudaLib, lib }:

     

       
1
       
1
       
+
       
{ _cuda, lib }:

     

       
2
       
2
       
+
       
let

     

       
3
       
3
       
+
       
  cudaLib = _cuda.lib;

     

       
4
       
4
       
+
       
in

     

       
2
       
5
       
 
       
{

     

       
3
       
6
       
 
       
  /**

     

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

     
···

       
18
       
21
       
 
       
    # Examples

     

       
19
       
22
       
 
       


     

       
20
       
23
       
 
       
    :::{.example}

     

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

     

       
24
       
24
       
+
       
    ## `_cuda.lib.majorMinorPatch` usage examples

     

       
22
       
25
       
 
       


     

       
23
       
26
       
 
       
    ```nix

     

       
24
       
27
       
 
       
    majorMinorPatch "11.0.3.4"

     
···

       
26
       
29
       
 
       
    ```

     

       
27
       
30
       
 
       
    :::

     

       
28
       
31
       
 
       
  */

     

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

     

       
32
       
32
       
+
       
  majorMinorPatch = cudaLib.trimComponents 3;

     

       
30
       
33
       
 
       


     

       
31
       
34
       
 
       
  /**

     

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

     
···

       
48
       
51
       
 
       
    # Examples

     

       
49
       
52
       
 
       


     

       
50
       
53
       
 
       
    :::{.example}

     

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

     

       
54
       
54
       
+
       
    ## `_cuda.lib.trimComponents` usage examples

     

       
52
       
55
       
 
       


     

       
53
       
56
       
 
       
    ```nix

     

       
54
       
57
       
 
       
    trimComponents 1 "1.2.3.4"

     

···

       
7
       
7
       
 
       
# Cf. https://github.com/NixOS/nixpkgs/pull/218265 for context

     

       
8
       
8
       
 
       
{

     

       
9
       
9
       
 
       
  config,

     

       
10
       
10
       
-
       
  cudaLib,

     

       
10
       
10
       
+
       
  _cuda,

     

       
11
       
11
       
 
       
  cudaMajorMinorVersion,

     

       
12
       
12
       
 
       
  lib,

     

       
13
       
13
       
 
       
  pkgs,

     
···

       
16
       
16
       
 
       
}:

     

       
17
       
17
       
 
       
let

     

       
18
       
18
       
 
       
  inherit (builtins) toJSON;

     

       
19
       
19
       
-
       
  inherit (cudaLib.data) allSortedCudaCapabilities cudaCapabilityToInfo nvccCompatibilities;

     

       
20
       
20
       
-
       
  inherit (cudaLib.utils)

     

       
19
       
19
       
+
       
  inherit (_cuda.db) allSortedCudaCapabilities cudaCapabilityToInfo nvccCompatibilities;

     

       
20
       
20
       
+
       
  inherit (_cuda.lib)

     

       
21
       
21
       
 
       
    _cudaCapabilityIsDefault

     

       
22
       
22
       
 
       
    _cudaCapabilityIsSupported

     

       
23
       
23
       
 
       
    _evaluateAssertions

     

···

       
1
       
1
       
 
       
{

     

       
2
       
2
       
+
       
  cudaData,

     

       
2
       
3
       
 
       
  cudaLib,

     

       
3
       
4
       
 
       
  cudaNamePrefix,

     

       
4
       
5
       
 
       
  lib,

     
···

       
6
       
7
       
 
       
}:

     

       
7
       
8
       
 
       
let

     

       
8
       
9
       
 
       
  inherit (builtins) deepSeq toJSON tryEval;

     

       
9
       
9
       
-
       
  inherit (cudaLib.data) cudaCapabilityToInfo;

     

       
10
       
10
       
-
       
  inherit (cudaLib.utils) formatCapabilities;

     

       
10
       
10
       
+
       
  inherit (cudaData) cudaCapabilityToInfo;

     

       
11
       
11
       
+
       
  inherit (cudaLib) formatCapabilities;

     

       
11
       
12
       
 
       
  inherit (lib.asserts) assertMsg;

     

       
12
       
13
       
 
       
in

     

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

     

···

       
2719
       
2719
       
 
       


     

       
2720
       
2720
       
 
       
  cron = isc-cron;

     

       
2721
       
2721
       
 
       


     

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

     

       
2723
       
2723
       
-
       


     

       
2724
       
2724
       
-
       
  cudaFixups = import ../development/cuda-modules/fixups;

     

       
2722
       
2722
       
+
       
  # Top-level fix-point used in `cudaPackages`' internals

     

       
2723
       
2723
       
+
       
  _cuda = import ../development/cuda-modules/_cuda;

     

       
2725
       
2724
       
 
       


     

       
2726
       
2725
       
 
       
  cudaPackages_11_0 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "11.0"; };

     

       
2727
       
2726
       
 
       
  cudaPackages_11_1 = callPackage ./cuda-packages.nix { cudaMajorMinorVersion = "11.1"; };

     

···

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

     

       
23
       
23
       
 
       
{

     

       
24
       
24
       
 
       
  config,

     

       
25
       
25
       
-
       
  cudaLib,

     

       
25
       
25
       
+
       
  _cuda,

     

       
26
       
26
       
 
       
  cudaMajorMinorVersion,

     

       
27
       
27
       
 
       
  lib,

     

       
28
       
28
       
 
       
  newScope,

     
···

       
38
       
38
       
 
       
    versions

     

       
39
       
39
       
 
       
    ;

     

       
40
       
40
       
 
       


     

       
41
       
41
       
+
       
  cudaLib = _cuda.lib;

     

       
42
       
42
       
+
       


     

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

     

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

     

       
43
       
45
       
 
       
  # Copied from backendStdenv.

     

       
44
       
46
       
 
       
  jetsonCudaCapabilities = lib.filter (

     

       
45
       
45
       
-
       
    cudaCapability: cudaLib.data.cudaCapabilityToInfo.${cudaCapability}.isJetson

     

       
46
       
46
       
-
       
  ) cudaLib.data.allSortedCudaCapabilities;

     

       
47
       
47
       
+
       
    cudaCapability: _cuda.db.cudaCapabilityToInfo.${cudaCapability}.isJetson

     

       
48
       
48
       
+
       
  ) _cuda.db.allSortedCudaCapabilities;

     

       
47
       
49
       
 
       
  hasJetsonCudaCapability =

     

       
48
       
50
       
 
       
    lib.intersectLists jetsonCudaCapabilities (config.cudaCapabilities or [ ]) != [ ];

     

       
49
       
49
       
-
       
  redistSystem = cudaLib.utils.getRedistSystem hasJetsonCudaCapability stdenv.hostPlatform.system;

     

       
51
       
51
       
+
       
  redistSystem = _cuda.lib.getRedistSystem hasJetsonCudaCapability stdenv.hostPlatform.system;

     

       
50
       
52
       
 
       


     

       
51
       
53
       
 
       
  passthruFunction = final: {

     

       
52
       
54
       
 
       
    # NOTE:

     

       
53
       
53
       
-
       
    # It is important that cudaLib and cudaFixups are not part of the package set fixed-point. As described by

     

       
55
       
55
       
+
       
    # It is important that _cuda is not part of the package set fixed-point. As described by

     

       
54
       
56
       
 
       
    # @SomeoneSerge:

     

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

     

       
56
       
58
       
 
       
    # > No arrows should point in the reverse directions.

     

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

     

       
58
       
60
       
 
       
    # functionality for interpreting configurations, resolving them against data, and constructing package sets.

     

       
59
       
61
       
 
       
    # This decision is driven both by a separation of concerns and by "NAMESET STRICTNESS" (see above).

     

       
62
       
62
       
+
       
    # Also see the comment in `pkgs/top-level/all-packages.nix` about the `_cuda` attribute.

     

       
60
       
63
       
 
       


     

       
61
       
64
       
 
       
    inherit cudaMajorMinorVersion;

     

       
62
       
65
       
 
       


     
···

       
77
       
80
       
 
       
    };

     

       
78
       
81
       
 
       


     

       
79
       
82
       
 
       
    flags =

     

       
80
       
80
       
-
       
      cudaLib.utils.formatCapabilities {

     

       
83
       
83
       
+
       
      cudaLib.formatCapabilities {

     

       
81
       
84
       
 
       
        inherit (final.backendStdenv) cudaCapabilities cudaForwardCompat;

     

       
82
       
82
       
-
       
        inherit (cudaLib.data) cudaCapabilityToInfo;

     

       
85
       
85
       
+
       
        inherit (_cuda.db) cudaCapabilityToInfo;

     

       
83
       
86
       
 
       
      }

     

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

     

       
85
       
88
       
 
       
      # time to allow users to migrate to cudaLib and backendStdenv.

     

       
86
       
89
       
 
       
      // {

     

       
87
       
87
       
-
       
        inherit (cudaLib.utils) dropDots;

     

       
90
       
90
       
+
       
        inherit (cudaLib) dropDots;

     

       
88
       
91
       
 
       
        cudaComputeCapabilityToName =

     

       
89
       
89
       
-
       
          cudaCapability: cudaLib.data.cudaCapabilityToInfo.${cudaCapability}.archName;

     

       
90
       
90
       
-
       
        dropDot = cudaLib.utils.dropDots;

     

       
92
       
92
       
+
       
          cudaCapability: _cuda.db.cudaCapabilityToInfo.${cudaCapability}.archName;

     

       
93
       
93
       
+
       
        dropDot = cudaLib.dropDots;

     

       
91
       
94
       
 
       
        isJetsonBuild = final.backendStdenv.hasJetsonCudaCapability;

     

       
92
       
95
       
 
       
      };

     

       
93
       
96
       
 
       


     

···

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
let

     

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

     

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

     

       
17
       
17
       
+
       
  inherit (import ../development/cuda-modules/_cuda) cudaLib;

     

       
18
       
18
       
 
       
in

     

       
19
       
19
       
 
       


     

       
20
       
20
       
 
       
{

     
···

       
27
       
27
       
 
       
  # Attributes passed to nixpkgs.

     

       
28
       
28
       
 
       
  nixpkgsArgs ? {

     

       
29
       
29
       
 
       
    config = {

     

       
30
       
30
       
-
       
      allowUnfreePredicate = cudaLib.utils.allowUnfreeCudaPredicate;

     

       
30
       
30
       
+
       
      allowUnfreePredicate = cudaLib.allowUnfreeCudaPredicate;

     

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

     

       
32
       
32
       
 
       
      inHydra = true;

     

       
33
       
33