Enable dpnp build on AMD GPU (#2302)

vlad-perevezentsev · web-flow · commit fdf9ba7a2aa6 · 2025-05-15T21:13:17.000+02:00
This PR updates `СMakeLists` files and `build_locally.py` to enable
building dpnp for AMD targets.

To build dpnp on AMD:
```
python scripts/build_locally.py --target-hip=gfx90a
```

To find the architecture, use
```
rocminfo | grep 'Name: *gfx.*'
```
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -17,6 +17,7 @@ This release achieves 100% compliance with Python Array API specification (revis
 * Added implementation of `dpnp.convolve` [#2205](https://github.com/IntelPython/dpnp/pull/2205)
 * Added implementation of `dpnp.kaiser` [#2387](https://github.com/IntelPython/dpnp/pull/2387)
 * Added implementation of `dpnp.interp` [#2417](https://github.com/IntelPython/dpnp/pull/2417)
+* Added support to build `dpnp` for specified AMD GPU architecture using [CodePlay oneAPI plug-in](https://developer.codeplay.com/products/oneapi/amd/home/) [#2302](https://github.com/IntelPython/dpnp/pull/2302)
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -75,27 +75,60 @@ option(DPNP_USE_ONEMKL_INTERFACES
     "Build DPNP with oneMKL Interfaces"
     OFF
 )
+set(HIP_TARGETS "" CACHE STRING "HIP architecture for target")
+
 set(_dpnp_sycl_targets)
+set(_use_onemkl_interfaces OFF)
 set(_use_onemkl_interfaces_cuda OFF)
+set(_use_onemkl_interfaces_hip OFF)
+
+set(_dpnp_sycl_target_compile_options)
+set(_dpnp_sycl_target_link_options)
+
 if ("x${DPNP_SYCL_TARGETS}" STREQUAL "x")
-   if(DPNP_TARGET_CUDA)
-      set(_dpnp_sycl_targets "nvptx64-nvidia-cuda,spir64-unknown-unknown")
-      set(_use_onemkl_interfaces_cuda ON)
-   else()
-      if(DEFINED ENV{DPNP_TARGET_CUDA})
-          set(_dpnp_sycl_targets "nvptx64-nvidia-cuda,spir64-unknown-unknown")
-          set(_use_onemkl_interfaces_cuda ON)
-      endif()
-   endif()
+    if(DPNP_TARGET_CUDA)
+        set(_dpnp_sycl_targets "nvptx64-nvidia-cuda,spir64-unknown-unknown")
+        set(_use_onemkl_interfaces_cuda ON)
+    endif()
+
+    if (NOT "x${HIP_TARGETS}" STREQUAL "x")
+        set(_use_onemkl_interfaces_hip ON)
+
+        if ("x${_dpnp_sycl_targets}" STREQUAL "x")
+            set(_dpnp_sycl_targets "amd_gpu_${HIP_TARGETS},spir64-unknown-unknown")
+        else()
+            set(_dpnp_sycl_targets "amd_gpu_${HIP_TARGETS},${_dpnp_sycl_targets}")
+        endif()
+    endif()
 else()
-   set(_dpnp_sycl_targets ${DPNP_SYCL_TARGETS})
+    set(_dpnp_sycl_targets ${DPNP_SYCL_TARGETS})
+
+    if ("${DPNP_SYCL_TARGETS}" MATCHES "nvptx64-nvidia-cuda")
+        set(_use_onemkl_interfaces_cuda ON)
+    endif()
+
+    if ("${DPNP_SYCL_TARGETS}" MATCHES "amd_gpu_")
+        set(_use_onemkl_interfaces_hip ON)
+
+        if ("x${HIP_TARGETS}" STREQUAL "x")
+            message(FATAL_ERROR "HIP_TARGETS must be specified when using HIP backend")
+        endif()
+    endif()
+
+    if ("${DPNP_SYCL_TARGETS}" MATCHES "amdgcn-amd-amdhsa")
+        message(FATAL_ERROR
+            "Legacy target 'amdgcn-amd-amdhsa' is not supported. "
+            "Use alias form 'amd_gpu_<arch>' instead"
+        )
+    endif()
 endif()
 
-if(_dpnp_sycl_targets)
+if (_dpnp_sycl_targets)
    message(STATUS "Compiling for -fsycl-targets=${_dpnp_sycl_targets}")
+   list(APPEND _dpnp_sycl_target_compile_options -fsycl-targets=${_dpnp_sycl_targets})
+   list(APPEND _dpnp_sycl_target_link_options -fsycl-targets=${_dpnp_sycl_targets})
 endif()
 
-set(_use_onemkl_interfaces OFF)
 if(DPNP_USE_ONEMKL_INTERFACES)
     set(_use_onemkl_interfaces ON)
 else()
@@ -107,13 +140,20 @@ endif()
 if(_use_onemkl_interfaces)
     set(BUILD_FUNCTIONAL_TESTS False)
     set(BUILD_EXAMPLES False)
+    set(ENABLE_MKLGPU_BACKEND True)
+    set(ENABLE_MKLCPU_BACKEND True)
+
     if(_use_onemkl_interfaces_cuda)
         set(ENABLE_CUBLAS_BACKEND True)
         set(ENABLE_CUSOLVER_BACKEND True)
         set(ENABLE_CUFFT_BACKEND True)
         # set(ENABLE_CURAND_BACKEND True)
-        set(ENABLE_MKLGPU_BACKEND True)
-        set(ENABLE_MKLCPU_BACKEND True)
+    endif()
+    if(_use_onemkl_interfaces_hip)
+        set(ENABLE_ROCBLAS_BACKEND True)
+        set(ENABLE_ROCSOLVER_BACKEND True)
+        set(ENABLE_ROCFFT_BACKEND True)
+        # set(ENABLE_ROCRAND_BACKEND True)
     endif()
 
     if(DPNP_ONEMKL_INTERFACES_DIR)
@@ -136,6 +176,13 @@ if(_use_onemkl_interfaces)
     endif()
     message(STATUS "MKL interfaces lib target used: ${MKL_INTERFACES_LIB}")
     set(CMAKE_INSTALL_RPATH "${CMAKE_BINARY_DIR}/lib")
+else()
+    if(_use_onemkl_interfaces_cuda OR _use_onemkl_interfaces_hip)
+        message(FATAL_ERROR
+            "CUDA or HIP targets are enabled, but oneMKL Interfaces are not. "
+            "Please set DPNP_USE_ONEMKL_INTERFACES=ON to enable them."
+        )
+    endif()
 endif()
 
 if(WIN32)
diff --git a/doc/quick_start_guide.rst b/doc/quick_start_guide.rst
@@ -136,18 +136,52 @@ Building ``dpnp`` for these targets requires that these CodePlay plugins be inst
 installation layout of compatible version. The following plugins from CodePlay are supported:
 
     - `oneAPI for NVIDIA(R) GPUs <codeplay_nv_plugin_>`_
+    - `oneAPI for AMD GPUs <codeplay_amd_plugin_>`_
 
 .. _codeplay_nv_plugin: https://developer.codeplay.com/products/oneapi/nvidia/
+.. _codeplay_amd_plugin: https://developer.codeplay.com/products/oneapi/amd/
 
 Building ``dpnp`` also requires `building Data Parallel Control Library for custom SYCL targets.
 <https://intelpython.github.io/dpctl/latest/beginners_guides/installation.html#building-for-custom-sycl-targets>`_
 
-Build ``dpnp`` as follows:
+``dpnp`` can be built for CUDA devices as follows:
 
 .. code-block:: bash
 
     python scripts/build_locally.py --target=cuda
 
+And for AMD devices:
+
+.. code-block:: bash
+
+    python scripts/build_locally.py --target-hip=<arch>
+
+Note that the *oneAPI for AMD GPUs* plugin requires the architecture be specified and only
+one architecture can be specified at a time.
+
+To determine the architecture code (``<arch>``) for your AMD GPU, run:
+
+.. code-block:: bash
+
+    rocminfo | grep 'Name: *gfx.*'
+
+This will print names like ``gfx90a``, ``gfx1030``, etc.
+You can then use one of them as the argument to ``--target-hip``.
+
+For example:
+
+.. code-block:: bash
+    python scripts/build_locally.py --target-hip=gfx90a
+
+
+It is, however, possible to build for Intel devices, CUDA devices, and an AMD device
+architecture all at once:
+
+.. code-block:: bash
+
+    python scripts/build_locally.py --target=cuda --target-hip=gfx90a
+
+
 Testing
 =======
 
diff --git a/dpnp/backend/extensions/blas/CMakeLists.txt b/dpnp/backend/extensions/blas/CMakeLists.txt
@@ -40,12 +40,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/dpnp/backend/extensions/fft/CMakeLists.txt b/dpnp/backend/extensions/fft/CMakeLists.txt
@@ -37,12 +37,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/dpnp/backend/extensions/indexing/CMakeLists.txt b/dpnp/backend/extensions/indexing/CMakeLists.txt
@@ -38,12 +38,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/dpnp/backend/extensions/lapack/CMakeLists.txt b/dpnp/backend/extensions/lapack/CMakeLists.txt
@@ -57,12 +57,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/dpnp/backend/extensions/statistics/CMakeLists.txt b/dpnp/backend/extensions/statistics/CMakeLists.txt
@@ -43,12 +43,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/dpnp/backend/extensions/ufunc/CMakeLists.txt b/dpnp/backend/extensions/ufunc/CMakeLists.txt
@@ -80,12 +80,12 @@ if(_dpnp_sycl_targets)
   target_compile_options(
     ${python_module_name}
     PRIVATE
-    -fsycl-targets=${_dpnp_sycl_targets}
+    ${_dpnp_sycl_target_compile_options}
   )
   target_link_options(
     ${python_module_name}
     PRIVATE
-    -fsycl-targets=${_dpnp_sycl_targets}
+    ${_dpnp_sycl_target_link_options}
   )
 endif()
 
diff --git a/dpnp/backend/extensions/window/CMakeLists.txt b/dpnp/backend/extensions/window/CMakeLists.txt
@@ -38,12 +38,12 @@ if(_dpnp_sycl_targets)
     target_compile_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_compile_options}
     )
     target_link_options(
         ${python_module_name}
         PRIVATE
-        -fsycl-targets=${_dpnp_sycl_targets}
+        ${_dpnp_sycl_target_link_options}
     )
 endif()
 
diff --git a/scripts/build_locally.py b/scripts/build_locally.py
@@ -39,6 +39,7 @@ def run(
     verbose=False,
     cmake_opts="",
     target="intel",
+    target_hip=None,
     onemkl_interfaces=False,
     onemkl_interfaces_dir=None,
 ):
@@ -97,13 +98,27 @@ def run(
         if "DPL_ROOT" in os.environ:
             os.environ["DPL_ROOT_HINT"] = os.environ["DPL_ROOT"]
 
+    if not target.strip():
+        target = "intel"
+
     if target == "cuda":
         cmake_args += [
             "-DDPNP_TARGET_CUDA=ON",
         ]
         # Always builds using oneMKL interfaces for the cuda target
         onemkl_interfaces = True
 
+    if target_hip is not None:
+        if not target_hip.strip():
+            raise ValueError(
+                "--target-hip requires an architecture (e.g., gfx90a)"
+            )
+        cmake_args += [
+            f"-DHIP_TARGETS={target_hip}",
+        ]
+        # Always builds using oneMKL interfaces for the hip target
+        onemkl_interfaces = True
+
     if onemkl_interfaces:
         cmake_args += [
             "-DDPNP_USE_ONEMKL_INTERFACES=ON",
@@ -177,6 +192,13 @@ def run(
         default="intel",
         type=str,
     )
+    driver.add_argument(
+        "--target-hip",
+        required=False,
+        help="Enable HIP target for build. "
+        "Must specify HIP architecture (e.g., --target-hip=gfx90a)",
+        type=str,
+    )
     driver.add_argument(
         "--onemkl-interfaces",
         help="Build using oneMKL Interfaces",
@@ -244,6 +266,7 @@ def run(
         verbose=args.verbose,
         cmake_opts=args.cmake_opts,
         target=args.target,
+        target_hip=args.target_hip,
         onemkl_interfaces=args.onemkl_interfaces,
         onemkl_interfaces_dir=args.onemkl_interfaces_dir,
     )

Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,12 @@ if(_dpnp_sycl_targets)`
`40`	`40`	`target_compile_options(`
`41`	`41`	`${python_module_name}`
`42`	`42`	`PRIVATE`
`43`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`43`	`+ ${_dpnp_sycl_target_compile_options}`
`44`	`44`	`)`
`45`	`45`	`target_link_options(`
`46`	`46`	`${python_module_name}`
`47`	`47`	`PRIVATE`
`48`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`48`	`+ ${_dpnp_sycl_target_link_options}`
`49`	`49`	`)`
`50`	`50`	`endif()`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,12 @@ if(_dpnp_sycl_targets)`
`37`	`37`	`target_compile_options(`
`38`	`38`	`${python_module_name}`
`39`	`39`	`PRIVATE`
`40`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`40`	`+ ${_dpnp_sycl_target_compile_options}`
`41`	`41`	`)`
`42`	`42`	`target_link_options(`
`43`	`43`	`${python_module_name}`
`44`	`44`	`PRIVATE`
`45`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`45`	`+ ${_dpnp_sycl_target_link_options}`
`46`	`46`	`)`
`47`	`47`	`endif()`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -38,12 +38,12 @@ if(_dpnp_sycl_targets)`
`38`	`38`	`target_compile_options(`
`39`	`39`	`${python_module_name}`
`40`	`40`	`PRIVATE`
`41`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`41`	`+ ${_dpnp_sycl_target_compile_options}`
`42`	`42`	`)`
`43`	`43`	`target_link_options(`
`44`	`44`	`${python_module_name}`
`45`	`45`	`PRIVATE`
`46`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`46`	`+ ${_dpnp_sycl_target_link_options}`
`47`	`47`	`)`
`48`	`48`	`endif()`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -57,12 +57,12 @@ if(_dpnp_sycl_targets)`
`57`	`57`	`target_compile_options(`
`58`	`58`	`${python_module_name}`
`59`	`59`	`PRIVATE`
`60`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`60`	`+ ${_dpnp_sycl_target_compile_options}`
`61`	`61`	`)`
`62`	`62`	`target_link_options(`
`63`	`63`	`${python_module_name}`
`64`	`64`	`PRIVATE`
`65`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`65`	`+ ${_dpnp_sycl_target_link_options}`
`66`	`66`	`)`
`67`	`67`	`endif()`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -43,12 +43,12 @@ if(_dpnp_sycl_targets)`
`43`	`43`	`target_compile_options(`
`44`	`44`	`${python_module_name}`
`45`	`45`	`PRIVATE`
`46`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`46`	`+ ${_dpnp_sycl_target_compile_options}`
`47`	`47`	`)`
`48`	`48`	`target_link_options(`
`49`	`49`	`${python_module_name}`
`50`	`50`	`PRIVATE`
`51`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`51`	`+ ${_dpnp_sycl_target_link_options}`
`52`	`52`	`)`
`53`	`53`	`endif()`
`54`	`54`
Original file line number	Diff line number	Diff line change
`@@ -80,12 +80,12 @@ if(_dpnp_sycl_targets)`
`80`	`80`	`target_compile_options(`
`81`	`81`	`${python_module_name}`
`82`	`82`	`PRIVATE`
`83`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`83`	`+ ${_dpnp_sycl_target_compile_options}`
`84`	`84`	`)`
`85`	`85`	`target_link_options(`
`86`	`86`	`${python_module_name}`
`87`	`87`	`PRIVATE`
`88`		`- -fsycl-targets=${_dpnp_sycl_targets}`
	`88`	`+ ${_dpnp_sycl_target_link_options}`
`89`	`89`	`)`
`90`	`90`	`endif()`
`91`	`91`