Require AdaptiveCpp >=24.06 and rename all hipSYCL references to AdaptiveCpp (uxlfoundation#699)

Co-authored-by: Pablo Lopez <pablo.lopez@codeplay.com>
Co-authored-by: lrpablo <155004933+lrpablo@users.noreply.github.com>
Co-authored-by: Andrey Alekseenko <al42and@gmail.com>

Author: 3 people

CMakeLists.txt

@@ -292,9 +292,12 @@ else()
   # Find necessary packages
   if(ONEMATH_SYCL_IMPLEMENTATION)
     string( TOLOWER "${ONEMATH_SYCL_IMPLEMENTATION}" ONEMATH_SYCL_IMPLEMENTATION)
-    if (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "hipsycl")
-      message(STATUS "Looking for hipSYCL")
-      find_package(hipSYCL CONFIG REQUIRED)
+    if (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "adaptivecpp")
+      message(STATUS "Looking for AdaptiveCpp")
+      find_package(AdaptiveCpp CONFIG REQUIRED)
+      if (${AdaptiveCpp_VERSION} VERSION_LESS "24.6")
+        message(FATAL_ERROR "AdaptiveCpp version 24.6 or higher is required but ${AdaptiveCpp_VERSION} was found")
+      endif()
       set(USE_ADD_SYCL_TO_TARGET_INTEGRATION true)
       set (CMAKE_CXX_STANDARD 17)
       add_library(ONEMATH::SYCL::SYCL INTERFACE IMPORTED)

README.md

@@ -175,7 +175,7 @@ Supported domains include: BLAS, LAPACK, RNG, DFT, SPARSE_BLAS
 Supported compilers include:
 - [Intel(R) oneAPI DPC++ Compiler](https://software.intel.com/en-us/oneapi/dpc-compiler): Intel proprietary compiler that supports CPUs and Intel GPUs. Intel(R) oneAPI DPC++ Compiler will be referred to as "Intel DPC++" in the "Supported Compiler" column of the tables below.
 - [oneAPI DPC++ Compiler](https://github.com/intel/llvm): Open source compiler that supports CPUs and Intel, NVIDIA, and AMD GPUs. oneAPI DPC++ Compiler will be referred to as "Open DPC++" in the "Supported Compiler" column of the tables below.
-- [AdaptiveCpp Compiler](https://github.com/AdaptiveCpp/AdaptiveCpp) (formerly known as hipSYCL): Open source compiler that supports CPUs and Intel, NVIDIA, and AMD GPUs.</br>**Note**: The source code and some documents in this project still use the previous name hipSYCL during this transition period.
+- [AdaptiveCpp Compiler](https://github.com/AdaptiveCpp/AdaptiveCpp): Open source compiler that supports CPUs and Intel, NVIDIA, and AMD GPUs.
 
 #### Linux*
 
@@ -584,7 +584,7 @@ Product | Supported Version | License
 [Ninja](https://ninja-build.org/) | 1.10.0 | [Apache License v2.0](https://github.com/ninja-build/ninja/blob/master/COPYING)
 [GNU* FORTRAN Compiler](https://gcc.gnu.org/wiki/GFortran) | 7.4.0 or higher | [GNU General Public License, version 3](https://gcc.gnu.org/onlinedocs/gcc-7.5.0/gfortran/Copying.html)
 [Intel(R) oneAPI DPC++ Compiler](https://software.intel.com/en-us/oneapi/dpc-compiler) | Latest | [End User License Agreement for the Intel(R) Software Development Products](https://software.intel.com/en-us/license/eula-for-intel-software-development-products)
-[AdaptiveCpp](https://github.com/AdaptiveCpp/AdaptiveCpp) | Later than [2cfa530](https://github.com/AdaptiveCpp/AdaptiveCpp/commit/2cfa5303fd88b8f84e539b5bb6ed41e49c6d6118) | [BSD-2-Clause License ](https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/LICENSE)
+[AdaptiveCpp](https://github.com/AdaptiveCpp/AdaptiveCpp) | 24.06 or higher | [BSD-2-Clause License ](https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/LICENSE)
 [oneAPI DPC++ Compiler binary for x86 CPU](https://github.com/intel/llvm/releases) | Daily builds | [Apache License v2](https://github.com/intel/llvm/blob/sycl/sycl/LICENSE.TXT)
 [oneAPI DPC++ Compiler source for NVIDIA and AMD GPUs](https://github.com/intel/llvm) | Daily source releases | [Apache License v2](https://github.com/intel/llvm/blob/sycl/sycl/LICENSE.TXT)
 [Intel(R) oneAPI Math Kernel Library](https://software.intel.com/en-us/oneapi/onemkl) | Latest | [Intel Simplified Software License](https://software.intel.com/en-us/license/intel-simplified-software-license)

cmake/FindcuRAND.cmake

@@ -59,7 +59,7 @@
 find_package(CUDA 10.0 REQUIRED)
 get_filename_component(SYCL_BINARY_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)
 
-if (NOT (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "hipsycl"))
+if (NOT (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "adaptivecpp"))
 # the OpenCL include file from cuda is opencl 1.1 and it is not compatible with DPC++
 # the OpenCL include headers 1.2 onward is required. This is used to bypass NVIDIA OpenCL headers
 find_path(OPENCL_INCLUDE_DIR
@@ -79,7 +79,7 @@ find_package(Threads REQUIRED)
 
 include(FindPackageHandleStandardArgs)
 
-if (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "hipsycl")
+if (ONEMATH_SYCL_IMPLEMENTATION STREQUAL "adaptivecpp")
 find_package_handle_standard_args(cuRAND
     REQUIRED_VARS
 	CUDA_TOOLKIT_INCLUDE

docs/building_the_project_with_adaptivecpp.rst

@@ -12,7 +12,7 @@ Environment Setup
    Build and install AdaptiveCpp. For a detailed description of available
    AdaptiveCpp backends, their dependencies, and installation, see the
    `AdaptiveCpp installation readme
-   <https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/doc/installing.md#compilation-flows>`_.
+   <https://adaptivecpp.github.io/AdaptiveCpp/installing/>`_.
 
 #. 
    Clone this project. The root directory of the cloned repository will be
@@ -35,13 +35,13 @@ On Linux (other OSes are not supported with the AdaptiveCpp compiler):
 
   # Inside <path to onemath>
   mkdir build && cd build
-  cmake .. -DONEMATH_SYCL_IMPLEMENTATION=hipsycl   \ # Indicate that AdaptiveCpp is being used.
-          -DENABLE_MKLGPU_BACKEND=False            \ # MKLGPU backend is not supported by AdaptiveCpp
-          -DENABLE_<BACKEND_NAME>_BACKEND=True     \ # Enable backend(s) (optional)
-          -DENABLE_<BACKEND_NAME_2>_BACKEND=True   \ # Multiple backends can be enabled at once.
-          -DHIPSYCL_TARGETS=omp/;hip:gfx90a,gfx906 \ # Set target architectures depending on supported devices.
-          -DBUILD_FUNCTIONAL_TESTS=False           \ # See section *Building the tests* for more on building tests. True by default.
-          -DBUILD_EXAMPLES=False                   # Optional: True by default.
+  cmake .. -DONEMATH_SYCL_IMPLEMENTATION=adaptivecpp \ # Indicate that AdaptiveCpp is being used.
+          -DENABLE_MKLGPU_BACKEND=False              \ # MKLGPU backend is not supported by AdaptiveCpp
+          -DENABLE_<BACKEND_NAME>_BACKEND=True       \ # Enable backend(s) (optional)
+          -DENABLE_<BACKEND_NAME_2>_BACKEND=True     \ # Multiple backends can be enabled at once.
+          -DACPP_TARGETS=omp\;hip:gfx90a,gfx906      \ # Set target architectures depending on supported devices.
+          -DBUILD_FUNCTIONAL_TESTS=False             \ # See section *Building the tests* for more on building tests. True by default.
+          -DBUILD_EXAMPLES=False                     # Optional: True by default.
   cmake --build .
   cmake --install . --prefix <path_to_install_dir> # required to have full package structure
 
@@ -53,9 +53,9 @@ configurations table
 <https://github.com/uxlfoundation/oneMath?tab=readme-ov-file#supported-configurations>`_,
 and the CMake option names are given in the table below. Some backends may
 require additional parameters to be set. See the relevant section below for
-additional guidance. The target architectures must be specified with
-``HIP_TARGETS``. See the `AdaptiveCpp documentation
-<https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/doc/using-hipsycl.md#adaptivecpp-targets-specification>`_.
+additional guidance. The target architectures may be specified with ``ACPP_TARGETS``,
+otherwise the ``generic`` target is used. See the `AdaptiveCpp documentation
+<https://adaptivecpp.github.io/AdaptiveCpp/using-acpp/#adaptivecpp-targets-specification>`_.
 
 If a backend library supports multiple domains (i.e. BLAS, DFT, RNG), it may be
 desirable to only enable selected domains. For this, the ``TARGET_DOMAINS``
@@ -129,14 +129,14 @@ Building for CUDA
 The CUDA backends can be enabled with ``ENABLE_CUBLAS_BACKEND``,
 ``ENABLE_CUFFT_BACKEND`` and ``ENABLE_CURAND_BACKEND``.
 
-The target architecture must be set using the ``HIPSYCL_TARGETS`` parameter. For
+The target architecture may be specified using the ``ACPP_TARGETS`` parameter. For
 example, to target a Nvidia A100 (Ampere architecture), set
-``-DHIPSYCL_TARGETS=cuda:sm_80``, where the figure ``80`` corresponds to a CUDA
+``-DACPP_TARGETS=cuda:sm_80``, where the figure ``80`` corresponds to a CUDA
 compute capability of 8.0. The correspondence between compute capabilities and
 Nvidia GPU products is given on the `Nvidia website
 <https://developer.nvidia.com/cuda-gpus>`_. Multiple architectures can be
 enabled using a comma separated list. See the `AdaptiveCpp documentation
-<https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/doc/using-hipsycl.md#adaptivecpp-targets-specification>`_.
+<https://adaptivecpp.github.io/AdaptiveCpp/using-acpp/#adaptivecpp-targets-specification>`_.
 
 No additional parameters are required for using CUDA libraries. In most cases,
 the CUDA libraries should be found automatically by CMake.
@@ -149,13 +149,13 @@ Building for ROCm
 The ROCm backends can be enabled with ``ENABLE_ROCBLAS_BACKEND``,
 ``ENABLE_ROCFFT_BACKEND`` and ``ENABLE_ROCRAND_BACKEND``.
 
-The target architecture must be set using the ``HIPSYCL_TARGETS`` parameter. See
+The target architecture may be specified using the ``ACPP_TARGETS`` parameter. See
 the `AdaptiveCpp documentation
-<https://github.com/AdaptiveCpp/AdaptiveCpp/blob/develop/doc/using-hipsycl.md#adaptivecpp-targets-specification>`_.
-For example, to target the MI200 series, set ``-DHIPSYCL_TARGETS=hip:gfx90a``.
+<https://adaptivecpp.github.io/AdaptiveCpp/using-acpp/#adaptivecpp-targets-specification>`_.
+For example, to target the MI200 series, set ``-DACPP_TARGETS=hip:gfx90a``.
 Multiple architectures can be enabled using a comma separated list. For example,
-``-DHIPSYCL_TARGETS=hip:gfx906,gfx90a``, and multiple APIs with a semicolon
-(``-DHIPSYCL_TARGETS=omp\;hip:gfx906,gfx90a``).
+``-DACPP_TARGETS=hip:gfx906,gfx90a``, and multiple APIs with a semicolon
+(``-DACPP_TARGETS=omp\;hip:gfx906,gfx90a``).
 
 For common AMD GPU architectures, see the :ref:`build_for_ROCM_dpcpp` in the
 DPC++ build guide.

docs/building_the_project_with_dpcpp.rst

@@ -356,7 +356,7 @@ When building oneMath the SYCL implementation can be specified by setting the
 * ``dpc++`` (default) for the `Intel(R) oneAPI DPC++ Compiler
   <https://software.intel.com/en-us/oneapi/dpc-compiler>`_ and for the `oneAPI
   DPC++ Compiler <https://github.com/intel/llvm>`_ compilers.
-* ``hipsycl`` for the `AdaptiveCpp <https://github.com/illuhad/AdaptiveCpp>`_
+* ``AdaptiveCpp`` for the `AdaptiveCpp <https://github.com/AdaptiveCpp/AdaptiveCpp>`_
   SYCL implementation.
 Please see :ref:`building_the_project_with_adaptivecpp` if using this option.
 

docs/selecting_a_compiler.rst

@@ -9,11 +9,11 @@ application.
 * If your application requires Intel GPU, use
   `Intel(R) oneAPI DPC++ Compiler <https://software.intel.com/en-us/oneapi/dpc-compiler>`_ ``icpx`` on Linux or ``icx`` on Windows.
 * If your Linux application requires NVIDIA GPU, build ``clang++`` from the latest source of
-  `oneAPI DPC++ Compiler <https://github.com/intel/llvm>`_ with `support for NVIDIA CUDA <https://github.com/intel/llvm/blob/sycl/sycl/doc/GetStartedGuide.md#build-dpc-toolchain-with-support-for-nvidia-cuda>`_ or use ``hipSYCL`` from the `hipSYCL repository <https://github.com/illuhad/hipSYCL>`_ (except for LAPACK domain).
-* If your Linux application requires AMD GPU, build ``clang++`` from the latest source of `oneAPI DPC++ Compiler <https://github.com/intel/llvm>`_ with `support for HIP AMD <https://github.com/intel/llvm/blob/sycl/sycl/doc/GetStartedGuide.md#build-dpc-toolchain-with-support-for-hip-amd>`_ or use ``hipSYCL``.
+  `oneAPI DPC++ Compiler <https://github.com/intel/llvm>`_ with `support for NVIDIA CUDA <https://github.com/intel/llvm/blob/sycl/sycl/doc/GetStartedGuide.md#build-dpc-toolchain-with-support-for-nvidia-cuda>`_ or use ``AdaptiveCpp`` from the `AdaptiveCpp repository <https://github.com/AdaptiveCpp/AdaptiveCpp>`_ (except for LAPACK or DFT domains).
+* If your Linux application requires AMD GPU, build ``clang++`` from the latest source of `oneAPI DPC++ Compiler <https://github.com/intel/llvm>`_ with `support for HIP AMD <https://github.com/intel/llvm/blob/sycl/sycl/doc/GetStartedGuide.md#build-dpc-toolchain-with-support-for-hip-amd>`_ or use ``AdaptiveCpp``.
 * If no Intel GPU, NVIDIA GPU, or AMD GPU is required, on Linux you can use
   `Intel(R) oneAPI DPC++ Compiler <https://software.intel.com/en-us/oneapi/dpc-compiler>`_
-  ``icpx``, `oneAPI DPC++ Compiler <https://github.com/intel/llvm/releases>`_ ``clang++``, or ``hipSYCL``,
+  ``icpx``, `oneAPI DPC++ Compiler <https://github.com/intel/llvm/releases>`_ ``clang++``, or ``AdaptiveCpp``,
   and on Windows you can use either
   `Intel(R) oneAPI DPC++ Compiler <https://software.intel.com/en-us/oneapi/dpc-compiler>`_
   ``icx`` or `oneAPI DPC++ Compiler <https://github.com/intel/llvm/releases>`_ ``clang-cl``.

examples/rng/device/CMakeLists.txt

@@ -63,7 +63,7 @@ endif()
 
 target_link_libraries(${EXAMPLE_TARGET} PUBLIC ONEMATH::SYCL::SYCL)
 
-if(NOT ${ONEMATH_SYCL_IMPLEMENTATION} STREQUAL "hipsycl")
+if(NOT ${ONEMATH_SYCL_IMPLEMENTATION} STREQUAL "adaptivecpp")
   # set strict warning flags for rng device API examples
   target_compile_options(${EXAMPLE_TARGET} PUBLIC -Wall -Werror -Wextra -Wpedantic -Wunreachable-code -Wfloat-conversion -Wextra-semi -Wshadow)
   target_link_options(${EXAMPLE_TARGET} PUBLIC -fsycl -fsycl-device-code-split=per_kernel)

examples/rng/device/include/rng_example_helper.hpp

@@ -29,22 +29,12 @@ struct has_member_code_meta<T, std::void_t<decltype(std::declval<T>().get_multi_
 
 template <typename T, typename std::enable_if<has_member_code_meta<T>::value>::type* = nullptr>
 auto get_multi_ptr(T acc) {
-// Workaround for AdaptiveCPP, as they do not yet support the get_multi_ptr function
-#ifndef __HIPSYCL__
     return acc.get_multi_ptr();
-#else
-    return acc.get_pointer();
-#endif
 }
 
 template <typename T, typename std::enable_if<!has_member_code_meta<T>::value>::type* = nullptr>
 auto get_multi_ptr(T acc) {
-// Workaround for AdaptiveCPP, as they do not yet support the get_multi_ptr function
-#ifndef __HIPSYCL__
     return acc.template get_multi_ptr<sycl::access::decorated::yes>();
-#else
-    return acc.get_pointer();
-#endif
 }
 
 #endif // _RNG_EXAMPLE_HELPER_HPP__

include/oneapi/math/detail/backend_selector_predicates.hpp

@@ -40,7 +40,7 @@ inline void backend_selector_precondition(sycl::queue&) {}
 template <>
 inline void backend_selector_precondition<backend::netlib>(sycl::queue& queue) {
 #ifndef ONEMATH_DISABLE_PREDICATES
-#ifdef __HIPSYCL__
+#ifdef __ADAPTIVECPP__
     if (!(queue.is_host() || queue.get_device().is_cpu())) {
 #else
     if (!queue.get_device().is_cpu()) {
@@ -55,7 +55,7 @@ inline void backend_selector_precondition<backend::netlib>(sycl::queue& queue) {
 template <>
 inline void backend_selector_precondition<backend::mklcpu>(sycl::queue& queue) {
 #ifndef ONEMATH_DISABLE_PREDICATES
-#ifdef __HIPSYCL__
+#ifdef __ADAPTIVECPP__
     if (!(queue.is_host() || queue.get_device().is_cpu())) {
 #else
     if (!queue.get_device().is_cpu()) {
@@ -70,7 +70,7 @@ inline void backend_selector_precondition<backend::mklcpu>(sycl::queue& queue) {
 template <>
 inline void backend_selector_precondition<backend::armpl>(sycl::queue& queue) {
 #ifndef ONEMKL_DISABLE_PREDICATES
-#ifdef __HIPSYCL__
+#ifdef __ADAPTIVECPP__
     if (!(queue.is_host() || queue.get_device().is_cpu())) {
 #else
     if (!queue.get_device().is_cpu()) {

include/oneapi/math/detail/get_device_id.hpp

@@ -31,7 +31,7 @@
 
 #define INTEL_ID  32902
 #define NVIDIA_ID 4318
-#ifndef __HIPSYCL__
+#ifndef __ADAPTIVECPP__
 #define AMD_ID 4098
 #else
 #define AMD_ID 1022
@@ -45,14 +45,14 @@ inline oneapi::math::device get_device_id(sycl::queue& queue) {
 #ifdef __x86_64__
     if (queue.get_device().is_cpu())
         device_id = device::x86cpu;
-#ifdef __HIPSYCL__
+#ifdef __ADAPTIVECPP__
     else if (queue.is_host())
         device_id = device::x86cpu;
 #endif
 #elif __aarch64__
     if (queue.get_device().is_cpu())
         device_id = device::aarch64cpu;
-#ifdef __HIPSYCL__
+#ifdef __ADAPTIVECPP__
     else if (queue.is_host())
         device_id = device::aarch64cpu;
 #endif