Merge branch 'develop' into regression

# Conflicts:
#	tests/backends/stdpar/stdpar_csvm.cpp

Author: breyerml

README.md

@@ -139,7 +139,7 @@ Additional dependencies for the Kokkos backend:
 
 Additional dependencies for the stdpar backend:
 
-- the code must be compiled with a stdpar capable compiler; currently supported are [nvc++](https://developer.nvidia.com/hpc-sdk), [roc-stdpar](https://github.com/ROCm/roc-stdpar), [icpx](https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler.html), [AdaptiveCpp](https://github.com/AdaptiveCpp/AdaptiveCpp), and [GNU GCC](https://gcc.gnu.org/))
+- the code must be compiled with a stdpar capable compiler; currently supported are [nvc++](https://developer.nvidia.com/hpc-sdk), [roc-stdpar](https://github.com/llvm/llvm-project) (merged into upstream LLVM starting with version 18), [icpx](https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler.html), [AdaptiveCpp](https://github.com/AdaptiveCpp/AdaptiveCpp), and [GNU GCC](https://gcc.gnu.org/))
 - depending on the used stdpar implementation, additional dependencies are required:
 
     - `nvc++`: a CUDA SDK

cmake/plssvm/plssvmstdparTargets.cmake

@@ -20,12 +20,12 @@ if (TARGET plssvm::plssvm-stdpar)
             return()
         endif ()
     elseif (PLSSVM_STDPAR_BACKEND MATCHES "roc-stdpar")
-        check_cxx_compiler_flag("-hipstdpar --hipstdpar-path=${PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH}" PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
+        check_cxx_compiler_flag("--hipstdpar" PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
         if (NOT PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
             set(plssvm_FOUND OFF)
             set(plssvm_stdpar_FOUND OFF)
             set(plssvm_NOT_FOUND_MESSAGE
-                "The CMAKE_CXX_COMPILER must be set to the hipstdpar patched LLVM compiler (acpp) in user code in order to use plssvm::stdpar!"
+                "The CMAKE_CXX_COMPILER must be set to a compatible LLVM (version 18 or newer) in user code in order to use plssvm::stdpar!"
             )
             return()
         endif ()

src/plssvm/backends/Kokkos/CMakeLists.txt

@@ -40,6 +40,9 @@ if (Kokkos_ENABLE_SYCL)
     if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
         message(FATAL_ERROR "For Kokkos::SYCL to work, the compiler must be IntelLLVM, but is ${CMAKE_CXX_COMPILER}!")
     endif ()
+    
+    target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -sycl-std=2020 -fsycl)
+    target_link_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl)
 
     # set icpx specific compiler flags based on the provided PLSSVM_TARGET_PLATFORMS
     set(PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS "")
@@ -64,15 +67,12 @@ if (Kokkos_ENABLE_SYCL)
         target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch=${PLSSVM_AMD_TARGET_ARCHS})
         target_link_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch=${PLSSVM_AMD_TARGET_ARCHS})
     endif ()
-    # intel targets
-    if (DEFINED PLSSVM_INTEL_TARGET_ARCHS)
-        # assemble -fsycl-targets
-        list(APPEND PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS "spir64_gen")
-    endif ()
     # set -fsycl-targets
     list(JOIN PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS "," PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS_STRING)
-    target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -sycl-std=2020 -fsycl -fsycl-targets=${PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS_STRING})
-    target_link_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl -fsycl-targets=${PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS_STRING})
+    if (NOT PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS STREQUAL "")
+        target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS_STRING})
+        target_link_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_KOKKOS_SYCL_FSYCL_TARGETS_STRING})
+    endif ()
 
     # add option for IntelLLVM Ahead-of-Time (AOT) compilation
     option(PLSSVM_KOKKOS_BACKEND_INTEL_LLVM_ENABLE_AOT "Enables Ahead-of-Time compilation for the Kokkos::SYCL execution space using IntelLLVM." ON)
@@ -104,6 +104,8 @@ if (Kokkos_ENABLE_SYCL)
             )
         endif ()
         if (DEFINED PLSSVM_INTEL_TARGET_ARCHS)
+            target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl-targets=spir64_gen)
+            target_link_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -fsycl-targets=spir64_gen)
             # add Intel GPU target specific flags for AOT
             list(JOIN PLSSVM_INTEL_TARGET_ARCHS "," PLSSVM_INTEL_TARGET_ARCHS_STRING)
             target_compile_options(${PLSSVM_KOKKOS_BACKEND_LIBRARY_NAME} PRIVATE -Xsycl-target-backend=spir64_gen "-device ${PLSSVM_INTEL_TARGET_ARCHS_STRING}")

src/plssvm/backends/SYCL/DPCPP/CMakeLists.txt

@@ -104,15 +104,12 @@ if (PLSSVM_SYCL_BACKEND_CHECK_FOR_DPCPP_COMPILER)
         )
         target_link_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch=${PLSSVM_AMD_TARGET_ARCHS})
     endif ()
-    # intel targets
-    if (DEFINED PLSSVM_INTEL_TARGET_ARCHS)
-        # assemble -fsycl-targets
-        list(APPEND PLSSVM_DPCPP_FSYCL_TARGETS "spir64_gen")
-    endif ()
     # set -fsycl-targets
     list(JOIN PLSSVM_DPCPP_FSYCL_TARGETS "," PLSSVM_DPCPP_FSYCL_TARGETS_STRING)
-    target_compile_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_DPCPP_FSYCL_TARGETS_STRING})
-    target_link_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_DPCPP_FSYCL_TARGETS_STRING})
+    if (NOT PLSSVM_DPCPP_FSYCL_TARGETS_STRING STREQUAL "")
+        target_compile_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_DPCPP_FSYCL_TARGETS_STRING})
+        target_link_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=${PLSSVM_DPCPP_FSYCL_TARGETS_STRING})
+    endif ()
 
     # add option for DPC++ Ahead-of-Time (AOT) compilation
     option(PLSSVM_SYCL_BACKEND_DPCPP_ENABLE_AOT "Enables Ahead-of-Time compilation for DPC++." ON)
@@ -148,6 +145,8 @@ if (PLSSVM_SYCL_BACKEND_CHECK_FOR_DPCPP_COMPILER)
         endif ()
         # intel targets
         if (DEFINED PLSSVM_INTEL_TARGET_ARCHS)
+            target_compile_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=spir64_gen)
+            target_link_options(${PLSSVM_SYCL_BACKEND_DPCPP_LIBRARY_NAME} PRIVATE -fsycl-targets=spir64_gen)
             # add target specific flags for AOT
             list(JOIN PLSSVM_INTEL_TARGET_ARCHS "," PLSSVM_INTEL_TARGET_ARCHS_STRING)
             target_compile_options(

src/plssvm/backends/stdpar/roc-stdpar/CMakeLists.txt

@@ -6,21 +6,11 @@
 
 message(CHECK_START "searching for roc-stdpar")
 
-# check whether the roc-stdpar include path has been provided
-if (DEFINED PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH)
-    set(PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH ${PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH}
-        CACHE STRING "The roc-stdpar path (--hipstdpar-path) necessary to compile the roc-stdpar backend." FORCE
-    )
-elseif (DEFINED ENV{PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH})
-    set(PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH $ENV{PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH}
-        CACHE STRING "The roc-stdpar path (--hipstdpar-path) necessary to compile the roc-stdpar backend." FORCE
-    )
-endif ()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH)
-    # check for AMD's roc-stdpar enabled compiler -> only possible with the provided path
+# check whether the roc-stdpar compiler is available
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    # check for AMD's roc-stdpar enabled compiler
     include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag("-hipstdpar --hipstdpar-path=${PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH}" PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
+    check_cxx_compiler_flag("--hipstdpar" PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
     if (NOT PLSSVM_HAS_HIPSTDPAR_STDPAR_FLAG)
         # the target offload flag couldn't be found!
         if (PLSSVM_ENABLE_STDPAR_BACKEND MATCHES "ON")
@@ -44,20 +34,14 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND PLSSVM_STDPAR_BACKEND_HIPSTDPAR_P
     # roc-stdpar found
     message(CHECK_PASS "found")
     set_local_and_parent(PLSSVM_STDPAR_BACKEND "roc-stdpar")
-else ()
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH)
-        message(STATUS "Try checking for the roc-stdpar backend but the roc-stdpar include path wasn't provided via \"PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH\"!")
-    endif ()
-    message(CHECK_FAIL "skipped")
-    return()
 endif ()
 
 # add stdpar implementation specific source file to library
 append_local_and_parent(PLSSVM_STDPAR_SOURCES ${CMAKE_CURRENT_LIST_DIR}/csvm.cpp)
 
 # set global roc-stdpar compiler flags
 set_local_and_parent(
-    PLSSVM_STDPAR_BACKEND_COMPILER_FLAG -hipstdpar --hipstdpar-path=${PLSSVM_STDPAR_BACKEND_HIPSTDPAR_PATH} --offload-arch=${PLSSVM_AMD_TARGET_ARCHS}
+    PLSSVM_STDPAR_BACKEND_COMPILER_FLAG --hipstdpar --offload-arch=${PLSSVM_AMD_TARGET_ARCHS}
 )
 # TODO: The flag "--hipstdpar-interpose-alloc" may be necessary for older AMD GPUs
 

tests/detail/cmd/parser_predict.cpp

@@ -365,31 +365,31 @@ TEST_F(ParserPredictVerbosityAndQuiet, parsing) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::quiet);
 }
 
-class ParserPredictHelp : public ParserPredict,
-                          public ::testing::WithParamInterface<std::string> { };
+class ParserPredictHelpDeathTest : public ParserPredict,
+                                   public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserPredictHelp, parsing) {
+TEST_P(ParserPredictHelpDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_predict{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictHelp, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserPredictHelp>);
+INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictHelpDeathTest, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserPredictHelpDeathTest>);
 
-class ParserPredictVersion : public ParserPredict,
-                             public ::testing::WithParamInterface<std::string> { };
+class ParserPredictVersionDeathTest : public ParserPredict,
+                                      public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserPredictVersion, parsing) {
+TEST_P(ParserPredictVersionDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-predict", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_predict{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserPredictHelp>);
+INSTANTIATE_TEST_SUITE_P(ParserPredict, ParserPredictVersionDeathTest, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserPredictVersionDeathTest>);
 
 class ParserPredictDeathTest : public ParserPredict { };
 

tests/detail/cmd/parser_scale.cpp

@@ -334,31 +334,31 @@ TEST_F(ParserScaleVerbosityAndQuiet, parsing) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::quiet);
 }
 
-class ParserScaleHelp : public ParserScale,
-                        public ::testing::WithParamInterface<std::string> { };
+class ParserScaleHelpDeathTest : public ParserScale,
+                                 public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserScaleHelp, parsing) {
+TEST_P(ParserScaleHelpDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_scale{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleHelp, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserScaleHelp>);
+INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleHelpDeathTest, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserScaleHelpDeathTest>);
 
-class ParserScaleVersion : public ParserScale,
-                           public ::testing::WithParamInterface<std::string> { };
+class ParserScaleVersionDeathTest : public ParserScale,
+                                    public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserScaleVersion, parsing) {
+TEST_P(ParserScaleVersionDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-scale", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_scale{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserScaleVersion>);
+INSTANTIATE_TEST_SUITE_P(ParserScale, ParserScaleVersionDeathTest, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserScaleVersionDeathTest>);
 
 class ParserScaleDeathTest : public ParserScale { };
 

tests/detail/cmd/parser_train.cpp

@@ -682,31 +682,31 @@ TEST_F(ParserTrainVerbosityAndQuiet, parsing) {
     EXPECT_EQ(plssvm::verbosity, plssvm::verbosity_level::quiet);
 }
 
-class ParserTrainHelp : public ParserTrain,
-                        public ::testing::WithParamInterface<std::string> { };
+class ParserTrainHelpDeathTest : public ParserTrain,
+                                 public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainHelp, parsing) {
+TEST_P(ParserTrainHelpDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_train{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainHelp, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserTrainHelp>);
+INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainHelpDeathTest, ::testing::Values("-h", "--help"), naming::pretty_print_parameter_flag<ParserTrainHelpDeathTest>);
 
-class ParserTrainVersion : public ParserTrain,
-                           public ::testing::WithParamInterface<std::string> { };
+class ParserTrainVersionDeathTest : public ParserTrain,
+                                    public ::testing::WithParamInterface<std::string> { };
 
-TEST_P(ParserTrainVersion, parsing) {
+TEST_P(ParserTrainVersionDeathTest, parsing) {
     const std::string &flag = GetParam();
     // create artificial command line arguments in test fixture
     this->CreateCMDArgs({ "./plssvm-train", flag });
     // create parameter object
     EXPECT_EXIT((plssvm::detail::cmd::parser_train{ this->get_argc(), this->get_argv() }), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
-INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainVersion, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserTrainVersion>);
+INSTANTIATE_TEST_SUITE_P(ParserTrain, ParserTrainVersionDeathTest, ::testing::Values("-v", "--version"), naming::pretty_print_parameter_flag<ParserTrainVersionDeathTest>);
 
 TEST_F(ParserTrainDeathTest, no_positional_argument) {
     this->CreateCMDArgs({ "./plssvm-train" });