Skip to content

Commit abb1f30

Browse files
JablonskiMateuszCompute-Runtime-Automation
JablonskiMateusz
authored and
Compute-Runtime-Automation
committed
Program implicit args only in case of stack calls or enabled debugger
Related-To: NEO-5081 Signed-off-by: Mateusz Jablonski <[email protected]>
1 parent 8e57e48 commit abb1f30

File tree

4 files changed

+353
-8
lines changed

4 files changed

+353
-8
lines changed

‎level_zero/core/test/unit_tests/sources/module/test_module.cpp‎

Lines changed: 69 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1931,7 +1931,7 @@ TEST_F(ModuleTests, givenConstDataStringSectionWhenLinkingModuleThenSegmentIsPat
19311931
EXPECT_EQ(static_cast<size_t>(stringsAddr), *reinterpret_cast<size_t *>(patchAddr));
19321932
}
19331933

1934-
TEST_F(ModuleTests, givenImplicitArgsRelocationWhenLinkingModuleThenSegmentIsPatchedAndImplicitArgsAreRequired) {
1934+
TEST_F(ModuleTests, givenImplicitArgsRelocationAndStackCallsWhenLinkingModuleThenSegmentIsPatchedAndImplicitArgsAreRequired) {
19351935
auto pModule = std::make_unique<Module>(device, nullptr, ModuleType::User);
19361936

19371937
char data[64]{};
@@ -1942,6 +1942,7 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationWhenLinkingModuleThenSegmentIsPat
19421942
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
19431943
kernelImmData->initialize(kernelInfo, device, 0, nullptr, nullptr, false);
19441944

1945+
kernelImmData->kernelDescriptor->kernelAttributes.flags.useStackCalls = true;
19451946
auto isaCpuPtr = reinterpret_cast<char *>(kernelImmData->isaGraphicsAllocation->getUnderlyingBuffer());
19461947
pModule->kernelImmDatas.push_back(std::move(kernelImmData));
19471948
pModule->translationUnit->programInfo.kernelInfos.push_back(kernelInfo);
@@ -1959,6 +1960,73 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationWhenLinkingModuleThenSegmentIsPat
19591960
EXPECT_TRUE(kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
19601961
}
19611962

1963+
TEST_F(ModuleTests, givenImplicitArgsRelocationAndDebuggerEnabledWhenLinkingModuleThenSegmentIsPatchedAndImplicitArgsAreRequired) {
1964+
if (!defaultHwInfo->capabilityTable.debuggerSupported) {
1965+
GTEST_SKIP();
1966+
}
1967+
DebugManagerStateRestore restorer;
1968+
DebugManager.flags.EnableMockSourceLevelDebugger.set(1);
1969+
auto pModule = std::make_unique<Module>(device, nullptr, ModuleType::User);
1970+
device->getNEODevice()->getRootDeviceEnvironmentRef().initDebugger();
1971+
1972+
EXPECT_NE(nullptr, neoDevice->getDebugger());
1973+
1974+
char data[64]{};
1975+
auto kernelInfo = new KernelInfo();
1976+
kernelInfo->heapInfo.KernelHeapSize = 64;
1977+
kernelInfo->heapInfo.pKernelHeap = data;
1978+
1979+
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
1980+
kernelImmData->initialize(kernelInfo, device, 0, nullptr, nullptr, false);
1981+
1982+
kernelImmData->kernelDescriptor->kernelAttributes.flags.useStackCalls = false;
1983+
auto isaCpuPtr = reinterpret_cast<char *>(kernelImmData->isaGraphicsAllocation->getUnderlyingBuffer());
1984+
pModule->kernelImmDatas.push_back(std::move(kernelImmData));
1985+
pModule->translationUnit->programInfo.kernelInfos.push_back(kernelInfo);
1986+
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
1987+
linkerInput->traits.requiresPatchingOfInstructionSegments = true;
1988+
linkerInput->relocations.push_back({{implicitArgsRelocationSymbolName, 0x8, LinkerInput::RelocationInfo::Type::AddressLow, SegmentType::Instructions}});
1989+
pModule->translationUnit->programInfo.linkerInput = std::move(linkerInput);
1990+
1991+
EXPECT_FALSE(kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
1992+
auto status = pModule->linkBinary();
1993+
EXPECT_TRUE(status);
1994+
1995+
EXPECT_EQ(sizeof(ImplicitArgs), *reinterpret_cast<uint32_t *>(ptrOffset(isaCpuPtr, 0x8)));
1996+
1997+
EXPECT_TRUE(kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
1998+
}
1999+
2000+
TEST_F(ModuleTests, givenImplicitArgsRelocationAndNoDebuggerOrStackCallsWhenLinkingModuleThenSegmentIsPatchedAndImplicitArgsAreNotRequired) {
2001+
auto pModule = std::make_unique<Module>(device, nullptr, ModuleType::User);
2002+
EXPECT_EQ(nullptr, neoDevice->getDebugger());
2003+
2004+
char data[64]{};
2005+
auto kernelInfo = new KernelInfo();
2006+
kernelInfo->heapInfo.KernelHeapSize = 64;
2007+
kernelInfo->heapInfo.pKernelHeap = data;
2008+
2009+
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
2010+
kernelImmData->initialize(kernelInfo, device, 0, nullptr, nullptr, false);
2011+
2012+
kernelImmData->kernelDescriptor->kernelAttributes.flags.useStackCalls = false;
2013+
auto isaCpuPtr = reinterpret_cast<char *>(kernelImmData->isaGraphicsAllocation->getUnderlyingBuffer());
2014+
pModule->kernelImmDatas.push_back(std::move(kernelImmData));
2015+
pModule->translationUnit->programInfo.kernelInfos.push_back(kernelInfo);
2016+
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
2017+
linkerInput->traits.requiresPatchingOfInstructionSegments = true;
2018+
linkerInput->relocations.push_back({{implicitArgsRelocationSymbolName, 0x8, LinkerInput::RelocationInfo::Type::AddressLow, SegmentType::Instructions}});
2019+
pModule->translationUnit->programInfo.linkerInput = std::move(linkerInput);
2020+
2021+
EXPECT_FALSE(kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
2022+
auto status = pModule->linkBinary();
2023+
EXPECT_TRUE(status);
2024+
2025+
EXPECT_EQ(0u, *reinterpret_cast<uint32_t *>(ptrOffset(isaCpuPtr, 0x8)));
2026+
2027+
EXPECT_FALSE(kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
2028+
}
2029+
19622030
using ModuleWithZebinTest = Test<ModuleWithZebinFixture>;
19632031
TEST_F(ModuleWithZebinTest, givenNoZebinThenSegmentsAreEmpty) {
19642032
auto segments = module->getZebinSegments();

‎opencl/test/unit_test/program/program_data_tests.cpp‎

Lines changed: 61 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
#include "shared/source/memory_manager/graphics_allocation.h"
1111
#include "shared/source/memory_manager/unified_memory_manager.h"
1212
#include "shared/source/program/program_info_from_patchtokens.h"
13+
#include "shared/test/common/helpers/debug_manager_state_restore.h"
1314
#include "shared/test/common/mocks/mock_csr.h"
1415
#include "shared/test/common/mocks/mock_execution_environment.h"
1516
#include "shared/test/common/mocks/mock_memory_manager.h"
@@ -728,12 +729,13 @@ TEST(ProgramStringSectionTest, WhenConstStringBufferIsPresentThenUseItForLinking
728729
program.getKernelInfoArray(rootDeviceIndex).clear();
729730
}
730731

731-
TEST(ProgramImplicitArgsTest, whenImplicitRelocationIsPresentThenKernelRequiresImplicitArgs) {
732+
TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndStackCallsThenKernelRequiresImplicitArgs) {
732733
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
733734
auto rootDeviceIndex = device->getRootDeviceIndex();
734735
MockProgram program{nullptr, false, toClDeviceVector(*device)};
735736
KernelInfo kernelInfo = {};
736737
kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
738+
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = true;
737739
uint8_t kernelHeapData[64] = {};
738740
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
739741
kernelInfo.heapInfo.KernelHeapSize = 64;
@@ -751,3 +753,61 @@ TEST(ProgramImplicitArgsTest, whenImplicitRelocationIsPresentThenKernelRequiresI
751753
EXPECT_TRUE(kernelInfo.kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
752754
program.getKernelInfoArray(rootDeviceIndex).clear();
753755
}
756+
757+
TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndEnabledDebuggerThenKernelRequiresImplicitArgs) {
758+
if (!defaultHwInfo->capabilityTable.debuggerSupported) {
759+
GTEST_SKIP();
760+
}
761+
DebugManagerStateRestore restorer;
762+
DebugManager.flags.EnableMockSourceLevelDebugger.set(1);
763+
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
764+
765+
EXPECT_NE(nullptr, device->getDebugger());
766+
auto rootDeviceIndex = device->getRootDeviceIndex();
767+
MockProgram program{nullptr, false, toClDeviceVector(*device)};
768+
KernelInfo kernelInfo = {};
769+
kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
770+
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = false;
771+
uint8_t kernelHeapData[64] = {};
772+
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
773+
kernelInfo.heapInfo.KernelHeapSize = 64;
774+
MockGraphicsAllocation kernelIsa(kernelHeapData, 64);
775+
kernelInfo.kernelAllocation = &kernelIsa;
776+
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
777+
778+
auto linkerInput = std::make_unique<WhiteBox<LinkerInput>>();
779+
linkerInput->relocations.push_back({{implicitArgsRelocationSymbolName, 0x8, LinkerInput::RelocationInfo::Type::AddressLow, SegmentType::Instructions}});
780+
linkerInput->traits.requiresPatchingOfInstructionSegments = true;
781+
program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
782+
auto ret = program.linkBinary(&device->getDevice(), nullptr, nullptr, {});
783+
EXPECT_EQ(CL_SUCCESS, ret);
784+
785+
EXPECT_TRUE(kernelInfo.kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
786+
program.getKernelInfoArray(rootDeviceIndex).clear();
787+
}
788+
789+
TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndNoStackCallsAndDisabledDebuggerThenKernelDoesntRequireImplicitArgs) {
790+
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
791+
EXPECT_EQ(nullptr, device->getDebugger());
792+
auto rootDeviceIndex = device->getRootDeviceIndex();
793+
MockProgram program{nullptr, false, toClDeviceVector(*device)};
794+
KernelInfo kernelInfo = {};
795+
kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
796+
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = false;
797+
uint8_t kernelHeapData[64] = {};
798+
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
799+
kernelInfo.heapInfo.KernelHeapSize = 64;
800+
MockGraphicsAllocation kernelIsa(kernelHeapData, 64);
801+
kernelInfo.kernelAllocation = &kernelIsa;
802+
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
803+
804+
auto linkerInput = std::make_unique<WhiteBox<LinkerInput>>();
805+
linkerInput->relocations.push_back({{implicitArgsRelocationSymbolName, 0x8, LinkerInput::RelocationInfo::Type::AddressLow, SegmentType::Instructions}});
806+
linkerInput->traits.requiresPatchingOfInstructionSegments = true;
807+
program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
808+
auto ret = program.linkBinary(&device->getDevice(), nullptr, nullptr, {});
809+
EXPECT_EQ(CL_SUCCESS, ret);
810+
811+
EXPECT_FALSE(kernelInfo.kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
812+
program.getKernelInfoArray(rootDeviceIndex).clear();
813+
}

‎shared/source/compiler_interface/linker.cpp‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -470,9 +470,14 @@ void Linker::resolveImplicitArgs(const KernelDescriptorsT &kernelDescriptors, De
470470
UNRECOVERABLE_IF(!kernelDescriptors[i]);
471471
KernelDescriptor &kernelDescriptor = *kernelDescriptors[i];
472472
auto pImplicitArgsReloc = pImplicitArgsRelocationAddresses.find(i);
473-
kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs = pImplicitArgsReloc != pImplicitArgsRelocationAddresses.end();
474-
if (kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs) {
475-
*pImplicitArgsReloc->second = sizeof(ImplicitArgs);
473+
if (pImplicitArgsReloc != pImplicitArgsRelocationAddresses.end()) {
474+
UNRECOVERABLE_IF(!pDevice);
475+
kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs = kernelDescriptor.kernelAttributes.flags.useStackCalls || pDevice->getDebugger() != nullptr;
476+
if (kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs) {
477+
*pImplicitArgsReloc->second = sizeof(ImplicitArgs);
478+
} else {
479+
*pImplicitArgsReloc->second = 0u;
480+
}
476481
}
477482
}
478483
}

0 commit comments

Comments
 (0)