import guix-hpc amd modules and add gfx1100 supportHEADmaster

1 files changed, 686 insertions, 0 deletions

diff --git a/amd/packages/rocm-libs.scm b/amd/packages/rocm-libs.scm
new file mode 100644
index 0000000..b66f17f
--- /dev/null
+++ b/amd/packages/rocm-libs.scm
@@ -0,0 +1,686 @@
+;;; Copyright © 2023 Advanced Micro Devices, Inc.
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (amd packages rocm-libs)
+  #:use-module (guix packages)
+  #:use-module (guix gexp)
+  #:use-module (guix build-system cmake)
+  #:use-module (guix build-system gnu)
+  #:use-module (guix git-download)
+  #:use-module (guix download)
+  #:use-module (guix licenses)
+  #:use-module (guix build utils)
+  #:use-module (guix utils)
+
+  #:use-module (gnu packages)
+  #:use-module (gnu packages python)
+  #:use-module (gnu packages python-xyz)
+  #:use-module (gnu packages linux)
+  #:use-module (gnu packages libevent)
+  #:use-module (gnu packages gcc)
+  #:use-module (gnu packages perl)
+  #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages autotools)
+  #:use-module (gnu packages debug)
+  #:use-module (gnu packages pciutils)
+  #:use-module (gnu packages pretty-print)
+  #:use-module (gnu packages version-control)
+  #:use-module (gnu packages sqlite)
+
+  #:use-module (amd packages rocm-origin)
+  #:use-module (amd packages rocm-base)
+  #:use-module (amd packages rocm-hip)
+  #:use-module (amd packages rocm-tools)
+  #:use-module (amd packages python-cppheaderparser)
+
+  #:use-module (gnu packages mpi)
+
+  #:use-module (gnu packages fabric-management))
+
+; rocdbg-api
+(define (make-rocdbg-api rocm-comgr hipamd)
+  (package
+    (name "rocdbg-api")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin "rocdbgapi" version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DPCI_IDS_PATH="
+                                               #$(this-package-input "hwdata")))))
+    (inputs (list libbacktrace hwdata rocm-comgr hipamd))
+    (synopsis "ROCm debugger API.")
+    (description
+     "The AMD Debugger API is a library that provides all the support necessary for a debugger
+and other tools to perform low level control of the execution and inspection of execution state
+of AMD's commercially available GPU architectures.")
+    (home-page "https://github.com/ROCm/ROCdbgapi")
+    (license expat)))
+
+(define-public rocdbg-api
+  (make-rocdbg-api llvm-comgr hipamd))
+
+; rocprim
+(define (make-rocprim rocm-cmake hipamd)
+  (package
+    (name "rocprim")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:build-type "Release"
+      #:tests? #f ;No tests.
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$(this-package-input "hipamd")
+                                               "/bin/hipcc"))))
+    (inputs (list hipamd))
+    (native-inputs (list rocm-cmake python-wrapper))
+    (synopsis
+     "rocPRIM: a header-only library providing HIP parallel primitives")
+    (description
+     "The rocPRIM is a header-only library providing HIP parallel primitives 
+for developing performant GPU-accelerated code on the AMD ROCm platform.")
+    (home-page "https://github.com/ROCmSoftwarePlatform/rocPRIM.git")
+    (license expat)))
+
+(define-public rocprim
+  (make-rocprim rocm-cmake hipamd))
+
+; hipcub
+(define-public (make-hipcub hipamd rocm-cmake rocprim)
+  (package
+    (name "hipcub")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DAMDGPU_TARGETS=gfx90a,gfx1030,gfx1100")))
+    (inputs (list hipamd rocprim))
+    (native-inputs (list rocm-cmake))
+    (synopsis "hipCUB is a HIP wrapper for rocPRIM.")
+    (description
+     "hipCUB is a thin wrapper library on top of rocPRIM or CUB. You can use it to port a
+CUB project into HIP so you can use AMD hardware (and ROCm software).")
+    (home-page "https://github.com/ROCm/hipCUB")
+    (license bsd-3)))
+
+(define-public hipcub
+  (make-hipcub hipamd rocm-cmake rocprim))
+
+; rccl
+(define-public (make-rccl hipamd rocm-cmake rocm-smi hipify)
+  (package
+    (name "rccl")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DROCM_PATH="
+                                               #$(this-package-input "hipamd"))
+                                (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$(this-package-input "hipamd")
+                                               "/bin/hipcc")
+                                "-DAMDGPU_TARGETS=gfx90a,gfx1030,gfx1100")
+      #:phases #~(modify-phases %standard-phases
+                   (add-before 'configure 'parallel-jobs
+                     (lambda _
+                       (substitute* "CMakeLists.txt"
+                         (("target_compile_options\\(rccl PRIVATE -parallel-jobs=.*\\)")
+                          "target_compile_options(rccl PRIVATE -parallel-jobs=1)")
+                         (("target_link_options\\(rccl PRIVATE -parallel-jobs=.*\\)")
+                          "target_link_options(rccl PRIVATE -parallel-jobs=4)")))))))
+    (inputs (list hipamd rocm-smi))
+    (native-inputs (list rocm-cmake hipify))
+    (properties '((max-silent-time . 14400)))
+    (synopsis "ROCm Communication Collectives Library")
+    (description
+     "RCCL (pronounced \"Rickle\") is a stand-alone library of standard collective communication
+routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, reduce-scatter, gather,
+scatter, and all-to-all. There is also initial support for direct GPU-to-GPU send and receive operations.
+It has been optimized to achieve high bandwidth on platforms using PCIe, xGMI as well as networking using
+InfiniBand Verbs or TCP/IP sockets. RCCL supports an arbitrary number of GPUs installed in a single node
+or multiple nodes, and can be used in either single- or multi-process (e.g., MPI) applications.")
+    (home-page "https://github.com/ROCm/rccl")
+    (license bsd-3)))
+
+(define-public rccl
+  (make-rccl hipamd rocm-cmake rocm-smi hipify))
+
+; rocthrust
+(define (make-rocthrust hipamd rocm-cmake rocprim)
+  (package
+    (name "rocthrust")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc"))))
+    (inputs (list rocprim hipamd))
+    (native-inputs (list rocm-cmake))
+    (synopsis "rocThrust is a parallel algorithm library.")
+    (description
+     "rocThrust is a parallel algorithm library that has been ported to HIP and ROCm,
+which uses the rocPRIM library. The HIP-ported library works on HIP and ROCm software.")
+    (home-page "https://github.com/ROCm/rocThrust.git")
+    (license asl2.0)))
+
+(define-public rocthrust
+  (make-rocthrust hipamd rocm-cmake rocprim))
+
+; rocsparse
+(define (make-rocsparse rocm-cmake hipamd rocm-device-libs rocr-runtime
+                        rocprim)
+  (package
+    (name "rocsparse")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:configure-flags #~(list "-DAMDGPU_TARGETS=gfx90a;gfx1030,gfx1100"
+                                (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$(this-package-input "hipamd")
+                                               "/bin/hipcc")
+                                (string-append "-DCMAKE_Fortran_COMPILER="
+                                               #$(this-package-native-input
+                                                  "gfortran") "/bin/gfortran")
+                                "-DBUILD_CLIENTS_SAMPLES:BOOL=OFF" ;build fails otherwise
+                                )))
+    (native-inputs (list git gfortran rocm-cmake python-wrapper))
+    (inputs (list hipamd rocm-device-libs rocr-runtime rocprim))
+    (synopsis "rocSPARSE provides an interface for sparse BLAS operations.")
+    (description
+     "rocSPARSE exposes a common interface that provides Basic Linear Algebra Subroutines (BLAS)
+for sparse computation. It's implemented on top of AMD ROCm runtime and toolchains. rocSPARSE is created using
+the HIP programming language and optimized for AMD's latest discrete GPUs.")
+    (home-page "https://github.com/ROCm/rocSPARSE.git")
+    (license expat)))
+
+(define-public rocsparse
+  (make-rocsparse rocm-cmake hipamd llvm-device-libs rocr-runtime rocprim))
+
+; hipsparse
+(define-public (make-hipsparse hipamd rocm-cmake rocsparse)
+  (package
+    (name "hipsparse")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DBUILD_CLIENTS_SAMPLES:BOOL=OFF" ;build fails otherwise
+                                "-DAMDGPU_TARGETS=gfx90a,gfx1030,gfx1100")))
+    (inputs (list hipamd rocsparse))
+    (native-inputs (list git gfortran rocm-cmake))
+    (synopsis "A HIP interface to rocSPARSE.")
+    (description
+     "hipSPARSE is a SPARSE marshalling library with multiple supported backends.
+It sits between your application and a 'worker' SPARSE library, where it marshals inputs to the backend
+library and marshals results to your application. hipSPARSE exports an interface that doesn't require the
+client to change, regardless of the chosen backend. Currently, hipSPARSE supports rocSPARSE and cuSPARSE
+backends.")
+    (home-page "https://github.com/ROCm/hipSPARSE.git")
+    (license expat)))
+
+(define-public hipsparse
+  (make-hipsparse hipamd rocm-cmake rocsparse))
+
+; libfabric built with rocm
+(define (make-ofi-rocm rocr-runtime)
+  (package/inherit libfabric
+    (name "libfabric-rocm")
+    (version (string-append (package-version libfabric) ".rocm"
+                            (package-version rocr-runtime)))
+
+    (arguments (substitute-keyword-arguments (package-arguments libfabric)
+                 ((#:configure-flags flags)
+                  #~(append (list (string-append "--with-rocr="
+                                                 #$rocr-runtime))
+                            #$flags))))
+    (inputs (modify-inputs (package-inputs libfabric)
+              (append rocr-runtime)))))
+
+(define-public ofi-rocm
+  (make-ofi-rocm rocr-runtime))
+
+; ucx built with rocm
+(define (make-ucx-rocm roct-thunk rocr-runtime hipamd)
+  (package/inherit ucx
+    (name "ucx-rocm")
+    (version (string-append (package-version ucx) ".rocm"
+                            (package-version hipamd)))
+    (arguments (substitute-keyword-arguments (package-arguments ucx)
+                 ((#:configure-flags flags)
+                  #~(append (list "--without-cuda" "--without-knem"
+                                  "--without-java"
+                                  (string-append "--with-rocm="
+                                                 #$(this-package-input
+                                                    "rocr-runtime"))
+                                  (string-append "--with-hip="
+                                                 #$(this-package-input
+                                                    "hipamd")))
+                            #$flags))))
+    (native-inputs (modify-inputs (package-native-inputs ucx)
+                     (append roct-thunk)))
+    (inputs (modify-inputs (package-inputs ucx)
+              (append hipamd)
+              (append rocr-runtime)))
+    (properties `((tunable? . #t) ,@(package-properties ucx)))))
+
+(define-public ucx-rocm
+  (make-ucx-rocm roct-thunk rocr-runtime hipamd))
+
+; openmpi built with ucx-rocm and libfabric-rocm
+(define (make-openmpi-rocm ucx ofi hipamd)
+  (package/inherit openmpi
+    (name (string-append (package-name openmpi) "-rocm"))
+    (version (string-append (package-version openmpi) ".rocm"
+                            (package-version hipamd)))
+    (arguments (substitute-keyword-arguments (package-arguments openmpi)
+                 ((#:configure-flags flags)
+                  #~(append (list (string-append "--with-rocm="
+                                                 #$(this-package-input
+                                                    "hipamd"))
+                                  (string-append "--with-ofi="
+                                                 #$(this-package-input
+                                                    "libfabric")))
+                            #$flags))
+                 ((#:phases phases
+                   '%standard-phases)
+                  #~(modify-phases #$phases
+                      ;; opensm is needed for InfiniBand support.
+                      (add-after 'unpack 'find-opensm-headers
+                        (lambda* (#:key inputs #:allow-other-keys)
+                          (setenv "C_INCLUDE_PATH"
+                                  (search-input-directory inputs
+                                   "/include/infiniband"))
+                          (setenv "CPLUS_INCLUDE_PATH"
+                                  (search-input-directory inputs
+                                   "/include/infiniband"))))))))
+    (inputs (modify-inputs (package-inputs openmpi)
+              (replace "ucx" ucx)
+              (replace "libfabric" ofi)
+              (append hipamd)))))
+
+(define-public openmpi-rocm
+  (make-openmpi-rocm ucx-rocm ofi-rocm hipamd))
+
+; roctracer
+(define (make-roctracer hipamd)
+  (package
+    (name "roctracer")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DROCM_PATH="
+                                               #$hipamd)
+                                #$(if (version>=? version "5.5.0") ""
+                                      "-DCMAKE_CXX_COMPILER=g++"))
+      #:phases #~(modify-phases %standard-phases
+                   (add-after 'unpack 'update-filesystem
+                     ;; only needed from 5.5 onwards
+                     (lambda _
+                       (substitute* (append (find-files "." ".cpp$")
+                                            (find-files "." ".h$"))
+                         (("std::experimental::filesystem")
+                          "std::filesystem")
+                         (("<experimental/filesystem>")
+                          "<filesystem>")))))))
+    (inputs (list numactl hipamd python python-cppheaderparser))
+    (synopsis "A callback/activity library for performance tracing AMD GPUs.")
+    (description
+     "ROCm tracer provides an API to provide functionality for registering
+the runtimes API callbacks and asynchronous activity records pool support.")
+    (home-page "https://github.com/ROCm/roctracer")
+    (license expat)))
+
+(define-public roctracer
+  (make-roctracer hipamd))
+
+; rocblas
+(define (make-rocblas tensile rocm-cmake hipamd)
+  (package
+    (name "rocblas")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:build-type "Release"
+      #:tests? #f
+      #:validate-runpath? #f
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                (string-append "-DTensile_CPU_THREADS="
+                                               (number->string (parallel-job-count)))
+                                "-DBUILD_WITH_PIP=OFF"
+                                (if (string=? #$version "5.3.3")
+                                 "-DCMAKE_TOOLCHAIN_FILE=toolchain-linux.cmake"
+                                 "") "-DAMDGPU_TARGETS=gfx1100;gfx1030;gfx90a")
+      #:phases #~(modify-phases %standard-phases
+                   (add-after 'set-paths 'adjust-CPLUS_INCLUDE_PATH
+                     ;; only needed for version<=5.4
+                     (lambda* (#:key inputs #:allow-other-keys)
+                       (define cplus-include-path
+                         ;; Delete glibc/include and gcc/include/c++ from CPLUS_INCLUDE_PATH
+                         ;; to allow clang to include the cuda_wrappers first.
+                         (delete (string-append (assoc-ref inputs "libc")
+                                                "/include")
+                                 (delete (string-append (assoc-ref inputs
+                                                                   "gcc")
+                                                        "/include/c++")
+                                         (string-split (getenv
+                                                        "CPLUS_INCLUDE_PATH")
+                                                       #\:))))
+                       (setenv "CPLUS_INCLUDE_PATH"
+                               (string-join cplus-include-path ":")))))))
+    (native-inputs (list python-wrapper tensile hipamd rocm-cmake))
+    (properties '((max-silent-time . 14400)))
+    (synopsis "Next generation BLAS implementation for ROCm platform.")
+    (description
+     "rocBLAS is the ROCm Basic Linear Algebra Subprograms (BLAS) library.
+rocBLAS is implemented in the HIP programming language and optimized for AMD GPUs.")
+    (home-page "https://github.com/ROCmSoftwarePlatform/rocBLAS.git")
+    (license (list expat bsd-3))))
+
+(define-public rocblas
+  (make-rocblas tensile rocm-cmake hipamd))
+
+; rocsolver
+(define (make-rocsolver hipamd rocm-cmake rocblas rocprim)
+  (package
+    (name "rocsolver")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DBUILD_WITH_SPARSE=OFF"
+                                "-DAMDGPU_TARGETS=gfx1100;gfx1030;gfx90a")
+      #:phases #~(modify-phases %standard-phases
+                   (add-after 'set-paths 'adjust-CPLUS_INCLUDE_PATH
+                     (lambda* (#:key inputs #:allow-other-keys)
+                       (define cplus-include-path
+                         ;; Delete glibc/include and gcc/include/c++ from CPLUS_INCLUDE_PATH
+                         ;; to allow clang to include the cuda_wrappers first.
+                         (delete (string-append (assoc-ref inputs "libc")
+                                                "/include")
+                                 (delete (string-append (assoc-ref inputs
+                                                                   "gcc")
+                                                        "/include/c++")
+                                         (string-split (getenv
+                                                        "CPLUS_INCLUDE_PATH")
+                                                       #\:))))
+                       (setenv "CPLUS_INCLUDE_PATH"
+                               (string-join cplus-include-path ":")))))))
+    (inputs (list fmt-8 hipamd rocblas rocprim))
+    (native-inputs (list python-wrapper rocm-cmake))
+    (synopsis "rocSOLVER provides LAPACK operations for the ROCm platform.")
+    (description
+     "rocSOLVER is a work-in-progress implementation of a subset of LAPACK functionality
+on the ROCm platform.")
+    (home-page "https://github.com/ROCm/rocSOLVER.git")
+    (license (list bsd-2 bsd-3))))
+
+(define-public rocsolver
+  (make-rocsolver hipamd rocm-cmake rocblas rocprim))
+
+; hipblas
+(define-public (make-hipblas hipamd rocm-cmake rocblas rocsolver)
+  (package
+    (name "hipblas")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DAMDGPU_TARGETS=gfx1100;gfx90a;gfx1030")))
+    (inputs (list gfortran hipamd rocblas rocsolver))
+    (native-inputs (list rocm-cmake))
+    (synopsis "hipBLAS is a HIP interface to rocBLAS.")
+    (description
+     "hipBLAS is a Basic Linear Algebra Subprograms (BLAS) marshalling library with multiple
+supported backends. It sits between your application and a 'worker' BLAS library, where it marshals inputs to
+the backend library and marshals results to your application. hipBLAS exports an interface that doesn't
+require the client to change, regardless of the chosen backend. Currently, hipBLAS supports rocBLAS and
+cuBLAS backends.")
+    (home-page "https://github.com/ROCm/hipBLAS.git")
+    (license (list bsd-3 expat))))
+
+(define-public hipblas
+  (make-hipblas hipamd rocm-cmake rocblas rocsolver))
+
+; rocrand
+(define-public (make-rocrand hipamd rocm-cmake)
+  (package
+    (name "rocrand")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version
+                  #:recursive? #f))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                (string-append
+                                 "-DCMAKE_SHARED_LINKER_FLAGS=-Wl,-rpath="
+                                 #$output "/lib") "-DBUILD_HIPRAND:BOOL=OFF"
+                                "-DAMDGPU_TARGETS=gfx1100;gfx90a;gfx1030")))
+    (inputs (list hipamd))
+    (native-inputs (list git rocm-cmake))
+    (synopsis "RAND library for HIP programming language.")
+    (description
+     "The rocRAND project provides functions that generate pseudorandom and quasirandom numbers.
+The rocRAND library is implemented in the HIP programming language and optimized for AMD's latest discrete GPUs.
+It is designed to run on top of AMD's ROCm runtime, but it also works on CUDA-enabled GPUs.")
+    (home-page "https://github.com/ROCm/rocRAND.git")
+    (license expat)))
+
+(define-public rocrand
+  (make-rocrand hipamd rocm-cmake))
+
+; hiprand
+(define-public (make-hiprand hipamd rocm-cmake rocrand)
+  (package
+    (name "hiprand")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DAMDGPU_TARGETS=gfx90a,gfx1100,gfx1030")))
+    (inputs (list hipamd rocrand))
+    (native-inputs (list git rocm-cmake))
+    (synopsis "RAND library for HIP programming language.")
+    (description
+     "The rocRAND project provides functions that generate pseudorandom and quasirandom numbers.
+The rocRAND library is implemented in the HIP programming language and optimized for AMD's latest discrete GPUs.
+It is designed to run on top of AMD's ROCm runtime, but it also works on CUDA-enabled GPUs.")
+    (home-page "https://github.com/ROCm/rocRAND.git")
+    (license expat)))
+
+(define-public hiprand
+  (make-hiprand hipamd rocm-cmake rocrand))
+
+; rocalution
+(define-public (make-rocalution hipamd
+                                rocm-cmake
+                                rocsparse
+                                rocblas
+                                rocprim
+                                rocrand)
+  (package
+    (name "rocalution")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                (string-append "-DROCM_PATH="
+                                               #$hipamd)
+                                "-DAMDGPU_TARGETS=gfx1030;gfx90a;gfx1100"
+                                "-DSUPPORT_HIP=ON"
+                                "-DBUILD_CLIENTS_SAMPLES=OFF"
+                                "-DBUILD_CLIENTS_TESTS=OFF"
+                                "-DBUILD_CLIENTS_BENCHMARKS=OFF")
+      #:phases #~(modify-phases %standard-phases
+                   (add-after 'set-paths 'adjust-CPLUS_INCLUDE_PATH
+                     (lambda* (#:key inputs #:allow-other-keys)
+                       (define cplus-include-path
+                         ;; Delete glibc/include and gcc/include/c++ from CPLUS_INCLUDE_PATH
+                         ;; to allow clang to include the cuda_wrappers first.
+                         (delete (string-append (assoc-ref inputs "libc")
+                                                "/include")
+                                 (delete (string-append (assoc-ref inputs
+                                                                   "gcc")
+                                                        "/include/c++")
+                                         (string-split (getenv
+                                                        "CPLUS_INCLUDE_PATH")
+                                                       #\:))))
+                       (setenv "CPLUS_INCLUDE_PATH"
+                               (string-join cplus-include-path ":")))))))
+    (inputs (list hipamd rocsparse rocblas rocprim rocrand))
+    (native-inputs (list git rocm-cmake))
+    (synopsis "rocALUTION is a sparse linear algebra library.")
+    (description
+     "rocALUTION is a sparse linear algebra library that can be used to explore fine-grained
+parallelism on top of the ROCm platform runtime and toolchains. Based on C++ and HIP, rocALUTION provides a
+portable, generic, and flexible design that allows seamless integration with other scientific software packages.")
+    (home-page "https://github.com/ROCm/rocALUTION.git")
+    (license expat)))
+
+(define-public rocalution
+  (make-rocalution hipamd
+                   rocm-cmake
+                   rocsparse
+                   rocblas
+                   rocprim
+                   rocrand))
+
+; rocfft
+(define (make-rocfft hipamd rocm-cmake)
+  (package
+    (name "rocfft")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      ;; #:build-type "Release"
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                "-DSQLITE_USE_SYSTEM_PACKAGE:BOOL=ON"
+                                "-DAMDGPU_TARGETS=gfx90a;gfx1030;gfx1100")))
+    (inputs (list hipamd))
+    (native-inputs (list rocm-cmake python-wrapper sqlite))
+    (properties '((max-silent-time . 14400)))
+    (synopsis "Fast Fourier transforms (FFTs) for ROCm.")
+    (description
+     "rocFFT is a software library for computing fast Fourier transforms (FFTs) written in
+the HIP programming language. It's part of AMD's software ecosystem based on ROCm. The rocFFT
+library can be used with AMD and NVIDIA GPUs.")
+    (home-page "https://github.com/ROCm/rocFFT")
+    (license expat)))
+
+(define-public rocfft
+  (make-rocfft hipamd rocm-cmake))
+
+; hipfft
+(define (make-hipfft hipamd rocm-cmake rocfft)
+  (package
+    (name "hipfft")
+    (version (package-version hipamd))
+    (source
+     (rocm-origin name version))
+    (build-system cmake-build-system)
+    (arguments
+     (list
+      #:tests? #f ;No tests.
+      #:configure-flags #~(list (string-append "-DCMAKE_CXX_COMPILER="
+                                               #$hipamd "/bin/hipcc")
+                                (string-append "-DROCM_PATH="
+                                               #$hipamd)
+                                "-DAMDGPU_TARGETS=gfx90a;gfx1030;gfx1100")))
+    (inputs (list hipamd rocfft))
+    (native-inputs (list git rocm-cmake)) ;python-wrapper
+    (synopsis "A HIP interface for rocFFT and cuFFT.")
+    (description
+     "hipFFT exports an interface that doesn't require the client to change, regardless of the
+chosen backend. It sits between your application and the backend FFT library, where it marshals
+inputs to the backend and marshals results back to your application.")
+    (home-page "https://github.com/ROCm/hipFFT")
+    (license expat)))
+
+(define-public hipfft
+  (make-hipfft hipamd rocm-cmake rocfft))