mirror of
https://github.com/intel/compute-runtime.git
synced 2025-09-15 13:01:45 +08:00
Refactoring Level Zero ULTs in order to use standalone spirv builtins
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
c8d1e082dd
commit
4804eca86d
@ -67,6 +67,8 @@ add_library(compute_runtime_mockable_extra
|
||||
${CMAKE_CURRENT_LIST_DIR}/l0_tests.cmake
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/utilities/cpuintrinsics.cpp
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/helpers/test_files.cpp
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/mocks/mock_compiler_interface_spirv.cpp
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/mocks/mock_compiler_interface_spirv.h
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/mocks/mock_command_stream_receiver.cpp
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/mocks/mock_device.cpp
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/aub_stream_mocks/aub_stream_interface_mock.cpp
|
||||
|
||||
@ -11,11 +11,6 @@
|
||||
|
||||
namespace L0 {
|
||||
|
||||
std::unique_ptr<BuiltinFunctionsLib> BuiltinFunctionsLib::create(Device *device,
|
||||
NEO::BuiltIns *builtins) {
|
||||
return std::unique_ptr<BuiltinFunctionsLib>(new BuiltinFunctionsLibImpl(device, builtins));
|
||||
}
|
||||
|
||||
std::unique_lock<BuiltinFunctionsLib::MutexType> BuiltinFunctionsLib::obtainUniqueOwnership() {
|
||||
return std::unique_lock<BuiltinFunctionsLib::MutexType>(this->ownershipMutex);
|
||||
}
|
||||
|
||||
@ -36,7 +36,7 @@ struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
|
||||
void initFunctions() override;
|
||||
void initImageFunctions() override;
|
||||
void initPageFaultFunction() override;
|
||||
std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName);
|
||||
MOCKABLE_VIRTUAL std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName);
|
||||
|
||||
protected:
|
||||
std::unique_ptr<BuiltinData> builtins[static_cast<uint32_t>(Builtin::COUNT)];
|
||||
@ -47,10 +47,15 @@ struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
|
||||
NEO::BuiltIns *builtInsLib;
|
||||
};
|
||||
struct BuiltinFunctionsLibImpl::BuiltinData {
|
||||
~BuiltinData() {
|
||||
MOCKABLE_VIRTUAL ~BuiltinData() {
|
||||
func.reset();
|
||||
module.reset();
|
||||
}
|
||||
BuiltinData() = default;
|
||||
BuiltinData(std::unique_ptr<L0::Module> mod, std::unique_ptr<L0::Kernel> ker) {
|
||||
module = std::move(mod);
|
||||
func = std::move(ker);
|
||||
}
|
||||
|
||||
std::unique_ptr<Module> module;
|
||||
std::unique_ptr<Kernel> func;
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
set(L0_SRCS_DLL
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/disallow_deferred_deleter.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/create_builtin_functions_lib.cpp
|
||||
)
|
||||
add_subdirectories()
|
||||
if(WIN32)
|
||||
|
||||
19
level_zero/core/source/dll/create_builtin_functions_lib.cpp
Normal file
19
level_zero/core/source/dll/create_builtin_functions_lib.cpp
Normal file
@ -0,0 +1,19 @@
|
||||
/*
|
||||
* Copyright (C) 2019-2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/built_ins/built_ins.h"
|
||||
|
||||
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
|
||||
|
||||
namespace L0 {
|
||||
|
||||
std::unique_ptr<BuiltinFunctionsLib> BuiltinFunctionsLib::create(Device *device,
|
||||
NEO::BuiltIns *builtins) {
|
||||
return std::unique_ptr<BuiltinFunctionsLib>(new BuiltinFunctionsLibImpl(device, builtins));
|
||||
}
|
||||
|
||||
} // namespace L0
|
||||
@ -29,6 +29,8 @@ add_executable(${TARGET_NAME}
|
||||
${NEO_SOURCE_DIR}/shared/test/unit_test/mocks/ult_device_factory.cpp
|
||||
${NEO_SOURCE_DIR}/shared/test/unit_test/mocks/ult_device_factory.h
|
||||
${L0_CORE_ENABLERS}
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/global_environment.cpp
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/helpers/kernel_binary_helper_hash_value.cpp
|
||||
)
|
||||
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
|
||||
@ -26,7 +26,7 @@ struct ModuleFixture : public DeviceFixture {
|
||||
|
||||
void createModuleFromBinary(ModuleType type = ModuleType::User) {
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, binaryFilename + "_", ".bin");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, binaryFilename + "_", ".bin");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(
|
||||
@ -74,7 +74,7 @@ struct MultiDeviceModuleFixture : public MultiDeviceFixture {
|
||||
|
||||
void createModuleFromBinary(uint32_t rootDeviceIndex) {
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, binaryFilename + "_", ".bin");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, binaryFilename + "_", ".bin");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(testFile.c_str(), size);
|
||||
|
||||
@ -54,6 +54,7 @@ using namespace L0::ult;
|
||||
|
||||
PRODUCT_FAMILY productFamily = NEO::DEFAULT_TEST_PLATFORM::hwInfo.platform.eProductFamily;
|
||||
GFXCORE_FAMILY renderCoreFamily = NEO::DEFAULT_TEST_PLATFORM::hwInfo.platform.eRenderCoreFamily;
|
||||
int32_t revId = -1;
|
||||
|
||||
namespace NEO {
|
||||
extern const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT];
|
||||
@ -187,6 +188,7 @@ int main(int argc, char **argv) {
|
||||
}
|
||||
productFamily = hwInfoForTests.platform.eProductFamily;
|
||||
renderCoreFamily = hwInfoForTests.platform.eRenderCoreFamily;
|
||||
revId = hwInfoForTests.platform.usRevId;
|
||||
|
||||
// Platforms with uninitialized factory are not supported
|
||||
if (L0::commandListFactory[productFamily] == nullptr) {
|
||||
@ -209,12 +211,17 @@ int main(int argc, char **argv) {
|
||||
binaryNameSuffix.append(hwInfoForTests.capabilityTable.platformType);
|
||||
|
||||
std::string testBinaryFiles = getRunPath(argv[0]);
|
||||
testBinaryFiles.append("/level_zero/");
|
||||
testBinaryFiles.append(binaryNameSuffix);
|
||||
std::string testBinaryFilesNoRev = testBinaryFiles;
|
||||
testBinaryFilesNoRev.append("/level_zero/");
|
||||
testBinaryFiles.append("/" + binaryNameSuffix + "/");
|
||||
testBinaryFilesNoRev.append(binaryNameSuffix + "/");
|
||||
|
||||
testBinaryFiles.append(std::to_string(revId));
|
||||
testBinaryFiles.append("/");
|
||||
testBinaryFiles.append(testFiles);
|
||||
testBinaryFilesNoRev.append(testFiles);
|
||||
testFiles = testBinaryFiles;
|
||||
|
||||
testFilesNoRev = testBinaryFilesNoRev;
|
||||
listeners.Append(new NEO::MemoryLeakListener);
|
||||
|
||||
NEO::GmmHelper::createGmmContextWrapperFunc =
|
||||
|
||||
@ -11,6 +11,8 @@ set(L0_MOCKS_SOURCES
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_create.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_built_ins.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_built_ins.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_builtin_functions_lib_impl.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_builtin_functions_lib_impl_timestamps.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_cmdlist.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_cmdlist.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_cmdqueue.h
|
||||
@ -18,6 +20,9 @@ set(L0_MOCKS_SOURCES
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_context.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_device.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_device.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_device_for_spirv.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_device_for_spirv.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_device_recompile_built_ins.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver_handle.h
|
||||
|
||||
@ -0,0 +1,59 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_module.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
|
||||
struct MockBuiltinFunctionsLibImpl : BuiltinFunctionsLibImpl {
|
||||
|
||||
using BuiltinFunctionsLibImpl::builtins;
|
||||
using BuiltinFunctionsLibImpl::getFunction;
|
||||
using BuiltinFunctionsLibImpl::imageBuiltins;
|
||||
MockBuiltinFunctionsLibImpl(L0::Device *device, NEO::BuiltIns *builtInsLib) : BuiltinFunctionsLibImpl(device, builtInsLib) {
|
||||
|
||||
dummyKernel = std::unique_ptr<WhiteBox<::L0::Kernel>>(new Mock<::L0::Kernel>());
|
||||
dummyModule = std::unique_ptr<Module>(new Mock<Module>(device, nullptr));
|
||||
dummyKernel->module = dummyModule.get();
|
||||
}
|
||||
void initFunctions() override {
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
|
||||
builtins[builtId] = loadBuiltIn(NEO::EBuiltInOps::CopyBufferToBuffer, "copyBufferToBufferBytesSingle");
|
||||
}
|
||||
}
|
||||
void initImageFunctions() override {
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
|
||||
imageBuiltins[builtId] = loadBuiltIn(NEO::EBuiltInOps::CopyImage3dToBuffer, "CopyImage3dToBuffer16Bytes");
|
||||
}
|
||||
}
|
||||
void initPageFaultFunction() override {
|
||||
pageFaultBuiltin = loadBuiltIn(NEO::EBuiltInOps::CopyBufferToBuffer, "CopyBufferToBufferSideRegion");
|
||||
}
|
||||
std::unique_ptr<WhiteBox<::L0::Kernel>> dummyKernel;
|
||||
std::unique_ptr<Module> dummyModule;
|
||||
|
||||
Kernel *getFunction(Builtin func) override {
|
||||
return dummyKernel.get();
|
||||
}
|
||||
Kernel *getImageFunction(ImageBuiltin func) override {
|
||||
return dummyKernel.get();
|
||||
}
|
||||
Kernel *getPageFaultFunction() override {
|
||||
return dummyKernel.get();
|
||||
}
|
||||
|
||||
std::unique_ptr<BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName) override {
|
||||
std::unique_ptr<Kernel> mockKernel(new Mock<::L0::Kernel>());
|
||||
std::unique_ptr<Module> mockModule(new Mock<Module>(device, nullptr));
|
||||
|
||||
return std::unique_ptr<BuiltinData>(new BuiltinData{std::move(mockModule), std::move(mockKernel)});
|
||||
}
|
||||
};
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
|
||||
struct MockBuiltinDataTimestamp : BuiltinFunctionsLibImpl::BuiltinData {
|
||||
using BuiltinFunctionsLibImpl::BuiltinData::BuiltinData;
|
||||
|
||||
~MockBuiltinDataTimestamp() {
|
||||
module.release();
|
||||
}
|
||||
};
|
||||
struct MockBuiltinFunctionsLibImplTimestamps : BuiltinFunctionsLibImpl {
|
||||
|
||||
using BuiltinFunctionsLibImpl::BuiltinFunctionsLibImpl;
|
||||
|
||||
void initFunctions() override {
|
||||
builtins[0] = loadBuiltIn(NEO::EBuiltInOps::QueryKernelTimestamps, "QueryKernelTimestamps");
|
||||
builtins[1] = loadBuiltIn(NEO::EBuiltInOps::QueryKernelTimestamps, "QueryKernelTimestampsWithOffsets");
|
||||
}
|
||||
void initImageFunctions() override {}
|
||||
|
||||
void initPageFaultFunction() override {}
|
||||
|
||||
Kernel *getFunction(Builtin func) override {
|
||||
return func == Builtin::QueryKernelTimestampsWithOffsets ? builtins[1]->func.get() : builtins[0]->func.get();
|
||||
}
|
||||
|
||||
std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName) override {
|
||||
using BuiltInCodeType = NEO::BuiltinCode::ECodeType;
|
||||
|
||||
auto builtInCodeType = NEO::DebugManager.flags.RebuildPrecompiledKernels.get() ? BuiltInCodeType::Intermediate : BuiltInCodeType::Binary;
|
||||
auto builtInCode = builtInsLib->getBuiltinsLib().getBuiltinCode(builtin, builtInCodeType, *device->getNEODevice());
|
||||
|
||||
ze_result_t res;
|
||||
std::unique_ptr<Module> module;
|
||||
ze_module_handle_t moduleHandle;
|
||||
ze_module_desc_t moduleDesc = {};
|
||||
moduleDesc.format = builtInCode.type == BuiltInCodeType::Binary ? ZE_MODULE_FORMAT_NATIVE : ZE_MODULE_FORMAT_IL_SPIRV;
|
||||
moduleDesc.pInputModule = reinterpret_cast<uint8_t *>(&builtInCode.resource[0]);
|
||||
moduleDesc.inputSize = builtInCode.resource.size();
|
||||
res = device->createModule(&moduleDesc, &moduleHandle, nullptr, ModuleType::Builtin);
|
||||
UNRECOVERABLE_IF(res != ZE_RESULT_SUCCESS);
|
||||
|
||||
module.reset(Module::fromHandle(moduleHandle));
|
||||
|
||||
std::unique_ptr<Kernel> kernel;
|
||||
ze_kernel_handle_t kernelHandle;
|
||||
ze_kernel_desc_t kernelDesc = {};
|
||||
kernelDesc.pKernelName = builtInName;
|
||||
res = module->createKernel(&kernelDesc, &kernelHandle);
|
||||
DEBUG_BREAK_IF(res != ZE_RESULT_SUCCESS);
|
||||
UNUSED_VARIABLE(res);
|
||||
kernel.reset(Kernel::fromHandle(kernelHandle));
|
||||
return std::unique_ptr<BuiltinData>(new MockBuiltinDataTimestamp{std::move(module), std::move(kernel)});
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_device_for_spirv.h"
|
||||
|
||||
#include "shared/source/helpers/file_io.h"
|
||||
#include "shared/test/unit_test/helpers/test_files.h"
|
||||
|
||||
#include "opencl/test/unit_test/global_environment.h"
|
||||
#include "opencl/test/unit_test/helpers/kernel_binary_helper.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
template <bool useImagesBuiltins>
|
||||
ze_result_t MockDeviceForSpv<useImagesBuiltins>::createModule(const ze_module_desc_t *desc, ze_module_handle_t *module,
|
||||
ze_module_build_log_handle_t *buildLog, ModuleType type) {
|
||||
if (!wasModuleCreated) {
|
||||
|
||||
std::string kernelName;
|
||||
retrieveBinaryKernelFilename(kernelName, (useImagesBuiltins ? KernelBinaryHelper::BUILT_INS_WITH_IMAGES : KernelBinaryHelper::BUILT_INS) + "_", ".gen");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(
|
||||
kernelName.c_str(),
|
||||
size);
|
||||
|
||||
ze_module_desc_t moduleDesc = {};
|
||||
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
|
||||
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
|
||||
moduleDesc.inputSize = size;
|
||||
|
||||
ModuleBuildLog *moduleBuildLog = nullptr;
|
||||
|
||||
mockModulePtr.reset(Module::create(this, &moduleDesc, moduleBuildLog, ModuleType::Builtin));
|
||||
wasModuleCreated = true;
|
||||
}
|
||||
*module = mockModulePtr.get();
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
template class MockDeviceForSpv<true>;
|
||||
template class MockDeviceForSpv<false>;
|
||||
}; // namespace ult
|
||||
} // namespace L0
|
||||
@ -0,0 +1,33 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/source/driver/driver_handle_imp.h"
|
||||
#include "level_zero/core/source/module/module.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
|
||||
template <bool useImagesBuiltins>
|
||||
class MockDeviceForSpv : public Mock<DeviceImp> {
|
||||
protected:
|
||||
bool wasModuleCreated;
|
||||
std::unique_ptr<L0::Module> mockModulePtr;
|
||||
|
||||
public:
|
||||
MockDeviceForSpv(NEO::Device *device, NEO::ExecutionEnvironment *ex, L0::DriverHandleImp *driverHandle) : Mock<DeviceImp>(device, ex) {
|
||||
this->driverHandle = driverHandle;
|
||||
wasModuleCreated = false;
|
||||
}
|
||||
ze_result_t createModule(const ze_module_desc_t *desc, ze_module_handle_t *module,
|
||||
ze_module_build_log_handle_t *buildLog, ModuleType type) override;
|
||||
~MockDeviceForSpv() {
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
@ -0,0 +1,48 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/source/device/device_imp.h"
|
||||
#include "level_zero/core/source/module/module_imp.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
|
||||
struct MockDeviceForRebuildBuilins : public Mock<DeviceImp> {
|
||||
|
||||
struct MockModuleForRebuildBuiltins : public ModuleImp {
|
||||
MockModuleForRebuildBuiltins(Device *device) : ModuleImp(device, nullptr) {}
|
||||
|
||||
ze_result_t createKernel(const ze_kernel_desc_t *desc,
|
||||
ze_kernel_handle_t *phFunction) override {
|
||||
|
||||
*phFunction = nullptr;
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
};
|
||||
|
||||
MockDeviceForRebuildBuilins(L0::Device *device) : Mock(device->getNEODevice(), static_cast<NEO::ExecutionEnvironment *>(device->getExecEnvironment())) {
|
||||
driverHandle = device->getDriverHandle();
|
||||
builtins = BuiltinFunctionsLib::create(this, neoDevice->getBuiltIns());
|
||||
}
|
||||
~MockDeviceForRebuildBuilins() {
|
||||
}
|
||||
|
||||
ze_result_t createModule(const ze_module_desc_t *desc,
|
||||
ze_module_handle_t *module,
|
||||
ze_module_build_log_handle_t *buildLog) override {
|
||||
|
||||
createModuleCalled = true;
|
||||
*module = new MockModuleForRebuildBuiltins(this);
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
bool createModuleCalled = false;
|
||||
};
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
@ -102,6 +102,7 @@ struct Mock<::L0::Kernel> : public WhiteBox<::L0::Kernel> {
|
||||
kernelTokens.header = &kernelHeader;
|
||||
|
||||
iOpenCL::SPatchExecutionEnvironment execEnv = {};
|
||||
execEnv.LargestCompiledSIMDSize = 8;
|
||||
kernelTokens.tokens.executionEnvironment = &execEnv;
|
||||
|
||||
this->kernelImmData = &immutableData;
|
||||
@ -125,6 +126,9 @@ struct Mock<::L0::Kernel> : public WhiteBox<::L0::Kernel> {
|
||||
std::unique_ptr<Kernel> clone() const override {
|
||||
return nullptr;
|
||||
}
|
||||
ze_result_t setArgBufferWithAlloc(uint32_t argIndex, uintptr_t argVal, NEO::GraphicsAllocation *allocation) override {
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
void printPrintfOutput() override {
|
||||
printPrintfOutputCalledTimes++;
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/create_ult_builtin_functions_lib.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/built_in_tests_l0.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/builtin_functions_tests.cpp
|
||||
)
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
#include "shared/source/built_ins/built_ins.h"
|
||||
#include "shared/source/execution_environment/root_device_environment.h"
|
||||
#include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
|
||||
#include "shared/test/unit_test/mocks/mock_compiler_interface.h"
|
||||
#include "shared/test/unit_test/mocks/mock_compiler_interface_spirv.h"
|
||||
|
||||
#include "test.h"
|
||||
|
||||
@ -17,37 +17,78 @@
|
||||
#include "level_zero/core/source/module/module.h"
|
||||
#include "level_zero/core/source/module/module_imp.h"
|
||||
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_device_for_spirv.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
template <bool useImagesBuiltins>
|
||||
class TestBuiltinFunctionsLibImpl : public DeviceFixture, public testing::Test {
|
||||
public:
|
||||
struct MockBuiltinFunctionsLibImpl : BuiltinFunctionsLibImpl {
|
||||
|
||||
using BuiltinFunctionsLibImpl::builtins;
|
||||
using BuiltinFunctionsLibImpl::getFunction;
|
||||
using BuiltinFunctionsLibImpl::imageBuiltins;
|
||||
MockBuiltinFunctionsLibImpl(L0::Device *device, NEO::BuiltIns *builtInsLib) : BuiltinFunctionsLibImpl(device, builtInsLib) {}
|
||||
};
|
||||
std::unique_ptr<BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName) override {
|
||||
ze_result_t res;
|
||||
std::unique_ptr<Module> module;
|
||||
ze_module_handle_t moduleHandle;
|
||||
ze_module_desc_t moduleDesc = {};
|
||||
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
|
||||
moduleDesc.pInputModule = nullptr;
|
||||
moduleDesc.inputSize = 0u;
|
||||
res = device->createModule(&moduleDesc, &moduleHandle, nullptr, ModuleType::Builtin);
|
||||
UNRECOVERABLE_IF(res != ZE_RESULT_SUCCESS);
|
||||
|
||||
module.reset(Module::fromHandle(moduleHandle));
|
||||
|
||||
std::unique_ptr<Kernel> kernel;
|
||||
ze_kernel_handle_t kernelHandle;
|
||||
ze_kernel_desc_t kernelDesc = {};
|
||||
kernelDesc.pKernelName = builtInName;
|
||||
res = module->createKernel(&kernelDesc, &kernelHandle);
|
||||
DEBUG_BREAK_IF(res != ZE_RESULT_SUCCESS);
|
||||
UNUSED_VARIABLE(res);
|
||||
kernel.reset(Kernel::fromHandle(kernelHandle));
|
||||
|
||||
return std::unique_ptr<BuiltinData>(new MockBuiltinData{std::move(module), std::move(kernel)});
|
||||
}
|
||||
};
|
||||
struct MockBuiltinData : BuiltinFunctionsLibImpl::BuiltinData {
|
||||
using BuiltinFunctionsLibImpl::BuiltinData::func;
|
||||
using BuiltinFunctionsLibImpl::BuiltinData::module;
|
||||
MockBuiltinData(std::unique_ptr<L0::Module> mod, std::unique_ptr<L0::Kernel> ker) {
|
||||
module = std::move(mod);
|
||||
func = std::move(ker);
|
||||
}
|
||||
~MockBuiltinData() override {
|
||||
module.release();
|
||||
}
|
||||
};
|
||||
void SetUp() override {
|
||||
DeviceFixture::SetUp();
|
||||
mockBuiltinFunctionsLibImpl.reset(new MockBuiltinFunctionsLibImpl(device, neoDevice->getBuiltIns()));
|
||||
mockDevicePtr = std::unique_ptr<MockDeviceForSpv<useImagesBuiltins>>(new MockDeviceForSpv<useImagesBuiltins>(device->getNEODevice(), device->getNEODevice()->getExecutionEnvironment(), driverHandle.get()));
|
||||
mockBuiltinFunctionsLibImpl.reset(new MockBuiltinFunctionsLibImpl(mockDevicePtr.get(), neoDevice->getBuiltIns()));
|
||||
}
|
||||
void TearDown() override {
|
||||
mockBuiltinFunctionsLibImpl.reset();
|
||||
DeviceFixture::TearDown();
|
||||
}
|
||||
|
||||
std::unique_ptr<MockBuiltinFunctionsLibImpl> mockBuiltinFunctionsLibImpl;
|
||||
std::unique_ptr<MockDeviceForSpv<useImagesBuiltins>> mockDevicePtr;
|
||||
};
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitImageFunctionWhenImageBultinsTableContainNullptrsAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
|
||||
class TestBuiltinFunctionsLibImplDefault : public TestBuiltinFunctionsLibImpl<false> {};
|
||||
class TestBuiltinFunctionsLibImplImages : public TestBuiltinFunctionsLibImpl<true> {};
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplImages, givenInitImageFunctionWhenImageBultinsTableContainNullptrsAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
|
||||
EXPECT_EQ(nullptr, mockBuiltinFunctionsLibImpl->imageBuiltins[builtId]);
|
||||
}
|
||||
if (device->getHwInfo().capabilityTable.supportsImages) {
|
||||
if (mockDevicePtr.get()->getHwInfo().capabilityTable.supportsImages) {
|
||||
mockBuiltinFunctionsLibImpl->initImageFunctions();
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
|
||||
EXPECT_NE(nullptr, mockBuiltinFunctionsLibImpl->imageBuiltins[builtId]);
|
||||
@ -56,7 +97,7 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitImageFunctionWhenImageBultinsTabl
|
||||
}
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitFunctionWhenBultinsTableContainNullptrsThenBuiltinsFunctionsAreLoaded) {
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, givenInitFunctionWhenBultinsTableContainNullptrsThenBuiltinsFunctionsAreLoaded) {
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
|
||||
EXPECT_EQ(nullptr, mockBuiltinFunctionsLibImpl->builtins[builtId]);
|
||||
}
|
||||
@ -67,8 +108,8 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitFunctionWhenBultinsTableContainNu
|
||||
}
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
|
||||
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterface());
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, givenCompilerInterfaceWhenCreateDeviceAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
|
||||
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterfaceSpirv());
|
||||
std::unique_ptr<L0::Device> testDevice(Device::create(device->getDriverHandle(), neoDevice, std::numeric_limits<uint32_t>::max(), false));
|
||||
|
||||
if (device->getHwInfo().capabilityTable.supportsImages) {
|
||||
@ -78,8 +119,8 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceAndI
|
||||
}
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceThenBuiltinsFunctionsAreLoaded) {
|
||||
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterface());
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, givenCompilerInterfaceWhenCreateDeviceThenBuiltinsFunctionsAreLoaded) {
|
||||
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterfaceSpirv());
|
||||
std::unique_ptr<L0::Device> testDevice(Device::create(device->getDriverHandle(), neoDevice, std::numeric_limits<uint32_t>::max(), false));
|
||||
|
||||
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
|
||||
@ -87,7 +128,7 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceThen
|
||||
}
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenRebuildPrecompiledKernelsDebugFlagWhenInitFuctionsThenIntermediateCodeForBuiltinsIsRequested) {
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, givenRebuildPrecompiledKernelsDebugFlagWhenInitFuctionsThenIntermediateCodeForBuiltinsIsRequested) {
|
||||
struct MockDeviceForRebuildBuilins : public Mock<DeviceImp> {
|
||||
struct MockModuleForRebuildBuiltins : public ModuleImp {
|
||||
MockModuleForRebuildBuiltins(Device *device) : ModuleImp(device, nullptr, ModuleType::Builtin) {}
|
||||
@ -110,26 +151,26 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenRebuildPrecompiledKernelsDebugFlagWhe
|
||||
EXPECT_EQ(desc->format, ZE_MODULE_FORMAT_IL_SPIRV);
|
||||
EXPECT_GT(desc->inputSize, 0u);
|
||||
EXPECT_NE(desc->pInputModule, nullptr);
|
||||
wasCreatedModuleCalled = true;
|
||||
createModuleCalled = true;
|
||||
|
||||
*module = new MockModuleForRebuildBuiltins(this);
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
bool wasCreatedModuleCalled = false;
|
||||
bool createModuleCalled = false;
|
||||
};
|
||||
|
||||
DebugManagerStateRestore dgbRestorer;
|
||||
NEO::DebugManager.flags.RebuildPrecompiledKernels.set(true);
|
||||
MockDeviceForRebuildBuilins testDevice(device);
|
||||
|
||||
testDevice.builtins.reset(new BuiltinFunctionsLibImpl(&testDevice, neoDevice->getBuiltIns()));
|
||||
testDevice.getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
EXPECT_TRUE(testDevice.wasCreatedModuleCalled);
|
||||
EXPECT_TRUE(testDevice.createModuleCalled);
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, givenNotToRebuildPrecompiledKernelsDebugFlagWhenInitFuctionsThenNativeCodeForBuiltinsIsRequested) {
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, givenNotToRebuildPrecompiledKernelsDebugFlagWhenInitFuctionsThenNativeCodeForBuiltinsIsRequested) {
|
||||
struct MockDeviceForRebuildBuilins : public Mock<DeviceImp> {
|
||||
MockDeviceForRebuildBuilins(L0::Device *device) : Mock(device->getNEODevice(), static_cast<NEO::ExecutionEnvironment *>(device->getExecEnvironment())) {
|
||||
driverHandle = device->getDriverHandle();
|
||||
@ -142,24 +183,25 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenNotToRebuildPrecompiledKernelsDebugFl
|
||||
EXPECT_EQ(desc->format, ZE_MODULE_FORMAT_NATIVE);
|
||||
EXPECT_GT(desc->inputSize, 0u);
|
||||
EXPECT_NE(desc->pInputModule, nullptr);
|
||||
wasCreatedModuleCalled = true;
|
||||
createModuleCalled = true;
|
||||
|
||||
return DeviceImp::createModule(desc, module, buildLog, type);
|
||||
}
|
||||
|
||||
bool wasCreatedModuleCalled = false;
|
||||
bool createModuleCalled = false;
|
||||
};
|
||||
|
||||
DebugManagerStateRestore dgbRestorer;
|
||||
NEO::DebugManager.flags.RebuildPrecompiledKernels.set(false);
|
||||
MockDeviceForRebuildBuilins testDevice(device);
|
||||
|
||||
L0::Device *testDevicePtr = &testDevice;
|
||||
testDevice.builtins.reset(new BuiltinFunctionsLibImpl(testDevicePtr, neoDevice->getBuiltIns()));
|
||||
testDevice.getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
EXPECT_TRUE(testDevice.wasCreatedModuleCalled);
|
||||
EXPECT_TRUE(testDevice.createModuleCalled);
|
||||
}
|
||||
|
||||
HWTEST_F(TestBuiltinFunctionsLibImpl, GivenBuiltinsWhenInitializingFunctionsThenModulesWithProperTypeAreCreated) {
|
||||
HWTEST_F(TestBuiltinFunctionsLibImplDefault, GivenBuiltinsWhenInitializingFunctionsThenModulesWithProperTypeAreCreated) {
|
||||
struct MockDeviceWithBuilins : public Mock<DeviceImp> {
|
||||
MockDeviceWithBuilins(L0::Device *device) : Mock(device->getNEODevice(), static_cast<NEO::ExecutionEnvironment *>(device->getExecEnvironment())) {
|
||||
driverHandle = device->getDriverHandle();
|
||||
@ -180,6 +222,8 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, GivenBuiltinsWhenInitializingFunctionsThen
|
||||
};
|
||||
|
||||
MockDeviceWithBuilins testDevice(device);
|
||||
L0::Device *testDevicePtr = &testDevice;
|
||||
testDevice.builtins.reset(new BuiltinFunctionsLibImpl(testDevicePtr, neoDevice->getBuiltIns()));
|
||||
testDevice.getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
EXPECT_EQ(ModuleType::Builtin, testDevice.typeCreated);
|
||||
|
||||
@ -0,0 +1,20 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/built_ins/built_ins.h"
|
||||
|
||||
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_builtin_functions_lib_impl.h"
|
||||
|
||||
namespace L0 {
|
||||
|
||||
std::unique_ptr<BuiltinFunctionsLib> BuiltinFunctionsLib::create(Device *device,
|
||||
NEO::BuiltIns *builtins) {
|
||||
return std::unique_ptr<BuiltinFunctionsLib>(new ult::MockBuiltinFunctionsLibImpl(device, builtins));
|
||||
}
|
||||
|
||||
} // namespace L0
|
||||
@ -17,7 +17,9 @@
|
||||
#include "level_zero/core/source/cmdqueue/cmdqueue_imp.h"
|
||||
#include "level_zero/core/source/kernel/kernel_imp.h"
|
||||
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_builtin_functions_lib_impl_timestamps.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_device_for_spirv.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_event.h"
|
||||
|
||||
namespace L0 {
|
||||
@ -519,17 +521,24 @@ using AppendQueryKernelTimestamps = CommandListCreate;
|
||||
using TestPlatforms = IsAtLeastProduct<IGFX_SKYLAKE>;
|
||||
|
||||
HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTimestampsWithoutOffsetsThenProperBuiltinWasAdded, TestPlatforms) {
|
||||
std::unique_ptr<MockDeviceForSpv<false>> testDevice = std::unique_ptr<MockDeviceForSpv<false>>(new MockDeviceForSpv<false>(device->getNEODevice(), device->getNEODevice()->getExecutionEnvironment(), driverHandle.get()));
|
||||
testDevice->builtins.reset(new MockBuiltinFunctionsLibImplTimestamps(testDevice.get(), testDevice->getNEODevice()->getBuiltIns()));
|
||||
testDevice->getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
device = testDevice.get();
|
||||
|
||||
MockCommandListForAppendLaunchKernel<gfxCoreFamily> commandList;
|
||||
commandList.initialize(device, NEO::EngineGroupType::RenderCompute);
|
||||
|
||||
device->getBuiltinFunctionsLib()->initFunctions();
|
||||
MockEvent event;
|
||||
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
event.signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
|
||||
void *alloc;
|
||||
|
||||
ze_device_mem_alloc_desc_t deviceDesc = {};
|
||||
auto result = driverHandle->allocDeviceMem(device, &deviceDesc, 128, 1, &alloc);
|
||||
|
||||
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
|
||||
ze_event_handle_t events[2] = {event.toHandle(), event.toHandle()};
|
||||
|
||||
@ -546,7 +555,7 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
|
||||
|
||||
EXPECT_TRUE(containsDstPtr);
|
||||
|
||||
EXPECT_EQ(device->getBuiltinFunctionsLib()->getFunction(Builtin::QueryKernelTimestamps)->getIsaAllocation()->getGpuAddress(), commandList.cmdListHelper.isaAllocation->getGpuAddress());
|
||||
EXPECT_EQ(testDevice->getBuiltinFunctionsLib()->getFunction(Builtin::QueryKernelTimestamps)->getIsaAllocation()->getGpuAddress(), commandList.cmdListHelper.isaAllocation->getGpuAddress());
|
||||
EXPECT_EQ(2u, commandList.cmdListHelper.groupSize[0]);
|
||||
EXPECT_EQ(1u, commandList.cmdListHelper.groupSize[1]);
|
||||
EXPECT_EQ(1u, commandList.cmdListHelper.groupSize[2]);
|
||||
@ -561,10 +570,15 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
|
||||
}
|
||||
|
||||
HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTimestampsWithOffsetsThenProperBuiltinWasAdded, TestPlatforms) {
|
||||
std::unique_ptr<MockDeviceForSpv<false>> testDevice = std::unique_ptr<MockDeviceForSpv<false>>(new MockDeviceForSpv<false>(device->getNEODevice(), device->getNEODevice()->getExecutionEnvironment(), driverHandle.get()));
|
||||
testDevice->builtins.reset(new MockBuiltinFunctionsLibImplTimestamps(testDevice.get(), testDevice->getNEODevice()->getBuiltIns()));
|
||||
testDevice->getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
device = testDevice.get();
|
||||
|
||||
MockCommandListForAppendLaunchKernel<gfxCoreFamily> commandList;
|
||||
commandList.initialize(device, NEO::EngineGroupType::RenderCompute);
|
||||
|
||||
device->getBuiltinFunctionsLib()->initFunctions();
|
||||
MockEvent event;
|
||||
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
event.signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
@ -618,10 +632,15 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
|
||||
}
|
||||
|
||||
HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTimestampsWithEventsNumberBiggerThanMaxWorkItemSizeThenProperGroupSizeAndGroupCountIsSet, TestPlatforms) {
|
||||
std::unique_ptr<MockDeviceForSpv<false>> testDevice = std::unique_ptr<MockDeviceForSpv<false>>(new MockDeviceForSpv<false>(device->getNEODevice(), device->getNEODevice()->getExecutionEnvironment(), driverHandle.get()));
|
||||
testDevice->builtins.reset(new MockBuiltinFunctionsLibImplTimestamps(testDevice.get(), testDevice->getNEODevice()->getBuiltIns()));
|
||||
testDevice->getBuiltinFunctionsLib()->initFunctions();
|
||||
|
||||
device = testDevice.get();
|
||||
|
||||
MockCommandListForAppendLaunchKernel<gfxCoreFamily> commandList;
|
||||
commandList.initialize(device, NEO::EngineGroupType::RenderCompute);
|
||||
|
||||
device->getBuiltinFunctionsLib()->initFunctions();
|
||||
MockEvent event;
|
||||
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
event.signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
|
||||
@ -607,6 +607,31 @@ TEST_F(KernelIsaTests, givenDebugONAndKernelDegugInfoWhenInitializingImmutableDa
|
||||
EXPECT_EQ(kernelInfo.kernelDescriptor.external.debugData->vIsaSize, static_cast<uint32_t>(123));
|
||||
}
|
||||
|
||||
TEST_F(KernelIsaTests, givenDebugONAndNoKernelDegugInfoWhenInitializingImmutableDataThenDoNotRegisterElf) {
|
||||
uint32_t kernelHeap = 0;
|
||||
KernelInfo kernelInfo;
|
||||
kernelInfo.heapInfo.KernelHeapSize = 1;
|
||||
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
|
||||
kernelInfo.kernelDescriptor.external.debugData.reset(nullptr);
|
||||
class MockDebugger : public DebuggerL0 {
|
||||
public:
|
||||
MockDebugger(NEO::Device *neodev) : DebuggerL0(neodev) {
|
||||
}
|
||||
void registerElf(NEO::DebugData *debugData, NEO::GraphicsAllocation *isaAllocation) override {
|
||||
debugData->vIsaSize = 123;
|
||||
};
|
||||
size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override { return static_cast<size_t>(0); };
|
||||
void programSbaTrackingCommands(NEO::LinearStream &cmdStream, const SbaAddresses &sba) override{};
|
||||
};
|
||||
MockDebugger *debugger = new MockDebugger(neoDevice);
|
||||
|
||||
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(static_cast<NEO::Debugger *>(debugger));
|
||||
KernelImmutableData kernelImmutableData(device);
|
||||
|
||||
kernelImmutableData.initialize(&kernelInfo, device, 0, nullptr, nullptr, false);
|
||||
EXPECT_EQ(kernelInfo.kernelDescriptor.external.debugData, nullptr);
|
||||
}
|
||||
|
||||
using KernelImpPatchBindlessTest = Test<ModuleFixture>;
|
||||
|
||||
TEST_F(KernelImpPatchBindlessTest, GivenKernelImpWhenPatchBindlessOffsetCalledThenOffsetPatchedCorrectly) {
|
||||
@ -700,9 +725,11 @@ struct MyMockKernel : public Mock<Kernel> {
|
||||
void setBufferSurfaceState(uint32_t argIndex, void *address, NEO::GraphicsAllocation *alloc) override {
|
||||
setSurfaceStateCalled = true;
|
||||
}
|
||||
ze_result_t setArgBufferWithAlloc(uint32_t argIndex, uintptr_t argVal, NEO::GraphicsAllocation *allocation) override {
|
||||
return KernelImp::setArgBufferWithAlloc(argIndex, argVal, allocation);
|
||||
}
|
||||
bool setSurfaceStateCalled = false;
|
||||
};
|
||||
|
||||
TEST_F(KernelImpPatchBindlessTest, GivenValidBindlessOffsetWhenSetArgBufferWithAllocThensetBufferSurfaceStateCalled) {
|
||||
ze_kernel_desc_t desc = {};
|
||||
desc.pKernelName = kernelName.c_str();
|
||||
|
||||
@ -257,7 +257,7 @@ struct ModuleSpecConstantsTests : public DeviceFixture,
|
||||
|
||||
HWTEST_F(ModuleSpecConstantsTests, givenSpecializationConstantsSetInDescriptorTheModuleCorrectlyPassesThemToTheCompiler) {
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, binaryFilename + "_", ".spv");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, binaryFilename + "_", ".spv");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(testFile.c_str(), size);
|
||||
@ -610,7 +610,7 @@ using ContextModuleCreateTest = Test<ContextFixture>;
|
||||
|
||||
HWTEST_F(ContextModuleCreateTest, givenCallToCreateModuleThenModuleIsReturned) {
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, "test_kernel_", ".bin");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, "test_kernel_", ".bin");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(testFile.c_str(), size);
|
||||
@ -658,7 +658,8 @@ HWTEST_F(ModuleTranslationUnitTest, GivenRebuildPrecompiledKernelsFlagAndFileWit
|
||||
NEO::DebugManager.flags.RebuildPrecompiledKernels.set(true);
|
||||
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, "test_kernel_", ".gen");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, "test_kernel_", ".gen");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(testFile.c_str(), size);
|
||||
|
||||
@ -685,7 +686,8 @@ HWTEST_F(ModuleTranslationUnitTest, GivenRebuildPrecompiledKernelsFlagAndFileWit
|
||||
NEO::DebugManager.flags.RebuildPrecompiledKernels.set(true);
|
||||
|
||||
std::string testFile;
|
||||
retrieveBinaryKernelFilename(testFile, "test_kernel_", ".bin");
|
||||
retrieveBinaryKernelFilenameNoRevision(testFile, "test_kernel_", ".bin");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(testFile.c_str(), size);
|
||||
|
||||
|
||||
@ -32,6 +32,9 @@ add_executable(
|
||||
${NEO_SOURCE_DIR}/shared/test/unit_test/mocks/ult_device_factory.cpp
|
||||
${NEO_SOURCE_DIR}/shared/test/unit_test/mocks/ult_device_factory.h
|
||||
${L0_CORE_ENABLERS}
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/global_environment.cpp
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/helpers/kernel_binary_helper_hash_value.cpp
|
||||
${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/sources/builtin/create_ult_builtin_functions_lib.cpp
|
||||
)
|
||||
|
||||
target_sources(
|
||||
|
||||
@ -36,10 +36,12 @@ target_sources(${TARGET_NAME} PRIVATE
|
||||
${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/test_mode.h
|
||||
${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/ult_configuration.cpp
|
||||
${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/white_box.h
|
||||
${NEO_SOURCE_DIR}/level_zero/core/source/dll/create_builtin_functions_lib.cpp
|
||||
${NEO_SHARED_TEST_DIRECTORY}/unit_test/tests_configuration.h
|
||||
)
|
||||
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/helpers${BRANCH_DIR_SUFFIX}/kernel_binary_helper_hash_value.cpp
|
||||
${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/libult/create_command_stream.cpp
|
||||
${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/libult/io_functions.cpp
|
||||
${NEO_SOURCE_DIR}/opencl/test/unit_test/global_environment.cpp
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
#
|
||||
|
||||
set(SHARED_TEST_PROJECTS_FOLDER "neo shared")
|
||||
if(NOT SKIP_NEO_UNIT_TESTS AND NOT SKIP_UNIT_TESTS)
|
||||
if(NOT SKIP_UNIT_TESTS)
|
||||
|
||||
set(TARGET_NAME neo_shared_tests)
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include "config.h"
|
||||
|
||||
std::string testFiles("test_files/" NEO_ARCH "/");
|
||||
std::string testFilesNoRev("test_files/" NEO_ARCH "/");
|
||||
std::string clFiles("test_files/");
|
||||
std::string binaryNameSuffix("");
|
||||
|
||||
@ -30,3 +31,19 @@ void retrieveBinaryKernelFilename(std::string &outputFilename, const std::string
|
||||
retrieveBinaryKernelFilename(outputFilename, kernelName, ".spv", options);
|
||||
}
|
||||
}
|
||||
|
||||
void retrieveBinaryKernelFilenameNoRevision(std::string &outputFilename, const std::string &kernelName, const std::string &extension, const std::string &options) {
|
||||
if (outputFilename.length() > 0) {
|
||||
outputFilename.clear();
|
||||
}
|
||||
outputFilename.reserve(2 * testFilesNoRev.length());
|
||||
outputFilename.append(testFilesNoRev);
|
||||
outputFilename.append(kernelName);
|
||||
outputFilename.append(binaryNameSuffix);
|
||||
outputFilename.append(extension);
|
||||
outputFilename.append(options);
|
||||
|
||||
if (!fileExists(outputFilename) && (extension == ".bc")) {
|
||||
retrieveBinaryKernelFilename(outputFilename, kernelName, ".spv", options);
|
||||
}
|
||||
}
|
||||
@ -9,7 +9,9 @@
|
||||
#include <string>
|
||||
|
||||
extern std::string testFiles;
|
||||
extern std::string testFilesNoRev;
|
||||
extern std::string clFiles;
|
||||
extern std::string binaryNameSuffix;
|
||||
|
||||
void retrieveBinaryKernelFilename(std::string &outputFilename, const std::string &kernelName, const std::string &extension, const std::string &options = "");
|
||||
void retrieveBinaryKernelFilenameNoRevision(std::string &outputFilename, const std::string &kernelName, const std::string &extension, const std::string &options = "");
|
||||
|
||||
@ -8,6 +8,8 @@ set(NEO_CORE_tests_mocks
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_command_stream_receiver.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_command_stream_receiver.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_compiler_interface_spirv.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_compiler_interface_spirv.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_direct_submission_hw.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_direct_submission_diagnostic_collector.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_dispatch_kernel_encoder_interface.cpp
|
||||
|
||||
@ -0,0 +1,34 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/test/unit_test/mocks/mock_compiler_interface_spirv.h"
|
||||
|
||||
#include "shared/source/helpers/file_io.h"
|
||||
#include "shared/test/unit_test/helpers/test_files.h"
|
||||
|
||||
#include "opencl/test/unit_test/global_environment.h"
|
||||
#include "opencl/test/unit_test/helpers/kernel_binary_helper.h"
|
||||
|
||||
namespace NEO {
|
||||
TranslationOutput::ErrorCode MockCompilerInterfaceSpirv::compile(const NEO::Device &device, const TranslationInput &input, TranslationOutput &output) {
|
||||
std::string kernelName;
|
||||
retrieveBinaryKernelFilename(kernelName, KernelBinaryHelper::BUILT_INS + "_", ".gen");
|
||||
|
||||
size_t size = 0;
|
||||
auto src = loadDataFromFile(
|
||||
kernelName.c_str(),
|
||||
size);
|
||||
output.deviceBinary.mem = std::move(src);
|
||||
output.deviceBinary.size = size;
|
||||
output.intermediateCodeType = IGC::CodeType::spirV;
|
||||
|
||||
return TranslationOutput::ErrorCode::Success;
|
||||
}
|
||||
TranslationOutput::ErrorCode MockCompilerInterfaceSpirv::build(const NEO::Device &device, const TranslationInput &input, TranslationOutput &out) {
|
||||
return this->compile(device, input, out);
|
||||
}
|
||||
} // namespace NEO
|
||||
18
shared/test/unit_test/mocks/mock_compiler_interface_spirv.h
Normal file
18
shared/test/unit_test/mocks/mock_compiler_interface_spirv.h
Normal file
@ -0,0 +1,18 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/test/unit_test/mocks/mock_compiler_interface.h"
|
||||
|
||||
#include "cif/common/cif_main.h"
|
||||
|
||||
namespace NEO {
|
||||
class MockCompilerInterfaceSpirv : public MockCompilerInterface {
|
||||
TranslationOutput::ErrorCode compile(const NEO::Device &device, const TranslationInput &input, TranslationOutput &output) override;
|
||||
TranslationOutput::ErrorCode build(const NEO::Device &device, const TranslationInput &input, TranslationOutput &out) override;
|
||||
};
|
||||
} // namespace NEO
|
||||
Reference in New Issue
Block a user