make hip-tests compileable with TheRock

projects/hip-tests/catch/CMakeLists.txt

@@ -1,16 +1,52 @@
-cmake_minimum_required(VERSION 3.16.8)
+cmake_minimum_required(VERSION 3.20)
 
-# to skip the simple compiler test
-set(CMAKE_C_COMPILER_WORKS 1)
-set(CMAKE_CXX_COMPILER_WORKS 1)
-
-project(hiptests)
+project(hiptests LANGUAGES C CXX HIP)                                         
 
 option(ENABLE_ADDRESS_SANITIZER "Option to enable ASAN build" OFF)
 option(BUILD_SHARED_LIBS "Option for testing shared libraries" ON)
-
+option(BUILD_UNIT_TESTS "Build unit tests" ON)
+option(BUILD_PERF_TESTS "Build perf tests" OFF)
+option(BUILD_STRESS_TESTS "Build stress tests" OFF)
 option(TEST_CLOCK_CYCLE "Option to use clock64" OFF)
-if (TEST_CLOCK_CYCLE)
+option(GENERATE_COVERATE "Generate coverage" OFF)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_HIP_STANDARD 17)
+set(CMAKE_HIP_STANDARD_REQUIRED ON)
+set(CMAKE_INSTALL_RPATH "$ORIGIN;$ORIGIN/../../lib")
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+find_package(hip REQUIRED)
+find_package(hiprtc)
+find_package(Git)
+find_package(Python 3 COMPONENTS Interpreter REQUIRED)
+find_program(HIPCONFIG_EXEC hipconfig REQUIRED)
+# hip root dir is 3 levels down the hip-config.cmake file path
+set(HIP_PATH ${hip_DIR}/../../../)
+if(NOT DEFINED ROCM_PATH)
+    set(ROCM_PATH "/opt/rocm")
+    if(NOT EXISTS "${ROCM_PATH}")
+        set(ROCM_PATH ${HIP_PATH})
+    endif()
+endif()
+if(UNIX)
+    find_program(ROCM_AGENT_ENUMERATOR_EXEC rocm_agent_enumerator REQUIRED)
+    find_program(GCC_EXEC gcc)
+    find_program(GXX_EXEC g++)
+else() # Win32
+    find_program(LLVM_RC_EXEC NAMES llvm-rc llvm-rc.exe
+                 PATHS ${HIP_PATH} ${HIP_PATH}../lc/bin ${ROCM_PATH})
+endif()
+find_program(CLANG_CPP_EXEC NAMES clang-cpp clang-cpp.exe
+             PATHS ${HIP_PATH} ${HIP_PATH}../lc/bin ${ROCM_PATH}/llvm/bin)
+message(STATUS "HIP Lib path: ${HIP_LIB_INSTALL_DIR}")
+
+# used by clang to find hip
+set(HIP_PATH_OPT "--hip-path=${HIP_PATH}")
+
+if(TEST_CLOCK_CYCLE)
     add_definitions(-DTEST_CLOCK_CYCLE)
 endif()
 
@@ -26,60 +62,13 @@ if(NOT HIP_PLATFORM STREQUAL "amd" AND NOT HIP_PLATFORM STREQUAL "nvidia")
     message(FATAL_ERROR "Unexpected HIP_PLATFORM: " ${HIP_PLATFORM})
 endif()
 
-if(HIP_PLATFORM STREQUAL "amd")
-    if(UNIX AND DEFINED ROCM_PATH)
-        # Read -DROCM_PATH and set CXX_FLAGS for amd platform only
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --rocm-path=${ROCM_PATH}")
-    endif()
-
-    if(DEFINED HIP_PATH)
-        # Read -DHIP_PATH and set CXX_FLAGS for amd platform only
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --hip-path=${HIP_PATH}")
-    endif()
-endif()
-
-# Read -DHIP_PATH
-# If not set read env{HIP_PATH} only on Windows
-if(WIN32)
-    if(NOT DEFINED HIP_PATH)
-        if(DEFINED ENV{HIP_PATH})
-            set(HIP_PATH $ENV{HIP_PATH} CACHE STRING "HIP Path")
-        endif()
-    endif()
-endif()
-
-if(NOT DEFINED HIP_PATH)
-    if(DEFINED ROCM_PATH)
-        set(HIP_PATH ${ROCM_PATH})
-    else()
-        set(HIP_PATH "/opt/rocm")
-    endif()
-endif()
-
-if(NOT DEFINED ROCM_PATH)
-    set(ROCM_PATH "/opt/rocm")
-endif()
-
-message(STATUS "HIP_PATH: ${HIP_PATH}")
-message(STATUS "ROCM_PATH: ${ROCM_PATH}")
-
-if (WIN32)
-  set(HIPCC_EXEC "hipcc.exe")
-  set(HIPCONFIG_EXEC "hipconfig.exe")
-else()
-  set(HIPCC_EXEC "hipcc")
-  set(HIPCONFIG_EXEC "hipconfig")
-endif()
-
-set(CMAKE_C_COMPILER   "${HIP_PATH}/bin/${HIPCC_EXEC}")
-set(CMAKE_CXX_COMPILER "${HIP_PATH}/bin/${HIPCC_EXEC}")
-execute_process(COMMAND ${HIP_PATH}/bin/${HIPCONFIG_EXEC} --version
+execute_process(COMMAND ${HIPCONFIG_EXEC} --version
                 OUTPUT_VARIABLE HIP_VERSION
                 RESULT_VARIABLE result
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 if(result AND NOT result EQUAL 0)
-  message(FATAL_ERROR "Failure trying to obtain HIP version via command: ${HIP_PATH}/bin/${HIPCONFIG_EXEC} --version: ${result}")
+  message(FATAL_ERROR "Failure trying to obtain HIP version via command: ${HIPCONFIG_EXEC} --version: ${result}")
 endif()
 
 if(NOT WIN32)
@@ -93,9 +82,6 @@ if(NOT WIN32)
   endif() # end BUILD_SHARED_LIBS
 endif() # end win32
 
-# enforce c++17
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++17")
-
 # Address sanitizer options
 if(ENABLE_ADDRESS_SANITIZER)
     message(STATUS "Building catch tests with Address Sanitizer options")
@@ -118,43 +104,34 @@ else()
    set(HIP_PACKAGING_VERSION_PATCH ${HIP_VERSION_PATCH}-${HIP_VERSION_GITHASH})
 endif()
 
-if(NOT DEFINED CATCH2_PATH)
-    if(DEFINED ENV{CATCH2_PATH})
-        set(CATCH2_PATH $ENV{CATCH2_PATH} CACHE STRING "Catch2 Path")
-    else()
-        set(CATCH2_PATH "${CMAKE_CURRENT_LIST_DIR}/external/Catch2")
-    endif()
-endif()
-message(STATUS "Catch2 Path: ${CATCH2_PATH}")
-
-# Set JSON Parser path
-if(NOT DEFINED JSON_PARSER)
-    if(DEFINED ENV{JSON_PARSER})
-        set(JSON_PARSER $ENV{JSON_PARSER} CACHE STRING "JSON Parser Path")
-    else()
-        set(JSON_PARSER "${CMAKE_CURRENT_LIST_DIR}/external/picojson")
-    endif()
+find_package(Catch2 3.8.1 QUIET)
+if(Catch2_FOUND)
+    message(STATUS "Catch2 v3.8.1 found: ${Catch2_DIR}")
+    # for packaging
+    set(CATCH_ADD_TESTS_SCRIPT ${Catch2_DIR}/CatchAddTests.cmake)
+    file(GLOB CATCH_LIBS "${Catch2_DIR}/../../*Catch2*")
+else()
+    # Setup catch2 manually
+    include(FetchContent)
+    FetchContent_Declare(
+        Catch2
+        DOWNLOAD_EXTRACT_TIMESTAMP OFF
+        URL "https://rocm-third-party-deps.s3.us-east-2.amazonaws.com/Catch2-3.8.1.tar.gz"
+        URL_HASH SHA256=18b3f70ac80fccc340d8c6ff0f339b2ae64944782f8d2fca2bd705cf47cadb79
+    )
+    FetchContent_MakeAvailable(Catch2)
+    # for packaging
+    set(CATCH_ADD_TESTS_SCRIPT ${Catch2_SOURCE_DIR}/extras/CatchAddTests.cmake)
+    set(CATCH_LIBS $<TARGET_FILE:Catch2>)
 endif()
 
-message(STATUS "Searching Catch2 in: ${CMAKE_CURRENT_LIST_DIR}/external")
-find_package(Catch2 REQUIRED
-    PATHS
-        ${CMAKE_CURRENT_LIST_DIR}/external
-    PATH_SUFFIXES
-    Catch2/cmake/Catch2
-)
-include(Catch)
+include(cmake/hip-tests.cmake)
 include(CTest)
 
-# path used for generating the *_include.cmake file
-set(CATCH2_INCLUDE ${CATCH2_PATH}/cmake/Catch2/catch_include.cmake.in)
-
 include_directories(
-    ${CATCH2_PATH}
     "./include"
     "./kernels"
-    ${HIP_PATH}/include
-    ${JSON_PARSER}
+    "${CMAKE_CURRENT_LIST_DIR}/external/picojson"
 )
 
 option(RTC_TESTING "Run tests using HIP RTC to compile the kernels" OFF)
@@ -171,22 +148,13 @@ foreach(json IN LISTS JSON_FILES)
     file(COPY ${json}
          DESTINATION ${HIP_TEST_CONFIG_BINARY_DIR})
 endforeach()
-set(CATCH_SCRIPT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/script)
-file(COPY ./external/Catch2/cmake/Catch2/CatchAddTests.cmake
-     DESTINATION ${CATCH_SCRIPT_BINARY_DIR})
-file(COPY ./external/Catch2/cmake/Catch2/catch_include.cmake
-     DESTINATION ${CATCH_SCRIPT_BINARY_DIR})
-set(ADD_SCRIPT_PATH ${CATCH_SCRIPT_BINARY_DIR}/CatchAddTests.cmake)
-set(CATCH_INCLUDE_PATH ${CATCH_SCRIPT_BINARY_DIR}/catch_include.cmake)
 
 if (WIN32)
   configure_file(catchProp_in_rc.in ${CMAKE_CURRENT_BINARY_DIR}/catchProp.rc @ONLY)
-  cmake_path(SET LLVM_RC_PATH "${HIP_PATH}/../lc/bin/llvm-rc.exe")
-  cmake_path(SET LLVM_RC_PATH NORMALIZE "${LLVM_RC_PATH}")
 
   # generates the .res files to be used by executables to populate the properties
   # expects LC folder with clang, llvm-rc to be present one level up of HIP
-  execute_process(COMMAND ${LLVM_RC_PATH} ${CMAKE_CURRENT_BINARY_DIR}/catchProp.rc
+  execute_process(COMMAND ${LLVM_RC_EXEC} ${CMAKE_CURRENT_BINARY_DIR}/catchProp.rc
                   OUTPUT_VARIABLE RC_OUTPUT)
   set(PROP_RC ${CMAKE_CURRENT_BINARY_DIR})
   # When args to linker exceeds max chars.
@@ -197,12 +165,10 @@ if (WIN32)
 endif()
 
 if(HIP_PLATFORM STREQUAL "amd")
-    add_compile_options(-Wall -Wextra -Wvla -Werror -Wno-deprecated -Wno-option-ignored)
-endif()
-
-cmake_policy(PUSH)
-if(POLICY CMP0037)
-    cmake_policy(SET CMP0037 OLD)
+    if(WIN32)
+        set(win_disable_warnings -Wno-ignored-attributes -Wno-microsoft-cast)
+    endif()
+    add_compile_options(${HIP_PATH_OPT} -std=c++17 -x hip -Wall -Wextra -Wvla -Wno-deprecated -Wno-option-ignored -Wno-unused-parameter ${win_disable_warnings}) # -Werror)
 endif()
 
 # Turn off CMAKE_HIP_ARCHITECTURES Feature if cmake version is 3.21+
@@ -220,8 +186,14 @@ message(STATUS "CMAKE HIP ARCHITECTURES: ${CMAKE_HIP_ARCHITECTURES}")
 # preference to pass arch -
 # OFFLOAD_ARCH_STR
 # rocm_agent_enumerator
-if(NOT DEFINED OFFLOAD_ARCH_STR
-   AND EXISTS "${ROCM_PATH}/bin/rocm_agent_enumerator"
+if(DEFINED OFFLOAD_ARCH_STR)
+    string(REPLACE "--offload-arch=" "" HIP_GPU_ARCH_LIST ${OFFLOAD_ARCH_STR})
+elseif(DEFINED GPU_TARGETS)
+    foreach(_hip_gpu_arch ${GPU_TARGETS})
+        set(OFFLOAD_ARCH_STR "--offload-arch=${_hip_gpu_arch} ${OFFLOAD_ARCH_STR}")
+    endforeach()
+elseif(NOT DEFINED OFFLOAD_ARCH_STR
+   AND EXISTS "${ROCM_AGENT_ENUMERATOR_EXEC}"
    AND HIP_PLATFORM STREQUAL "amd" AND UNIX)
     execute_process(COMMAND "${ROCM_PATH}/bin/rocm_agent_enumerator"
          OUTPUT_VARIABLE HIP_GPU_ARCH
@@ -240,16 +212,16 @@ if(NOT DEFINED OFFLOAD_ARCH_STR
     else()
         message(STATUS "ROCm Agent Enumerator found no valid architectures")
     endif()
-elseif(DEFINED OFFLOAD_ARCH_STR)
-    string(REPLACE "--offload-arch=" "" HIP_GPU_ARCH_LIST ${OFFLOAD_ARCH_STR})
 endif()
 
+# Trim any trailing spaces, this trips up the cxx function call
+string(STRIP "${OFFLOAD_ARCH_STR}" OFFLOAD_ARCH_STR)
+
+message(STATUS "Using offload arch string: ${OFFLOAD_ARCH_STR}")
 if(DEFINED OFFLOAD_ARCH_STR)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OFFLOAD_ARCH_STR} ")
+    set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} ${OFFLOAD_ARCH_STR}")
 endif()
-message(STATUS "Using offload arch string: ${OFFLOAD_ARCH_STR}")
 
-find_package(Git)
 # get hip-tests commit short hash
 execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
@@ -276,9 +248,8 @@ if(WIN32)
     set(configToUse "config_amd_windows")
     set(config_file ${CMAKE_SOURCE_DIR}/hipTestMain/config/${configToUse})
     set(json_file ${HIP_TEST_CONFIG_BINARY_DIR}/${configToUse}.json)
-    set(CLANG_CPP "${HIP_PATH}/../lc/bin/clang-cpp.exe")
 
-    set(cmd "${CLANG_CPP} -P -DGITHASH=\"${HIP_VERSION_GITHASH}\" ${config_file}>${json_file}")
+    set(cmd "${CLANG_CPP_EXEC} -P -DGITHASH=\"${HIP_VERSION_GITHASH}\" ${config_file}>${json_file}")
     message(${cmd})
     execute_process(COMMAND cmd.exe /C ${cmd}
     RESULT_VARIABLE json_result)
@@ -288,7 +259,7 @@ else()
     foreach(arch ${hip_gpu_arch_list})
         set(config_file ${CMAKE_SOURCE_DIR}/hipTestMain/config/${configToUse})
         set(json_file ${HIP_TEST_CONFIG_BINARY_DIR}/${configToUse}_${arch}.json)
-        set(cmd "${ROCM_PATH}/llvm/bin/clang-cpp -P -D${arch} -DGITHASH=\\\"${HIP_VERSION_GITHASH}\\\" ${config_file}>${json_file}")
+        set(cmd "${CLANG_CPP_EXEC} -P -D${arch} -DGITHASH=\\\"${HIP_VERSION_GITHASH}\\\" ${config_file}>${json_file}")
         message(${cmd})
         execute_process(COMMAND bash -c ${cmd}
         RESULT_VARIABLE json_result)
@@ -306,7 +277,13 @@ file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/catchInfo.txt ${_catch
 # allows user to run ctest from catch_tests level
 set(_subdirs ${_autogen} "subdirs(..)\n")
 file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/CTestTestfile.cmake ${_subdirs})
-find_package(Python3 COMPONENTS Interpreter REQUIRED)
+
+set(CATCH_SCRIPT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/script)
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/cmake/hip-tests.cmake
+     DESTINATION ${CATCH_SCRIPT_BINARY_DIR})
+file(COPY ${CATCH_ADD_TESTS_SCRIPT}
+         DESTINATION ${CATCH_SCRIPT_BINARY_DIR})
+set_property(GLOBAL APPEND PROPERTY G_INSTALL_SCRIPT_TARGETS ${CATCH_ADD_TESTS_SCRIPT})
 
 # copy python script and headers to catch test package
 set(CATCH_INCLUDE_DIR include)
@@ -318,7 +295,6 @@ file(COPY ./unit/compileAndCaptureOutput.py
 
 file(COPY ./include/hip_test_common.hh DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/${CATCH_INCLUDE_DIR})
 file(COPY ./include/hip_test_context.hh DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/${CATCH_INCLUDE_DIR})
-file(COPY ./external/Catch2/catch.hpp DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${CATCH_BUILD_DIR}/${CATCH_INCLUDE_DIR})
 
 # Enable device lambda on nvidia platforms
 if(HIP_PLATFORM STREQUAL "nvidia")
@@ -329,43 +305,38 @@ endif()
 # Disable CXX extensions (gnu++11 etc)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-add_custom_target(build_tests)
+add_custom_target(build_tests ALL)
 
 # Tests folder
-add_subdirectory(unit ${CATCH_BUILD_DIR}/unit)
-add_subdirectory(ABM ${CATCH_BUILD_DIR}/ABM)
-add_subdirectory(kernels ${CATCH_BUILD_DIR}/kernels)
-add_subdirectory(hipTestMain ${CATCH_BUILD_DIR}/hipTestMain)
-add_subdirectory(stress ${CATCH_BUILD_DIR}/stress)
-add_subdirectory(TypeQualifiers ${CATCH_BUILD_DIR}/TypeQualifiers)
-add_subdirectory(perftests ${CATCH_BUILD_DIR}/perftests)
-add_subdirectory(multiproc ${CATCH_BUILD_DIR}/multiproc)
-add_subdirectory(performance ${CATCH_BUILD_DIR}/performance)
-
-add_custom_target(gen_coverage
+if(BUILD_UNIT_TESTS)
+    add_subdirectory(unit ${CATCH_BUILD_DIR}/unit)
+    add_subdirectory(ABM ${CATCH_BUILD_DIR}/ABM)
+    add_subdirectory(kernels ${CATCH_BUILD_DIR}/kernels)
+    add_subdirectory(hipTestMain ${CATCH_BUILD_DIR}/hipTestMain)
+    add_subdirectory(TypeQualifiers ${CATCH_BUILD_DIR}/TypeQualifiers)
+    if(UNIX)
+      add_subdirectory(multiproc ${CATCH_BUILD_DIR}/multiproc)
+    endif()
+endif()
+if(BUILD_PERF_TESTS)
+    add_subdirectory(perftests ${CATCH_BUILD_DIR}/perftests)
+    add_subdirectory(performance ${CATCH_BUILD_DIR}/performance)
+endif()
+if(BUILD_STRESS_TESTS)
+    add_subdirectory(stress ${CATCH_BUILD_DIR}/stress)
+endif()
+
+if(GENERATE_COVERATE)
+    add_custom_target(gen_coverage
                   COMMAND ${CMAKE_COMMAND} -B build/
                   COMMAND ${CMAKE_COMMAND} --build build/
                   COMMAND ./build/generateHipAPICoverage ${HIP_PATH}/include
                   WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../utils/coverage
                   COMMENT "Generating Test Coverage Report")
-
-cmake_policy(POP)
+endif()
 
 # packaging the tests
-# make package_test to generate packages for test
-set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/)
 add_subdirectory(packaging)
-if(UNIX)
-add_custom_target(package_test COMMAND ${CMAKE_COMMAND} .
-    COMMAND rm -rf *.deb *.rpm *.tar.gz
-    COMMAND make package
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-else()
-file(TO_NATIVE_PATH ${PROJECT_BINARY_DIR} CATCH_BINARY_DIR)
-add_custom_target(package_test COMMAND ${CMAKE_COMMAND} .
-    COMMAND cpack
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-endif()
 
 # Doxygen documentation
 # check if doxygen is installed