commit c74e5ffb6526ac1b4870504921b9ba9362189a17 · pyrox.dev/nixpkgs

doc/release-notes/rl-2511.section.md

···

       68
       68
        
         The binary name remains `webfontkitgenerator`.

     

       69
       69
        
         The `webfontkitgenerator` package is an alias to `webfont-bundler`.

     

       70
       70
        
       

     

       71
       71
       +
       - `python3Packages.triton` no longer takes an `enableRocm` argument and supports ROCm in all build configurations via runtime binding. In most cases no action will be needed. If triton is unable to find the HIP SDK add `rocmPackages.clr` as a build input or set the environment variable `HIP_PATH="${rocmPackages.clr}"`.

     

       72
       72
       +
       

     

       71
       73
        
       - `inspircd` has been updated to the v4 release series. Please refer to the upstream documentation for [general information](https://docs.inspircd.org/4/overview/#v4-overview) and a list of [breaking changes](https://docs.inspircd.org/4/breaking-changes/).

     

       72
       74
        
       

     

       73
       75
        
       - `lima` package now only includes the guest agent for the host's architecture by default. If your guest VM's architecture differs from your Lima host's, you'll need to enable the `lima-additional-guestagents` package by setting `withAdditionalGuestAgents = true` when overriding lima with this input.

+1 -7

pkgs/development/python-modules/torch/source/default.nix

···

       72
       72
        
         #          (dependencies without cuda support).

     

       73
       73
        
         #          Instead we should rely on overlays and nixpkgsFun.

     

       74
       74
        
         # (@SomeoneSerge)

     

       75
       75
       -
         _tritonEffective ?

     

       76
       76
       -
           if cudaSupport then

     

       77
       77
       -
             triton-cuda

     

       78
       78
       -
           else if rocmSupport then

     

       79
       79
       -
             rocmPackages.triton

     

       80
       80
       -
           else

     

       81
       81
       -
             triton,

     

       75
       75
       +
         _tritonEffective ? if cudaSupport then triton-cuda else triton,

     

       82
       76
        
         triton-cuda,

     

       83
       77
        
       

     

       84
       78
        
         # Disable MKLDNN on aarch64-darwin, it negatively impacts performance,

-28

pkgs/development/python-modules/triton/0002-nvidia-amd-driver-short-circuit-before-ldconfig.patch

···

       1
       1
       -
       diff --git a/third_party/amd/backend/driver.py b/third_party/amd/backend/driver.py

     

       2
       2
       -
       index ca712f904..0961d2dda 100644

     

       3
       3
       -
       --- a/third_party/amd/backend/driver.py

     

       4
       4
       -
       +++ b/third_party/amd/backend/driver.py

     

       5
       5
       -
       @@ -79,6 +79,9 @@ def _get_path_to_hip_runtime_dylib():

     

       6
       6
       -
                    return mmapped_path

     

       7
       7
       -
                raise RuntimeError(f"memory mapped '{mmapped_path}' in process does not point to a valid {lib_name}")

     

       8
       8
       -
        

     

       9
       9
       -
       +    if os.path.isdir("@libhipDir@"):

     

       10
       10
       -
       +        return ["@libhipDir@"]

     

       11
       11
       -
       +

     

       12
       12
       -
            paths = []

     

       13
       13
       -
        

     

       14
       14
       -
            import site

     

       15
       15
       -
       diff --git a/third_party/nvidia/backend/driver.py b/third_party/nvidia/backend/driver.py

     

       16
       16
       -
       index d088ec092..625de2db8 100644

     

       17
       17
       -
       --- a/third_party/nvidia/backend/driver.py

     

       18
       18
       -
       +++ b/third_party/nvidia/backend/driver.py

     

       19
       19
       -
       @@ -23,6 +23,9 @@ def libcuda_dirs():

     

       20
       20
       -
            if env_libcuda_path:

     

       21
       21
       -
                return [env_libcuda_path]

     

       22
       22
       -
        

     

       23
       23
       -
       +    if os.path.exists("@libcudaStubsDir@"):

     

       24
       24
       -
       +        return ["@libcudaStubsDir@"]

     

       25
       25
       -
       +

     

       26
       26
       -
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode()

     

       27
       27
       -
            # each line looks like the following:

     

       28
       28
       -
            # libcuda.so.1 (libc6,x86-64) => /lib/x86_64-linux-gnu/libcuda.so.1

+14

pkgs/development/python-modules/triton/0002-nvidia-driver-short-circuit-before-ldconfig.patch

···

       1
       1
       +
       diff --git a/third_party/nvidia/backend/driver.py b/third_party/nvidia/backend/driver.py

     

       2
       2
       +
       index d088ec092..625de2db8 100644

     

       3
       3
       +
       --- a/third_party/nvidia/backend/driver.py

     

       4
       4
       +
       +++ b/third_party/nvidia/backend/driver.py

     

       5
       5
       +
       @@ -23,6 +23,9 @@ def libcuda_dirs():

     

       6
       6
       +
            if env_libcuda_path:

     

       7
       7
       +
                return [env_libcuda_path]

     

       8
       8
       +
        

     

       9
       9
       +
       +    if os.path.exists("@libcudaStubsDir@"):

     

       10
       10
       +
       +        return ["@libcudaStubsDir@"]

     

       11
       11
       +
       +

     

       12
       12
       +
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode()

     

       13
       13
       +
            # each line looks like the following:

     

       14
       14
       +
            # libcuda.so.1 (libc6,x86-64) => /lib/x86_64-linux-gnu/libcuda.so.1

+60

pkgs/development/python-modules/triton/0005-amd-search-env-paths.patch

···

       1
       1
       +
       From 9e4e58b647c17c5fa098c8a74e221f88d3cb1a43 Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: Luna Nova <git@lunnova.dev>

     

       3
       3
       +
       Date: Sun, 24 Aug 2025 07:41:30 -0700

     

       4
       4
       +
       Subject: [PATCH] [AMD] Search HIP_PATH, hipconfig, and ROCM_PATH for

     

       5
       5
       +
        libamdhip64

     

       6
       6
       +
       

     

       7
       7
       +
       Search for libamdhip64 from HIP_PATH env var, hipconfig --path output,

     

       8
       8
       +
       and ROCM_PATH before looking in system-wide ldconfig or /opt/rocm.

     

       9
       9
       +
       

     

       10
       10
       +
       The system-wide ROCm path isn't guaranteed to be where the ROCm

     

       11
       11
       +
       install we're building against is located, so follow typical ROCm

     

       12
       12
       +
       lib behavior and look under env paths first.

     

       13
       13
       +
       

     

       14
       14
       +
       This is especially important for non-FHS distros like NixOS

     

       15
       15
       +
       where /opt/rocm never exists, but may be useful in more

     

       16
       16
       +
       typical distros if multiple ROCm installs are present

     

       17
       17
       +
       to ensure the right libamdhip64.so is picked up.

     

       18
       18
       +
       ---

     

       19
       19
       +
        third_party/amd/backend/driver.py | 28 ++++++++++++++++++++++++++++

     

       20
       20
       +
        1 file changed, 28 insertions(+)

     

       21
       21
       +
       

     

       22
       22
       +
       diff --git a/third_party/amd/backend/driver.py b/third_party/amd/backend/driver.py

     

       23
       23
       +
       index af8e1a5c8097..57b0f7388c60 100644

     

       24
       24
       +
       --- a/third_party/amd/backend/driver.py

     

       25
       25
       +
       +++ b/third_party/amd/backend/driver.py

     

       26
       26
       +
       @@ -110,6 +110,34 @@ def _get_path_to_hip_runtime_dylib():

     

       27
       27
       +
                        return f

     

       28
       28
       +
                    paths.append(f)

     

       29
       29
       +
        

     

       30
       30
       +
       +    # HIP_PATH should point to HIP SDK root if set

     

       31
       31
       +
       +    env_hip_path = os.getenv("HIP_PATH")

     

       32
       32
       +
       +    if env_hip_path:

     

       33
       33
       +
       +        hip_lib_path = os.path.join(env_hip_path, "lib", lib_name)

     

       34
       34
       +
       +        if os.path.exists(hip_lib_path):

     

       35
       35
       +
       +            return hip_lib_path

     

       36
       36
       +
       +        paths.append(hip_lib_path)

     

       37
       37
       +
       +

     

       38
       38
       +
       +    # if available, `hipconfig --path` prints the HIP SDK root

     

       39
       39
       +
       +    try:

     

       40
       40
       +
       +        hip_root = subprocess.check_output(["hipconfig", "--path"]).decode().strip()

     

       41
       41
       +
       +        if hip_root:

     

       42
       42
       +
       +            hip_lib_path = os.path.join(hip_root, "lib", lib_name)

     

       43
       43
       +
       +            if os.path.exists(hip_lib_path):

     

       44
       44
       +
       +                return hip_lib_path

     

       45
       45
       +
       +            paths.append(hip_lib_path)

     

       46
       46
       +
       +    except (subprocess.CalledProcessError, FileNotFoundError):

     

       47
       47
       +
       +        # hipconfig may not be available

     

       48
       48
       +
       +        pass

     

       49
       49
       +
       +

     

       50
       50
       +
       +    # ROCm lib dir based on env var

     

       51
       51
       +
       +    env_rocm_path = os.getenv("ROCM_PATH")

     

       52
       52
       +
       +    if env_rocm_path:

     

       53
       53
       +
       +        rocm_lib_path = os.path.join(env_rocm_path, "lib", lib_name)

     

       54
       54
       +
       +        if os.path.exists(rocm_lib_path):

     

       55
       55
       +
       +            return rocm_lib_path

     

       56
       56
       +
       +        paths.append(rocm_lib_path)

     

       57
       57
       +
       +

     

       58
       58
       +
            # Afterwards try to search the loader dynamic library resolution paths.

     

       59
       59
       +
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode(errors="ignore")

     

       60
       60
       +
            # each line looks like the following:

+52 -3

pkgs/development/python-modules/triton/default.nix

···

       23
       23
        
         torchWithRocm,

     

       24
       24
        
         zlib,

     

       25
       25
        
         cudaSupport ? config.cudaSupport,

     

       26
       26
       -
         rocmSupport ? config.rocmSupport,

     

       26
       26
       +
         runCommand,

     

       27
       27
        
         rocmPackages,

     

       28
       28
        
         triton,

     

       29
       29
        
       }:

     
···

       45
       45
        
           (replaceVars ./0001-_build-allow-extra-cc-flags.patch {

     

       46
       46
        
             ccCmdExtraFlags = "-Wl,-rpath,${addDriverRunpath.driverLink}/lib";

     

       47
       47
        
           })

     

       48
       48
       -
           (replaceVars ./0002-nvidia-amd-driver-short-circuit-before-ldconfig.patch {

     

       49
       49
       -
             libhipDir = if rocmSupport then "${lib.getLib rocmPackages.clr}/lib" else null;

     

       48
       48
       +
           (replaceVars ./0002-nvidia-driver-short-circuit-before-ldconfig.patch {

     

       50
       49
        
             libcudaStubsDir =

     

       51
       50
        
               if cudaSupport then "${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs" else null;

     

       52
       51
        
           })

     

       52
       52
       +
           # Upstream PR: https://github.com/triton-lang/triton/pull/7959

     

       53
       53
       +
           ./0005-amd-search-env-paths.patch

     

       53
       54
        
         ]

     

       54
       55
        
         ++ lib.optionals cudaSupport [

     

       55
       56
        
           (replaceVars ./0003-nvidia-cudart-a-systempath.patch {

     
···

       81
       82
        
             substituteInPlace cmake/AddTritonUnitTest.cmake \

     

       82
       83
        
               --replace-fail "include(\''${PROJECT_SOURCE_DIR}/unittest/googletest.cmake)" ""\

     

       83
       84
        
               --replace-fail "include(GoogleTest)" "find_package(GTest REQUIRED)"

     

       85
       85
       +
           ''

     

       86
       86
       +
           # Don't use FHS path for ROCm LLD

     

       87
       87
       +
           # Remove this after `[AMD] Use lld library API #7548` makes it into a release

     

       88
       88
       +
           + ''

     

       89
       89
       +
             substituteInPlace third_party/amd/backend/compiler.py \

     

       90
       90
       +
               --replace-fail 'lld = Path("/opt/rocm/llvm/bin/ld.lld")' \

     

       91
       91
       +
               "import os;lld = Path(os.getenv('HIP_PATH', '/opt/rocm/')"' + "/llvm/bin/ld.lld")'

     

       84
       92
        
           '';

     

       85
       93
        
       

     

       86
       94
        
         build-system = [ setuptools ];

     
···

       204
       212
        
         passthru.tests = {

     

       205
       213
        
           # Ultimately, torch is our test suite:

     

       206
       214
        
           inherit torchWithRocm;

     

       215
       215
       +
       

     

       216
       216
       +
           # Test that _get_path_to_hip_runtime_dylib works when ROCm is available at runtime

     

       217
       217
       +
           rocm-libamdhip64-path =

     

       218
       218
       +
             runCommand "triton-rocm-libamdhip64-path-test"

     

       219
       219
       +
               {

     

       220
       220
       +
                 buildInputs = [

     

       221
       221
       +
                   triton

     

       222
       222
       +
                   python

     

       223
       223
       +
                   rocmPackages.clr

     

       224
       224
       +
                 ];

     

       225
       225
       +
               }

     

       226
       226
       +
               ''

     

       227
       227
       +
                 python -c "

     

       228
       228
       +
                 import os

     

       229
       229
       +
                 import triton

     

       230
       230
       +
                 path = triton.backends.amd.driver._get_path_to_hip_runtime_dylib()

     

       231
       231
       +
                 print(f'libamdhip64 path: {path}')

     

       232
       232
       +
                 assert os.path.exists(path)

     

       233
       233
       +
                 " && touch $out

     

       234
       234
       +
               '';

     

       235
       235
       +
       

     

       236
       236
       +
           # Test that path_to_rocm_lld works when ROCm is available at runtime

     

       237
       237
       +
           # Remove this after `[AMD] Use lld library API #7548` makes it into a release

     

       238
       238
       +
           rocm-lld-path =

     

       239
       239
       +
             runCommand "triton-rocm-lld-test"

     

       240
       240
       +
               {

     

       241
       241
       +
                 buildInputs = [

     

       242
       242
       +
                   triton

     

       243
       243
       +
                   python

     

       244
       244
       +
                   rocmPackages.clr

     

       245
       245
       +
                 ];

     

       246
       246
       +
               }

     

       247
       247
       +
               ''

     

       248
       248
       +
                 python -c "

     

       249
       249
       +
                 import os

     

       250
       250
       +
                 import triton

     

       251
       251
       +
                 path = triton.backends.backends['amd'].compiler.path_to_rocm_lld()

     

       252
       252
       +
                 print(f'ROCm LLD path: {path}')

     

       253
       253
       +
                 assert os.path.exists(path)

     

       254
       254
       +
                 " && touch $out

     

       255
       255
       +
               '';

     

       207
       256
        
       

     

       208
       257
        
           # Test as `nix run -f "<nixpkgs>" python3Packages.triton.tests.axpy-cuda`

     

       209
       258
        
           # or, using `programs.nix-required-mounts`, as `nix build -f "<nixpkgs>" python3Packages.triton.tests.axpy-cuda.gpuCheck`