From 20862ad8fdf671ae61adb684335465e9081f2da0 Mon Sep 17 00:00:00 2001 From: "Naklicki, Mateusz" Date: Mon, 28 Aug 2023 11:37:11 +0000 Subject: [PATCH] fix: resolve builtins depending on the product Related-To: NEO-6875 Signed-off-by: Naklicki, Mateusz --- shared/source/compiler_interface/linker.cpp | 9 +- shared/source/os_interface/product_helper.h | 1 + shared/source/os_interface/product_helper.inl | 8 + .../source/os_interface/product_helper_hw.h | 1 + shared/source/release_helper/release_helper.h | 2 + .../release_helper/release_helper_base.inl | 5 + .../compiler_interface/CMakeLists.txt | 2 +- .../compiler_interface/linker_tests.cpp | 139 +++++++++--------- .../release_helper_12_55_tests.cpp | 1 + .../release_helper_12_56_tests.cpp | 1 + .../release_helper_12_57_tests.cpp | 1 + .../release_helper_12_70_tests.cpp | 1 + .../release_helper_12_71_tests.cpp | 1 + 13 files changed, 100 insertions(+), 72 deletions(-) diff --git a/shared/source/compiler_interface/linker.cpp b/shared/source/compiler_interface/linker.cpp index 2c63936b3f..bec0d69190 100644 --- a/shared/source/compiler_interface/linker.cpp +++ b/shared/source/compiler_interface/linker.cpp @@ -21,6 +21,7 @@ #include "shared/source/memory_manager/graphics_allocation.h" #include "shared/source/memory_manager/memory_manager.h" #include "shared/source/program/program_info.h" +#include "shared/source/release_helper/release_helper.h" #include "RelocationInfo.h" @@ -326,7 +327,13 @@ LinkingStatus Linker::link(const SegmentInfo &globalVariablesSegInfo, const Segm removeLocalSymbolsFromRelocatedSymbols(); resolveImplicitArgs(kernelDescriptors, pDevice); - resolveBuiltins(pDevice, outUnresolvedExternals, instructionsSegments); + + auto &productHelper = pDevice->getProductHelper(); + auto releaseHelper = pDevice->getReleaseHelper(); + if (productHelper.isResolvingBuiltinsNeeded(releaseHelper)) { + resolveBuiltins(pDevice, outUnresolvedExternals, instructionsSegments); + } + if (initialUnresolvedExternalsCount < outUnresolvedExternals.size()) { return LinkingStatus::LinkedPartially; } diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h index daaa84a878..a1fc11a1ac 100644 --- a/shared/source/os_interface/product_helper.h +++ b/shared/source/os_interface/product_helper.h @@ -208,6 +208,7 @@ class ProductHelper { virtual bool isCachingOnCpuAvailable() const = 0; virtual bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const = 0; virtual bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const = 0; + virtual bool isResolvingBuiltinsNeeded(const ReleaseHelper *releaseHelper) const = 0; virtual std::optional getPreferredAllocationMethod() const = 0; virtual ~ProductHelper() = default; diff --git a/shared/source/os_interface/product_helper.inl b/shared/source/os_interface/product_helper.inl index 760c3bd1c1..95c54d4d01 100644 --- a/shared/source/os_interface/product_helper.inl +++ b/shared/source/os_interface/product_helper.inl @@ -800,4 +800,12 @@ std::optional ProductHelperHw::getPreferr return {}; } +template +bool ProductHelperHw::isResolvingBuiltinsNeeded(const ReleaseHelper *releaseHelper) const { + if (releaseHelper) { + return releaseHelper->isResolvingBuiltinsNeeded(); + } + return true; +} + } // namespace NEO diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h index 2284298771..fd29e134e4 100644 --- a/shared/source/os_interface/product_helper_hw.h +++ b/shared/source/os_interface/product_helper_hw.h @@ -159,6 +159,7 @@ class ProductHelperHw : public ProductHelper { bool isCachingOnCpuAvailable() const override; bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const override; bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override; + bool isResolvingBuiltinsNeeded(const ReleaseHelper *releaseHelper) const override; std::optional getPreferredAllocationMethod() const override; ~ProductHelperHw() override = default; diff --git a/shared/source/release_helper/release_helper.h b/shared/source/release_helper/release_helper.h index ab1dd5ad8c..691612e390 100644 --- a/shared/source/release_helper/release_helper.h +++ b/shared/source/release_helper/release_helper.h @@ -33,6 +33,7 @@ class ReleaseHelper { virtual bool isBFloat16ConversionSupported() const = 0; virtual int getProductMaxPreferredSlmSize(int preferredEnumValue) const = 0; virtual bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const = 0; + virtual bool isResolvingBuiltinsNeeded() const = 0; protected: ReleaseHelper(HardwareIpVersion hardwareIpVersion) : hardwareIpVersion(hardwareIpVersion) {} @@ -55,6 +56,7 @@ class ReleaseHelperHw : public ReleaseHelper { bool isBFloat16ConversionSupported() const override; int getProductMaxPreferredSlmSize(int preferredEnumValue) const override; bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const override; + bool isResolvingBuiltinsNeeded() const override; private: ReleaseHelperHw(HardwareIpVersion hardwareIpVersion) : ReleaseHelper(hardwareIpVersion) {} diff --git a/shared/source/release_helper/release_helper_base.inl b/shared/source/release_helper/release_helper_base.inl index 044f3555bb..73708c4341 100644 --- a/shared/source/release_helper/release_helper_base.inl +++ b/shared/source/release_helper/release_helper_base.inl @@ -52,4 +52,9 @@ template bool ReleaseHelperHw::getMediaFrequencyTileIndex(uint32_t &tileIndex) const { return false; } + +template +bool ReleaseHelperHw::isResolvingBuiltinsNeeded() const { + return true; +} } // namespace NEO diff --git a/shared/test/unit_test/compiler_interface/CMakeLists.txt b/shared/test/unit_test/compiler_interface/CMakeLists.txt index 57e6c77cff..1e8d8144cb 100644 --- a/shared/test/unit_test/compiler_interface/CMakeLists.txt +++ b/shared/test/unit_test/compiler_interface/CMakeLists.txt @@ -22,4 +22,4 @@ else() target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/linux/compiler_cache_tests_linux.cpp ) -endif() \ No newline at end of file +endif() diff --git a/shared/test/unit_test/compiler_interface/linker_tests.cpp b/shared/test/unit_test/compiler_interface/linker_tests.cpp index 3cbd4305ab..8527af979a 100644 --- a/shared/test/unit_test/compiler_interface/linker_tests.cpp +++ b/shared/test/unit_test/compiler_interface/linker_tests.cpp @@ -14,6 +14,7 @@ #include "shared/source/memory_manager/graphics_allocation.h" #include "shared/source/program/program_initialization.h" #include "shared/test/common/compiler_interface/linker_mock.h" +#include "shared/test/common/fixtures/device_fixture.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/default_hw_info.h" #include "shared/test/common/helpers/gtest_helpers.h" @@ -637,7 +638,9 @@ TEST(LinkerInputTests, GivenInstructionRelocationWithLocalSymbolPointingToFuncti EXPECT_TRUE(linkerInput.getTraits().requiresPatchingOfInstructionSegments); } -TEST(LinkerTests, GivenSymbolToInstructionsAndNoCorrespondingInstructionSegmentWhenRelocatingSymbolsThenFail) { +using LinkerTests = Test; + +TEST_F(LinkerTests, GivenSymbolToInstructionsAndNoCorrespondingInstructionSegmentWhenRelocatingSymbolsThenFail) { WhiteBox linkerInput; auto &symbol = linkerInput.symbols["func"]; symbol.segment = SegmentType::Instructions; @@ -649,7 +652,7 @@ TEST(LinkerTests, GivenSymbolToInstructionsAndNoCorrespondingInstructionSegmentW EXPECT_FALSE(result); } -TEST(LinkerTests, GivenSymbolToInstructionBiggerThanCorrespondingInstructionSegmentWhenRelocatingSymbolsThenFail) { +TEST_F(LinkerTests, GivenSymbolToInstructionBiggerThanCorrespondingInstructionSegmentWhenRelocatingSymbolsThenFail) { WhiteBox linkerInput; auto &symbol = linkerInput.symbols["func"]; symbol.segment = SegmentType::Instructions; @@ -665,7 +668,7 @@ TEST(LinkerTests, GivenSymbolToInstructionBiggerThanCorrespondingInstructionSegm EXPECT_FALSE(result); } -TEST(LinkerTests, GivenValidSymbolToInstructionsWhenRelocatingSymbolsThenSymbolIsProperlyRelocated) { +TEST_F(LinkerTests, GivenValidSymbolToInstructionsWhenRelocatingSymbolsThenSymbolIsProperlyRelocated) { WhiteBox linkerInput; auto &symbol = linkerInput.symbols["func"]; symbol.segment = SegmentType::Instructions; @@ -684,7 +687,7 @@ TEST(LinkerTests, GivenValidSymbolToInstructionsWhenRelocatingSymbolsThenSymbolI EXPECT_EQ(linker.relocatedSymbols["func"].gpuAddress, instSegments[0].gpuAddress + symbol.offset); } -TEST(LinkerTests, GivenRelocationToInstructionSegmentWithLocalUndefinedSymbolWhenPatchingInstructionsSegmentsThenItIsPatchedWithZeroes) { +TEST_F(LinkerTests, GivenRelocationToInstructionSegmentWithLocalUndefinedSymbolWhenPatchingInstructionsSegmentsThenItIsPatchedWithZeroes) { WhiteBox linkerInput; linkerInput.traits.requiresPatchingOfInstructionSegments = true; NEO::LinkerInput::RelocationInfo rela; @@ -733,7 +736,7 @@ TEST(LinkerInputTests, GivenInvalidFunctionsSymbolsUsedInFunctionsRelocationsWhe EXPECT_TRUE(mockLinkerInput.extFunDependencies.empty()); } -TEST(LinkerTests, givenEmptyLinkerInputThenLinkerOutputIsEmpty) { +HWTEST_F(LinkerTests, givenEmptyLinkerInputThenLinkerOutputIsEmpty) { NEO::LinkerInput linkerInput; NEO::Linker linker(linkerInput); NEO::Linker::SegmentInfo globalVar, globalConst, exportedFunc; @@ -746,14 +749,14 @@ TEST(LinkerTests, givenEmptyLinkerInputThenLinkerOutputIsEmpty) { auto linkResult = linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); EXPECT_EQ(0U, unresolvedExternals.size()); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, relocatedSymbols.size()); } -TEST(LinkerTests, givenInvalidLinkerInputThenLinkerFails) { +HWTEST_F(LinkerTests, givenInvalidLinkerInputThenLinkerFails) { WhiteBox mockLinkerInput; mockLinkerInput.valid = false; NEO::Linker linker(mockLinkerInput); @@ -768,11 +771,11 @@ TEST(LinkerTests, givenInvalidLinkerInputThenLinkerFails) { auto linkResult = linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, extFuncs); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, extFuncs); EXPECT_EQ(NEO::LinkingStatus::Error, linkResult); } -TEST(LinkerTests, givenUnresolvedExternalSymbolsWhenResolveBuiltinsIsCalledThenSubDeviceIDSymbolsAreRmoved) { +HWTEST_F(LinkerTests, givenUnresolvedExternalSymbolsWhenResolveBuiltinsIsCalledThenSubDeviceIDSymbolsAreRemoved) { struct LinkerMock : public NEO::Linker { public: using NEO::Linker::resolveBuiltins; @@ -799,20 +802,19 @@ TEST(LinkerTests, givenUnresolvedExternalSymbolsWhenResolveBuiltinsIsCalledThenS DebugManager.flags.CreateMultipleSubDevices.set(2); DebugManager.flags.EnableImplicitScaling.set(1); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); - linker.resolveBuiltins(device.get(), unresolvedExternals, instructionsSegments); + linker.resolveBuiltins(pDevice, unresolvedExternals, instructionsSegments); EXPECT_EQ(2U, unresolvedExternals.size()); for (auto &symbol : unresolvedExternals) { EXPECT_NE(NEO::Linker::subDeviceID, symbol.unresolvedRelocation.symbolName); } - auto gpuAddressAs64bit = device->getDefaultEngine().commandStreamReceiver->getWorkPartitionAllocationGpuAddress(); + auto gpuAddressAs64bit = pDevice->getDefaultEngine().commandStreamReceiver->getWorkPartitionAllocationGpuAddress(); EXPECT_EQ(*reinterpret_cast(&instructionSegment[64]), static_cast((gpuAddressAs64bit >> 32) & 0xffffffff)); EXPECT_EQ(*reinterpret_cast(instructionSegment.data()), static_cast(gpuAddressAs64bit & 0xffffffff)); } -TEST(LinkerTests, givenUnresolvedExternalsWhenLinkThenSubDeviceIDSymbolsAreRemoved) { +HWTEST_F(LinkerTests, givenUnresolvedExternalsWhenLinkThenSubDeviceIDSymbolsAreCorrectlyHandled) { NEO::LinkerInput linkerInput; NEO::Linker linker(linkerInput); @@ -838,26 +840,31 @@ TEST(LinkerTests, givenUnresolvedExternalsWhenLinkThenSubDeviceIDSymbolsAreRemov DebugManager.flags.CreateMultipleSubDevices.set(2); DebugManager.flags.EnableImplicitScaling.set(1); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); - linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, instructionsSegments, - unresolvedExternals, device.get(), nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + + auto releaseHelper = pDevice->getReleaseHelper(); + auto &productHelper = pDevice->getProductHelper(); + size_t expectedUnresolvedExternals = productHelper.isResolvingBuiltinsNeeded(releaseHelper) ? 2u : 4u; auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, relocatedSymbols.size()); - EXPECT_EQ(2U, unresolvedExternals.size()); - for (auto &symbol : unresolvedExternals) { - EXPECT_NE(NEO::Linker::subDeviceID, symbol.unresolvedRelocation.symbolName); + EXPECT_EQ(expectedUnresolvedExternals, unresolvedExternals.size()); + + if (productHelper.isResolvingBuiltinsNeeded(releaseHelper)) { + for (auto &symbol : unresolvedExternals) { + EXPECT_NE(NEO::Linker::subDeviceID, symbol.unresolvedRelocation.symbolName); + } } - auto gpuAddressAs64bit = device->getDefaultEngine().commandStreamReceiver->getWorkPartitionAllocationGpuAddress(); + auto gpuAddressAs64bit = pDevice->getDefaultEngine().commandStreamReceiver->getWorkPartitionAllocationGpuAddress(); EXPECT_EQ(*reinterpret_cast(&instructionSegment[64]), static_cast((gpuAddressAs64bit >> 32) & 0xffffffff)); EXPECT_EQ(*reinterpret_cast(instructionSegment.data()), static_cast(gpuAddressAs64bit & 0xffffffff)); } -TEST(LinkerTests, givenUnresolvedExternalWhenPatchingInstructionsThenLinkPartially) { +HWTEST_F(LinkerTests, givenUnresolvedExternalWhenPatchingInstructionsThenLinkPartially) { NEO::LinkerInput linkerInput; vISA::GenRelocEntry entry = {}; entry.r_symbol[0] = 'A'; @@ -884,7 +891,7 @@ TEST(LinkerTests, givenUnresolvedExternalWhenPatchingInstructionsThenLinkPartial auto linkResult = linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, relocatedSymbols.size()); @@ -895,7 +902,7 @@ TEST(LinkerTests, givenUnresolvedExternalWhenPatchingInstructionsThenLinkPartial EXPECT_EQ(std::string(entry.r_symbol), std::string(unresolvedExternals[0].unresolvedRelocation.symbolName)); } -TEST(LinkerTests, givenValidSymbolsAndRelocationsThenInstructionSegmentsAreProperlyPatched) { +HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsThenInstructionSegmentsAreProperlyPatched) { NEO::LinkerInput linkerInput; vISA::GenSymEntry symGlobalVariable = {}; @@ -995,7 +1002,7 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsThenInstructionSegmentsArePrope auto linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, unresolvedExternals, - nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, unresolvedExternals.size()); @@ -1028,7 +1035,7 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsThenInstructionSegmentsArePrope EXPECT_EQ(kd.kernelAttributes.crossThreadDataSize, perThreadPayloadOffsetPatchedValue); } -TEST(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenRelocationFails) { +HWTEST_F(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenRelocationFails) { NEO::LinkerInput linkerInput; vISA::GenSymEntry symGlobalVariable = {}; @@ -1059,7 +1066,7 @@ TEST(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenRelocation auto linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::Error, linkResult); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, unresolvedExternals.size()); @@ -1069,11 +1076,11 @@ TEST(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenRelocation linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, unresolvedExternals, - nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); } -TEST(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFails) { +HWTEST_F(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFails) { NEO::LinkerInput linkerInput; vISA::GenSymEntry symGlobalVariable = {}; @@ -1111,7 +1118,7 @@ TEST(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFails) { auto linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(1U, relocatedSymbols.size()); @@ -1122,11 +1129,11 @@ TEST(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFails) { linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); } -TEST(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocationFails) { +HWTEST_F(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocationFails) { WhiteBox linkerInput; vISA::GenSymEntry symGlobalVariable = {}; @@ -1166,7 +1173,7 @@ TEST(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocationFa auto linkResult = linker.link( globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::Error, linkResult); auto relocatedSymbols = linker.extractRelocatedSymbols(); EXPECT_EQ(0U, relocatedSymbols.size()); @@ -1175,11 +1182,11 @@ TEST(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocationFa linkerInput.symbols["A"].segment = NEO::SegmentType::GlobalVariables; linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); } -TEST(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsProperlyPatched) { +HWTEST_F(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsProperlyPatched) { NEO::Linker::SegmentInfo stringSegment; stringSegment.gpuAddress = 0x1234; stringSegment.segmentSize = 0x10; @@ -1214,7 +1221,7 @@ TEST(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsPrope auto linkResult = linker.link( {}, {}, {}, stringSegment, nullptr, nullptr, patchableInstructionSegments, unresolvedExternals, - nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); EXPECT_EQ(0U, unresolvedExternals.size()); EXPECT_TRUE(linker.extractRelocatedSymbols().empty()); @@ -1225,7 +1232,7 @@ TEST(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsPrope EXPECT_EQ(static_cast(strAddr), *reinterpret_cast(patchAddr)); } -TEST(LinkerTests, givenValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenTheyAreProperlyPatched) { +HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenTheyAreProperlyPatched) { uint64_t initGlobalConstantData[3]; initGlobalConstantData[0] = 0x10; // var1 address will be added here initGlobalConstantData[1] = 0x1234; // <- const1 @@ -1363,13 +1370,12 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenThe } NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; auto linkResult = linker.link(globalVariablesSegmentInfo, globalConstantsSegmentInfo, exportedFunctionsSegmentInfo, {}, &globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {}, - unresolvedExternals, device.get(), initGlobalConstantData, sizeof(initGlobalConstantData), + unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); EXPECT_EQ(0U, unresolvedExternals.size()); @@ -1400,7 +1406,7 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenThe } } -TEST(LinkerTests, givenValidSymbolsAndRelocationsToBssDataSectionsWhenPatchingDataSegmentsThenTheyAreProperlyPatched) { +HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsToBssDataSectionsWhenPatchingDataSegmentsThenTheyAreProperlyPatched) { uint64_t initGlobalConstantData[] = {0x1234}; //<- const1 - initValue should be ignored uint64_t initGlobalVariablesData[] = {0x4321}; // <- var1 - initValue should be ignored @@ -1515,13 +1521,12 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsToBssDataSectionsWhenPatchingDa } NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; auto linkResult = linker.link(globalVariablesSegmentInfo, globalConstantsSegmentInfo, {}, {}, &globalVariablesPatchableSegment, &globalConstantsPatchableSegment, patchableInstructionSegments, - unresolvedExternals, device.get(), initGlobalConstantData, sizeof(initGlobalConstantData), + unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); EXPECT_EQ(0U, unresolvedExternals.size()); @@ -1540,7 +1545,7 @@ TEST(LinkerTests, givenValidSymbolsAndRelocationsToBssDataSectionsWhenPatchingDa EXPECT_EQ(bssVarAddr, *(reinterpret_cast(instructionsData2.data()))); } -TEST(LinkerTests, givenInvalidSymbolWhenPatchingDataSegmentsThenRelocationIsUnresolved) { +HWTEST_F(LinkerTests, givenInvalidSymbolWhenPatchingDataSegmentsThenRelocationIsUnresolved) { uint64_t initGlobalConstantData[3] = {}; uint64_t initGlobalVariablesData[3] = {}; @@ -1563,19 +1568,18 @@ TEST(LinkerTests, givenInvalidSymbolWhenPatchingDataSegmentsThenRelocationIsUnre linkerInput.dataRelocations.push_back(relocationInfo); NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; auto linkResult = linker.link(globalVariablesSegmentInfo, globalConstantsSegmentInfo, {}, {}, &globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {}, - unresolvedExternals, device.get(), initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, + unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult); EXPECT_EQ(1U, unresolvedExternals.size()); } -TEST(LinkerTests, givenInvalidRelocationOffsetWhenPatchingDataSegmentsThenRelocationIsUnresolved) { +HWTEST_F(LinkerTests, givenInvalidRelocationOffsetWhenPatchingDataSegmentsThenRelocationIsUnresolved) { uint64_t initGlobalConstantData[3] = {}; uint64_t initGlobalVariablesData[3] = {}; @@ -1603,19 +1607,18 @@ TEST(LinkerTests, givenInvalidRelocationOffsetWhenPatchingDataSegmentsThenReloca linkerInput.dataRelocations.push_back(relocationInfo); NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; auto linkResult = linker.link(globalVariablesSegmentInfo, globalConstantsSegmentInfo, {}, {}, &globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {}, - unresolvedExternals, device.get(), initGlobalConstantData, sizeof(initGlobalConstantData), + unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult); EXPECT_EQ(1U, unresolvedExternals.size()); } -TEST(LinkerTests, givenInvalidRelocationSegmentWhenPatchingDataSegmentsThenRelocationIsUnresolved) { +HWTEST_F(LinkerTests, givenInvalidRelocationSegmentWhenPatchingDataSegmentsThenRelocationIsUnresolved) { WhiteBox linkerInput; auto &symbol = linkerInput.symbols["symbol"]; symbol.segment = SegmentType::GlobalVariables; @@ -1628,7 +1631,6 @@ TEST(LinkerTests, givenInvalidRelocationSegmentWhenPatchingDataSegmentsThenReloc relocationInfo.type = NEO::LinkerInput::RelocationInfo::Type::Address; linkerInput.dataRelocations.push_back(relocationInfo); NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; @@ -1637,12 +1639,12 @@ TEST(LinkerTests, givenInvalidRelocationSegmentWhenPatchingDataSegmentsThenReloc globalSegment.segmentSize = 8u; auto linkResult = linker.link(globalSegment, {}, {}, {}, nullptr, nullptr, {}, - unresolvedExternals, device.get(), nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult); EXPECT_EQ(1U, unresolvedExternals.size()); } -TEST(LinkerTests, given32BitBinaryWithValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenTreatAddressRelocationAsLowerHalfOfTheAddress) { +HWTEST_F(LinkerTests, given32BitBinaryWithValidSymbolsAndRelocationsWhenPatchingDataSegmentsThenTreatAddressRelocationAsLowerHalfOfTheAddress) { uint64_t initGlobalConstantData[3] = {}; uint64_t initGlobalVariablesData[3] = {}; @@ -1671,13 +1673,12 @@ TEST(LinkerTests, given32BitBinaryWithValidSymbolsAndRelocationsWhenPatchingData linkerInput.dataRelocations.push_back(relocationInfo); NEO::Linker linker(linkerInput); - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; NEO::Linker::KernelDescriptorsT kernelDescriptors; NEO::Linker::ExternalFunctionsT externalFunctions; auto linkResult = linker.link(globalVariablesSegmentInfo, globalConstantsSegmentInfo, {}, {}, &globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {}, - unresolvedExternals, device.get(), initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, + unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions); EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult); EXPECT_EQ(0U, unresolvedExternals.size()); @@ -1781,7 +1782,7 @@ TEST(RelocationsDebugMessageTests, givenListOfRelocatedSymbolsThenReturnProperDe EXPECT_STREQ(expected.str().c_str(), message.c_str()); } -TEST(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocationsAreAppliedInMemory) { +TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocationsAreAppliedInMemory) { NEO::Elf::ElfFileHeader header; header.shOff = header.ehSize; header.shNum = 4; @@ -1933,7 +1934,7 @@ TEST(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocationsA EXPECT_EQ(expectedValue5, *reloc5Location); } -TEST(LinkerTests, givenImplicitArgRelocationAndStackCallsThenPatchRelocationWithSizeOfImplicitArgStructAndUpdateKernelDescriptor) { +TEST_F(LinkerTests, givenImplicitArgRelocationAndStackCallsThenPatchRelocationWithSizeOfImplicitArgStructAndUpdateKernelDescriptor) { NEO::LinkerInput linkerInput; vISA::GenRelocEntry reloc = {}; @@ -2098,7 +2099,7 @@ TEST_F(LinkerDebuggingSupportedTests, givenNoImplicitArgRelocationAndEnabledDebu EXPECT_FALSE(kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs); } -TEST(LinkerTests, givenImplicitArgRelocationWithoutStackCallsAndDisabledDebuggerThenDontPatchRelocationAndUpdateKernelDescriptor) { +TEST_F(LinkerTests, givenImplicitArgRelocationWithoutStackCallsAndDisabledDebuggerThenDontPatchRelocationAndUpdateKernelDescriptor) { NEO::LinkerInput linkerInput; vISA::GenRelocEntry reloc = {}; @@ -2155,7 +2156,7 @@ TEST(LinkerTests, givenImplicitArgRelocationWithoutStackCallsAndDisabledDebugger EXPECT_FALSE(kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs); } -TEST(LinkerTests, givenNoImplicitArgRelocationAndStackCallsThenImplicitArgsAreNotRequired) { +TEST_F(LinkerTests, givenNoImplicitArgRelocationAndStackCallsThenImplicitArgsAreNotRequired) { NEO::LinkerInput linkerInput; NEO::Linker linker(linkerInput); @@ -2198,7 +2199,7 @@ TEST(LinkerTests, givenNoImplicitArgRelocationAndStackCallsThenImplicitArgsAreNo EXPECT_FALSE(kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs); } -TEST(LinkerTests, givenMultipleImplicitArgsRelocationsWithinSingleKernelWhenLinkingThenPatchAllOfThem) { +TEST_F(LinkerTests, givenMultipleImplicitArgsRelocationsWithinSingleKernelWhenLinkingThenPatchAllOfThem) { NEO::LinkerInput linkerInput; vISA::GenRelocEntry reloc0 = {}; @@ -2256,7 +2257,7 @@ TEST(LinkerTests, givenMultipleImplicitArgsRelocationsWithinSingleKernelWhenLink } } -TEST(LinkerTests, givenDependencyOnMissingExternalFunctionWhenLinkingThenFail) { +HWTEST_F(LinkerTests, givenDependencyOnMissingExternalFunctionWhenLinkingThenFail) { WhiteBox linkerInput; linkerInput.extFunDependencies.push_back({"fun0", "fun1"}); NEO::Linker linker(linkerInput); @@ -2270,11 +2271,11 @@ TEST(LinkerTests, givenDependencyOnMissingExternalFunctionWhenLinkingThenFail) { auto linkResult = linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(LinkingStatus::Error, linkResult); } -TEST(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunctionInfosWhenLinkingThenDoNotResolveDependenciesAndReturnSuccess) { +HWTEST_F(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunctionInfosWhenLinkingThenDoNotResolveDependenciesAndReturnSuccess) { WhiteBox linkerInput; linkerInput.extFunDependencies.push_back({"fun0", "fun1"}); NEO::Linker linker(linkerInput); @@ -2288,11 +2289,11 @@ TEST(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunctionI auto linkResult = linker.link( globalVar, globalConst, exportedFunc, {}, patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, - unresolvedExternals, nullptr, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); + unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions); EXPECT_EQ(LinkingStatus::LinkedFully, linkResult); } -TEST(LinkerTests, givenRelaWhenPatchingInstructionsSegmentThenAddendIsAdded) { +TEST_F(LinkerTests, givenRelaWhenPatchingInstructionsSegmentThenAddendIsAdded) { WhiteBox linkerInput; linkerInput.traits.requiresPatchingOfInstructionSegments = true; NEO::LinkerInput::RelocationInfo rela; @@ -2318,7 +2319,7 @@ TEST(LinkerTests, givenRelaWhenPatchingInstructionsSegmentThenAddendIsAdded) { EXPECT_EQ(static_cast(rela.addend + symValue), segmentData); } -TEST(LinkerTests, givenRelaWhenPatchingDataSegmentThenAddendIsAdded) { +HWTEST_F(LinkerTests, givenRelaWhenPatchingDataSegmentThenAddendIsAdded) { uint64_t globalConstantSegmentData{0U}; NEO::MockGraphicsAllocation globalConstantsPatchableSegment{&globalConstantSegmentData, sizeof(globalConstantSegmentData)}; @@ -2340,13 +2341,12 @@ TEST(LinkerTests, givenRelaWhenPatchingDataSegmentThenAddendIsAdded) { constexpr uint64_t symValue = 64U; linker.relocatedSymbols[rela.symbolName].gpuAddress = symValue; - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; - linker.patchDataSegments({}, globalConstantsSegmentInfo, {}, &globalConstantsPatchableSegment, unresolvedExternals, device.get(), &globalConstantSegmentData, sizeof(globalConstantSegmentData), nullptr, 0); + linker.patchDataSegments({}, globalConstantsSegmentInfo, {}, &globalConstantsPatchableSegment, unresolvedExternals, pDevice, &globalConstantSegmentData, sizeof(globalConstantSegmentData), nullptr, 0); EXPECT_EQ(static_cast(rela.addend + symValue), globalConstantSegmentData); } -TEST(LinkerTests, givenRelocationInfoWhenPatchingDataSegmentWithGlobalVariableSymbolThenAddendIsAdded) { +HWTEST_F(LinkerTests, givenRelocationInfoWhenPatchingDataSegmentWithGlobalVariableSymbolThenAddendIsAdded) { uint64_t globalVariableSegmentData{0U}; NEO::MockGraphicsAllocation globalVariablesPatchableSegment{&globalVariableSegmentData, sizeof(globalVariableSegmentData)}; @@ -2368,13 +2368,12 @@ TEST(LinkerTests, givenRelocationInfoWhenPatchingDataSegmentWithGlobalVariableSy constexpr uint64_t symValue = 64U; linker.relocatedSymbols[relocationInfo.symbolName].gpuAddress = symValue; - auto device = std::unique_ptr(NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get())); NEO::Linker::UnresolvedExternals unresolvedExternals; - linker.patchDataSegments(globalVariablesSegmentInfo, {}, &globalVariablesPatchableSegment, {}, unresolvedExternals, device.get(), nullptr, 0, &globalVariableSegmentData, sizeof(globalVariableSegmentData)); + linker.patchDataSegments(globalVariablesSegmentInfo, {}, &globalVariablesPatchableSegment, {}, unresolvedExternals, pDevice, nullptr, 0, &globalVariableSegmentData, sizeof(globalVariableSegmentData)); EXPECT_EQ(static_cast(relocationInfo.addend + symValue), globalVariableSegmentData); } -TEST(LinkerTests, givenPerThreadPayloadOffsetRelocationWhenPatchingInstructionSegmentsThenPatchItWithCTDSize) { +TEST_F(LinkerTests, givenPerThreadPayloadOffsetRelocationWhenPatchingInstructionSegmentsThenPatchItWithCTDSize) { WhiteBox linkerInput; linkerInput.traits.requiresPatchingOfInstructionSegments = true; NEO::LinkerInput::RelocationInfo rel; diff --git a/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp index cda49ec5ee..bc06883bb8 100644 --- a/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp +++ b/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp @@ -27,6 +27,7 @@ TEST(ReleaseHelperTest, givenReleaseHelper1255ThenCorrectPropertiesAreReturned) EXPECT_EQ(revision < 4, releaseHelper->isPrefetchDisablingRequired()); EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported()); + EXPECT_TRUE(releaseHelper->isResolvingBuiltinsNeeded()); } } diff --git a/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp index 0d1dea6bb3..47b3b8de02 100644 --- a/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp +++ b/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp @@ -27,6 +27,7 @@ TEST(ReleaseHelperTest, givenReleaseHelper1256ThenCorrectPropertiesAreReturned) EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired()); EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported()); + EXPECT_TRUE(releaseHelper->isResolvingBuiltinsNeeded()); } } diff --git a/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp index 443042eb6e..15681da183 100644 --- a/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp +++ b/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp @@ -27,6 +27,7 @@ TEST(ReleaseHelperTest, givenReleaseHelper1257ThenCorrectPropertiesAreReturned) EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired()); EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported()); + EXPECT_TRUE(releaseHelper->isResolvingBuiltinsNeeded()); } } diff --git a/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp index 3969d6ccbe..4bd5156ad1 100644 --- a/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp +++ b/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp @@ -28,6 +28,7 @@ TEST(ReleaseHelperTest, givenReleaseHelper1270ThenCorrectPropertiesAreReturned) EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired()); EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported()); + EXPECT_TRUE(releaseHelper->isResolvingBuiltinsNeeded()); } } diff --git a/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp index 4ef6ec39be..ec84ecbfeb 100644 --- a/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp +++ b/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp @@ -28,6 +28,7 @@ TEST(ReleaseHelperTest, givenReleaseHelper1271ThenCorrectPropertiesAreReturned) EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired()); EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported()); + EXPECT_TRUE(releaseHelper->isResolvingBuiltinsNeeded()); } }