Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Require exact revision when getting binary builtin for PVC 

this change also implements logic for recompilation of builtin from spv in L0
in case when binary resource is not available


Related-To: NEO-6170
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2021-12-22 15:32:45 +00:00 committed by Compute-Runtime-Automation
parent c92a4acc01
commit 896e01c1cb
19 changed files with 261 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
level_zero/core/source/builtin/builtin_functions_lib_impl.cpp
View File

@ -227,16 +227,28 @@ Kernel *BuiltinFunctionsLibImpl::getImageFunction(ImageBuiltin func) {
std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> BuiltinFunctionsLibImpl::loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName) {
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());
StackVec<BuiltInCodeType, 2> supportedTypes{};
if (!NEO::DebugManager.flags.RebuildPrecompiledKernels.get()) {
supportedTypes.push_back(BuiltInCodeType::Binary);
}
supportedTypes.push_back(BuiltInCodeType::Intermediate);
NEO::BuiltinCode builtinCode{};
for (auto &builtinCodeType : supportedTypes) {
builtinCode = builtInsLib->getBuiltinsLib().getBuiltinCode(builtin, builtinCodeType, *device->getNEODevice());
if (!builtinCode.resource.empty()) {
break;
}
}
[[maybe_unused]] 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();
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);

23
level_zero/core/test/unit_tests/mocks/mock_device_recompile_built_ins.h
View File

@ -5,9 +5,9 @@
*
*/
#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"
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
namespace L0 {
namespace ult {
@ -15,34 +15,31 @@ namespace ult {
struct MockDeviceForRebuildBuilins : public Mock<DeviceImp> {
struct MockModuleForRebuildBuiltins : public ModuleImp {
MockModuleForRebuildBuiltins(Device *device) : ModuleImp(device, nullptr) {}
MockModuleForRebuildBuiltins(Device *device, ModuleType type) : ModuleImp(device, nullptr, type) {}
ze_result_t createKernel(const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phFunction) override {
*phFunction = nullptr;
*phFunction = new Mock<Kernel>();
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() {
MockDeviceForRebuildBuilins(NEO::Device *device) : Mock(device, device->getExecutionEnvironment()) {
}
ze_result_t createModule(const ze_module_desc_t *desc,
ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) override {
ze_module_build_log_handle_t *buildLog, ModuleType type) override {
createModuleCalled = true;
*module = new MockModuleForRebuildBuiltins(this);
if (desc) {
formatForModule = desc->format;
}
*module = new MockModuleForRebuildBuiltins(this, type);
return ZE_RESULT_SUCCESS;
}
bool createModuleCalled = false;
ze_module_format_t formatForModule{};
};
} // namespace ult
} // namespace L0

5
level_zero/core/test/unit_tests/sources/builtin/CMakeLists.txt
View File

@ -10,3 +10,8 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/built_in_tests_l0.cpp
${CMAKE_CURRENT_SOURCE_DIR}/builtin_functions_tests.cpp
)
if(TARGET ${BUILTINS_SPIRV_LIB_NAME})
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/built_in_spv_tests_l0.cpp
)
endif()

48
level_zero/core/test/unit_tests/sources/builtin/built_in_spv_tests_l0.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/built_ins/built_ins.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_builtinslib.h"
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device_recompile_built_ins.h"
using namespace NEO;
using BuiltInTestL0 = Test<NEO::DeviceFixture>;
TEST_F(BuiltInTestL0, GivenBuiltinTypeIntermediateWhenGettingBuiltinResourceForNotRegisteredRevisionThenResourceSizeIsNonZero) {
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
auto mockBuiltinsLib = std::unique_ptr<MockBuiltinsLib>(new MockBuiltinsLib());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferRect, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillBuffer, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToImage3d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImage3dToBuffer, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage1d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage2d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage3d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage1d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage2d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage3d, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::COUNT, BuiltinCode::ECodeType::Intermediate, *pDevice).size());
}
HWTEST_F(BuiltInTestL0, givenDeviceWithUnregisteredBinaryBuiltinWhenGettingBuiltinKernelThenTakeBinaryBuiltinFromDefaultRevision) {
pDevice->incRefInternal();
L0::ult::MockDeviceForRebuildBuilins deviceL0(pDevice);
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
L0::BuiltinFunctionsLibImpl builtinFunctionsLib{&deviceL0, pDevice->getBuiltIns()};
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(L0::Builtin::COUNT); builtId++) {
deviceL0.formatForModule = {};
ASSERT_NE(nullptr, builtinFunctionsLib.getFunction(static_cast<L0::Builtin>(builtId)));
EXPECT_EQ(ZE_MODULE_FORMAT_NATIVE, deviceL0.formatForModule);
}
}

1
level_zero/core/test/unit_tests/xe_hpc_core/CMakeLists.txt
View File

@ -7,6 +7,7 @@
if(TESTS_XE_HPC_CORE)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/built_in_xe_hpc_core_tests_l0.cpp
${CMAKE_CURRENT_SOURCE_DIR}/enable_l0_mocks_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdlist_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdqueue_xe_hpc_core.cpp

54
level_zero/core/test/unit_tests/xe_hpc_core/built_in_xe_hpc_core_tests_l0.cpp Normal file
View File

@ -0,0 +1,54 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/built_ins/built_ins.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_builtinslib.h"
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device_recompile_built_ins.h"
namespace L0 {
namespace ult {
using XeHpcCoreBuiltInTestL0 = Test<NEO::DeviceFixture>;
HWTEST_EXCLUDE_PRODUCT(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBuiltinFromDefaultRevisionIsTaken, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(BuiltInTestL0, givenDeviceWithUnregisteredBinaryBuiltinWhenGettingBuiltinKernelThenTakeBinaryBuiltinFromDefaultRevision, IGFX_XE_HPC_CORE);
HWTEST2_F(XeHpcCoreBuiltInTestL0, givenDeviceWithUnregisteredBinaryBuiltinWhenGettingBuiltinKernelThenFallbackToIntermediate, IsXeHpcCore) {
pDevice->incRefInternal();
L0::ult::MockDeviceForRebuildBuilins deviceL0(pDevice);
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
L0::BuiltinFunctionsLibImpl builtinFunctionsLib{&deviceL0, pDevice->getBuiltIns()};
for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(L0::Builtin::COUNT); builtId++) {
deviceL0.formatForModule = {};
ASSERT_NE(nullptr, builtinFunctionsLib.getFunction(static_cast<L0::Builtin>(builtId)));
EXPECT_EQ(ZE_MODULE_FORMAT_IL_SPIRV, deviceL0.formatForModule);
}
}
HWTEST2_F(XeHpcCoreBuiltInTestL0, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenResourceSizeIsZero, IsXeHpcCore) {
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
auto mockBuiltinsLib = std::unique_ptr<MockBuiltinsLib>(new MockBuiltinsLib());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferRect, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillBuffer, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToImage3d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImage3dToBuffer, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage1d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage2d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage3d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage1d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage2d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage3d, BuiltinCode::ECodeType::Binary, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::COUNT, BuiltinCode::ECodeType::Binary, *pDevice).size());
}
} // namespace ult
} // namespace L0

19
opencl/test/unit_test/built_ins/built_in_tests.cpp
View File

@ -19,6 +19,7 @@
#include "shared/test/common/mocks/mock_compiler_interface.h"
#include "shared/test/common/mocks/mock_compilers.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
#include "shared/test/common/mocks/ult_device_factory.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/unit_test/utilities/base_object_utils.h"
@ -1444,6 +1445,24 @@ HWCMDTEST_F(IGFX_GEN8_CORE, BuiltInTests, GivenBuiltinTypeBinaryWhenGettingBuilt
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::COUNT, BuiltinCode::ECodeType::Binary, *pDevice).size());
}
TEST_F(BuiltInTests, GivenBuiltinTypeSourceWhenGettingBuiltinResourceForNotRegisteredRevisionThenResourceSizeIsNonZero) {
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
auto mockBuiltinsLib = std::unique_ptr<MockBuiltinsLib>(new MockBuiltinsLib());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferRect, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillBuffer, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyBufferToImage3d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImage3dToBuffer, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage1d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage2d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::CopyImageToImage3d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage1d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage2d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::FillImage3d, BuiltinCode::ECodeType::Source, *pDevice).size());
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(EBuiltInOps::COUNT, BuiltinCode::ECodeType::Source, *pDevice).size());
}
TEST_F(BuiltInTests, GivenTypeAnyWhenCreatingProgramFromCodeThenValidPointerIsReturned) {
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Any, *pDevice);

5
opencl/test/unit_test/helpers/hw_helper_tests.cpp
View File

@ -1414,3 +1414,8 @@ HWTEST2_F(HwHelperTest, givenAtsOrDg2WhenDisableL3ForDebugCalledThenTrueIsReturn
const auto &hwHelper = HwHelper::get(renderCoreFamily);
EXPECT_TRUE(hwHelper.disableL3CacheForDebug());
}
HWTEST_F(HwHelperTest, givenHwHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenFalseIsReturned) {
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
EXPECT_FALSE(hwHelper.isRevisionSpecificBinaryBuiltinRequired());
}

1
opencl/test/unit_test/xe_hpc_core/CMakeLists.txt
View File

@ -13,6 +13,7 @@ if(TESTS_XE_HPC_CORE)
set(IGDRCL_SRCS_tests_xe_hpc_core
${IGDRCL_SRCS_tests_xe_hpc_core_excludes}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/built_in_xe_hpc_core_tests_ocl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/cmd_parse_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_cmds_programming_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/copy_engine_tests_xe_hpc_core.cpp

33
opencl/test/unit_test/xe_hpc_core/built_in_xe_hpc_core_tests_ocl.cpp Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_builtinslib.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using XeHpcCoreBuiltInTests = Test<DeviceFixture>;
XE_HPC_CORETEST_F(XeHpcCoreBuiltInTests, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBinaryBuiltinIsNotAvailable) {
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
auto mockBuiltinsLib = std::unique_ptr<MockBuiltinsLib>(new MockBuiltinsLib());
const std::array<uint32_t, 11> builtinTypes{EBuiltInOps::CopyBufferToBuffer,
EBuiltInOps::CopyBufferRect,
EBuiltInOps::FillBuffer,
EBuiltInOps::CopyBufferToImage3d,
EBuiltInOps::CopyImage3dToBuffer,
EBuiltInOps::CopyImageToImage1d,
EBuiltInOps::CopyImageToImage2d,
EBuiltInOps::CopyImageToImage3d,
EBuiltInOps::FillImage1d,
EBuiltInOps::FillImage2d,
EBuiltInOps::FillImage3d};
for (auto &builtinType : builtinTypes) {
EXPECT_EQ(0u, mockBuiltinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDevice).size());
}
}

4
opencl/test/unit_test/xe_hpc_core/excludes_xe_hpc_core.cpp
View File

@ -54,4 +54,6 @@ HWTEST_EXCLUDE_PRODUCT(PipeControlHelperTestsXeHPAndLater, WhenGettingSizeForAdd
HWTEST_EXCLUDE_PRODUCT(HwHelperTest, whenQueryingMaxNumSamplersThenReturnSixteen, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(MemoryManagerGetAlloctionDataTests, givenCommandBufferAllocationTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(MultiDeviceStorageInfoTest, givenSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoreThemInSystemMemory, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(HwHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(HwHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(HwHelperTest, givenHwHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenFalseIsReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBuiltinFromDefaultRevisionIsTaken, IGFX_XE_HPC_CORE);

11
shared/source/built_ins/built_ins_storage.cpp
View File

@ -197,9 +197,16 @@ BuiltinResourceT BuiltinsLib::getBuiltinResource(EBuiltInOps::Type builtin, Buil
getFamilyNameWithType(hwInfo),
hwInfo.platform.usRevId);
for (auto &rn : {resourceNameForPlatformTypeAndStepping, resourceNameForPlatformType, resourceNameGeneric}) { // first look for dedicated version, only fallback to generic one
StackVec<const std::string *, 3> resourcesToLookup;
resourcesToLookup.push_back(&resourceNameForPlatformTypeAndStepping);
if (BuiltinCode::ECodeType::Binary != requestedCodeType || !hwHelper.isRevisionSpecificBinaryBuiltinRequired()) {
resourcesToLookup.push_back(&resourceNameForPlatformType);
resourcesToLookup.push_back(&resourceNameGeneric);
}
for (auto &rn : resourcesToLookup) { // first look for dedicated version, only fallback to generic one
for (auto &s : allStorages) {
bc = s.get()->load(rn);
UNRECOVERABLE_IF(!rn);
bc = s.get()->load(*rn);
if (bc.size() != 0) {
return bc;
}

2
shared/source/helpers/hw_helper.h
View File

@ -152,6 +152,7 @@ class HwHelper {
virtual bool isStatelesToStatefullWithOffsetSupported() const = 0;
virtual void encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) = 0;
virtual bool disableL3CacheForDebug() const = 0;
virtual bool isRevisionSpecificBinaryBuiltinRequired() const = 0;
protected:
HwHelper() = default;
@ -386,6 +387,7 @@ class HwHelperHw : public HwHelper {
bool isStatelesToStatefullWithOffsetSupported() const override;
void encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) override;
bool disableL3CacheForDebug() const override;
bool isRevisionSpecificBinaryBuiltinRequired() const override;
protected:
static const AuxTranslationMode defaultAuxTranslationMode;

5
shared/source/helpers/hw_helper_base.inl
View File

@ -705,4 +705,9 @@ template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::disableL3CacheForDebug() const {
return false;
}
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::isRevisionSpecificBinaryBuiltinRequired() const {
return false;
}
} // namespace NEO

5
shared/source/xe_hpc_core/hw_helper_xe_hpc_core.cpp
View File

@ -416,6 +416,11 @@ uint32_t HwHelperHw<Family>::getComputeUnitsUsedForScratch(const HardwareInfo *p
return pHwInfo->gtSystemInfo.MaxSubSlicesSupported * pHwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio;
}
template <>
bool HwHelperHw<Family>::isRevisionSpecificBinaryBuiltinRequired() const {
return true;
}
} // namespace NEO
#include "shared/source/helpers/hw_helper_pvc_and_later.inl"

1
shared/test/common/xe_hpc_core/pvc/CMakeLists.txt
View File

@ -8,7 +8,6 @@ if(TESTS_PVC)
set(NEO_CORE_TESTS_XE_HPC_CORE_PVC
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_encode_dispatch_kernel_pvc.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_helper_pvc.cpp
)
target_sources(${TARGET_NAME} PRIVATE ${NEO_CORE_TESTS_XE_HPC_CORE_PVC})

35
shared/test/unit_test/built_ins/built_in_tests_shared.inl
View File

@ -6,7 +6,10 @@
*/
#include "shared/source/built_ins/built_ins.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/mocks/mock_builtinslib.h"
#include "shared/test/common/mocks/ult_device_factory.h"
#include "shared/test/common/test_macros/test.h"
#include "gtest/gtest.h"
@ -68,4 +71,34 @@ void givenUseBindlessBuiltinEnabledWhenBinExtensionPassedThenNameHasBindlessPref
EXPECT_EQ(0, strcmp(expectedResourceNameForPlatform.c_str(), resourceNameForPlatform.c_str()));
EXPECT_EQ(0, strcmp(expectedResourceNameForPlatformAndStepping.c_str(), resourceNameForPlatformAndStepping.c_str()));
}
} // namespace NEO
} // namespace NEO
using namespace NEO;
using BuiltInSharedTest = Test<DeviceFixture>;
HWTEST_F(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBuiltinFromDefaultRevisionIsTaken) {
pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->platform.usRevId += 0xdead;
auto mockBuiltinsLib = std::unique_ptr<MockBuiltinsLib>(new MockBuiltinsLib());
const std::array<uint32_t, 11> builtinTypes{EBuiltInOps::CopyBufferToBuffer,
EBuiltInOps::CopyBufferRect,
EBuiltInOps::FillBuffer,
EBuiltInOps::CopyBufferToImage3d,
EBuiltInOps::CopyImage3dToBuffer,
EBuiltInOps::CopyImageToImage1d,
EBuiltInOps::CopyImageToImage2d,
EBuiltInOps::CopyImageToImage3d,
EBuiltInOps::FillImage1d,
EBuiltInOps::FillImage2d,
EBuiltInOps::FillImage3d};
for (auto &builtinType : builtinTypes) {
EXPECT_NE(0u, mockBuiltinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDevice).size());
}
UltDeviceFactory deviceFactory{1, 0};
auto pDeviceWithDefaultRevision = deviceFactory.rootDevices[0];
for (auto &builtinType : builtinTypes) {
EXPECT_EQ(mockBuiltinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDeviceWithDefaultRevision).size(), mockBuiltinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDevice).size());
}
}

1
shared/test/unit_test/xe_hpc_core/CMakeLists.txt
View File

@ -9,6 +9,7 @@ if(TESTS_XE_HPC_CORE)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_2_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpc_core_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_xe_hpc_core_tests.cpp
)
add_subdirectories()
endif()

13
shared/test/common/xe_hpc_core/pvc/test_hw_helper_pvc.cpp → shared/test/unit_test/xe_hpc_core/hw_helper_xe_hpc_core_tests.cpp
View File

@ -11,9 +11,9 @@
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using HwHelperTestPvc = ::testing::Test;
using HwHelperXeHpcCoreTest = ::testing::Test;
PVCTEST_F(HwHelperTestPvc, givenSlmSizeWhenEncodingThenReturnCorrectValues) {
XE_HPC_CORETEST_F(HwHelperXeHpcCoreTest, givenSlmSizeWhenEncodingThenReturnCorrectValues) {
ComputeSlmTestInput computeSlmValuesPvcAndLaterTestsInput[] = {
{0, 0 * KB},
{1, 0 * KB + 1},
@ -49,12 +49,17 @@ PVCTEST_F(HwHelperTestPvc, givenSlmSizeWhenEncodingThenReturnCorrectValues) {
EXPECT_THROW(hwHelper.computeSlmValues(hwInfo, 129 * KB), std::exception);
}
PVCTEST_F(HwHelperTestPvc, WhenGettingIsCpuImageTransferPreferredThenTrueIsReturned) {
XE_HPC_CORETEST_F(HwHelperXeHpcCoreTest, WhenGettingIsCpuImageTransferPreferredThenTrueIsReturned) {
auto &hwHelper = HwHelper::get(renderCoreFamily);
EXPECT_TRUE(hwHelper.isCpuImageTransferPreferred(*defaultHwInfo));
}
PVCTEST_F(HwHelperTestPvc, givenHwHelperWhenGettingISAPaddingThenCorrectValueIsReturned) {
XE_HPC_CORETEST_F(HwHelperXeHpcCoreTest, givenHwHelperWhenGettingISAPaddingThenCorrectValueIsReturned) {
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
EXPECT_EQ(hwHelper.getPaddingForISAAllocation(), 3584u);
}
XE_HPC_CORETEST_F(HwHelperXeHpcCoreTest, givenHwHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenTrueIsReturned) {
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
EXPECT_TRUE(hwHelper.isRevisionSpecificBinaryBuiltinRequired());
}