| # CMake find_package() module for level-zero | |
| # | |
| # Example usage: | |
| # | |
| # find_package(LevelZero) | |
| # | |
| # If successful, the following variables will be defined: | |
| # LevelZero_FOUND | |
| # LevelZero_INCLUDE_DIRS | |
| # LevelZero_LIBRARY | |
| # LevelZero_LIBRARIES_DIR | |
| # | |
| # By default, the module searches the standard paths to locate the "ze_api.h" | |
| # and the ze_loader shared library. When using a custom level-zero installation, | |
| # the environment variable "LEVEL_ZERO_DIR" should be specified telling the | |
| # module to get the level-zero library and headers from that location. | |
| include(FindPackageHandleStandardArgs) | |
| # Search path priority | |
| # 1. CMake Variable LEVEL_ZERO_DIR | |
| # 2. Environment Variable LEVEL_ZERO_DIR | |
| if(NOT LEVEL_ZERO_DIR) | |
| if(DEFINED ENV{LEVEL_ZERO_DIR}) | |
| set(LEVEL_ZERO_DIR "$ENV{LEVEL_ZERO_DIR}") | |
| endif() | |
| endif() | |
| if(LEVEL_ZERO_DIR) | |
| find_path(LevelZeroRuntime_INCLUDE_DIR | |
| NAMES level_zero/ze_api.h | |
| PATHS ${LEVEL_ZERO_DIR}/include | |
| NO_DEFAULT_PATH | |
| ) | |
| if(LINUX) | |
| find_library(LevelZeroRuntime_LIBRARY | |
| NAMES ze_loader | |
| PATHS ${LEVEL_ZERO_DIR}/lib | |
| ${LEVEL_ZERO_DIR}/lib/x86_64-linux-gnu | |
| NO_DEFAULT_PATH | |
| ) | |
| else() | |
| find_library(LevelZeroRuntime_LIBRARY | |
| NAMES ze_loader | |
| PATHS ${LEVEL_ZERO_DIR}/lib | |
| NO_DEFAULT_PATH | |
| ) | |
| endif() | |
| else() | |
| find_path(LevelZeroRuntime_INCLUDE_DIR | |
| NAMES level_zero/ze_api.h | |
| ) | |
| find_library(LevelZeroRuntime_LIBRARY | |
| NAMES ze_loader | |
| ) | |
| endif() | |
| # Compares the two version string that are supposed to be in x.y.z format | |
| # and reports if the argument VERSION_STR1 is greater than or equal than | |
| # version_str2. The strings are compared lexicographically after conversion to | |
| # lists of equal lengths, with the shorter string getting zero-padded. | |
| function(compare_versions VERSION_STR1 VERSION_STR2 OUTPUT) | |
| # Convert the strings to list | |
| string(REPLACE "." ";" VL1 ${VERSION_STR1}) | |
| string(REPLACE "." ";" VL2 ${VERSION_STR2}) | |
| # get lengths of both lists | |
| list(LENGTH VL1 VL1_LEN) | |
| list(LENGTH VL2 VL2_LEN) | |
| set(LEN ${VL1_LEN}) | |
| # If they differ in size pad the shorter list with 0s | |
| if(VL1_LEN GREATER VL2_LEN) | |
| math(EXPR DIFF "${VL1_LEN} - ${VL2_LEN}" OUTPUT_FORMAT DECIMAL) | |
| foreach(IDX RANGE 1 ${DIFF} 1) | |
| list(APPEND VL2 "0") | |
| endforeach() | |
| elseif(VL2_LEN GREATER VL2_LEN) | |
| math(EXPR DIFF "${VL1_LEN} - ${VL2_LEN}" OUTPUT_FORMAT DECIMAL) | |
| foreach(IDX RANGE 1 ${DIFF} 1) | |
| list(APPEND VL2 "0") | |
| endforeach() | |
| set(LEN ${VL2_LEN}) | |
| endif() | |
| math(EXPR LEN_SUB_ONE "${LEN}-1") | |
| foreach(IDX RANGE 0 ${LEN_SUB_ONE} 1) | |
| list(GET VL1 ${IDX} VAL1) | |
| list(GET VL2 ${IDX} VAL2) | |
| if(${VAL1} GREATER ${VAL2}) | |
| set(${OUTPUT} TRUE PARENT_SCOPE) | |
| break() | |
| elseif(${VAL1} LESS ${VAL2}) | |
| set(${OUTPUT} FALSE PARENT_SCOPE) | |
| break() | |
| else() | |
| set(${OUTPUT} TRUE PARENT_SCOPE) | |
| endif() | |
| endforeach() | |
| endfunction(compare_versions) | |
| # Creates a small function to run and extract the LevelZero loader version. | |
| function(get_l0_loader_version) | |
| set(L0_VERSIONEER_SRC | |
| [====[ | |
| #include <iostream> | |
| #include <level_zero/loader/ze_loader.h> | |
| #include <string> | |
| int main() { | |
| ze_result_t result; | |
| std::string loader("loader"); | |
| zel_component_version_t *versions; | |
| size_t size = 0; | |
| result = zeInit(0); | |
| if (result != ZE_RESULT_SUCCESS) { | |
| std::cerr << "Failed to init ze driver" << std::endl; | |
| return -1; | |
| } | |
| zelLoaderGetVersions(&size, nullptr); | |
| versions = new zel_component_version_t[size]; | |
| zelLoaderGetVersions(&size, versions); | |
| for (size_t i = 0; i < size; i++) { | |
| if (loader.compare(versions[i].component_name) == 0) { | |
| std::cout << versions[i].component_lib_version.major << "." | |
| << versions[i].component_lib_version.minor << "." | |
| << versions[i].component_lib_version.patch; | |
| break; | |
| } | |
| } | |
| delete[] versions; | |
| return 0; | |
| } | |
| ]====] | |
| ) | |
| set(L0_VERSIONEER_FILE ${CMAKE_BINARY_DIR}/temp/l0_versioneer.cpp) | |
| file(WRITE ${L0_VERSIONEER_FILE} "${L0_VERSIONEER_SRC}") | |
| # We need both the directories in the include path as ze_loader.h | |
| # includes "ze_api.h" and not "level_zero/ze_api.h". | |
| list(APPEND INCLUDE_DIRS ${LevelZeroRuntime_INCLUDE_DIR}) | |
| list(APPEND INCLUDE_DIRS ${LevelZeroRuntime_INCLUDE_DIR}/level_zero) | |
| list(JOIN INCLUDE_DIRS ";" INCLUDE_DIRS_STR) | |
| try_run(L0_VERSIONEER_RUN L0_VERSIONEER_COMPILE | |
| "${CMAKE_BINARY_DIR}" | |
| "${L0_VERSIONEER_FILE}" | |
| LINK_LIBRARIES ${LevelZeroRuntime_LIBRARY} | |
| CMAKE_FLAGS | |
| "-DINCLUDE_DIRECTORIES=${INCLUDE_DIRS_STR}" | |
| RUN_OUTPUT_VARIABLE L0_VERSION | |
| ) | |
| if(${L0_VERSIONEER_COMPILE} AND(DEFINED L0_VERSIONEER_RUN)) | |
| set(LevelZeroRuntime_VERSION ${L0_VERSION} PARENT_SCOPE) | |
| message(STATUS "Found Level Zero of version: ${L0_VERSION}") | |
| else() | |
| message(FATAL_ERROR | |
| "Could not compile a level-zero program to extract loader version" | |
| ) | |
| endif() | |
| endfunction(get_l0_loader_version) | |
| if(LevelZeroRuntime_INCLUDE_DIR AND LevelZeroRuntime_LIBRARY) | |
| list(APPEND LevelZeroRuntime_LIBRARIES "${LevelZeroRuntime_LIBRARY}") | |
| list(APPEND LevelZeroRuntime_INCLUDE_DIRS ${LevelZeroRuntime_INCLUDE_DIR}) | |
| if(OpenCL_FOUND) | |
| list(APPEND LevelZeroRuntime_INCLUDE_DIRS ${OpenCL_INCLUDE_DIRS}) | |
| endif() | |
| cmake_path(GET LevelZeroRuntime_LIBRARY PARENT_PATH LevelZeroRuntime_LIBRARIES_PATH) | |
| set(LevelZeroRuntime_LIBRARIES_DIR ${LevelZeroRuntime_LIBRARIES_PATH}) | |
| if(NOT TARGET LevelZeroRuntime::LevelZeroRuntime) | |
| add_library(LevelZeroRuntime::LevelZeroRuntime INTERFACE IMPORTED) | |
| set_target_properties(LevelZeroRuntime::LevelZeroRuntime | |
| PROPERTIES INTERFACE_LINK_LIBRARIES "${LevelZeroRuntime_LIBRARIES}" | |
| ) | |
| set_target_properties(LevelZeroRuntime::LevelZeroRuntime | |
| PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${LevelZeroRuntime_INCLUDE_DIRS}" | |
| ) | |
| endif() | |
| endif() | |
| # Check if a specific version of Level Zero is required | |
| if(LevelZeroRuntime_FIND_VERSION) | |
| get_l0_loader_version() | |
| set(VERSION_GT_FIND_VERSION FALSE) | |
| compare_versions( | |
| ${LevelZeroRuntime_VERSION} | |
| ${LevelZeroRuntime_FIND_VERSION} | |
| VERSION_GT_FIND_VERSION | |
| ) | |
| if(${VERSION_GT_FIND_VERSION}) | |
| set(LevelZeroRuntime_FOUND TRUE) | |
| else() | |
| set(LevelZeroRuntime_FOUND FALSE) | |
| endif() | |
| else() | |
| set(LevelZeroRuntime_FOUND TRUE) | |
| endif() | |
| find_package_handle_standard_args(LevelZeroRuntime | |
| REQUIRED_VARS | |
| LevelZeroRuntime_FOUND | |
| LevelZeroRuntime_INCLUDE_DIRS | |
| LevelZeroRuntime_LIBRARY | |
| LevelZeroRuntime_LIBRARIES_DIR | |
| HANDLE_COMPONENTS | |
| ) | |
| mark_as_advanced(LevelZeroRuntime_LIBRARY LevelZeroRuntime_INCLUDE_DIRS) | |
| if(LevelZeroRuntime_FOUND) | |
| find_package_message(LevelZeroRuntime "Found LevelZero: ${LevelZeroRuntime_LIBRARY}" | |
| "(found version ${LevelZeroRuntime_VERSION})" | |
| ) | |
| else() | |
| find_package_message(LevelZeroRuntime "Could not find LevelZero" "") | |
| endif() |