intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 09:14:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Link igdgmm in link time

Browse Source 
change mock_gmm to object library

Resolves: NEO-2551

Change-Id: I7546868209191cc5833b2048ce9298881d2b79ac
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-01-09 16:14:59 +01:00
committed by sys_ocldev
parent 67ff9655e2
commit e3cc20fdcc
24 changed files with 165 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
CMakeLists.txt
View File

@@ -4,7 +4,11 @@
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
cmake_minimum_required(VERSION 3.2.0 FATAL_ERROR) if(WIN32)
cmake_minimum_required(VERSION 3.13.0 FATAL_ERROR)
else()
cmake_minimum_required(VERSION 3.2.0 FATAL_ERROR)
endif()
include(ExternalProject) include(ExternalProject)
# Include custom configs # Include custom configs
@@ -368,92 +372,90 @@ if(WIN32)
endif() endif()
# GmmLib detection # GmmLib detection
if(NOT DEFINED GMMUMD_LIB_NAME) if(TARGET igfx_gmmumd_dll)
if(TARGET igfx_gmmumd_dll) set(GMM_TARGET_NAME "igfx_gmmumd_dll")
set(GMMUMD_LIB_NAME "igfx_gmmumd_dll") set(GMM_LINK_NAME $<TARGET_PROPERTY:${GMM_TARGET_NAME},OUTPUT_NAME>)
if(UNIX) set(IGDRCL__GMM_LIBRARY_PATH $<TARGET_FILE_DIR:${GMM_TARGET_NAME}>)
set(IGDRCL__GMM_LIBRARY_PATH "$<TARGET_FILE_DIR:${GMMUMD_LIB_NAME}>") set(UMKM_SHAREDDATA_INCLUDE_PATHS $<TARGET_PROPERTY:${GMM_TARGET_NAME},INTERFACE_INCLUDE_DIRECTORIES>)
endif() else()
if(DEFINED GMM_DIR)
get_filename_component(GMM_DIR "${GMM_DIR}" ABSOLUTE)
else() else()
if(DEFINED GMM_DIR) get_filename_component(GMM_DIR_tmp "${NEO_SOURCE_DIR}/../gmmlib" ABSOLUTE)
get_filename_component(GMM_DIR "${GMM_DIR}" ABSOLUTE) if(IS_DIRECTORY "${GMM_DIR_tmp}")
else() set(GMM_DIR "${GMM_DIR_tmp}")
get_filename_component(GMM_DIR_tmp "${NEO_SOURCE_DIR}/../gmmlib" ABSOLUTE)
if(IS_DIRECTORY "${GMM_DIR_tmp}")
set(GMM_DIR "${GMM_DIR_tmp}")
endif()
endif()
if(UNIX)
if(DEFINED GMM_DIR)
if(IS_DIRECTORY "${GMM_DIR}/lib/pkgconfig/")
set(__tmp_LIBDIR "lib")
elseif(IS_DIRECTORY "${GMM_DIR}/${CMAKE_INSTALL_LIBDIR}/pkgconfig/")
set(__tmp_LIBDIR ${CMAKE_INSTALL_LIBDIR})
endif()
endif()
find_package(PkgConfig)
if(DEFINED __tmp_LIBDIR)
set(OLD_PKG_CONFIG_PATH $ENV{PKG_CONFIG_PATH})
set(ENV{PKG_CONFIG_PATH} "${GMM_DIR}/${__tmp_LIBDIR}/pkgconfig/")
endif()
pkg_check_modules(IGDRCL__GMM igdgmm)
if(DEFINED __tmp_LIBDIR)
set(ENV{PKG_CONFIG_PATH} ${OLD_PKG_CONFIG_PATH})
endif()
if(IGDRCL__GMM_FOUND)
if(DEFINED __tmp_LIBDIR)
string(REPLACE "${IGDRCL__GMM_INCLUDEDIR}" "${GMM_DIR}/include/igdgmm" IGDRCL__GMM_INCLUDE_DIRS "${IGDRCL__GMM_INCLUDE_DIRS}")
string(REPLACE "${IGDRCL__GMM_LIBDIR}" "${GMM_DIR}/${__tmp_LIBDIR}" IGDRCL__GMM_LIBDIR "${IGDRCL__GMM_LIBDIR}")
set(IGDRCL__GMM_LIBRARY_PATH "${IGDRCL__GMM_LIBDIR}")
endif()
set(GMMUMD_LIB_NAME "igfx_gmmumd_dll")
set(IGDRCL__GMM_INCLUDE_DIR ${IGDRCL__GMM_INCLUDE_DIRS})
set(UMKM_SHAREDDATA_INCLUDE_PATHS "${IGDRCL__GMM_INCLUDE_DIR}")
message(STATUS "GmmLib include dirs: ${IGDRCL__GMM_INCLUDE_DIR}")
else()
message(FATAL_ERROR "GmmLib not found!")
endif()
if(DEFINED __tmp_LIBDIR)
unset(__tmp_LIBDIR)
endif()
else()
if(EXISTS "${GMM_DIR}/CMakeLists.txt")
message(STATUS "GmmLib source dir is: ${GMM_DIR}")
add_subdirectory_unique("${GMM_DIR}" "${NEO_BUILD_DIR}/gmmlib")
if(NOT DEFINED GMMUMD_LIB_NAME)
set(GMMUMD_LIB_NAME "igfx_gmmumd_dll")
endif()
set(UMKM_SHAREDDATA_INCLUDE_PATHS $<TARGET_PROPERTY:${GMMUMD_LIB_NAME},INTERFACE_INCLUDE_DIRECTORIES>)
else()
message(FATAL_ERROR "GmmLib not found!")
endif()
endif() endif()
endif() endif()
else()
set(UMKM_SHAREDDATA_INCLUDE_PATHS $<TARGET_PROPERTY:${GMMUMD_LIB_NAME},INTERFACE_INCLUDE_DIRECTORIES>)
if(UNIX) if(UNIX)
set(IGDRCL__GMM_LIBRARY_PATH "$<TARGET_FILE_DIR:${GMMUMD_LIB_NAME}>") if(DEFINED GMM_DIR)
if(IS_DIRECTORY "${GMM_DIR}/lib/pkgconfig/")
set(__tmp_LIBDIR "lib")
elseif(IS_DIRECTORY "${GMM_DIR}/${CMAKE_INSTALL_LIBDIR}/pkgconfig/")
set(__tmp_LIBDIR ${CMAKE_INSTALL_LIBDIR})
endif()
endif()
find_package(PkgConfig)
if(DEFINED __tmp_LIBDIR)
set(OLD_PKG_CONFIG_PATH $ENV{PKG_CONFIG_PATH})
set(ENV{PKG_CONFIG_PATH} "${GMM_DIR}/${__tmp_LIBDIR}/pkgconfig/")
endif()
pkg_check_modules(IGDRCL__GMM igdgmm)
if(DEFINED __tmp_LIBDIR)
set(ENV{PKG_CONFIG_PATH} ${OLD_PKG_CONFIG_PATH})
endif()
if(IGDRCL__GMM_FOUND)
if(DEFINED __tmp_LIBDIR)
string(REPLACE "${IGDRCL__GMM_INCLUDEDIR}" "${GMM_DIR}/include/igdgmm" IGDRCL__GMM_INCLUDE_DIRS "${IGDRCL__GMM_INCLUDE_DIRS}")
string(REPLACE "${IGDRCL__GMM_LIBDIR}" "${GMM_DIR}/${__tmp_LIBDIR}" IGDRCL__GMM_LIBDIR "${IGDRCL__GMM_LIBDIR}")
set(IGDRCL__GMM_LIBRARY_PATH "${IGDRCL__GMM_LIBDIR}")
endif()
set(GMM_TARGET_NAME "igfx_gmmumd_dll")
set(GMM_LINK_NAME ${IGDRCL__GMM_LIBRARIES})
set(IGDRCL__GMM_INCLUDE_DIR ${IGDRCL__GMM_INCLUDE_DIRS})
set(UMKM_SHAREDDATA_INCLUDE_PATHS "${IGDRCL__GMM_INCLUDE_DIR}")
message(STATUS "GmmLib include dirs: ${IGDRCL__GMM_INCLUDE_DIR}")
else()
message(FATAL_ERROR "GmmLib not found!")
endif()
if(DEFINED __tmp_LIBDIR)
unset(__tmp_LIBDIR)
endif()
else()
if(EXISTS "${GMM_DIR}/CMakeLists.txt")
message(STATUS "GmmLib source dir is: ${GMM_DIR}")
add_subdirectory_unique("${GMM_DIR}" "${NEO_BUILD_DIR}/gmmlib")
if(NOT DEFINED GMM_TARGET_NAME)
set(GMM_TARGET_NAME "igfx_gmmumd_dll")
endif()
set(UMKM_SHAREDDATA_INCLUDE_PATHS $<TARGET_PROPERTY:${GMM_TARGET_NAME},INTERFACE_INCLUDE_DIRECTORIES>)
set(IGDRCL__GMM_LIBRARY_PATH $<TARGET_FILE_DIR:${GMM_TARGET_NAME}>)
set(GMM_LINK_NAME $<TARGET_PROPERTY:${GMM_TARGET_NAME},OUTPUT_NAME>)
else()
message(FATAL_ERROR "GmmLib not found!")
endif()
endif() endif()
endif() endif()
macro(copy_gmm_dll_for target) macro(copy_gmm_dll_for target)
if(NOT UNIX) if(NOT UNIX)
add_dependencies(${target} ${GMMUMD_LIB_NAME}) add_dependencies(${target} ${GMM_TARGET_NAME})
add_custom_command( add_custom_command(
TARGET ${target} TARGET ${target}
POST_BUILD POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${GMMUMD_LIB_NAME}> $<TARGET_FILE_DIR:${target}> COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${GMM_TARGET_NAME}> $<TARGET_FILE_DIR:${target}>
) )
endif() endif()
endmacro() endmacro()
link_directories(${IGDRCL__GMM_LIBRARY_PATH})
# Instrumentation detection # Instrumentation detection
if(NOT DEFINED INSTRUMENTATION_LIB_NAME) if(NOT DEFINED INSTRUMENTATION_LIB_NAME)
if(DEFINED INSTRUMENTATION_SOURCE_DIR) if(DEFINED INSTRUMENTATION_SOURCE_DIR)

3
core/gmm_helper/gmm_helper.cpp
View File

@@ -36,10 +36,9 @@ uint32_t GmmHelper::getMOCS(uint32_t type) {
} }
GmmHelper::GmmHelper(OSInterface *osInterface, const HardwareInfo *pHwInfo) : hwInfo(pHwInfo) { GmmHelper::GmmHelper(OSInterface *osInterface, const HardwareInfo *pHwInfo) : hwInfo(pHwInfo) {
loadLib();
auto hwInfoAddressWidth = Math::log2(hwInfo->capabilityTable.gpuAddressSpace + 1); auto hwInfoAddressWidth = Math::log2(hwInfo->capabilityTable.gpuAddressSpace + 1);
GmmHelper::addressWidth = std::max(hwInfoAddressWidth, static_cast<uint32_t>(48)); GmmHelper::addressWidth = std::max(hwInfoAddressWidth, static_cast<uint32_t>(48));
gmmClientContext = GmmHelper::createGmmContextWrapperFunc(osInterface, const_cast<HardwareInfo *>(pHwInfo), this->initGmmFunc, this->destroyGmmFunc); gmmClientContext = GmmHelper::createGmmContextWrapperFunc(osInterface, const_cast<HardwareInfo *>(pHwInfo), InitializeGmm, GmmAdapterDestroy);
UNRECOVERABLE_IF(!gmmClientContext); UNRECOVERABLE_IF(!gmmClientContext);
} }

5
core/gmm_helper/gmm_helper.h
View File

@@ -42,13 +42,8 @@ class GmmHelper {
static std::unique_ptr<GmmClientContext> (*createGmmContextWrapperFunc)(OSInterface *, HardwareInfo *, decltype(&InitializeGmm), decltype(&GmmAdapterDestroy)); static std::unique_ptr<GmmClientContext> (*createGmmContextWrapperFunc)(OSInterface *, HardwareInfo *, decltype(&InitializeGmm), decltype(&GmmAdapterDestroy));
protected: protected:
void loadLib();
static uint32_t addressWidth; static uint32_t addressWidth;
const HardwareInfo *hwInfo = nullptr; const HardwareInfo *hwInfo = nullptr;
std::unique_ptr<OsLibrary> gmmLib;
std::unique_ptr<GmmClientContext> gmmClientContext; std::unique_ptr<GmmClientContext> gmmClientContext;
decltype(&InitializeGmm) initGmmFunc;
decltype(&GmmAdapterDestroy) destroyGmmFunc;
}; };
} // namespace NEO } // namespace NEO

4
package.cmake
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2017-2019 Intel Corporation # Copyright (C) 2017-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -132,6 +132,8 @@ if(UNIX)
string(REPLACE ";" ", " CPACK_RPM_OPENCL_PACKAGE_REQUIRES "${_external_package_dependencies_rpm}") string(REPLACE ";" ", " CPACK_RPM_OPENCL_PACKAGE_REQUIRES "${_external_package_dependencies_rpm}")
string(REPLACE ";" ", " CPACK_RPM_OCLOC_PACKAGE_REQUIRES "${_igc_package_dependencies_rpm}") string(REPLACE ";" ", " CPACK_RPM_OCLOC_PACKAGE_REQUIRES "${_igc_package_dependencies_rpm}")
set(CPACK_PROPERTIES_FILE "${CMAKE_CURRENT_SOURCE_DIR}/package_config.cmake")
set(CPACK_LD_LIBRARY_PATH "${IGDRCL__GMM_LIBRARY_PATH}")
include(CPack) include(CPack)
get_directory_property(__HAS_PARENT PARENT_DIRECTORY) get_directory_property(__HAS_PARENT PARENT_DIRECTORY)

7
package_config.cmake Normal file
View File

@@ -0,0 +1,7 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(ENV{LD_LIBRARY_PATH} ${CPACK_LD_LIBRARY_PATH})

8
runtime/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018-2019 Intel Corporation # Copyright (C) 2018-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -140,8 +140,8 @@ if(${GENERATE_EXECUTABLE})
set_property(GLOBAL APPEND PROPERTY NEO_COMPONENTS_LIST "opencl") set_property(GLOBAL APPEND PROPERTY NEO_COMPONENTS_LIST "opencl")
endif() endif()
if(TARGET ${GMMUMD_LIB_NAME}) if(TARGET ${GMM_TARGET_NAME})
add_dependencies(${NEO_DYNAMIC_LIB_NAME} ${GMMUMD_LIB_NAME}) add_dependencies(${NEO_DYNAMIC_LIB_NAME} ${GMM_TARGET_NAME})
endif() endif()
if(NOT DISABLED_GTPIN_SUPPORT) if(NOT DISABLED_GTPIN_SUPPORT)
@@ -153,7 +153,7 @@ if(${GENERATE_EXECUTABLE})
add_subdirectory(dll) add_subdirectory(dll)
target_link_libraries(${NEO_DYNAMIC_LIB_NAME} ${NEO_STATIC_LIB_NAME} ${IGDRCL_EXTRA_LIBS}) target_link_libraries(${NEO_DYNAMIC_LIB_NAME} ${NEO_STATIC_LIB_NAME} ${IGDRCL_EXTRA_LIBS} ${GMM_LINK_NAME})
target_include_directories(${NEO_DYNAMIC_LIB_NAME} BEFORE PRIVATE target_include_directories(${NEO_DYNAMIC_LIB_NAME} BEFORE PRIVATE
${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}

3
runtime/dll/linux/options_linux.cpp
View File

@@ -15,9 +15,6 @@ namespace Os {
const char *frontEndDllName = FCL_LIBRARY_NAME; const char *frontEndDllName = FCL_LIBRARY_NAME;
const char *igcDllName = IGC_LIBRARY_NAME; const char *igcDllName = IGC_LIBRARY_NAME;
const char *libvaDllName = "libva.so.2"; const char *libvaDllName = "libva.so.2";
const char *gmmDllName = GMM_UMD_DLL;
const char *gmmInitFuncName = GMM_ADAPTER_INIT_NAME;
const char *gmmDestroyFuncName = GMM_ADAPTER_DESTROY_NAME;
const char *sysFsPciPath = "/sys/bus/pci/devices/"; const char *sysFsPciPath = "/sys/bus/pci/devices/";
const char *tbxLibName = "libtbxAccess.so"; const char *tbxLibName = "libtbxAccess.so";

3
runtime/dll/windows/options_windows.cpp
View File

@@ -13,9 +13,6 @@ namespace Os {
const char *frontEndDllName = FCL_LIBRARY_NAME; const char *frontEndDllName = FCL_LIBRARY_NAME;
const char *igcDllName = IGC_LIBRARY_NAME; const char *igcDllName = IGC_LIBRARY_NAME;
const char *gdiDllName = "gdi32.dll"; const char *gdiDllName = "gdi32.dll";
const char *gmmDllName = GMM_UMD_DLL;
const char *gmmInitFuncName = GMM_ADAPTER_INIT_NAME;
const char *gmmDestroyFuncName = GMM_ADAPTER_DESTROY_NAME;
// Os specific Metrics Library name // Os specific Metrics Library name
#if _WIN64 #if _WIN64

1
runtime/gmm_helper/CMakeLists.txt
View File

@@ -6,7 +6,6 @@
set(RUNTIME_SRCS_GMM_HELPER_BASE set(RUNTIME_SRCS_GMM_HELPER_BASE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/gmm_interface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gmm_types_converter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gmm_types_converter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gmm_types_converter.h ${CMAKE_CURRENT_SOURCE_DIR}/gmm_types_converter.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/gmm_utils.cpp ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/gmm_utils.cpp

27
runtime/gmm_helper/gmm_interface.cpp
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/gmm_helper/gmm_helper.h"
#include "core/helpers/debug_helpers.h"
#include "core/os_interface/os_library.h"
namespace Os {
extern const char *gmmDllName;
extern const char *gmmInitFuncName;
extern const char *gmmDestroyFuncName;
} // namespace Os
namespace NEO {
void GmmHelper::loadLib() {
gmmLib.reset(OsLibrary::load(Os::gmmDllName));
UNRECOVERABLE_IF(!gmmLib);
initGmmFunc = reinterpret_cast<decltype(&InitializeGmm)>(gmmLib->getProcAddress(Os::gmmInitFuncName));
destroyGmmFunc = reinterpret_cast<decltype(&GmmAdapterDestroy)>(gmmLib->getProcAddress(Os::gmmDestroyFuncName));
UNRECOVERABLE_IF(!initGmmFunc || !destroyGmmFunc);
}
} // namespace NEO

3
unit_tests/CMakeLists.txt
View File

@@ -83,6 +83,7 @@ set(NEO_IGDRCL_TESTS__TARGET_OBJECTS
$<TARGET_OBJECTS:igdrcl_libult> $<TARGET_OBJECTS:igdrcl_libult>
$<TARGET_OBJECTS:igdrcl_libult_cs> $<TARGET_OBJECTS:igdrcl_libult_cs>
$<TARGET_OBJECTS:igdrcl_libult_env> $<TARGET_OBJECTS:igdrcl_libult_env>
$<TARGET_OBJECTS:mock_gmm>
$<TARGET_OBJECTS:${SHARINGS_ENABLE_LIB_NAME}> $<TARGET_OBJECTS:${SHARINGS_ENABLE_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}> $<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_BINARIES_LIB_NAME}> $<TARGET_OBJECTS:${BUILTINS_BINARIES_LIB_NAME}>
@@ -513,8 +514,6 @@ macro(macro_for_each_gen)
endmacro() endmacro()
apply_macro_for_each_gen("TESTED") apply_macro_for_each_gen("TESTED")
add_subdirectories() add_subdirectories()
add_dependencies(unit_tests mock_gmm)
add_dependencies(igdrcl_tests mock_gmm)
create_project_source_tree(igdrcl_tests ${NEO_SOURCE_DIR}/runtime) create_project_source_tree(igdrcl_tests ${NEO_SOURCE_DIR}/runtime)
set(UltPchHeader "${CMAKE_CURRENT_SOURCE_DIR}/igdrcl_tests_pch.h") set(UltPchHeader "${CMAKE_CURRENT_SOURCE_DIR}/igdrcl_tests_pch.h")

2
unit_tests/aub_tests/CMakeLists.txt
View File

@@ -65,7 +65,7 @@ add_subdirectories()
target_link_libraries(igdrcl_aub_tests igdrcl_mocks) target_link_libraries(igdrcl_aub_tests igdrcl_mocks)
target_link_libraries(igdrcl_aub_tests ${NEO_MOCKABLE_LIB_NAME}) target_link_libraries(igdrcl_aub_tests ${NEO_MOCKABLE_LIB_NAME})
target_link_libraries(igdrcl_aub_tests igdrcl_mocks) target_link_libraries(igdrcl_aub_tests igdrcl_mocks)
target_link_libraries(igdrcl_aub_tests gmock-gtest ${IGDRCL_EXTRA_LIBS}) target_link_libraries(igdrcl_aub_tests gmock-gtest ${IGDRCL_EXTRA_LIBS} ${GMM_LINK_NAME})
target_include_directories(igdrcl_aub_tests BEFORE PRIVATE ${NEO_SOURCE_DIR}/core/unit_tests/test_macros${BRANCH_DIR_SUFFIX}) target_include_directories(igdrcl_aub_tests BEFORE PRIVATE ${NEO_SOURCE_DIR}/core/unit_tests/test_macros${BRANCH_DIR_SUFFIX})

3
unit_tests/gmm_helper/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018 Intel Corporation # Copyright (C) 2018-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -7,7 +7,6 @@
set(IGDRCL_SRCS_tests_gmm_helper set(IGDRCL_SRCS_tests_gmm_helper
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/gmm_helper_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gmm_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gmm_interface_tests.cpp
) )
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gmm_helper}) target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gmm_helper})
add_subdirectories() add_subdirectories()

50
unit_tests/gmm_helper/gmm_helper_tests.cpp
View File

@@ -10,6 +10,7 @@
#include "core/helpers/hw_info.h" #include "core/helpers/hw_info.h"
#include "core/helpers/options.h" #include "core/helpers/options.h"
#include "core/helpers/ptr_math.h" #include "core/helpers/ptr_math.h"
#include "core/sku_info/operations/sku_info_transfer.h"
#include "core/unit_tests/helpers/debug_manager_state_restore.h" #include "core/unit_tests/helpers/debug_manager_state_restore.h"
#include "runtime/gmm_helper/gmm_types_converter.h" #include "runtime/gmm_helper/gmm_types_converter.h"
#include "runtime/memory_manager/os_agnostic_memory_manager.h" #include "runtime/memory_manager/os_agnostic_memory_manager.h"
@@ -29,6 +30,10 @@
using namespace ::testing; using namespace ::testing;
extern GMM_INIT_IN_ARGS passedInputArgs;
extern SKU_FEATURE_TABLE passedFtrTable;
extern WA_TABLE passedWaTable;
extern bool copyInputArgs;
namespace NEO { namespace NEO {
struct GmmTests : public ::testing::Test { struct GmmTests : public ::testing::Test {
void SetUp() override { void SetUp() override {
@@ -780,4 +785,49 @@ TEST(GmmHelperTest, givenPlatformAlreadyDestroyedWhenResourceIsBeingDestroyedThe
executionEnvironment->decRefInternal(); executionEnvironment->decRefInternal();
} }
TEST(GmmHelperTest, givenValidGmmFunctionsWhenCreateGmmHelperWithInitializedOsInterfaceThenProperParametersArePassed) {
std::unique_ptr<GmmHelper> gmmHelper;
auto executionEnvironment = platform()->peekExecutionEnvironment();
size_t numDevices;
DeviceFactory::getDevices(numDevices, *executionEnvironment);
VariableBackup<decltype(passedInputArgs)> passedInputArgsBackup(&passedInputArgs);
VariableBackup<decltype(passedFtrTable)> passedFtrTableBackup(&passedFtrTable);
VariableBackup<decltype(passedWaTable)> passedWaTableBackup(&passedWaTable);
VariableBackup<decltype(copyInputArgs)> copyInputArgsBackup(&copyInputArgs, true);
auto hwInfo = platformDevices[0];
SKU_FEATURE_TABLE expectedFtrTable = {};
WA_TABLE expectedWaTable = {};
SkuInfoTransfer::transferFtrTableForGmm(&expectedFtrTable, &hwInfo->featureTable);
SkuInfoTransfer::transferWaTableForGmm(&expectedWaTable, &hwInfo->workaroundTable);
gmmHelper.reset(new GmmHelper(executionEnvironment->osInterface.get(), hwInfo));
EXPECT_EQ(0, memcmp(&hwInfo->platform, &passedInputArgs.Platform, sizeof(PLATFORM)));
EXPECT_EQ(&hwInfo->gtSystemInfo, passedInputArgs.pGtSysInfo);
EXPECT_EQ(0, memcmp(&expectedFtrTable, &passedFtrTable, sizeof(SKU_FEATURE_TABLE)));
EXPECT_EQ(0, memcmp(&expectedWaTable, &passedWaTable, sizeof(WA_TABLE)));
EXPECT_EQ(GMM_CLIENT::GMM_OCL_VISTA, passedInputArgs.ClientType);
}
TEST(GmmHelperTest, givenValidGmmFunctionsWhenCreateGmmHelperWithoutOsInterfaceThenInitializationDoesntCrashAndProperParametersArePassed) {
std::unique_ptr<GmmHelper> gmmHelper;
VariableBackup<decltype(passedInputArgs)> passedInputArgsBackup(&passedInputArgs);
VariableBackup<decltype(passedFtrTable)> passedFtrTableBackup(&passedFtrTable);
VariableBackup<decltype(passedWaTable)> passedWaTableBackup(&passedWaTable);
VariableBackup<decltype(copyInputArgs)> copyInputArgsBackup(&copyInputArgs, true);
auto hwInfo = platformDevices[0];
SKU_FEATURE_TABLE expectedFtrTable = {};
WA_TABLE expectedWaTable = {};
SkuInfoTransfer::transferFtrTableForGmm(&expectedFtrTable, &hwInfo->featureTable);
SkuInfoTransfer::transferWaTableForGmm(&expectedWaTable, &hwInfo->workaroundTable);
gmmHelper.reset(new GmmHelper(nullptr, hwInfo));
EXPECT_EQ(0, memcmp(&hwInfo->platform, &passedInputArgs.Platform, sizeof(PLATFORM)));
EXPECT_EQ(&hwInfo->gtSystemInfo, passedInputArgs.pGtSysInfo);
EXPECT_EQ(0, memcmp(&expectedFtrTable, &passedFtrTable, sizeof(SKU_FEATURE_TABLE)));
EXPECT_EQ(0, memcmp(&expectedWaTable, &passedWaTable, sizeof(WA_TABLE)));
EXPECT_EQ(GMM_CLIENT::GMM_OCL_VISTA, passedInputArgs.ClientType);
}
} // namespace NEO } // namespace NEO

144
unit_tests/gmm_helper/gmm_interface_tests.cpp
View File

@@ -1,144 +0,0 @@
/*
* Copyright (C) 2018-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/gmm_helper/gmm_helper.h"
#include "core/helpers/hw_info.h"
#include "core/sku_info/operations/sku_info_transfer.h"
#include "runtime/execution_environment/execution_environment.h"
#include "runtime/os_interface/os_interface.h"
#include "runtime/platform/platform.h"
#include "unit_tests/helpers/variable_backup.h"
#include "gtest/gtest.h"
#include <array>
#ifdef _WIN32
#ifdef _WIN64
const char *mockGmmInitFuncName = "initMockGmm";
const char *mockGmmDestroyFuncName = "destroyMockGmm";
#else
const char *mockGmmInitFuncName = "_initMockGmm@8";
const char *mockGmmDestroyFuncName = "_destroyMockGmm@4";
#endif
#define EXPORT_KEYWORD __declspec(dllexport)
#else
const char *mockGmmInitFuncName = "initMockGmm";
const char *mockGmmDestroyFuncName = "destroyMockGmm";
#define EXPORT_KEYWORD
#endif
GMM_STATUS openGmmReturnValue = GMM_SUCCESS;
GMM_INIT_IN_ARGS passedInputArgs = {};
SKU_FEATURE_TABLE passedFtrTable = {};
WA_TABLE passedWaTable = {};
bool copyInputArgs = false;
extern "C" {
EXPORT_KEYWORD GMM_STATUS GMM_STDCALL initMockGmm(GMM_INIT_IN_ARGS *pInArgs, GMM_INIT_OUT_ARGS *pOutArgs) {
if (copyInputArgs && pInArgs) {
passedInputArgs = *pInArgs;
passedFtrTable = *reinterpret_cast<SKU_FEATURE_TABLE *>(pInArgs->pSkuTable);
passedWaTable = *reinterpret_cast<WA_TABLE *>(pInArgs->pWaTable);
}
pOutArgs->pGmmClientContext = reinterpret_cast<GMM_CLIENT_CONTEXT *>(0x01);
return openGmmReturnValue;
}
EXPORT_KEYWORD void GMM_STDCALL destroyMockGmm(GMM_INIT_OUT_ARGS *pInArgs) {
}
}
namespace Os {
extern const char *gmmDllName;
extern const char *gmmInitFuncName;
extern const char *gmmDestroyFuncName;
} // namespace Os
namespace NEO {
extern const HardwareInfo **platformDevices;
}
using namespace NEO;
struct GmmInterfaceTest : public ::testing::Test {
const char *empty = "";
VariableBackup<const char *> gmmDllNameBackup = {&Os::gmmDllName, empty};
VariableBackup<const char *> gmmInitNameBackup = {&Os::gmmInitFuncName, mockGmmInitFuncName};
VariableBackup<const char *> gmmDestroyNameBackup = {&Os::gmmDestroyFuncName, mockGmmDestroyFuncName};
};
TEST_F(GmmInterfaceTest, givenValidGmmLibWhenCreateGmmHelperThenEverythingWorksFine) {
std::unique_ptr<GmmHelper> gmmHelper;
EXPECT_NO_THROW(gmmHelper.reset(new GmmHelper(nullptr, *platformDevices)));
}
TEST_F(GmmInterfaceTest, givenInvalidGmmLibNameWhenCreateGmmHelperThenThrowException) {
std::unique_ptr<GmmHelper> gmmHelper;
gmmDllNameBackup = "invalidName";
EXPECT_THROW(gmmHelper.reset(new GmmHelper(nullptr, *platformDevices)), std::exception);
}
TEST_F(GmmInterfaceTest, givenGmmLibWhenOpenGmmFunctionFailsThenThrowException) {
std::unique_ptr<GmmHelper> gmmHelper;
VariableBackup<GMM_STATUS> openGmmReturnValueBackup(&openGmmReturnValue, GMM_ERROR);
EXPECT_THROW(gmmHelper.reset(new GmmHelper(nullptr, *platformDevices)), std::exception);
}
TEST_F(GmmInterfaceTest, givenInvalidGmmInitFunctionNameWhenCreateGmmHelperThenThrowException) {
std::unique_ptr<GmmHelper> gmmHelper;
gmmInitNameBackup = "invalidName";
EXPECT_THROW(gmmHelper.reset(new GmmHelper(nullptr, *platformDevices)), std::exception);
}
TEST_F(GmmInterfaceTest, givenInvalidGmmDestroyFunctionNameWhenCreateGmmHelperThenThrowException) {
std::unique_ptr<GmmHelper> gmmHelper;
gmmDestroyNameBackup = "invalidName";
EXPECT_THROW(gmmHelper.reset(new GmmHelper(nullptr, *platformDevices)), std::exception);
}
TEST_F(GmmInterfaceTest, givenValidGmmFunctionsWhenCreateGmmHelperWithInitializedOsInterfaceThenProperParametersArePassed) {
std::unique_ptr<GmmHelper> gmmHelper;
auto executionEnvironment = platform()->peekExecutionEnvironment();
size_t numDevices;
DeviceFactory::getDevices(numDevices, *executionEnvironment);
VariableBackup<decltype(passedInputArgs)> passedInputArgsBackup(&passedInputArgs);
VariableBackup<decltype(passedFtrTable)> passedFtrTableBackup(&passedFtrTable);
VariableBackup<decltype(passedWaTable)> passedWaTableBackup(&passedWaTable);
VariableBackup<decltype(copyInputArgs)> copyInputArgsBackup(&copyInputArgs, true);
auto hwInfo = platformDevices[0];
SKU_FEATURE_TABLE expectedFtrTable = {};
WA_TABLE expectedWaTable = {};
SkuInfoTransfer::transferFtrTableForGmm(&expectedFtrTable, &hwInfo->featureTable);
SkuInfoTransfer::transferWaTableForGmm(&expectedWaTable, &hwInfo->workaroundTable);
gmmHelper.reset(new GmmHelper(executionEnvironment->osInterface.get(), hwInfo));
EXPECT_EQ(0, memcmp(&hwInfo->platform, &passedInputArgs.Platform, sizeof(PLATFORM)));
EXPECT_EQ(&hwInfo->gtSystemInfo, passedInputArgs.pGtSysInfo);
EXPECT_EQ(0, memcmp(&expectedFtrTable, &passedFtrTable, sizeof(SKU_FEATURE_TABLE)));
EXPECT_EQ(0, memcmp(&expectedWaTable, &passedWaTable, sizeof(WA_TABLE)));
EXPECT_EQ(GMM_CLIENT::GMM_OCL_VISTA, passedInputArgs.ClientType);
}
TEST_F(GmmInterfaceTest, givenValidGmmFunctionsWhenCreateGmmHelperWithoutOsInterfaceThenInitializationDoesntCrashAndProperParametersArePassed) {
std::unique_ptr<GmmHelper> gmmHelper;
VariableBackup<decltype(passedInputArgs)> passedInputArgsBackup(&passedInputArgs);
VariableBackup<decltype(passedFtrTable)> passedFtrTableBackup(&passedFtrTable);
VariableBackup<decltype(passedWaTable)> passedWaTableBackup(&passedWaTable);
VariableBackup<decltype(copyInputArgs)> copyInputArgsBackup(&copyInputArgs, true);
auto hwInfo = platformDevices[0];
SKU_FEATURE_TABLE expectedFtrTable = {};
WA_TABLE expectedWaTable = {};
SkuInfoTransfer::transferFtrTableForGmm(&expectedFtrTable, &hwInfo->featureTable);
SkuInfoTransfer::transferWaTableForGmm(&expectedWaTable, &hwInfo->workaroundTable);
gmmHelper.reset(new GmmHelper(nullptr, hwInfo));
EXPECT_EQ(0, memcmp(&hwInfo->platform, &passedInputArgs.Platform, sizeof(PLATFORM)));
EXPECT_EQ(&hwInfo->gtSystemInfo, passedInputArgs.pGtSysInfo);
EXPECT_EQ(0, memcmp(&expectedFtrTable, &passedFtrTable, sizeof(SKU_FEATURE_TABLE)));
EXPECT_EQ(0, memcmp(&expectedWaTable, &passedWaTable, sizeof(WA_TABLE)));
EXPECT_EQ(GMM_CLIENT::GMM_OCL_VISTA, passedInputArgs.ClientType);
}

5
unit_tests/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2017-2019 Intel Corporation # Copyright (C) 2017-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -49,6 +49,7 @@ foreach(target_name linux_tests linux_dll_tests)
${IGDRCL_SRCS_${target_name}} ${IGDRCL_SRCS_${target_name}}
$<TARGET_OBJECTS:igdrcl_libult> $<TARGET_OBJECTS:igdrcl_libult>
$<TARGET_OBJECTS:igdrcl_libult_cs> $<TARGET_OBJECTS:igdrcl_libult_cs>
$<TARGET_OBJECTS:mock_gmm>
) )
target_link_libraries(igdrcl_${target_name} ${NEO_MOCKABLE_LIB_NAME} igdrcl_mocks ${IGDRCL_EXTRA_LIBS} gmock-gtest) target_link_libraries(igdrcl_${target_name} ${NEO_MOCKABLE_LIB_NAME} igdrcl_mocks ${IGDRCL_EXTRA_LIBS} gmock-gtest)
@@ -61,4 +62,4 @@ foreach(target_name linux_tests linux_dll_tests)
) )
add_dependencies(unit_tests igdrcl_${target_name}) add_dependencies(unit_tests igdrcl_${target_name})
endforeach() endforeach()
add_subdirectories() add_subdirectories()

12
unit_tests/main.cpp
View File

@@ -54,11 +54,6 @@ namespace MockSipData {
extern std::unique_ptr<MockSipKernel> mockSipKernel; extern std::unique_ptr<MockSipKernel> mockSipKernel;
} }
} // namespace NEO } // namespace NEO
namespace Os {
extern const char *gmmDllName;
extern const char *gmmInitFuncName;
extern const char *gmmDestroyFuncName;
} // namespace Os
using namespace NEO; using namespace NEO;
TestEnvironment *gEnvironment; TestEnvironment *gEnvironment;
@@ -459,14 +454,9 @@ int main(int argc, char **argv) {
#else #else
SetUnhandledExceptionFilter(&UltExceptionFilter); SetUnhandledExceptionFilter(&UltExceptionFilter);
#endif #endif
if (!useMockGmm) { if (useMockGmm) {
Os::gmmDllName = GMM_UMD_DLL;
Os::gmmInitFuncName = GMM_ADAPTER_INIT_NAME;
Os::gmmDestroyFuncName = GMM_ADAPTER_DESTROY_NAME;
} else {
GmmHelper::createGmmContextWrapperFunc = GmmClientContextBase::create<MockGmmClientContext>; GmmHelper::createGmmContextWrapperFunc = GmmClientContextBase::create<MockGmmClientContext>;
} }
std::unique_ptr<OsLibrary> gmmLib(OsLibrary::load(Os::gmmDllName));
initializeTestHelpers(); initializeTestHelpers();
retVal = RUN_ALL_TESTS(); retVal = RUN_ALL_TESTS();

13
unit_tests/mock_gmm/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018-2019 Intel Corporation # Copyright (C) 2018-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -11,23 +11,14 @@ project(${target_name})
set(IGDRCL_SRCS_tests_mock_gmm set(IGDRCL_SRCS_tests_mock_gmm
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm.cpp ${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm.def
) )
add_library(${target_name} EXCLUDE_FROM_ALL SHARED ${IGDRCL_SRCS_tests_mock_gmm}) add_library(${target_name} EXCLUDE_FROM_ALL OBJECT ${IGDRCL_SRCS_tests_mock_gmm})
target_include_directories(${target_name} PRIVATE target_include_directories(${target_name} PRIVATE
${WDK_INCLUDE_PATHS} ${WDK_INCLUDE_PATHS}
${UMKM_SHAREDDATA_INCLUDE_PATHS} ${UMKM_SHAREDDATA_INCLUDE_PATHS}
) )
set_target_properties(
${target_name}
PROPERTIES DEBUG_OUTPUT_NAME ${target_name}
RELEASE_OUTPUT_NAME ${target_name}
RELEASEINTERNAL_OUTPUT_NAME ${target_name}
OUTPUT_NAME ${target_name}
)
create_project_source_tree(${target_name}) create_project_source_tree(${target_name})
set_target_properties(${target_name} PROPERTIES FOLDER "test mocks") set_target_properties(${target_name} PROPERTIES FOLDER "test mocks")
target_compile_definitions(${target_name} PUBLIC) target_compile_definitions(${target_name} PUBLIC)

20
unit_tests/mock_gmm/mock_gmm.cpp
View File

@@ -7,22 +7,24 @@
#include "GmmLib.h" #include "GmmLib.h"
#ifdef __cplusplus GMM_INIT_IN_ARGS passedInputArgs = {};
extern "C" { SKU_FEATURE_TABLE passedFtrTable = {};
#endif WA_TABLE passedWaTable = {};
bool copyInputArgs = false;
GMM_STATUS GMM_STDCALL initMockGmm(GMM_INIT_IN_ARGS *pInArgs, GMM_INIT_OUT_ARGS *pOutArgs) { GMM_STATUS GMM_STDCALL InitializeGmm(GMM_INIT_IN_ARGS *pInArgs, GMM_INIT_OUT_ARGS *pOutArgs) {
pOutArgs->pGmmClientContext = reinterpret_cast<GMM_CLIENT_CONTEXT *>(0x01); pOutArgs->pGmmClientContext = reinterpret_cast<GMM_CLIENT_CONTEXT *>(0x01);
if (pInArgs->Platform.eProductFamily == PRODUCT_FAMILY::IGFX_UNKNOWN && if (pInArgs->Platform.eProductFamily == PRODUCT_FAMILY::IGFX_UNKNOWN &&
pInArgs->Platform.ePCHProductFamily == PCH_PRODUCT_FAMILY::PCH_UNKNOWN) { pInArgs->Platform.ePCHProductFamily == PCH_PRODUCT_FAMILY::PCH_UNKNOWN) {
return GMM_ERROR; return GMM_ERROR;
} }
if (copyInputArgs && pInArgs) {
passedInputArgs = *pInArgs;
passedFtrTable = *reinterpret_cast<SKU_FEATURE_TABLE *>(pInArgs->pSkuTable);
passedWaTable = *reinterpret_cast<WA_TABLE *>(pInArgs->pWaTable);
}
return GMM_SUCCESS; return GMM_SUCCESS;
} }
void GMM_STDCALL destroyMockGmm(GMM_INIT_OUT_ARGS *pInArgs) { void GMM_STDCALL GmmAdapterDestroy(GMM_INIT_OUT_ARGS *pInArgs) {
} }
#ifdef __cplusplus
}
#endif

10
unit_tests/mock_gmm/mock_gmm.def
View File

@@ -1,10 +0,0 @@
;
; Copyright (C) 2018-2019 Intel Corporation
;
; SPDX-License-Identifier: MIT
;
LIBRARY "mock_gmm"
EXPORTS
initMockGmm
destroyMockGmm

5
unit_tests/mt_tests/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2017-2019 Intel Corporation # Copyright (C) 2017-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -15,6 +15,7 @@ add_executable(igdrcl_mt_tests EXCLUDE_FROM_ALL
$<TARGET_OBJECTS:igdrcl_libult> $<TARGET_OBJECTS:igdrcl_libult>
$<TARGET_OBJECTS:igdrcl_libult_cs> $<TARGET_OBJECTS:igdrcl_libult_cs>
$<TARGET_OBJECTS:igdrcl_libult_env> $<TARGET_OBJECTS:igdrcl_libult_env>
$<TARGET_OBJECTS:mock_gmm>
$<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}> $<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
) )
@@ -45,7 +46,7 @@ endif()
add_custom_target(run_mt_unit_tests) add_custom_target(run_mt_unit_tests)
add_dependencies(igdrcl_mt_tests test_dynamic_lib mock_gmm) add_dependencies(igdrcl_mt_tests test_dynamic_lib)
create_project_source_tree(igdrcl_mt_tests ${NEO_SOURCE_DIR}/runtime ${NEO_SOURCE_DIR}/unit_tests) create_project_source_tree(igdrcl_mt_tests ${NEO_SOURCE_DIR}/runtime ${NEO_SOURCE_DIR}/unit_tests)

5
unit_tests/os_interface/windows/options.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2017-2019 Intel Corporation * Copyright (C) 2017-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -18,9 +18,6 @@ namespace Os {
const char *frontEndDllName = ""; const char *frontEndDllName = "";
const char *igcDllName = ""; const char *igcDllName = "";
const char *gdiDllName = "gdi32_mock.dll"; const char *gdiDllName = "gdi32_mock.dll";
const char *gmmDllName = "mock_gmm.dll";
const char *gmmInitFuncName = "initMockGmm";
const char *gmmDestroyFuncName = "destroyMockGmm";
const char *testDllName = "test_dynamic_lib.dll"; const char *testDllName = "test_dynamic_lib.dll";
const char *metricsLibraryDllName = ""; const char *metricsLibraryDllName = "";
} // namespace Os } // namespace Os

1
unit_tests/page_fault_manager_tests/CMakeLists.txt
View File

@@ -10,6 +10,7 @@ add_executable(neo_page_fault_manager_tests
$<TARGET_OBJECTS:igdrcl_libult> $<TARGET_OBJECTS:igdrcl_libult>
$<TARGET_OBJECTS:igdrcl_libult_cs> $<TARGET_OBJECTS:igdrcl_libult_cs>
$<TARGET_OBJECTS:igdrcl_libult_env> $<TARGET_OBJECTS:igdrcl_libult_env>
$<TARGET_OBJECTS:mock_gmm>
${NEO_SOURCE_DIR}/runtime/aub/aub_stream_interface.cpp ${NEO_SOURCE_DIR}/runtime/aub/aub_stream_interface.cpp
${NEO_SOURCE_DIR}/unit_tests/libult/os_interface.cpp ${NEO_SOURCE_DIR}/unit_tests/libult/os_interface.cpp
${NEO_SOURCE_DIR}/unit_tests/ult_configuration.cpp ${NEO_SOURCE_DIR}/unit_tests/ult_configuration.cpp

3
unit_tests/windows/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018-2019 Intel Corporation # Copyright (C) 2018-2020 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -10,6 +10,7 @@ project(igdrcl_windows_dll_tests)
set(NEO_IGDRCL_WINDOWS_DLL_TESTS_TARGET_OBJECTS set(NEO_IGDRCL_WINDOWS_DLL_TESTS_TARGET_OBJECTS
$<TARGET_OBJECTS:igdrcl_libult> $<TARGET_OBJECTS:igdrcl_libult>
$<TARGET_OBJECTS:igdrcl_libult_env> $<TARGET_OBJECTS:igdrcl_libult_env>
$<TARGET_OBJECTS:mock_gmm>
) )
add_executable(igdrcl_windows_dll_tests add_executable(igdrcl_windows_dll_tests