281e6d2cc4
Adds LevelZeroRuntime wrapper and tests. Co-authored-by: Artem Kroviakov <artem.kroviakov@intel.com> Co-authored-by: Nishant Patel <nishant.b.patel@intel.com> --------- Co-authored-by: Artem Kroviakov <artem.kroviakov@intel.com> Co-authored-by: Nishant Patel <nishant.b.patel@intel.com>
224 lines
7.3 KiB
CMake
224 lines
7.3 KiB
CMake
# 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()
|