From 66d80ca9ad0788d2cb8f3c24c973781db035d23b Mon Sep 17 00:00:00 2001 From: Jiacheng Huang Date: Wed, 15 Jul 2026 09:33:18 +0800 Subject: [PATCH 1/2] build: add CMake package config --- CMakeLists.txt | 37 +++++- README.md | 29 +++-- cmake/InfiniRTConfig.cmake.in | 167 +++++++++++++++++++++++++ docs/build.md | 5 +- docs/getting-started.md | 27 ++-- examples/consumer_cmake/CMakeLists.txt | 18 +-- examples/consumer_cmake/README.md | 2 +- src/CMakeLists.txt | 54 +++++--- tests/CMakeLists.txt | 99 +++++---------- tests/compile_install_consumer.cmake | 135 +++++++++++--------- tests/install_consumer/CMakeLists.txt | 33 +++++ 11 files changed, 420 insertions(+), 186 deletions(-) create mode 100644 cmake/InfiniRTConfig.cmake.in create mode 100644 tests/install_consumer/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 5182bab..65e63ec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,12 @@ cmake_minimum_required(VERSION 3.18) -project(InfiniRT LANGUAGES CXX) +project(InfiniRT VERSION 0.1.0 LANGUAGES CXX) + +include(CMakePackageConfigHelpers) +include(GNUInstallDirs) + +set(INFINI_RT_INSTALL_CMAKEDIR + "${CMAKE_INSTALL_LIBDIR}/cmake/InfiniRT" + CACHE STRING "Directory for the installed InfiniRT CMake package") set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) @@ -334,6 +341,34 @@ endif() add_subdirectory(src) +set(INFINI_RT_PACKAGE_NEEDS_CUDATOOLKIT OFF) +if(WITH_NVIDIA OR WITH_ILUVATAR OR WITH_HYGON) + set(INFINI_RT_PACKAGE_NEEDS_CUDATOOLKIT ON) +endif() + +set(INFINI_RT_PACKAGE_VENDOR_BACKEND "") +foreach(_backend METAX MOORE CAMBRICON ASCEND) + if(WITH_${_backend}) + set(INFINI_RT_PACKAGE_VENDOR_BACKEND "${_backend}") + endif() +endforeach() + +configure_package_config_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake/InfiniRTConfig.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/InfiniRTConfig.cmake" + INSTALL_DESTINATION "${INFINI_RT_INSTALL_CMAKEDIR}") + +write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/InfiniRTConfigVersion.cmake" + VERSION "${PROJECT_VERSION}" + COMPATIBILITY SameMinorVersion) + +install( + FILES + "${CMAKE_CURRENT_BINARY_DIR}/InfiniRTConfig.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/InfiniRTConfigVersion.cmake" + DESTINATION "${INFINI_RT_INSTALL_CMAKEDIR}") + if(INFINI_RT_BUILD_TESTING OR INFINI_RT_BUILD_PERFORMANCE_TESTING) enable_testing() add_subdirectory(tests) diff --git a/README.md b/README.md index afb76a5..1f7f625 100644 --- a/README.md +++ b/README.md @@ -110,29 +110,28 @@ backend. ## Using Installed InfiniRT From Another Project -Downstream projects should consume the installed headers and libraries instead of depending on the InfiniRT source tree. +Downstream projects should consume the installed CMake package instead of +depending on the InfiniRT source tree: -Typical include and library paths are: +```cmake +find_package(InfiniRT 0.1 CONFIG REQUIRED) -```text -/path/to/infini-rt-prefix/include -/path/to/infini-rt-prefix/lib +add_executable(app main.cc) +target_link_libraries(app PRIVATE InfiniRT::infinirt) ``` -A simple compile command may look like: +Point CMake at the installation prefix when configuring the consumer: ```bash -c++ main.cc \ - -I/path/to/infini-rt-prefix/include \ - -L/path/to/infini-rt-prefix/lib \ - -linfinirt +cmake -S . -B build \ + -DCMAKE_PREFIX_PATH=/path/to/infini-rt-prefix +cmake --build build -j ``` -At runtime, make sure the dynamic linker can find `libinfinirt.so`, for example: - -```bash -export LD_LIBRARY_PATH=/path/to/infini-rt-prefix/lib:$LD_LIBRARY_PATH -``` +The imported target provides the installed include directory, library, C++17 +requirement, and required backend link dependencies. `InfiniRT_ENABLED_BACKENDS` +and the `InfiniRT_WITH_` variables report the backends compiled into +the installed library. See [examples/consumer_cmake](examples/consumer_cmake) for a minimal CMake consumer project. diff --git a/cmake/InfiniRTConfig.cmake.in b/cmake/InfiniRTConfig.cmake.in new file mode 100644 index 0000000..09bce5a --- /dev/null +++ b/cmake/InfiniRTConfig.cmake.in @@ -0,0 +1,167 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) + +set(InfiniRT_VERSION "@PROJECT_VERSION@") +set(InfiniRT_ENABLED_BACKENDS "@INFINI_RT_PUBLIC_HEADER_DEVICES@") + +set(InfiniRT_WITH_CPU @WITH_CPU@) +set(InfiniRT_WITH_NVIDIA @WITH_NVIDIA@) +set(InfiniRT_WITH_ILUVATAR @WITH_ILUVATAR@) +set(InfiniRT_WITH_HYGON @WITH_HYGON@) +set(InfiniRT_WITH_METAX @WITH_METAX@) +set(InfiniRT_WITH_MOORE @WITH_MOORE@) +set(InfiniRT_WITH_CAMBRICON @WITH_CAMBRICON@) +set(InfiniRT_WITH_ASCEND @WITH_ASCEND@) + +if(@INFINI_RT_PACKAGE_NEEDS_CUDATOOLKIT@) + find_dependency(CUDAToolkit) +endif() + +function(_infinirt_define_backend_runtime include_dirs link_libraries) + if(NOT TARGET InfiniRT::BackendRuntime) + add_library(InfiniRT::BackendRuntime INTERFACE IMPORTED) + set_target_properties(InfiniRT::BackendRuntime PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${include_dirs}" + INTERFACE_LINK_LIBRARIES "${link_libraries}") + endif() +endfunction() + +set(_InfiniRT_VENDOR_BACKEND "@INFINI_RT_PACKAGE_VENDOR_BACKEND@") + +if(_InfiniRT_VENDOR_BACKEND STREQUAL "METAX") + set(_InfiniRT_ROOT_HINTS "${InfiniRT_METAX_ROOT}") + if(DEFINED ENV{MACA_PATH}) + list(APPEND _InfiniRT_ROOT_HINTS "$ENV{MACA_PATH}") + endif() + find_path(_InfiniRT_BACKEND_INCLUDE_DIR + NAMES mcr/mc_runtime.h + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES include) + find_library(_InfiniRT_BACKEND_RUNTIME_LIBRARY + NAMES mcruntime + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES lib lib64) + if(NOT _InfiniRT_BACKEND_INCLUDE_DIR OR + NOT _InfiniRT_BACKEND_RUNTIME_LIBRARY) + set(InfiniRT_FOUND FALSE) + set(InfiniRT_NOT_FOUND_MESSAGE + "MetaX SDK not found. Set InfiniRT_METAX_ROOT or MACA_PATH.") + return() + endif() + _infinirt_define_backend_runtime( + "${_InfiniRT_BACKEND_INCLUDE_DIR}" + "${_InfiniRT_BACKEND_RUNTIME_LIBRARY}") +elseif(_InfiniRT_VENDOR_BACKEND STREQUAL "MOORE") + set(_InfiniRT_ROOT_HINTS "${InfiniRT_MOORE_ROOT}") + foreach(_InfiniRT_ENV MUSA_ROOT MUSA_HOME MUSA_PATH) + if(DEFINED ENV{${_InfiniRT_ENV}}) + list(APPEND _InfiniRT_ROOT_HINTS "$ENV{${_InfiniRT_ENV}}") + endif() + endforeach() + list(APPEND _InfiniRT_ROOT_HINTS /usr/local/musa) + find_path(_InfiniRT_BACKEND_INCLUDE_DIR + NAMES musa_runtime.h + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES include) + find_library(_InfiniRT_BACKEND_RUNTIME_LIBRARY + NAMES musa + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES lib lib64) + find_library(_InfiniRT_BACKEND_DRIVER_LIBRARY + NAMES musart + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES lib lib64) + if(NOT _InfiniRT_BACKEND_INCLUDE_DIR OR + NOT _InfiniRT_BACKEND_RUNTIME_LIBRARY OR + NOT _InfiniRT_BACKEND_DRIVER_LIBRARY) + set(InfiniRT_FOUND FALSE) + set(InfiniRT_NOT_FOUND_MESSAGE + "Moore SDK not found. Set InfiniRT_MOORE_ROOT or a MUSA root environment variable.") + return() + endif() + _infinirt_define_backend_runtime( + "${_InfiniRT_BACKEND_INCLUDE_DIR}" + "${_InfiniRT_BACKEND_RUNTIME_LIBRARY};${_InfiniRT_BACKEND_DRIVER_LIBRARY}") +elseif(_InfiniRT_VENDOR_BACKEND STREQUAL "CAMBRICON") + set(_InfiniRT_ROOT_HINTS "${InfiniRT_CAMBRICON_ROOT}") + if(DEFINED ENV{NEUWARE_HOME}) + list(APPEND _InfiniRT_ROOT_HINTS "$ENV{NEUWARE_HOME}") + endif() + find_path(_InfiniRT_BACKEND_INCLUDE_DIR + NAMES cnrt.h + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES include) + find_library(_InfiniRT_BACKEND_RUNTIME_LIBRARY + NAMES cnrt + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES lib lib64) + if(NOT _InfiniRT_BACKEND_INCLUDE_DIR OR + NOT _InfiniRT_BACKEND_RUNTIME_LIBRARY) + set(InfiniRT_FOUND FALSE) + set(InfiniRT_NOT_FOUND_MESSAGE + "Cambricon SDK not found. Set InfiniRT_CAMBRICON_ROOT or NEUWARE_HOME.") + return() + endif() + _infinirt_define_backend_runtime( + "${_InfiniRT_BACKEND_INCLUDE_DIR}" + "${_InfiniRT_BACKEND_RUNTIME_LIBRARY}") +elseif(_InfiniRT_VENDOR_BACKEND STREQUAL "ASCEND") + set(_InfiniRT_ROOT_HINTS "${InfiniRT_ASCEND_ROOT}") + if(DEFINED ENV{ASCEND_HOME_PATH}) + list(APPEND _InfiniRT_ROOT_HINTS "$ENV{ASCEND_HOME_PATH}") + endif() + list(APPEND _InfiniRT_ROOT_HINTS + /usr/local/Ascend/ascend-toolkit/latest) + + find_path(_InfiniRT_BACKEND_INCLUDE_DIR + NAMES acl/acl.h + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES include) + find_library(_InfiniRT_BACKEND_RUNTIME_LIBRARY + NAMES ascendcl + HINTS ${_InfiniRT_ROOT_HINTS} + PATH_SUFFIXES lib64 lib) + + set(_InfiniRT_ASCEND_HAL_HINTS "") + foreach(_InfiniRT_ROOT IN LISTS _InfiniRT_ROOT_HINTS) + if(_InfiniRT_ROOT) + get_filename_component( + _InfiniRT_ASCEND_ROOT "${_InfiniRT_ROOT}/../.." ABSOLUTE) + list(APPEND _InfiniRT_ASCEND_HAL_HINTS + "${_InfiniRT_ASCEND_ROOT}/driver/lib64/driver" + "${_InfiniRT_ROOT}/runtime/lib64/stub" + "${_InfiniRT_ROOT}/${CMAKE_SYSTEM_PROCESSOR}-linux/devlib") + endif() + endforeach() + find_library(_InfiniRT_BACKEND_DRIVER_LIBRARY + NAMES ascend_hal + HINTS ${_InfiniRT_ASCEND_HAL_HINTS}) + + if(NOT _InfiniRT_BACKEND_INCLUDE_DIR OR + NOT _InfiniRT_BACKEND_RUNTIME_LIBRARY OR + NOT _InfiniRT_BACKEND_DRIVER_LIBRARY) + set(InfiniRT_FOUND FALSE) + set(InfiniRT_NOT_FOUND_MESSAGE + "Ascend SDK not found. Set InfiniRT_ASCEND_ROOT or ASCEND_HOME_PATH.") + return() + endif() + + set(_InfiniRT_ASCEND_INCLUDE_DIRS + "${_InfiniRT_BACKEND_INCLUDE_DIR}") + get_filename_component( + _InfiniRT_ASCEND_HOME "${_InfiniRT_BACKEND_INCLUDE_DIR}" DIRECTORY) + foreach(_InfiniRT_INCLUDE_SUBDIR aclnn aclnnop) + if(IS_DIRECTORY + "${_InfiniRT_ASCEND_HOME}/include/${_InfiniRT_INCLUDE_SUBDIR}") + list(APPEND _InfiniRT_ASCEND_INCLUDE_DIRS + "${_InfiniRT_ASCEND_HOME}/include/${_InfiniRT_INCLUDE_SUBDIR}") + endif() + endforeach() + _infinirt_define_backend_runtime( + "${_InfiniRT_ASCEND_INCLUDE_DIRS}" + "${_InfiniRT_BACKEND_RUNTIME_LIBRARY};${_InfiniRT_BACKEND_DRIVER_LIBRARY};${CMAKE_DL_LIBS}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/InfiniRTTargets.cmake") +check_required_components(InfiniRT) diff --git a/docs/build.md b/docs/build.md index 9e1fd05..b04e6df 100644 --- a/docs/build.md +++ b/docs/build.md @@ -79,8 +79,9 @@ Run them with: ctest --test-dir build --output-on-failure ``` -The `test_install_consumer` test installs InfiniRT to a temporary prefix, -compiles a small external consumer against the installed prefix, and runs it. +The `test_install_consumer` test installs InfiniRT to a temporary prefix, uses +`find_package(InfiniRT CONFIG REQUIRED)` from a separate CMake project, links +that project to `InfiniRT::infinirt`, and runs it. ## Performance Tests diff --git a/docs/getting-started.md b/docs/getting-started.md index d791aa9..a04c3dc 100644 --- a/docs/getting-started.md +++ b/docs/getting-started.md @@ -57,23 +57,30 @@ int main() { } ``` -Compile it against the installed prefix: +Create a `CMakeLists.txt` that imports the installed package: -```bash -c++ main.cc \ - -std=c++17 \ - -I/path/to/infini-rt-prefix/include \ - -L/path/to/infini-rt-prefix/lib \ - -linfinirt \ - -Wl,-rpath,/path/to/infini-rt-prefix/lib +```cmake +cmake_minimum_required(VERSION 3.18) +project(infinirt_example LANGUAGES CXX) + +find_package(InfiniRT 0.1 CONFIG REQUIRED) + +add_executable(infinirt_example main.cc) +target_link_libraries(infinirt_example PRIVATE InfiniRT::infinirt) ``` -If the runtime linker cannot find `libinfinirt.so`, set `LD_LIBRARY_PATH`: +Configure and build it against the installed prefix: ```bash -export LD_LIBRARY_PATH=/path/to/infini-rt-prefix/lib:$LD_LIBRARY_PATH +cmake -S . -B build \ + -DCMAKE_PREFIX_PATH=/path/to/infini-rt-prefix +cmake --build build -j ``` +The `InfiniRT::infinirt` target supplies the required include path, library, +C++ language level, and backend dependencies. For an accelerator build, the +corresponding SDK must also be available when configuring the consumer. + ## Next Steps See [Runtime API](api/runtime.md) for backend dispatch and runtime functions, diff --git a/examples/consumer_cmake/CMakeLists.txt b/examples/consumer_cmake/CMakeLists.txt index bcaef1e..adbf99d 100644 --- a/examples/consumer_cmake/CMakeLists.txt +++ b/examples/consumer_cmake/CMakeLists.txt @@ -4,22 +4,8 @@ project(infinirt_consumer_example LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) -if(NOT DEFINED INFINI_RT_PREFIX) - message(FATAL_ERROR "Set INFINI_RT_PREFIX to an installed InfiniRT prefix.") -endif() - -find_library(INFINI_RT_LIBRARY - NAMES infinirt - PATHS "${INFINI_RT_PREFIX}/lib" "${INFINI_RT_PREFIX}/lib64" - REQUIRED - NO_DEFAULT_PATH) +find_package(InfiniRT CONFIG REQUIRED) add_executable(infinirt_consumer main.cc) -target_include_directories(infinirt_consumer PRIVATE - "${INFINI_RT_PREFIX}/include") -target_link_libraries(infinirt_consumer PRIVATE "${INFINI_RT_LIBRARY}") - -get_filename_component(INFINI_RT_LIBRARY_DIR "${INFINI_RT_LIBRARY}" DIRECTORY) -set_target_properties(infinirt_consumer PROPERTIES - BUILD_RPATH "${INFINI_RT_LIBRARY_DIR}") +target_link_libraries(infinirt_consumer PRIVATE InfiniRT::infinirt) diff --git a/examples/consumer_cmake/README.md b/examples/consumer_cmake/README.md index bc590ea..f944bcf 100644 --- a/examples/consumer_cmake/README.md +++ b/examples/consumer_cmake/README.md @@ -16,7 +16,7 @@ Then build this consumer: ```bash cmake -S . -B build \ - -DINFINI_RT_PREFIX=/path/to/infini-rt-prefix + -DCMAKE_PREFIX_PATH=/path/to/infini-rt-prefix cmake --build build -j ./build/infinirt_consumer ``` diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6776d2b..2091963 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,6 +1,13 @@ add_library(infinirt SHARED) +add_library(InfiniRT::infinirt ALIAS infinirt) -include(GNUInstallDirs) +function(_infinirt_use_backend_runtime include_dirs link_libraries) + add_library(InfiniRT::BackendRuntime INTERFACE IMPORTED GLOBAL) + set_target_properties(InfiniRT::BackendRuntime PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${include_dirs}" + INTERFACE_LINK_LIBRARIES "${link_libraries}") + target_link_libraries(infinirt PUBLIC InfiniRT::BackendRuntime) +endfunction() file(GLOB BASE_SRCS CONFIGURE_DEPENDS "*.cc") target_sources(infinirt PRIVATE @@ -58,23 +65,23 @@ endif() if(WITH_METAX) target_compile_definitions(infinirt PRIVATE WITH_METAX=1) - - target_include_directories(infinirt PUBLIC "${MACA_PATH}/include") - target_link_libraries(infinirt PUBLIC ${MACA_RUNTIME_LIB}) + _infinirt_use_backend_runtime( + "${MACA_PATH}/include" + "${MACA_RUNTIME_LIB}") endif() if(WITH_MOORE) target_compile_definitions(infinirt PRIVATE WITH_MOORE=1) - - target_include_directories(infinirt PUBLIC "${MUSA_ROOT}/include") - target_link_libraries(infinirt PUBLIC ${MUSA_LIB} ${MUSART_LIB}) + _infinirt_use_backend_runtime( + "${MUSA_ROOT}/include" + "${MUSA_LIB};${MUSART_LIB}") endif() if(WITH_CAMBRICON) target_compile_definitions(infinirt PRIVATE WITH_CAMBRICON=1) - - target_include_directories(infinirt PUBLIC "${NEUWARE_HOME}/include") - target_link_libraries(infinirt PUBLIC ${CAMBRICON_RUNTIME_LIB}) + _infinirt_use_backend_runtime( + "${NEUWARE_HOME}/include" + "${CAMBRICON_RUNTIME_LIB}") endif() if(WITH_ASCEND) @@ -102,14 +109,16 @@ if(WITH_ASCEND) message(FATAL_ERROR "libascend_hal.so not found (tried ${ASCEND_HAL_REAL}, ${ASCEND_HAL_STUB}, and ${ASCEND_HAL_DEVLIB})") endif() - target_include_directories(infinirt PUBLIC - "${ASCEND_HOME}/include" - "${ASCEND_HOME}/include/aclnn" - "${ASCEND_HOME}/include/aclnnop") - target_link_libraries(infinirt PUBLIC - "${ASCEND_HOME}/lib64/libascendcl.so" - "${ASCEND_HAL_LIB}" - ${CMAKE_DL_LIBS}) + set(INFINI_RT_ASCEND_INCLUDE_DIRS "${ASCEND_HOME}/include") + foreach(_include_subdir aclnn aclnnop) + if(IS_DIRECTORY "${ASCEND_HOME}/include/${_include_subdir}") + list(APPEND INFINI_RT_ASCEND_INCLUDE_DIRS + "${ASCEND_HOME}/include/${_include_subdir}") + endif() + endforeach() + _infinirt_use_backend_runtime( + "${INFINI_RT_ASCEND_INCLUDE_DIRS}" + "${ASCEND_HOME}/lib64/libascendcl.so;${ASCEND_HAL_LIB};${CMAKE_DL_LIBS}") endif() target_include_directories(infinirt @@ -120,12 +129,21 @@ target_include_directories(infinirt $ ) +target_compile_features(infinirt PUBLIC cxx_std_17) + install(TARGETS infinirt + EXPORT InfiniRTTargets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) +install(EXPORT InfiniRTTargets + FILE InfiniRTTargets.cmake + NAMESPACE InfiniRT:: + DESTINATION ${INFINI_RT_INSTALL_CMAKEDIR} +) + install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 66a10c6..b231d19 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -149,32 +149,14 @@ endif() set(INFINI_RT_TEST_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/install_consumer_prefix") set(INFINI_RT_TEST_CONSUMER_BINARY - "${CMAKE_CURRENT_BINARY_DIR}/install_consumer_smoke") -set(INFINI_RT_TEST_EXTRA_LIBRARY_DIRS "") -set(INFINI_RT_TEST_EXTRA_INCLUDE_DIRS "") + "${CMAKE_CURRENT_BINARY_DIR}/install_consumer_build") set(INFINI_RT_TEST_CONSUMER_BACKEND NONE) +set(INFINI_RT_TEST_CUDATOOLKIT_ROOT "${CUDAToolkit_ROOT}") +set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE "") +set(INFINI_RT_TEST_BACKEND_ROOT "") -if(WITH_NVIDIA OR WITH_ILUVATAR OR WITH_HYGON) - if(CUDAToolkit_INCLUDE_DIRS) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - ${CUDAToolkit_INCLUDE_DIRS}) - elseif(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}) - endif() - - if(CUDAToolkit_LIBRARY_DIR) - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${CUDAToolkit_LIBRARY_DIR}") - endif() - if(CUDAToolkit_TARGET_DIR) - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${CUDAToolkit_TARGET_DIR}/lib64") - endif() - if(CUDAToolkit_ROOT_DIR) - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${CUDAToolkit_ROOT_DIR}/lib64") - endif() +if(NOT INFINI_RT_TEST_CUDATOOLKIT_ROOT AND CUDAToolkit_ROOT_DIR) + set(INFINI_RT_TEST_CUDATOOLKIT_ROOT "${CUDAToolkit_ROOT_DIR}") endif() if(WITH_NVIDIA) @@ -183,71 +165,58 @@ elseif(WITH_ILUVATAR) set(INFINI_RT_TEST_CONSUMER_BACKEND ILUVATAR) elseif(WITH_HYGON) set(INFINI_RT_TEST_CONSUMER_BACKEND HYGON) - if(HYGON_CUDA_ROOT) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - "${HYGON_CUDA_ROOT}/include") - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${HYGON_CUDA_ROOT}/lib64") + if(NOT INFINI_RT_TEST_CUDATOOLKIT_ROOT) + set(INFINI_RT_TEST_CUDATOOLKIT_ROOT "${HYGON_CUDA_ROOT}") endif() elseif(WITH_METAX) set(INFINI_RT_TEST_CONSUMER_BACKEND METAX) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - "${MACA_PATH}/include") - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${MACA_PATH}/lib") + set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_METAX_ROOT) + set(INFINI_RT_TEST_BACKEND_ROOT "${MACA_PATH}") elseif(WITH_MOORE) set(INFINI_RT_TEST_CONSUMER_BACKEND MOORE) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - "${MUSA_ROOT}/include") - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${MUSA_ROOT}/lib") + set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_MOORE_ROOT) + set(INFINI_RT_TEST_BACKEND_ROOT "${MUSA_ROOT}") elseif(WITH_CAMBRICON) set(INFINI_RT_TEST_CONSUMER_BACKEND CAMBRICON) - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - "${NEUWARE_HOME}/include") - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${NEUWARE_HOME}/lib" - "${NEUWARE_HOME}/lib64") + set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_CAMBRICON_ROOT) + set(INFINI_RT_TEST_BACKEND_ROOT "${NEUWARE_HOME}") elseif(WITH_ASCEND) # The install-consumer smoke checks Ascend public headers and linkage. # Runtime behavior is covered by test_ascend_runtime and dispatch tests. - list(APPEND INFINI_RT_TEST_EXTRA_INCLUDE_DIRS - "${ASCEND_HOME}/include" - "${ASCEND_HOME}/include/aclnn" - "${ASCEND_HOME}/include/aclnnop") + set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_ASCEND_ROOT) + set(INFINI_RT_TEST_BACKEND_ROOT "${ASCEND_HOME}") elseif(WITH_CPU) set(INFINI_RT_TEST_CONSUMER_BACKEND CPU) endif() -if(WITH_ASCEND) - get_filename_component( - INFINI_RT_ASCEND_DEVLIB - "${ASCEND_HOME}/${CMAKE_SYSTEM_PROCESSOR}-linux/devlib" - ABSOLUTE) - list(APPEND INFINI_RT_TEST_EXTRA_LIBRARY_DIRS - "${ASCEND_HOME}/lib64" - "${INFINI_RT_ASCEND_DEVLIB}" - "${ASCEND_HOME}/runtime/lib64/stub") +set(INFINI_RT_TEST_INSTALL_COMMAND + "${CMAKE_COMMAND}" --install "${CMAKE_BINARY_DIR}" + --prefix "${INFINI_RT_TEST_INSTALL_PREFIX}") +if(CMAKE_CONFIGURATION_TYPES) + list(APPEND INFINI_RT_TEST_INSTALL_COMMAND --config "$") endif() - -list(JOIN INFINI_RT_TEST_EXTRA_LIBRARY_DIRS ":" INFINI_RT_TEST_EXTRA_LIBRARY_PATHS) -list(JOIN INFINI_RT_TEST_EXTRA_INCLUDE_DIRS ":" INFINI_RT_TEST_EXTRA_INCLUDE_PATHS) - -add_test( - NAME test_install - COMMAND "${CMAKE_COMMAND}" --install "${CMAKE_BINARY_DIR}" - --prefix "${INFINI_RT_TEST_INSTALL_PREFIX}") +add_test(NAME test_install COMMAND ${INFINI_RT_TEST_INSTALL_COMMAND}) set_tests_properties(test_install PROPERTIES FIXTURES_SETUP infini_rt_install) add_test( NAME test_install_consumer COMMAND "${CMAKE_COMMAND}" "-DINFINI_RT_INSTALL_PREFIX=${INFINI_RT_TEST_INSTALL_PREFIX}" + "-DINFINI_RT_REQUIRED_VERSION=${PROJECT_VERSION}" + "-DINFINI_RT_CONSUMER_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/install_consumer" "-DINFINI_RT_CONSUMER_SOURCE=${CMAKE_CURRENT_SOURCE_DIR}/install_consumer_smoke.cc" "-DINFINI_RT_CONSUMER_BINARY=${INFINI_RT_TEST_CONSUMER_BINARY}" + "-DINFINI_RT_CMAKE_GENERATOR=${CMAKE_GENERATOR}" + "-DINFINI_RT_CMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}" + "-DINFINI_RT_CMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}" + "-DINFINI_RT_CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}" + "-DINFINI_RT_BUILD_CONFIG=$" "-DINFINI_RT_CXX_COMPILER=${CMAKE_CXX_COMPILER}" - "-DINFINI_RT_EXTRA_LIBRARY_PATHS=${INFINI_RT_TEST_EXTRA_LIBRARY_PATHS}" - "-DINFINI_RT_EXTRA_INCLUDE_PATHS=${INFINI_RT_TEST_EXTRA_INCLUDE_PATHS}" + "-DINFINI_RT_CMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}" + "-DINFINI_RT_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}" + "-DINFINI_RT_CUDATOOLKIT_ROOT=${INFINI_RT_TEST_CUDATOOLKIT_ROOT}" + "-DINFINI_RT_BACKEND_ROOT_VARIABLE=${INFINI_RT_TEST_BACKEND_ROOT_VARIABLE}" + "-DINFINI_RT_BACKEND_ROOT=${INFINI_RT_TEST_BACKEND_ROOT}" "-DINFINI_RT_CONSUMER_BACKEND=${INFINI_RT_TEST_CONSUMER_BACKEND}" -P "${CMAKE_CURRENT_SOURCE_DIR}/compile_install_consumer.cmake") set_tests_properties(test_install_consumer PROPERTIES diff --git a/tests/compile_install_consumer.cmake b/tests/compile_install_consumer.cmake index 1bb96d1..a89793f 100644 --- a/tests/compile_install_consumer.cmake +++ b/tests/compile_install_consumer.cmake @@ -1,77 +1,96 @@ -set(INFINI_RT_INCLUDE_DIR "${INFINI_RT_INSTALL_PREFIX}/include") -set(INFINI_RT_LIBRARY_DIR "${INFINI_RT_INSTALL_PREFIX}/lib") +foreach(INFINI_RT_REQUIRED_VARIABLE + IN ITEMS + INFINI_RT_INSTALL_PREFIX + INFINI_RT_REQUIRED_VERSION + INFINI_RT_CONSUMER_SOURCE_DIR + INFINI_RT_CONSUMER_SOURCE + INFINI_RT_CONSUMER_BINARY + INFINI_RT_CTEST_COMMAND) + if(NOT DEFINED ${INFINI_RT_REQUIRED_VARIABLE} + OR "${${INFINI_RT_REQUIRED_VARIABLE}}" STREQUAL "") + message(FATAL_ERROR + "${INFINI_RT_REQUIRED_VARIABLE} is required for the install consumer test.") + endif() +endforeach() -if(NOT EXISTS "${INFINI_RT_LIBRARY_DIR}/libinfinirt.so") - set(INFINI_RT_LIBRARY_DIR "${INFINI_RT_INSTALL_PREFIX}/lib64") -endif() +set(INFINI_RT_CONFIGURE_ARGS + -S "${INFINI_RT_CONSUMER_SOURCE_DIR}" + -B "${INFINI_RT_CONSUMER_BINARY}" + "-DCMAKE_PREFIX_PATH=${INFINI_RT_INSTALL_PREFIX}" + "-DINFINI_RT_REQUIRED_VERSION=${INFINI_RT_REQUIRED_VERSION}" + "-DINFINI_RT_CONSUMER_SOURCE=${INFINI_RT_CONSUMER_SOURCE}" + "-DINFINI_RT_CONSUMER_BACKEND=${INFINI_RT_CONSUMER_BACKEND}") -if(NOT EXISTS "${INFINI_RT_INCLUDE_DIR}/infini/rt.h") - message(FATAL_ERROR "The installed public header was not found.") +if(INFINI_RT_CMAKE_GENERATOR) + list(APPEND INFINI_RT_CONFIGURE_ARGS + -G "${INFINI_RT_CMAKE_GENERATOR}") endif() - -if(NOT EXISTS "${INFINI_RT_LIBRARY_DIR}/libinfinirt.so") - message(FATAL_ERROR "The installed InfiniRT library was not found.") +if(INFINI_RT_CMAKE_GENERATOR_PLATFORM) + list(APPEND INFINI_RT_CONFIGURE_ARGS + -A "${INFINI_RT_CMAKE_GENERATOR_PLATFORM}") endif() - -set(INFINI_RT_EXTRA_LINK_ARGS "") -set(INFINI_RT_EXTRA_COMPILE_ARGS "") -set(INFINI_RT_LD_LIBRARY_PATH "${INFINI_RT_LIBRARY_DIR}") - -if(INFINI_RT_EXTRA_INCLUDE_PATHS) - string(REPLACE ":" ";" INFINI_RT_EXTRA_INCLUDE_DIRS - "${INFINI_RT_EXTRA_INCLUDE_PATHS}") - foreach(INFINI_RT_EXTRA_INCLUDE_DIR ${INFINI_RT_EXTRA_INCLUDE_DIRS}) - if(EXISTS "${INFINI_RT_EXTRA_INCLUDE_DIR}") - list(APPEND INFINI_RT_EXTRA_COMPILE_ARGS - "-I${INFINI_RT_EXTRA_INCLUDE_DIR}") - endif() - endforeach() +if(INFINI_RT_CMAKE_GENERATOR_TOOLSET) + list(APPEND INFINI_RT_CONFIGURE_ARGS + -T "${INFINI_RT_CMAKE_GENERATOR_TOOLSET}") +endif() +if(INFINI_RT_CMAKE_BUILD_TYPE) + list(APPEND INFINI_RT_CONFIGURE_ARGS + "-DCMAKE_BUILD_TYPE=${INFINI_RT_CMAKE_BUILD_TYPE}") +endif() +if(INFINI_RT_CXX_COMPILER) + list(APPEND INFINI_RT_CONFIGURE_ARGS + "-DCMAKE_CXX_COMPILER=${INFINI_RT_CXX_COMPILER}") +endif() +if(INFINI_RT_CMAKE_TOOLCHAIN_FILE) + list(APPEND INFINI_RT_CONFIGURE_ARGS + "-DCMAKE_TOOLCHAIN_FILE=${INFINI_RT_CMAKE_TOOLCHAIN_FILE}") endif() +if(INFINI_RT_CUDATOOLKIT_ROOT) + list(APPEND INFINI_RT_CONFIGURE_ARGS + "-DCUDAToolkit_ROOT=${INFINI_RT_CUDATOOLKIT_ROOT}") +endif() +if(INFINI_RT_BACKEND_ROOT_VARIABLE AND INFINI_RT_BACKEND_ROOT) + list(APPEND INFINI_RT_CONFIGURE_ARGS + "-D${INFINI_RT_BACKEND_ROOT_VARIABLE}=${INFINI_RT_BACKEND_ROOT}") +endif() + +execute_process( + COMMAND "${CMAKE_COMMAND}" ${INFINI_RT_CONFIGURE_ARGS} + RESULT_VARIABLE INFINI_RT_CONFIGURE_RESULT + OUTPUT_VARIABLE INFINI_RT_CONFIGURE_OUTPUT + ERROR_VARIABLE INFINI_RT_CONFIGURE_ERROR) -if(INFINI_RT_CONSUMER_BACKEND AND NOT INFINI_RT_CONSUMER_BACKEND STREQUAL "NONE") - list(APPEND INFINI_RT_EXTRA_COMPILE_ARGS - "-DINFINI_RT_CONSUMER_BACKEND_${INFINI_RT_CONSUMER_BACKEND}=1") +if(NOT INFINI_RT_CONFIGURE_RESULT EQUAL 0) + message(FATAL_ERROR + "Configuring the install consumer failed.\n" + "${INFINI_RT_CONFIGURE_OUTPUT}\n${INFINI_RT_CONFIGURE_ERROR}") endif() -if(INFINI_RT_EXTRA_LIBRARY_PATHS) - string(REPLACE ":" ";" INFINI_RT_EXTRA_LIBRARY_DIRS - "${INFINI_RT_EXTRA_LIBRARY_PATHS}") - foreach(INFINI_RT_EXTRA_LIBRARY_DIR ${INFINI_RT_EXTRA_LIBRARY_DIRS}) - if(EXISTS "${INFINI_RT_EXTRA_LIBRARY_DIR}") - list(APPEND INFINI_RT_EXTRA_LINK_ARGS - "-Wl,-rpath-link,${INFINI_RT_EXTRA_LIBRARY_DIR}") - set(INFINI_RT_LD_LIBRARY_PATH - "${INFINI_RT_LD_LIBRARY_PATH}:${INFINI_RT_EXTRA_LIBRARY_DIR}") - endif() - endforeach() +set(INFINI_RT_BUILD_ARGS --build "${INFINI_RT_CONSUMER_BINARY}") +if(INFINI_RT_BUILD_CONFIG) + list(APPEND INFINI_RT_BUILD_ARGS --config "${INFINI_RT_BUILD_CONFIG}") endif() execute_process( - COMMAND "${INFINI_RT_CXX_COMPILER}" - -std=c++17 - -Werror - "-I${INFINI_RT_INCLUDE_DIR}" - ${INFINI_RT_EXTRA_COMPILE_ARGS} - "${INFINI_RT_CONSUMER_SOURCE}" - "-L${INFINI_RT_LIBRARY_DIR}" - -linfinirt - "-Wl,-rpath,${INFINI_RT_LIBRARY_DIR}" - ${INFINI_RT_EXTRA_LINK_ARGS} - -o "${INFINI_RT_CONSUMER_BINARY}" - RESULT_VARIABLE INFINI_RT_COMPILE_RESULT - OUTPUT_VARIABLE INFINI_RT_COMPILE_OUTPUT - ERROR_VARIABLE INFINI_RT_COMPILE_ERROR) + COMMAND "${CMAKE_COMMAND}" ${INFINI_RT_BUILD_ARGS} + RESULT_VARIABLE INFINI_RT_BUILD_RESULT + OUTPUT_VARIABLE INFINI_RT_BUILD_OUTPUT + ERROR_VARIABLE INFINI_RT_BUILD_ERROR) -if(NOT INFINI_RT_COMPILE_RESULT EQUAL 0) +if(NOT INFINI_RT_BUILD_RESULT EQUAL 0) message(FATAL_ERROR - "Compiling the install consumer failed.\n" - "${INFINI_RT_COMPILE_OUTPUT}\n${INFINI_RT_COMPILE_ERROR}") + "Building the install consumer failed.\n" + "${INFINI_RT_BUILD_OUTPUT}\n${INFINI_RT_BUILD_ERROR}") +endif() + +set(INFINI_RT_CTEST_ARGS --output-on-failure) +if(INFINI_RT_BUILD_CONFIG) + list(APPEND INFINI_RT_CTEST_ARGS -C "${INFINI_RT_BUILD_CONFIG}") endif() execute_process( - COMMAND "${CMAKE_COMMAND}" -E env - "LD_LIBRARY_PATH=${INFINI_RT_LD_LIBRARY_PATH}:$ENV{LD_LIBRARY_PATH}" - "${INFINI_RT_CONSUMER_BINARY}" + COMMAND "${INFINI_RT_CTEST_COMMAND}" ${INFINI_RT_CTEST_ARGS} + WORKING_DIRECTORY "${INFINI_RT_CONSUMER_BINARY}" RESULT_VARIABLE INFINI_RT_RUN_RESULT OUTPUT_VARIABLE INFINI_RT_RUN_OUTPUT ERROR_VARIABLE INFINI_RT_RUN_ERROR) diff --git a/tests/install_consumer/CMakeLists.txt b/tests/install_consumer/CMakeLists.txt new file mode 100644 index 0000000..b705bbf --- /dev/null +++ b/tests/install_consumer/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.18) +project(infinirt_install_consumer LANGUAGES CXX) + +if(NOT INFINI_RT_CONSUMER_SOURCE) + message(FATAL_ERROR "INFINI_RT_CONSUMER_SOURCE is required.") +endif() +if(NOT INFINI_RT_REQUIRED_VERSION) + message(FATAL_ERROR "INFINI_RT_REQUIRED_VERSION is required.") +endif() + +find_package(InfiniRT ${INFINI_RT_REQUIRED_VERSION} EXACT CONFIG REQUIRED) + +if(NOT TARGET InfiniRT::infinirt) + message(FATAL_ERROR "The InfiniRT::infinirt target was not imported.") +endif() +if(NOT InfiniRT_ENABLED_BACKENDS) + message(FATAL_ERROR "InfiniRT did not report its enabled backends.") +endif() + +add_executable(infinirt_install_consumer "${INFINI_RT_CONSUMER_SOURCE}") +target_link_libraries(infinirt_install_consumer PRIVATE InfiniRT::infinirt) + +if(INFINI_RT_CONSUMER_BACKEND + AND NOT INFINI_RT_CONSUMER_BACKEND STREQUAL "NONE") + target_compile_definitions( + infinirt_install_consumer + PRIVATE + "INFINI_RT_CONSUMER_BACKEND_${INFINI_RT_CONSUMER_BACKEND}=1") +endif() + +enable_testing() +add_test(NAME run_infinirt_install_consumer + COMMAND infinirt_install_consumer) From 9ae8f8fd0b0ac4807a0d8b325fb0d3b2809fb161 Mon Sep 17 00:00:00 2001 From: Jiacheng Huang Date: Wed, 15 Jul 2026 10:49:26 +0800 Subject: [PATCH 2/2] test: validate installed package metadata --- CONTRIBUTING.md | 7 +++-- tests/CMakeLists.txt | 6 ++-- tests/compile_install_consumer.cmake | 2 ++ tests/install_consumer/CMakeLists.txt | 45 +++++++++++++++++++++++++-- 4 files changed, 53 insertions(+), 7 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 69c9bc8..b387366 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -205,8 +205,9 @@ ruff check . build directory per platform or delete the stale build directory. 3. **Generated headers are stale**: Re-run CMake configure. Public headers are generated during configuration. -4. **`test_install_consumer` fails to link or run**: Verify that the install - prefix contains both headers and libraries, and that the backend SDK library - paths are available to the consumer build and runtime linker. +4. **`test_install_consumer` fails to configure, link, or run**: Verify that the + install prefix contains the CMake package, headers, and libraries. Check that + `CMAKE_PREFIX_PATH` and the backend SDK root variables documented above are + available to the consumer build and runtime linker. 5. **Documentation build cannot find Doxygen**: Install Doxygen and Graphviz, or rely on the Documentation Pages workflow for validation. diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b231d19..559db6c 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -150,6 +150,8 @@ set(INFINI_RT_TEST_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/install_consumer_prefix") set(INFINI_RT_TEST_CONSUMER_BINARY "${CMAKE_CURRENT_BINARY_DIR}/install_consumer_build") +string(JOIN "," INFINI_RT_TEST_EXPECTED_BACKENDS + ${INFINI_RT_PUBLIC_HEADER_DEVICES}) set(INFINI_RT_TEST_CONSUMER_BACKEND NONE) set(INFINI_RT_TEST_CUDATOOLKIT_ROOT "${CUDAToolkit_ROOT}") set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE "") @@ -181,8 +183,7 @@ elseif(WITH_CAMBRICON) set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_CAMBRICON_ROOT) set(INFINI_RT_TEST_BACKEND_ROOT "${NEUWARE_HOME}") elseif(WITH_ASCEND) - # The install-consumer smoke checks Ascend public headers and linkage. - # Runtime behavior is covered by test_ascend_runtime and dispatch tests. + set(INFINI_RT_TEST_CONSUMER_BACKEND ASCEND) set(INFINI_RT_TEST_BACKEND_ROOT_VARIABLE InfiniRT_ASCEND_ROOT) set(INFINI_RT_TEST_BACKEND_ROOT "${ASCEND_HOME}") elseif(WITH_CPU) @@ -203,6 +204,7 @@ add_test( COMMAND "${CMAKE_COMMAND}" "-DINFINI_RT_INSTALL_PREFIX=${INFINI_RT_TEST_INSTALL_PREFIX}" "-DINFINI_RT_REQUIRED_VERSION=${PROJECT_VERSION}" + "-DINFINI_RT_EXPECTED_BACKENDS=${INFINI_RT_TEST_EXPECTED_BACKENDS}" "-DINFINI_RT_CONSUMER_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/install_consumer" "-DINFINI_RT_CONSUMER_SOURCE=${CMAKE_CURRENT_SOURCE_DIR}/install_consumer_smoke.cc" "-DINFINI_RT_CONSUMER_BINARY=${INFINI_RT_TEST_CONSUMER_BINARY}" diff --git a/tests/compile_install_consumer.cmake b/tests/compile_install_consumer.cmake index a89793f..8130a24 100644 --- a/tests/compile_install_consumer.cmake +++ b/tests/compile_install_consumer.cmake @@ -2,6 +2,7 @@ foreach(INFINI_RT_REQUIRED_VARIABLE IN ITEMS INFINI_RT_INSTALL_PREFIX INFINI_RT_REQUIRED_VERSION + INFINI_RT_EXPECTED_BACKENDS INFINI_RT_CONSUMER_SOURCE_DIR INFINI_RT_CONSUMER_SOURCE INFINI_RT_CONSUMER_BINARY @@ -18,6 +19,7 @@ set(INFINI_RT_CONFIGURE_ARGS -B "${INFINI_RT_CONSUMER_BINARY}" "-DCMAKE_PREFIX_PATH=${INFINI_RT_INSTALL_PREFIX}" "-DINFINI_RT_REQUIRED_VERSION=${INFINI_RT_REQUIRED_VERSION}" + "-DINFINI_RT_EXPECTED_BACKENDS=${INFINI_RT_EXPECTED_BACKENDS}" "-DINFINI_RT_CONSUMER_SOURCE=${INFINI_RT_CONSUMER_SOURCE}" "-DINFINI_RT_CONSUMER_BACKEND=${INFINI_RT_CONSUMER_BACKEND}") diff --git a/tests/install_consumer/CMakeLists.txt b/tests/install_consumer/CMakeLists.txt index b705bbf..c1a3c33 100644 --- a/tests/install_consumer/CMakeLists.txt +++ b/tests/install_consumer/CMakeLists.txt @@ -7,14 +7,55 @@ endif() if(NOT INFINI_RT_REQUIRED_VERSION) message(FATAL_ERROR "INFINI_RT_REQUIRED_VERSION is required.") endif() +if(NOT INFINI_RT_EXPECTED_BACKENDS) + message(FATAL_ERROR "INFINI_RT_EXPECTED_BACKENDS is required.") +endif() find_package(InfiniRT ${INFINI_RT_REQUIRED_VERSION} EXACT CONFIG REQUIRED) if(NOT TARGET InfiniRT::infinirt) message(FATAL_ERROR "The InfiniRT::infinirt target was not imported.") endif() -if(NOT InfiniRT_ENABLED_BACKENDS) - message(FATAL_ERROR "InfiniRT did not report its enabled backends.") +string(REPLACE "," ";" _infinirt_expected_backends + "${INFINI_RT_EXPECTED_BACKENDS}") +if(NOT "${InfiniRT_ENABLED_BACKENDS}" STREQUAL + "${_infinirt_expected_backends}") + message(FATAL_ERROR + "InfiniRT reported enabled backends '${InfiniRT_ENABLED_BACKENDS}', expected '${_infinirt_expected_backends}'.") +endif() + +foreach(_infinirt_backend CPU NVIDIA ILUVATAR HYGON METAX MOORE CAMBRICON ASCEND) + string(TOLOWER "${_infinirt_backend}" _infinirt_backend_lower) + list(FIND _infinirt_expected_backends "${_infinirt_backend_lower}" + _infinirt_backend_index) + if(_infinirt_backend_index EQUAL -1) + set(_infinirt_expected_state OFF) + else() + set(_infinirt_expected_state ON) + endif() + + if(NOT DEFINED InfiniRT_WITH_${_infinirt_backend}) + message(FATAL_ERROR + "InfiniRT did not report InfiniRT_WITH_${_infinirt_backend}.") + endif() + if(NOT "${InfiniRT_WITH_${_infinirt_backend}}" STREQUAL + "${_infinirt_expected_state}") + message(FATAL_ERROR + "InfiniRT_WITH_${_infinirt_backend} is '${InfiniRT_WITH_${_infinirt_backend}}', expected '${_infinirt_expected_state}'.") + endif() +endforeach() + +if(INFINI_RT_CONSUMER_BACKEND + AND NOT INFINI_RT_CONSUMER_BACKEND STREQUAL "NONE") + string(TOLOWER "${INFINI_RT_CONSUMER_BACKEND}" + _infinirt_consumer_backend_lower) + list(FIND _infinirt_expected_backends + "${_infinirt_consumer_backend_lower}" + _infinirt_consumer_backend_index) + if(_infinirt_consumer_backend_index EQUAL -1) + message(FATAL_ERROR + "The consumer backend '${INFINI_RT_CONSUMER_BACKEND}' is not enabled in InfiniRT.") + endif() endif() add_executable(infinirt_install_consumer "${INFINI_RT_CONSUMER_SOURCE}")