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

fix: Compile built-ins per release 

- Preserve releases on CMake level.
- Instead of generating builtins per platform, generate them per-release
(+ correct naming accordingly).
- Stop using revisions in builtin compilation logic path, as they are
already embedded in release (device ip).
- Remove platform names & revisions from names for generated files
(related to builtins).
- Remove unnecessary code, refactor ULT logic.

Related-To: NEO-7783
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak 2023-07-07 12:09:44 +00:00 committed by Compute-Runtime-Automation
parent 1a398c7199
commit b908203001
26 changed files with 133 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
cmake/setup_platform_flags.cmake
View File

@ -67,6 +67,7 @@ if(SUPPORT_GEN8)
endif()
if(SUPPORT_BDW)
set(BDW_GEN8_REVISIONS 0)
set(BDW_GEN8_RELEASES "8.0.0")
ADD_PRODUCT("SUPPORTED" "BDW" "IGFX_BROADWELL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN8" "BDW")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_2_0" "GEN8" "BDW")
@ -84,6 +85,7 @@ if(SUPPORT_GEN9)
endif()
if(SUPPORT_SKL)
set(SKL_GEN9_REVISIONS 9)
set(SKL_GEN9_RELEASES "9.0.9")
ADD_PRODUCT("SUPPORTED" "SKL" "IGFX_SKYLAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN9" "SKL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_2_0" "GEN9" "SKL")
@ -97,6 +99,7 @@ if(SUPPORT_GEN9)
if(SUPPORT_KBL)
set(KBL_GEN9_REVISIONS 9)
set(KBL_GEN9_RELEASES "9.1.9")
ADD_PRODUCT("SUPPORTED" "KBL" "IGFX_KABYLAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN9" "KBL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_2_0" "GEN9" "KBL")
@ -110,6 +113,7 @@ if(SUPPORT_GEN9)
if(SUPPORT_GLK)
set(GLK_GEN9_REVISIONS 0)
set(GLK_GEN9_RELEASES "9.4.0")
ADD_PRODUCT("SUPPORTED" "GLK" "IGFX_GEMINILAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN9" "GLK")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_VME" "GEN9" "GLK")
@ -122,6 +126,7 @@ if(SUPPORT_GEN9)
if(SUPPORT_CFL)
set(CFL_GEN9_REVISIONS 9)
set(CFL_GEN9_RELEASES "9.2.9")
ADD_PRODUCT("SUPPORTED" "CFL" "IGFX_COFFEELAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN9" "CFL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_2_0" "GEN9" "CFL")
@ -135,6 +140,7 @@ if(SUPPORT_GEN9)
if(SUPPORT_BXT)
set(BXT_GEN9_REVISIONS 0)
set(BXT_GEN9_RELEASES "9.3.0")
ADD_PRODUCT("SUPPORTED" "BXT" "IGFX_BROXTON")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN9" "BXT")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_VME" "GEN9" "BXT")
@ -153,6 +159,7 @@ if(SUPPORT_GEN11)
if(SUPPORT_ICLLP)
set(ICLLP_GEN11_REVISIONS 0)
set(ICLLP_GEN11_RELEASES "11.0.0")
ADD_PRODUCT("SUPPORTED" "ICLLP" "IGFX_ICELAKE_LP")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN11" "ICLLP")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_2_0" "GEN11" "ICLLP")
@ -166,6 +173,7 @@ if(SUPPORT_GEN11)
if(SUPPORT_LKF)
set(LKF_GEN11_REVISIONS 0)
set(LKF_GEN11_RELEASES "11.1.0")
ADD_PRODUCT("SUPPORTED" "LKF" "IGFX_LAKEFIELD")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN11" "LKF")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN11" "LKF")
@ -177,6 +185,7 @@ if(SUPPORT_GEN11)
if(SUPPORT_EHL)
set(EHL_GEN11_REVISIONS 0)
set(EHL_GEN11_RELEASES "11.2.0")
ADD_PRODUCT("SUPPORTED" "EHL" "IGFX_ELKHARTLAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN11" "EHL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN11" "EHL")
@ -193,6 +202,7 @@ if(SUPPORT_GEN12LP)
endif()
if(SUPPORT_TGLLP)
set(TGLLP_GEN12LP_REVISIONS 0)
set(TGLLP_GEN12LP_RELEASES "12.0.0")
ADD_PRODUCT("SUPPORTED" "TGLLP" "IGFX_TIGERLAKE_LP")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "TGLLP")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "TGLLP")
@ -205,6 +215,7 @@ if(SUPPORT_GEN12LP)
if(SUPPORT_DG1)
set(DG1_GEN12LP_REVISIONS 0)
set(DG1_GEN12LP_RELEASES "12.10.0")
ADD_PRODUCT("SUPPORTED" "DG1" "IGFX_DG1")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "DG1")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "DG1")
@ -217,6 +228,7 @@ if(SUPPORT_GEN12LP)
if(SUPPORT_RKL)
set(RKL_GEN12LP_REVISIONS 0)
set(RKL_GEN12LP_RELEASES "12.1.0")
ADD_PRODUCT("SUPPORTED" "RKL" "IGFX_ROCKETLAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "RKL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "RKL")
@ -229,6 +241,7 @@ if(SUPPORT_GEN12LP)
if(SUPPORT_ADLS)
set(ADLS_GEN12LP_REVISIONS 0)
set(ADLS_GEN12LP_RELEASES "12.2.0")
ADD_PRODUCT("SUPPORTED" "ADLS" "IGFX_ALDERLAKE_S")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "ADLS")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "ADLS")
@ -241,6 +254,7 @@ if(SUPPORT_GEN12LP)
if(SUPPORT_ADLP)
set(ADLP_GEN12LP_REVISIONS 0)
set(ADLP_GEN12LP_RELEASES "12.3.0")
ADD_PRODUCT("SUPPORTED" "ADLP" "IGFX_ALDERLAKE_P")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "ADLP")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "ADLP")
@ -253,6 +267,7 @@ if(SUPPORT_GEN12LP)
if(SUPPORT_ADLN)
set(ADLN_GEN12LP_REVISIONS 0)
set(ADLN_GEN12LP_RELEASES "12.4.0")
ADD_PRODUCT("SUPPORTED" "ADLN" "IGFX_ALDERLAKE_N")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "GEN12LP" "ADLN")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "GEN12LP" "ADLN")
@ -270,6 +285,7 @@ if(SUPPORT_XE_HPG_CORE)
endif()
if(SUPPORT_MTL)
set(MTL_XE_HPG_CORE_REVISIONS 0)
set(MTL_XE_HPG_CORE_RELEASES "12.70.0" "12.70.4" "12.71.0" "12.71.4")
ADD_PRODUCT("SUPPORTED" "MTL" "IGFX_METEORLAKE")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "XE_HPG_CORE" "MTL")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_IMAGES" "XE_HPG_CORE" "MTL")
@ -281,6 +297,7 @@ if(SUPPORT_XE_HPG_CORE)
endif()
if(SUPPORT_DG2)
set(DG2_XE_HPG_CORE_REVISIONS 0)
set(DG2_XE_HPG_CORE_RELEASES "12.55.0" "12.55.1" "12.55.4" "12.55.8" "12.56.0" "12.56.4" "12.56.5" "12.57.0")
ADD_PRODUCT("SUPPORTED" "DG2" "IGFX_DG2")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "XE_HPG_CORE" "DG2")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_AUX_TRANSLATION" "XE_HPG_CORE" "DG2")
@ -300,6 +317,7 @@ if(SUPPORT_XE_HPC_CORE)
if(SUPPORT_PVC)
set(PVC_XE_HPC_CORE_REVISIONS 0 3 30 38 46 47 157)
set(PVC_XE_HPC_CORE_RELEASES "12.60.0" "12.60.1" "12.60.3" "12.60.5" "12.60.6" "12.60.7")
ADD_PRODUCT("SUPPORTED" "PVC" "IGFX_PVC")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED" "XE_HPC_CORE" "PVC")
ADD_PLATFORM_FOR_CORE_TYPE("SUPPORTED_AUX_TRANSLATION" "XE_HPC_CORE" "PVC")

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

@ -7,7 +7,6 @@
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}/test_cmdlist_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdqueue_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_xe_hpc_core.cpp

55
level_zero/core/test/unit_tests/xe_hpc_core/built_in_xe_hpc_core_tests_l0.cpp
View File

@ -1,55 +0,0 @@
/*
* Copyright (C) 2021-2023 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/mocks/mock_device.h"
#include "shared/test/common/test_macros/hw_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

2
manifests/manifest.yml
View File

@ -41,7 +41,7 @@ components:
dest_dir: kernels_bin
type: git
branch: kernels_bin
revision: 2063-704
revision: 2063-711
kmdaf:
branch: kmdaf
dest_dir: kmdaf

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

@ -14,7 +14,6 @@ if(TESTS_XE_HPC_CORE)
${IGDRCL_SRCS_tests_xe_hpc_core_excludes}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/api_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/built_in_xe_hpc_core_tests_ocl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/copy_engine_tests_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/enqueue_tests_xe_hpc_core.cpp

38
opencl/test/unit_test/xe_hpc_core/built_in_xe_hpc_core_tests_ocl.cpp
View File

@ -1,38 +0,0 @@
/*
* Copyright (C) 2021-2023 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/mocks/mock_device.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
#include "hw_cmds_xe_hpc_core_base.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());
}
}

53
shared/generate_cpp_array/source/generate_cpp_array.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -18,17 +18,29 @@ static void showUsage(std::string name) {
<< "Options :\n"
<< "\t -f, --file\t\tA file which content will be parsed into a uint32_t array in a .cpp file\n"
<< "\t -o, --output\t\t.Cpp output file name\n"
<< "\t -p, --platform\t\tOPTIONAL - Family name with type\n"
<< "\t -r, --revision_id\t\tOPTIONAL - Revision id\n"
<< "\t -d, --device\t\tOPTIONAL - device ip version in format <major>_<minor>_<revision>\n"
<< "\t -a, --array\t\tName of an uin32_t type array containing parsed input file" << std::endl;
}
std::string parseToCharArray(std::unique_ptr<uint8_t[]> &binary, size_t size, std::string &builtinName, std::string &platform, std::string revisionId, bool isSpirV) {
std::string parseToCharArray(std::unique_ptr<uint8_t[]> &binary, size_t size, std::string &builtinName, std::string &deviceIp, bool isSpirV) {
std::ostringstream out;
bool deviceIpPresent = !deviceIp.empty();
out << "#include <cstddef>\n";
out << "#include <cstdint>\n\n";
out << "size_t " << builtinName << "BinarySize_" << platform << "_" << revisionId << " = " << size << ";\n";
out << "uint32_t " << builtinName << "Binary_" << platform << "_" << revisionId << "[" << (size + 3) / 4 << "] = {"
out << "size_t " << builtinName;
if (deviceIpPresent) {
out << "BinarySize_" << deviceIp;
} else {
out << "BinarySize";
}
out << " = " << size << ";\n";
out << "uint32_t " << builtinName;
if (deviceIpPresent) {
out << "Binary_" << deviceIp;
} else {
out << "Binary";
}
out << "[" << (size + 3) / 4 << "] = {"
<< std::endl
<< " ";
uint32_t *binaryUint = reinterpret_cast<uint32_t *>(binary.get());
@ -62,11 +74,23 @@ std::string parseToCharArray(std::unique_ptr<uint8_t[]> &binary, size_t size, st
isSpirV ? out << "Ir(" : out << "Bin(";
out << std::endl;
out << " \"";
platform != "" ? out << platform << "_" << revisionId << "_" << builtinName : out << builtinName;
deviceIp != "" ? out << deviceIp << "_" << builtinName : out << builtinName;
isSpirV ? out << ".builtin_kernel.bc\"," : out << ".builtin_kernel.bin\",";
out << std::endl;
out << " (const char *)" << builtinName << "Binary_" << platform << "_" << revisionId << "," << std::endl;
out << " " << builtinName << "BinarySize_" << platform << "_" << revisionId << ");" << std::endl;
out << " (const char *)" << builtinName;
if (deviceIpPresent) {
out << "Binary_" << deviceIp;
} else {
out << "Binary";
}
out << "," << std::endl;
out << " " << builtinName;
if (deviceIpPresent) {
out << "BinarySize_" << deviceIp;
} else {
out << "BinarySize";
}
out << ");" << std::endl;
out << "}" << std::endl;
return out.str();
@ -80,8 +104,7 @@ int main(int argc, char *argv[]) {
std::string fileName;
std::string cppOutputName;
std::string arrayName;
std::string platform = "";
std::string revisionId = "0";
std::string deviceIp = "";
size_t size = 0;
std::fstream inputFile;
bool isSpirV;
@ -93,10 +116,8 @@ int main(int argc, char *argv[]) {
cppOutputName = argv[++i];
} else if ((arg == "-a") || (arg == "--array")) {
arrayName = argv[++i];
} else if ((arg == "-p") || (arg == "--platform")) {
platform = argv[++i];
} else if ((arg == "-r") || (arg == "--revision_id")) {
revisionId = argv[++i];
} else if ((arg == "-d") || (arg == "--device")) {
deviceIp = argv[++i];
} else {
return 1;
}
@ -115,7 +136,7 @@ int main(int argc, char *argv[]) {
inputFile.read(reinterpret_cast<char *>(memblock.get()), size);
inputFile.close();
isSpirV = fileName.find(".spv") != std::string::npos;
std::string cpp = parseToCharArray(memblock, size, arrayName, platform, revisionId, isSpirV);
std::string cpp = parseToCharArray(memblock, size, arrayName, deviceIp, isSpirV);
std::fstream(cppOutputName.c_str(), std::ios::out | std::ios::binary).write(cpp.c_str(), cpp.size());
} else {
std::cerr << "File cannot be opened!" << std::endl;

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

@ -82,11 +82,14 @@ std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::stri
StackVec<std::string, 3> getBuiltinResourceNames(EBuiltInOps::Type builtin, BuiltinCode::ECodeType type, const Device &device) {
auto &hwInfo = device.getHardwareInfo();
auto &gfxCoreHelper = device.getGfxCoreHelper();
auto &productHelper = device.getRootDeviceEnvironment().getHelper<ProductHelper>();
const auto platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const auto revisionId = std::to_string(hwInfo.platform.usRevId);
auto createDeviceIdFilenameComponent = [](const NEO::HardwareIpVersion &hwIpVersion) {
std::ostringstream deviceId;
deviceId << hwIpVersion.architecture << "_" << hwIpVersion.release << "_" << hwIpVersion.revision;
return deviceId.str();
};
const auto deviceIp = createDeviceIdFilenameComponent(hwInfo.ipVersion);
const auto builtinName = getBuiltinAsString(builtin);
const auto extension = BuiltinCode::getExtension(type);
auto getAddressingMode = [type, &productHelper, builtin]() {
@ -105,22 +108,19 @@ StackVec<std::string, 3> getBuiltinResourceNames(EBuiltInOps::Type builtin, Buil
};
const auto addressingMode = getAddressingMode();
auto createBuiltinResourceName = [](ConstStringRef platformName, ConstStringRef revisionId, ConstStringRef addressingMode, ConstStringRef builtinName, ConstStringRef extension) {
auto createBuiltinResourceName = [](ConstStringRef deviceIpPath, ConstStringRef addressingMode, ConstStringRef builtinName, ConstStringRef extension) {
std::ostringstream outResourceName;
if (false == platformName.empty()) {
outResourceName << platformName.str() << "_" << revisionId.str() << "_";
if (false == deviceIpPath.empty()) {
outResourceName << deviceIpPath.str() << "_";
}
outResourceName << addressingMode.str() << builtinName.str() << extension.str();
return outResourceName.str();
};
StackVec<std::string, 3> resourcesToLookup = {};
resourcesToLookup.push_back(createBuiltinResourceName(platformName, revisionId, addressingMode, builtinName, extension));
resourcesToLookup.push_back(createBuiltinResourceName(deviceIp, addressingMode, builtinName, extension));
const bool requiresSpecificResource = (BuiltinCode::ECodeType::Binary == type && gfxCoreHelper.isRevisionSpecificBinaryBuiltinRequired());
if (false == requiresSpecificResource) {
const auto defaultRevisionId = std::to_string(productHelper.getDefaultRevisionId());
resourcesToLookup.push_back(createBuiltinResourceName(platformName, defaultRevisionId, addressingMode, builtinName, extension));
resourcesToLookup.push_back(createBuiltinResourceName("", "", addressingMode, builtinName, extension));
if (BuiltinCode::ECodeType::Binary != type) {
resourcesToLookup.push_back(createBuiltinResourceName("", addressingMode, builtinName, extension));
}
return resourcesToLookup;
}

22
shared/source/built_ins/kernels/CMakeLists.txt
View File

@ -65,30 +65,31 @@ function(compile_builtin core_type platform_it builtin bits builtin_options mode
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${builtin} ocloc copy_compiler_files
)
foreach(REVISION_ID ${${platform_it}_${core_type}_REVISIONS})
foreach(RELEASE ${${platform_it}_${core_type}_RELEASES})
string(REPLACE "." "_" RELEASE_FILENAME ${RELEASE})
set(OUTPUT_FILE_CPP
${OUTPUTDIR}/${mode}_${BASENAME}_${platform_it_lower}_${REVISION_ID}.cpp
${OUTPUTDIR}/${mode}_${BASENAME}_${RELEASE_FILENAME}.cpp
)
set(BINARY_OUTPUT "${OUTPUTDIR}/${mode}_${BASENAME}_${REVISION_ID}_${platform_it_lower}")
set(BINARY_OUTPUT "${OUTPUTDIR}/${mode}_${BASENAME}_${RELEASE_FILENAME}")
if(NOT NEO_DISABLE_BUILTINS_COMPILATION)
set(OUTPUT_FILES_BINARIES ${BINARY_OUTPUT}.bin)
get_filename_component(absolute_filepath_spv ${OUTPUT_FILE_SPV} ABSOLUTE)
add_custom_command(
OUTPUT ${OUTPUT_FILES_BINARIES}
COMMAND ${ocloc_cmd_prefix} -q -file ${absolute_filepath_spv} -spirv_input -device ${platform_it_lower} ${builtin_options} -${bits} -output ${mode}_${BASENAME}_${REVISION_ID} -out_dir ${OUTPUTDIR} -revision_id ${REVISION_ID} ${INTERNAL_OPTIONS} -options "$<JOIN:${__ocloc__options__}, >"
COMMAND ${ocloc_cmd_prefix} -q -file ${absolute_filepath_spv} -spirv_input -device ${RELEASE} ${builtin_options} -${bits} -output ${mode}_${BASENAME}_${RELEASE_FILENAME} -output_no_suffix -out_dir ${OUTPUTDIR} ${INTERNAL_OPTIONS} -options "$<JOIN:${__ocloc__options__}, >"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${OUTPUT_FILE_SPV} ocloc copy_compiler_files
)
add_custom_command(
OUTPUT ${OUTPUT_FILE_CPP}
COMMAND $<TARGET_FILE:cpp_generate_tool> --file ${BINARY_OUTPUT}.bin --output ${OUTPUT_FILE_CPP} --array ${mode}_${BASENAME} --platform ${platform_it_lower} --revision_id ${REVISION_ID}
COMMAND $<TARGET_FILE:cpp_generate_tool> --file ${BINARY_OUTPUT}.bin --output ${OUTPUT_FILE_CPP} --array ${mode}_${BASENAME} --device ${RELEASE_FILENAME}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${OUTPUT_FILES_BINARIES} $<TARGET_FILE:cpp_generate_tool>
)
list(APPEND BUILTINS_COMMANDS "${OUTPUT_FILE_CPP}")
else()
foreach(_file_name "bin")
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/${core_type_lower}/${mode}_${BASENAME}_${REVISION_ID}_${platform_it_lower}.${_file_name}")
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/${core_type_lower}/${mode}_${BASENAME}_${RELEASE_FILENAME}.${_file_name}")
if(EXISTS ${_file_prebuilt})
add_custom_command(
OUTPUT ${BINARY_OUTPUT}.${_file_name}
@ -97,7 +98,7 @@ function(compile_builtin core_type platform_it builtin bits builtin_options mode
)
endif()
endforeach()
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/${core_type_lower}/${mode}_${BASENAME}_${platform_it_lower}_${REVISION_ID}.cpp")
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/${core_type_lower}/${mode}_${BASENAME}_${RELEASE_FILENAME}.cpp")
if(EXISTS ${_file_prebuilt})
add_custom_command(
OUTPUT ${OUTPUT_FILE_CPP}
@ -113,12 +114,11 @@ endfunction()
function(generate_cpp_spirv builtin)
get_filename_component(BASENAME ${builtin} NAME_WE)
get_filename_component(DIR ${builtin} DIRECTORY)
set(INPUT_FILENAME ${builtin}.builtin_kernel)
get_filename_component(absolute_filepath ${INPUT_FILENAME} ABSOLUTE)
set(OUTPUTDIR "${BUILTINS_OUTDIR_WITH_ARCH}/spirv/${DIR}")
set(OUTPUTDIR "${BUILTINS_OUTDIR_WITH_ARCH}/spirv/")
string(REPLACE "//" "/" OUTPUTDIR ${OUTPUTDIR})
set(GENERATED_SPV_INPUT ${OUTPUTDIR}/${BASENAME}.spv)
@ -140,13 +140,13 @@ function(generate_cpp_spirv builtin)
)
set(OUTPUT_LIST_CPP_FILES ${OUTPUT_LIST_CPP_FILES} ${OUTPUT_FILE_CPP} PARENT_SCOPE)
else()
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/spirv/${DIR}/${BASENAME}.spv")
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/spirv/${BASENAME}.spv")
add_custom_command(
OUTPUT ${GENERATED_SPV_INPUT}
COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUTDIR}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${_file_prebuilt} ${OUTPUTDIR}
)
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/spirv/${DIR}/${BASENAME}.cpp")
set(_file_prebuilt "${NEO_KERNELS_BIN_DIR}/built_ins/${NEO_ARCH}/spirv/${BASENAME}.cpp")
add_custom_command(
OUTPUT ${OUTPUT_FILE_CPP}
COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUTDIR}

5
shared/source/gen9/cfl/os_agnostic_product_helper_cfl.inl
View File

@ -14,9 +14,4 @@ std::optional<aub_stream::ProductFamily> ProductHelperHw<gfxProduct>::getAubStre
return aub_stream::ProductFamily::Cfl;
};
template <>
uint32_t ProductHelperHw<gfxProduct>::getDefaultRevisionId() const {
return 9u;
}
} // namespace NEO

5
shared/source/gen9/kbl/os_agnostic_product_helper_kbl.inl
View File

@ -14,9 +14,4 @@ std::optional<aub_stream::ProductFamily> ProductHelperHw<gfxProduct>::getAubStre
return aub_stream::ProductFamily::Kbl;
};
template <>
uint32_t ProductHelperHw<gfxProduct>::getDefaultRevisionId() const {
return 9u;
}
} // namespace NEO

5
shared/source/gen9/skl/os_agnostic_product_helper_skl.inl
View File

@ -13,9 +13,4 @@ std::optional<aub_stream::ProductFamily> ProductHelperHw<gfxProduct>::getAubStre
return aub_stream::ProductFamily::Skl;
};
template <>
uint32_t ProductHelperHw<gfxProduct>::getDefaultRevisionId() const {
return 9u;
}
} // namespace NEO

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

@ -154,7 +154,6 @@ class GfxCoreHelper {
virtual uint64_t getPatIndex(CacheRegion cacheRegion, CachePolicy cachePolicy) const = 0;
virtual bool isStatelessToStatefulWithOffsetSupported() const = 0;
virtual void encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) const = 0;
virtual bool isRevisionSpecificBinaryBuiltinRequired() const = 0;
virtual bool forceNonGpuCoherencyWA(bool requiresCoherency) const = 0;
virtual bool platformSupportsImplicitScaling(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) const = 0;
virtual size_t getBatchBufferEndSize() const = 0;
@ -367,7 +366,6 @@ class GfxCoreHelperHw : public GfxCoreHelper {
uint64_t getPatIndex(CacheRegion cacheRegion, CachePolicy cachePolicy) const override;
bool isStatelessToStatefulWithOffsetSupported() const override;
void encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) const override;
bool isRevisionSpecificBinaryBuiltinRequired() const override;
bool forceNonGpuCoherencyWA(bool requiresCoherency) const override;
bool platformSupportsImplicitScaling(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) const override;
size_t getBatchBufferEndSize() const override;

4
shared/source/helpers/gfx_core_helper_base.inl
View File

@ -605,10 +605,6 @@ void GfxCoreHelperHw<GfxFamily>::encodeBufferSurfaceState(EncodeSurfaceStateArgs
EncodeSurfaceState<GfxFamily>::encodeBuffer(args);
}
template <typename GfxFamily>
bool GfxCoreHelperHw<GfxFamily>::isRevisionSpecificBinaryBuiltinRequired() const {
return false;
}
template <typename GfxFamily>
bool GfxCoreHelperHw<GfxFamily>::forceNonGpuCoherencyWA(bool requiresCoherency) const {
return requiresCoherency;
}

1
shared/source/os_interface/product_helper.h
View File

@ -200,7 +200,6 @@ class ProductHelper {
virtual void fillFrontEndPropertiesSupportStructure(FrontEndPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const = 0;
virtual void fillPipelineSelectPropertiesSupportStructure(PipelineSelectPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const = 0;
virtual void fillStateBaseAddressPropertiesSupportStructure(StateBaseAddressPropertiesSupport &propertiesSupport) const = 0;
virtual uint32_t getDefaultRevisionId() const = 0;
virtual bool isFusedEuDisabledForDpas(bool kernelHasDpasInstructions, const uint32_t *lws, const uint32_t *groupCount, const HardwareInfo &hwInfo) const = 0;
virtual bool isCalculationForDisablingEuFusionWithDpasNeeded(const HardwareInfo &hwInfo) const = 0;

5
shared/source/os_interface/product_helper.inl
View File

@ -732,11 +732,6 @@ void ProductHelperHw<gfxProduct>::fillPipelineSelectPropertiesSupportStructure(P
propertiesSupport.systolicMode = isSystolicModeConfigurable(hwInfo);
}
template <PRODUCT_FAMILY gfxProduct>
uint32_t ProductHelperHw<gfxProduct>::getDefaultRevisionId() const {
return 0u;
}
template <PRODUCT_FAMILY gfxProduct>
uint64_t ProductHelperHw<gfxProduct>::overridePatIndex(AllocationType allocationType, uint64_t patIndex) const {
return patIndex;

1
shared/source/os_interface/product_helper_hw.h
View File

@ -153,7 +153,6 @@ class ProductHelperHw : public ProductHelper {
void fillFrontEndPropertiesSupportStructure(FrontEndPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const override;
void fillPipelineSelectPropertiesSupportStructure(PipelineSelectPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const override;
void fillStateBaseAddressPropertiesSupportStructure(StateBaseAddressPropertiesSupport &propertiesSupport) const override;
uint32_t getDefaultRevisionId() const override;
bool isFusedEuDisabledForDpas(bool kernelHasDpasInstructions, const uint32_t *lws, const uint32_t *groupCount, const HardwareInfo &hwInfo) const override;
bool isCalculationForDisablingEuFusionWithDpasNeeded(const HardwareInfo &hwInfo) const override;

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

@ -367,11 +367,6 @@ uint32_t GfxCoreHelperHw<Family>::getComputeUnitsUsedForScratch(const RootDevice
return hwInfo->gtSystemInfo.MaxSubSlicesSupported * hwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio;
}
template <>
bool GfxCoreHelperHw<Family>::isRevisionSpecificBinaryBuiltinRequired() const {
return true;
}
template <>
size_t GfxCoreHelperHw<Family>::getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const {
return 40 * MB;

89
shared/test/unit_test/built_ins/builtin_tests.cpp
View File

@ -24,46 +24,36 @@ HWTEST2_F(BuiltInSharedTest, givenUseBindlessBuiltinDisabledWhenBinExtensionPass
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.UseBindlessMode.set(0);
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper<ProductHelper>();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
const std::string defaultRevId = std::to_string(productHelper.getDefaultRevisionId());
std::string deviceIpString = std::to_string(hwInfo.ipVersion.architecture) + "_" + std::to_string(hwInfo.ipVersion.release) + "_" + std::to_string(hwInfo.ipVersion.revision);
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Binary, *pDevice);
std::string expectedResourceNameGeneric = "bindful_copy_buffer_to_buffer.builtin_kernel.bin";
std::string expectedResourceNameForPlatform = platformName + "_" + defaultRevId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForPlatformAndStepping = platformName + "_" + revId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForRelease = deviceIpString + "_" + expectedResourceNameGeneric;
EXPECT_EQ(resourceNames[0], expectedResourceNameForPlatformAndStepping);
EXPECT_EQ(resourceNames[1], expectedResourceNameForPlatform);
EXPECT_EQ(resourceNames[2], expectedResourceNameGeneric);
EXPECT_EQ(1u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceNameForRelease);
}
HWTEST2_F(BuiltInSharedTest, givenUseBindlessBuiltinEnabledWhenBinExtensionPassedThenNameHasBindlessPrefix, HasStatefulSupport) {
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.UseBindlessMode.set(1);
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper<ProductHelper>();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
const std::string defaultRevId = std::to_string(productHelper.getDefaultRevisionId());
std::string deviceIpString = std::to_string(hwInfo.ipVersion.architecture) + "_" + std::to_string(hwInfo.ipVersion.release) + "_" + std::to_string(hwInfo.ipVersion.revision);
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Binary, *pDevice);
std::string expectedResourceNameGeneric = "bindless_copy_buffer_to_buffer.builtin_kernel.bin";
std::string expectedResourceNameForPlatform = platformName + "_" + defaultRevId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForPlatformAndStepping = platformName + "_" + revId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForRelease = deviceIpString + "_" + expectedResourceNameGeneric;
EXPECT_EQ(resourceNames[0], expectedResourceNameForPlatformAndStepping);
EXPECT_EQ(resourceNames[1], expectedResourceNameForPlatform);
EXPECT_EQ(resourceNames[2], expectedResourceNameGeneric);
EXPECT_EQ(1u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceNameForRelease);
}
HWTEST2_F(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBuiltinFromDefaultRevisionIsTaken, HasStatefulSupport) {
HWTEST_F(BuiltInSharedTest, whenTryingToGetBuiltinResourceForUnregisteredPlatformThenOnlyIntermediateFormatIsAvailable) {
auto builtinsLib = std::make_unique<MockBuiltinsLib>();
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
hwInfo.platform.usRevId += 0xdead;
hwInfo.ipVersion.value += 0xdead;
const std::array<uint32_t, 11> builtinTypes{EBuiltInOps::CopyBufferToBuffer,
EBuiltInOps::CopyBufferRect,
EBuiltInOps::FillBuffer,
@ -75,71 +65,61 @@ HWTEST2_F(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceFor
EBuiltInOps::FillImage1d,
EBuiltInOps::FillImage2d,
EBuiltInOps::FillImage3d};
UltDeviceFactory deviceFactory{1, 0};
auto pDeviceWithDefaultRevision = deviceFactory.rootDevices[0];
for (auto &builtinType : builtinTypes) {
auto builtinResource = builtinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDevice);
EXPECT_NE(0U, builtinResource.size());
auto expectedBuiltinResource = builtinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDeviceWithDefaultRevision);
EXPECT_EQ(expectedBuiltinResource.size(), builtinResource.size());
for (auto &builtinType : builtinTypes) {
auto binaryBuiltinResource = builtinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Binary, *pDevice);
EXPECT_EQ(0U, binaryBuiltinResource.size());
auto intermediateBuiltinResource = builtinsLib->getBuiltinResource(builtinType, BuiltinCode::ECodeType::Intermediate, *pDevice);
EXPECT_NE(0U, intermediateBuiltinResource.size());
}
}
HWTEST2_F(BuiltInSharedTest, GivenStatelessBuiltinWhenGettingResourceNameThenAddressingIsStateless, HasStatefulSupport) {
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper<ProductHelper>();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
const std::string defaultRevId = std::to_string(productHelper.getDefaultRevisionId());
std::string deviceIpString = std::to_string(hwInfo.ipVersion.architecture) + "_" + std::to_string(hwInfo.ipVersion.release) + "_" + std::to_string(hwInfo.ipVersion.revision);
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBufferStateless, BuiltinCode::ECodeType::Binary, *pDevice);
std::string expectedResourceNameGeneric = "stateless_copy_buffer_to_buffer_stateless.builtin_kernel.bin";
std::string expectedResourceNameForPlatform = platformName + "_" + defaultRevId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForPlatformAndStepping = platformName + "_" + revId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForRelease = deviceIpString + "_" + expectedResourceNameGeneric;
EXPECT_EQ(resourceNames[0], expectedResourceNameForPlatformAndStepping);
EXPECT_EQ(resourceNames[1], expectedResourceNameForPlatform);
EXPECT_EQ(resourceNames[2], expectedResourceNameGeneric);
EXPECT_EQ(1u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceNameForRelease);
}
HWTEST2_F(BuiltInSharedTest, GivenPlatformWithoutStatefulAddresingSupportWhenGettingResourceNamesThenStatelessResourceNameIsReturned, HasNoStatefulSupport) {
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
std::string deviceIpString = std::to_string(hwInfo.ipVersion.architecture) + "_" + std::to_string(hwInfo.ipVersion.release) + "_" + std::to_string(hwInfo.ipVersion.revision);
{
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Binary, *pDevice);
std::string expectedResourceName = platformName + "_" + revId + "_stateless_copy_buffer_to_buffer.builtin_kernel.bin";
std::string expectedResourceName = deviceIpString + "_stateless_copy_buffer_to_buffer.builtin_kernel.bin";
EXPECT_EQ(1u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceName);
}
{
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBufferStateless, BuiltinCode::ECodeType::Binary, *pDevice);
std::string expectedResourceName = platformName + "_" + revId + "_stateless_copy_buffer_to_buffer_stateless.builtin_kernel.bin";
std::string expectedResourceName = deviceIpString + "_stateless_copy_buffer_to_buffer_stateless.builtin_kernel.bin";
EXPECT_EQ(1u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceName);
}
}
HWTEST_F(BuiltInSharedTest, GivenRequestedTypeIntermediateWhenGettingResourceNamesThenCorrectNameIsReturned) {
HWTEST_F(BuiltInSharedTest, GivenRequestedTypeIntermediateWhenGettingResourceNamesThenReturnForReleaseAndGenericResourceNames) {
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.UseBindlessMode.set(0);
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper<ProductHelper>();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
const std::string defaultRevId = std::to_string(productHelper.getDefaultRevisionId());
std::string deviceIpString = std::to_string(hwInfo.ipVersion.architecture) + "_" + std::to_string(hwInfo.ipVersion.release) + "_" + std::to_string(hwInfo.ipVersion.revision);
auto resourceNames = getBuiltinResourceNames(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Intermediate, *pDevice);
std::string expectedResourceNameGeneric = "copy_buffer_to_buffer.builtin_kernel.bc";
std::string expectedResourceNameForPlatform = platformName + "_" + defaultRevId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForPlatformAndStepping = platformName + "_" + revId + "_" + expectedResourceNameGeneric;
std::string expectedResourceNameForRelease = deviceIpString + "_" + expectedResourceNameGeneric;
EXPECT_EQ(resourceNames[0], expectedResourceNameForPlatformAndStepping);
EXPECT_EQ(resourceNames[1], expectedResourceNameForPlatform);
EXPECT_EQ(resourceNames[2], expectedResourceNameGeneric);
EXPECT_EQ(2u, resourceNames.size());
EXPECT_EQ(resourceNames[0], expectedResourceNameForRelease);
EXPECT_EQ(resourceNames[1], expectedResourceNameGeneric);
}
HWTEST_F(BuiltInSharedTest, GivenValidBuiltinTypeAndExtensionWhenCreatingBuiltinResourceNameThenCorrectNameIsReturned) {
@ -150,13 +130,6 @@ HWTEST_F(BuiltInSharedTest, GivenValidBuiltinTypeAndExtensionWhenCreatingBuiltin
HWTEST_F(BuiltInSharedTest, GivenValidBuiltinTypeAndAnyTypeWhenGettingBuiltinCodeThenNonEmptyBuiltinIsReturned) {
auto builtinsLib = std::make_unique<MockBuiltinsLib>();
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper<ProductHelper>();
const std::string platformName = hardwarePrefix[hwInfo.platform.eProductFamily];
const std::string revId = std::to_string(hwInfo.platform.usRevId);
const std::string defaultRevId = std::to_string(productHelper.getDefaultRevisionId());
auto builtinCode = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Any, *pDevice);
EXPECT_EQ(BuiltinCode::ECodeType::Binary, builtinCode.type);
EXPECT_NE(0U, builtinCode.resource.size());

4
shared/test/unit_test/gen9/cfl/test_product_helper_cfl.cpp
View File

@ -23,10 +23,6 @@ using namespace NEO;
using CflProductHelper = ProductHelperTest;
CFLTEST_F(CflProductHelper, whenGettingDefaultRevisionIdThen9IsReturned) {
EXPECT_EQ(9u, productHelper->getDefaultRevisionId());
}
CFLTEST_F(CflProductHelper, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto &compilerProductHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<CompilerProductHelper>();

4
shared/test/unit_test/gen9/kbl/test_product_helper_kbl.cpp
View File

@ -21,10 +21,6 @@ using namespace NEO;
using KblProductHelper = ProductHelperTest;
KBLTEST_F(KblProductHelper, whenGettingDefaultRevisionIdThen9IsReturned) {
EXPECT_EQ(9u, productHelper->getDefaultRevisionId());
}
KBLTEST_F(KblProductHelper, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto &compilerProductHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<CompilerProductHelper>();

4
shared/test/unit_test/gen9/skl/test_product_helper_skl.cpp
View File

@ -21,10 +21,6 @@
using namespace NEO;
using SklProductHelper = ProductHelperTest;
SKLTEST_F(SklProductHelper, whenGettingDefaultRevisionIdThen9IsReturned) {
EXPECT_EQ(9u, productHelper->getDefaultRevisionId());
}
SKLTEST_F(SklProductHelper, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto &compilerProductHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<CompilerProductHelper>();

5
shared/test/unit_test/helpers/gfx_core_helper_tests.cpp
View File

@ -1261,11 +1261,6 @@ HWTEST_F(GfxCoreHelperTest, whenBlitterSupportIsDisabledThenDontExposeAnyBcsEngi
}
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenFalseIsReturned) {
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isRevisionSpecificBinaryBuiltinRequired());
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenGettingIsPlatformFlushTaskEnabledThenTrueIsReturned) {
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto &productHelper = getHelper<ProductHelper>();

23
shared/test/unit_test/main.cpp
View File

@ -5,11 +5,13 @@
*
*/
#include "shared/source/built_ins/built_ins.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/gmm_interface.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/os_interface/product_helper.h"
#include "shared/source/utilities/const_stringref.h"
#include "shared/source/utilities/debug_settings_reader.h"
#include "shared/source/utilities/logger.h"
#include "shared/test/common/base_ult_config_listener.h"
@ -141,6 +143,25 @@ std::string getRunPath(char *argv0) {
return res;
}
void registerMockSpirvBuiltinsInEmbeddedStorage() {
const std::array<ConstStringRef, 11> builtinIntermediateNames{"copy_buffer_to_buffer.builtin_kernel.bc",
"copy_buffer_rect.builtin_kernel.bc",
"fill_buffer.builtin_kernel.bc",
"copy_buffer_to_image3d.builtin_kernel.bc",
"copy_image3d_to_buffer.builtin_kernel.bc",
"copy_image_to_image1d.builtin_kernel.bc",
"copy_image_to_image2d.builtin_kernel.bc",
"copy_image_to_image3d.builtin_kernel.bc",
"fill_image1d.builtin_kernel.bc",
"fill_image2d.builtin_kernel.bc",
"fill_image3d.builtin_kernel.bc"};
auto &storageRegistry = EmbeddedStorageRegistry::getInstance();
for (auto builtinIntermediateName : builtinIntermediateNames) {
std::string resource = "__mock_spirv_resource";
storageRegistry.store(builtinIntermediateName.str(), createBuiltinResource(resource.data(), resource.size() + 1));
}
}
int main(int argc, char **argv) {
int retVal = 0;
bool useDefaultListener = false;
@ -306,6 +327,8 @@ int main(int argc, char **argv) {
executionDirectory += "/";
executionDirectory += std::to_string(revId);
registerMockSpirvBuiltinsInEmbeddedStorage();
#ifdef WIN32
#include <direct.h>
if (_chdir(executionDirectory.c_str())) {

4
shared/test/unit_test/os_interface/product_helper_tests.cpp
View File

@ -64,10 +64,6 @@ HWTEST_F(ProductHelperTest, givenDebugFlagSetWhenAskingForHostMemCapabilitesThen
EXPECT_NE(0u, productHelper->getHostMemCapabilities(&pInHwInfo));
}
HWTEST_F(ProductHelperTest, whenGettingDefaultRevisionIdThenZeroIsReturned) {
EXPECT_EQ(0u, productHelper->getDefaultRevisionId());
}
HWTEST_F(ProductHelperTest, givenProductHelperWhenGettingSharedSystemMemCapabilitiesThenCorrectValueIsReturned) {
DebugManagerStateRestore restore;

6
shared/test/unit_test/xe_hpc_core/gfx_core_helper_xe_hpc_core_tests.cpp
View File

@ -62,12 +62,6 @@ XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, WhenGettingIsCpuImageTransferPrefe
EXPECT_TRUE(gfxCoreHelper.isCpuImageTransferPreferred(*defaultHwInfo));
}
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenGfxCoreHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenTrueIsReturned) {
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isRevisionSpecificBinaryBuiltinRequired());
}
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenGfxCoreHelperWhenCheckTimestampWaitSupportThenReturnTrue) {
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();