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

refactor: Rename member variables to camelCase 3/n 

Additionally enable clang-tidy check for member variables

Signed-off-by: Fabian Zwolinski <fabian.zwolinski@intel.com>
This commit is contained in:
Fabian Zwolinski 2023-04-28 09:38:31 +00:00 committed by Compute-Runtime-Automation
parent fd1ad7c1f0
commit cbce863dc2
111 changed files with 622 additions and 620 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-tidy
View File

@ -24,6 +24,8 @@ CheckOptions:
value: camelBack
- key: readability-identifier-naming.ClassMemberCase
value: camelBack
- key: readability-identifier-naming.MemberCase
value: camelBack
- key: readability-identifier-naming.ClassMethodCase
value: camelBack
- key: readability-identifier-naming.LocalVariableCase

12
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -76,7 +76,7 @@ ze_result_t KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device
auto neoDevice = deviceImp->getActiveDevice();
auto memoryManager = neoDevice->getMemoryManager();
auto kernelIsaSize = kernelInfo->heapInfo.KernelHeapSize;
auto kernelIsaSize = kernelInfo->heapInfo.kernelHeapSize;
UNRECOVERABLE_IF(kernelIsaSize == 0);
UNRECOVERABLE_IF(!kernelInfo->heapInfo.pKernelHeap);
const auto allocType = internalKernel ? NEO::AllocationType::KERNEL_ISA_INTERNAL : NEO::AllocationType::KERNEL_ISA;
@ -112,16 +112,16 @@ ze_result_t KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device
kernelDescriptor->payloadMappings.implicitArgs.simdSize, kernelDescriptor->kernelAttributes.simdSize);
}
if (kernelInfo->heapInfo.SurfaceStateHeapSize != 0) {
this->surfaceStateHeapSize = kernelInfo->heapInfo.SurfaceStateHeapSize;
if (kernelInfo->heapInfo.surfaceStateHeapSize != 0) {
this->surfaceStateHeapSize = kernelInfo->heapInfo.surfaceStateHeapSize;
surfaceStateHeapTemplate.reset(new uint8_t[surfaceStateHeapSize]);
memcpy_s(surfaceStateHeapTemplate.get(), surfaceStateHeapSize,
kernelInfo->heapInfo.pSsh, surfaceStateHeapSize);
}
if (kernelInfo->heapInfo.DynamicStateHeapSize != 0) {
this->dynamicStateHeapSize = kernelInfo->heapInfo.DynamicStateHeapSize;
if (kernelInfo->heapInfo.dynamicStateHeapSize != 0) {
this->dynamicStateHeapSize = kernelInfo->heapInfo.dynamicStateHeapSize;
dynamicStateHeapTemplate.reset(new uint8_t[dynamicStateHeapSize]);
memcpy_s(dynamicStateHeapTemplate.get(), dynamicStateHeapSize,
@ -841,7 +841,7 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
isaAllocation,
0,
this->kernelImmData->getKernelInfo()->heapInfo.pKernelHeap,
static_cast<size_t>(this->kernelImmData->getKernelInfo()->heapInfo.KernelHeapSize));
static_cast<size_t>(this->kernelImmData->getKernelInfo()->heapInfo.kernelHeapSize));
}
for (const auto &argT : kernelDescriptor.payloadMappings.explicitArgs) {

12
level_zero/core/source/module/module_imp.cpp
View File

@ -656,7 +656,7 @@ ze_result_t ModuleImp::initialize(const ze_module_desc_t *desc, NEO::Device *neo
NEO::MemoryTransferHelper::transferMemoryToAllocation(productHelper.isBlitCopyRequiredForLocalMemory(rootDeviceEnvironment, *ki->getIsaGraphicsAllocation()),
*neoDevice, ki->getIsaGraphicsAllocation(), 0, ki->getKernelInfo()->heapInfo.pKernelHeap,
static_cast<size_t>(ki->getKernelInfo()->heapInfo.KernelHeapSize));
static_cast<size_t>(ki->getKernelInfo()->heapInfo.kernelHeapSize));
ki->setIsaCopiedToAllocation();
}
@ -711,7 +711,7 @@ void ModuleImp::passDebugData() {
device->getSourceLevelDebugger()->notifyKernelDebugData(notifyDebugData,
kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
kernelInfo->heapInfo.pKernelHeap,
kernelInfo->heapInfo.KernelHeapSize);
kernelInfo->heapInfo.kernelHeapSize);
}
}
}
@ -935,8 +935,8 @@ bool ModuleImp::linkBinary() {
auto kernelInfo = this->translationUnit->programInfo.kernelInfos.at(i);
auto &kernHeapInfo = kernelInfo->heapInfo;
const char *originalIsa = reinterpret_cast<const char *>(kernHeapInfo.pKernelHeap);
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.KernelHeapSize));
isaSegmentsForPatching.push_back(Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelImmDatas.at(i)->getIsaGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.KernelHeapSize});
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.kernelHeapSize));
isaSegmentsForPatching.push_back(Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelImmDatas.at(i)->getIsaGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.kernelHeapSize});
kernelDescriptors.push_back(&kernelInfo->kernelDescriptor);
}
}
@ -1178,8 +1178,8 @@ ze_result_t ModuleImp::performDynamicLink(uint32_t numModules,
const auto kernelInfo = this->translationUnit->programInfo.kernelInfos.at(i);
auto &kernHeapInfo = kernelInfo->heapInfo;
const char *originalIsa = reinterpret_cast<const char *>(kernHeapInfo.pKernelHeap);
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.KernelHeapSize));
isaSegmentsForPatching.push_back(NEO::Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelImmDatas.at(i)->getIsaGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.KernelHeapSize});
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.kernelHeapSize));
isaSegmentsForPatching.push_back(NEO::Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelImmDatas.at(i)->getIsaGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.kernelHeapSize});
}
}
for (const auto &unresolvedExternal : moduleId->unresolvedExternalsInfo) {

2
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp
View File

@ -196,7 +196,7 @@ void CommandListPrivateHeapsFixture::setUp() {
mockKernelImmData->kernelDescriptor->payloadMappings.samplerTable.borderColor = 0;
kernel->dynamicStateHeapData.reset(new uint8_t[512]);
mockKernelImmData->mockKernelInfo->heapInfo.SurfaceStateHeapSize = 128;
mockKernelImmData->mockKernelInfo->heapInfo.surfaceStateHeapSize = 128;
mockKernelImmData->kernelDescriptor->payloadMappings.bindingTable.numEntries = 1;
mockKernelImmData->kernelDescriptor->payloadMappings.bindingTable.tableOffset = 64;
kernel->surfaceStateHeapDataSize = 128;

2
level_zero/core/test/unit_tests/fixtures/module_fixture.cpp
View File

@ -29,7 +29,7 @@ ModuleImmutableDataFixture::MockImmutableData::MockImmutableData(uint32_t perHwT
mockKernelInfo = new NEO::KernelInfo;
mockKernelInfo->heapInfo.pKernelHeap = kernelHeap;
mockKernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
mockKernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
kernelInfo = mockKernelInfo;
auto ptr = reinterpret_cast<void *>(0x1234);

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp
View File

@ -854,12 +854,12 @@ HWTEST2_F(ImmediateCmdListSharedHeapsTest, givenMultipleCommandListsUsingSharedH
mockKernelImmData->mockKernelDescriptor->payloadMappings.samplerTable = mockKernelImmData->kernelInfo->kernelDescriptor.payloadMappings.samplerTable;
}
mockKernelImmData->kernelInfo->heapInfo.SurfaceStateHeapSize = static_cast<uint32_t>(sizeof(RENDER_SURFACE_STATE) + sizeof(uint32_t));
mockKernelImmData->kernelInfo->heapInfo.surfaceStateHeapSize = static_cast<uint32_t>(sizeof(RENDER_SURFACE_STATE) + sizeof(uint32_t));
mockKernelImmData->mockKernelDescriptor->payloadMappings.bindingTable.numEntries = 1;
mockKernelImmData->mockKernelDescriptor->payloadMappings.bindingTable.tableOffset = 0x40;
mockKernelImmData->mockKernelDescriptor->kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::BindfulAndStateless;
kernel->surfaceStateHeapDataSize = mockKernelImmData->kernelInfo->heapInfo.SurfaceStateHeapSize;
kernel->surfaceStateHeapDataSize = mockKernelImmData->kernelInfo->heapInfo.surfaceStateHeapSize;
kernel->surfaceStateHeapData.reset(new uint8_t[kernel->surfaceStateHeapDataSize]);
EXPECT_TRUE(commandListImmediate->isFlushTaskSubmissionEnabled);

8
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@ -173,11 +173,11 @@ HWTEST2_P(L0DebuggerParameterizedTests, givenDebuggerWhenAppendingKernelToComman
auto debugSurface = static_cast<L0::DeviceImp *>(device)->getDebugSurface();
SURFACE_STATE_BUFFER_LENGTH length;
length.Length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
length.length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
EXPECT_EQ(length.SurfaceState.Depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.SurfaceState.Height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(length.surfaceState.depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.surfaceState.width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.surfaceState.height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(debugSurface->getGpuAddress(), debugSurfaceState->getSurfaceBaseAddress());
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, debugSurfaceState->getSurfaceType());

40
level_zero/core/test/unit_tests/sources/debugger/test_module_with_debug.cpp
View File

@ -187,7 +187,7 @@ TEST_F(ModuleWithSLDTest, GivenNoDebugDataWhenInitializingModuleThenRelocatedDeb
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernel;
@ -231,7 +231,7 @@ TEST_F(ModuleWithSLDTest, GivenDebugDataWithSingleRelocationWhenInitializingModu
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -283,7 +283,7 @@ TEST_F(ModuleWithSLDTest, GivenDebugDataWithMultipleRelocationsWhenInitializingM
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -359,7 +359,7 @@ HWTEST_F(KernelDebugSurfaceTest, givenDebuggerAndBindfulKernelWhenAppendingKerne
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernel;
@ -379,11 +379,11 @@ HWTEST_F(KernelDebugSurfaceTest, givenDebuggerAndBindfulKernelWhenAppendingKerne
debugSurfaceState = ptrOffset(debugSurfaceState, sizeof(RENDER_SURFACE_STATE));
SURFACE_STATE_BUFFER_LENGTH length;
length.Length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
length.length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
EXPECT_EQ(length.SurfaceState.Depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.SurfaceState.Height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(length.surfaceState.depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.surfaceState.width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.surfaceState.height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(debugSurface->getGpuAddress(), debugSurfaceState->getSurfaceBaseAddress());
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, debugSurfaceState->getSurfaceType());
@ -419,7 +419,7 @@ using KernelInitializeTest = Test<L0DebuggerHwFixture>;
TEST_F(KernelInitializeTest, givenDebuggingEnabledWhenKernelsAreInitializedThenAllocationsAreNotResidentAndNotCopied) {
uint32_t kernelHeap = 0xDEAD;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 4;
kernelInfo.heapInfo.kernelHeapSize = 4;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -459,7 +459,7 @@ HWTEST_F(ModuleWithDebuggerL0MultiTileTest, GivenSubDeviceWhenCreatingModuleThen
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -506,7 +506,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenDebugDataWithRelocationsWhenInitializing
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -551,7 +551,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenBuiltinModuleWhenInitializingModuleThenM
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -599,7 +599,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenDebugDataWithoutRelocationsWhenInitializ
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -653,7 +653,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenNoDebugDataWhenInitializingModuleThenDoN
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -685,7 +685,7 @@ HWTEST_F(ModuleWithZebinAndL0DebuggerTest, GivenZebinDebugDataWhenInitializingMo
uint32_t kernelHeap = 0;
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;
@ -729,7 +729,7 @@ HWTEST_F(ModuleWithZebinAndL0DebuggerTest, GivenDumpElfFlagAndZebinWhenInitializ
uint32_t kernelHeap = 0;
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;
@ -791,7 +791,7 @@ HWTEST_F(ModuleWithZebinAndL0DebuggerTest, GivenZebinWhenModuleIsInitializedAndD
uint32_t kernelHeap = 0;
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;
@ -842,7 +842,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenNonZebinBinaryWhenDestroyModuleThenModul
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -895,7 +895,7 @@ HWTEST_F(ModuleWithDebuggerL0Test, GivenNoDebugDataWhenDestroyingModuleThenNotif
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -925,7 +925,7 @@ HWTEST_F(ModuleWithZebinAndL0DebuggerTest, GivenModuleDebugHandleZeroWhenInitial
uint32_t kernelHeap = 0;
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;

22
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -808,7 +808,7 @@ TEST_F(KernelImmutableDataTests, givenInternalModuleWhenKernelIsCreatedIsaIsNotC
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernelMock;
@ -1873,7 +1873,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithoutAllo
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1899,7 +1899,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithAllowed
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1923,7 +1923,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithDisallo
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1941,7 +1941,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithDisallo
TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithInternalIsaThenCorrectAllocationTypeIsUsed) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1953,7 +1953,7 @@ TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithInternalI
TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithNonInternalIsaThenCorrectAllocationTypeIsUsed) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1965,7 +1965,7 @@ TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithNonIntern
TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithIsaThenPaddingIsAdded) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -1973,13 +1973,13 @@ TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithIsaThenPa
auto graphicsAllocation = kernelImmutableData.getIsaGraphicsAllocation();
auto &helper = device->getNEODevice()->getRootDeviceEnvironment().getHelper<GfxCoreHelper>();
size_t isaPadding = helper.getPaddingForISAAllocation();
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), kernelInfo.heapInfo.KernelHeapSize + isaPadding);
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), kernelInfo.heapInfo.kernelHeapSize + isaPadding);
}
TEST_F(KernelIsaTests, givenGlobalBuffersWhenCreatingKernelImmutableDataThenBuffersAreAddedToResidencyContainer) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
@ -2734,7 +2734,7 @@ HWTEST_F(PrintfHandlerTests, givenKernelWithPrintfWhenPrintingOutputWithBlitterU
Mock<L0::DeviceImp> deviceImp(device.get(), device->getExecutionEnvironment());
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
char kernelHeap[1];
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;
@ -2798,7 +2798,7 @@ HWTEST_F(PrintfHandlerTests, givenPrintDebugMessagesAndKernelWithPrintfWhenBlitt
bcsCsr->flushBcsTaskReturnValue = NEO::CompletionStamp::gpuHang;
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
char kernelHeap[1];
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = ZebinTestData::ValidEmptyProgram<>::kernelName;

68
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@ -322,10 +322,10 @@ HWTEST_F(ModuleTest, givenBufferWhenOffsetIsNotPatchedThenSizeIsDecereasedByOffs
auto surfaceStateAddressRaw = ptrOffset(kernelImp->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
length.Length = static_cast<uint32_t>((gpuAlloc->getUnderlyingBufferSize() - offset) - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.SurfaceState.Width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.SurfaceState.Height + 1));
EXPECT_EQ(surfaceStateAddress->getDepth(), static_cast<uint32_t>(length.SurfaceState.Depth + 1));
length.length = static_cast<uint32_t>((gpuAlloc->getUnderlyingBufferSize() - offset) - 1);
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
EXPECT_EQ(surfaceStateAddress->getDepth(), static_cast<uint32_t>(length.surfaceState.depth + 1));
Kernel::fromHandle(kernelHandle)->destroy();
@ -363,10 +363,10 @@ HWTEST_F(ModuleTest, givenUnalignedHostBufferWhenSurfaceStateProgrammedThenUnali
auto surfaceStateAddressRaw = ptrOffset(kernelImp->getSurfaceStateHeapData(), argInfo.bindful);
auto surfaceStateAddress = reinterpret_cast<RENDER_SURFACE_STATE *>(const_cast<unsigned char *>(surfaceStateAddressRaw));
SURFACE_STATE_BUFFER_LENGTH length = {0};
length.Length = alignUp(static_cast<uint32_t>((mockGa.getUnderlyingBufferSize() + allocationOffset)), alignment) - 1;
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.SurfaceState.Width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.SurfaceState.Height + 1));
EXPECT_EQ(surfaceStateAddress->getDepth(), static_cast<uint32_t>(length.SurfaceState.Depth + 1));
length.length = alignUp(static_cast<uint32_t>((mockGa.getUnderlyingBufferSize() + allocationOffset)), alignment) - 1;
EXPECT_EQ(surfaceStateAddress->getWidth(), static_cast<uint32_t>(length.surfaceState.width + 1));
EXPECT_EQ(surfaceStateAddress->getHeight(), static_cast<uint32_t>(length.surfaceState.height + 1));
EXPECT_EQ(surfaceStateAddress->getDepth(), static_cast<uint32_t>(length.surfaceState.depth + 1));
Kernel::fromHandle(kernelHandle)->destroy();
}
@ -1030,7 +1030,7 @@ HWTEST_F(ModuleLinkingTest, whenExternFunctionsAllocationIsPresentThenItsBeingAd
uint8_t data{};
KernelInfo kernelInfo{};
kernelInfo.heapInfo.pKernelHeap = &data;
kernelInfo.heapInfo.KernelHeapSize = sizeof(data);
kernelInfo.heapInfo.kernelHeapSize = sizeof(data);
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
kernelImmData->initialize(&kernelInfo, device, 0, nullptr, nullptr, false);
@ -1276,7 +1276,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithUnresolvedSymbolWhenTheOtherModule
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1322,7 +1322,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithUnresolvedSymbolWhenTheOtherModule
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1390,7 +1390,7 @@ TEST_F(ModuleDynamicLinkTests, givenMultipleModulesWithUnresolvedSymbolWhenTheEa
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1414,7 +1414,7 @@ TEST_F(ModuleDynamicLinkTests, givenMultipleModulesWithUnresolvedSymbolWhenTheEa
auto kernelInfo2 = std::make_unique<NEO::KernelInfo>();
kernelInfo2->heapInfo.pKernelHeap = kernelHeap2;
kernelInfo2->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo2->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module1->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo2.release());
auto linkerInput1 = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1461,7 +1461,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithInternalRelocationAndUnresolvedExt
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::cacheLineSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::cacheLineSize;
kernelInfo->kernelDescriptor.kernelAttributes.flags.useStackCalls = true;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
@ -1534,7 +1534,7 @@ TEST_F(ModuleDynamicLinkTests, givenMultipleModulesWithUnresolvedSymbolWhenTheEa
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1558,7 +1558,7 @@ TEST_F(ModuleDynamicLinkTests, givenMultipleModulesWithUnresolvedSymbolWhenTheEa
auto kernelInfo2 = std::make_unique<NEO::KernelInfo>();
kernelInfo2->heapInfo.pKernelHeap = kernelHeap2;
kernelInfo2->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo2->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module1->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo2.release());
auto linkerInput1 = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1617,7 +1617,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithUnresolvedSymbolWhenTheOtherModule
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1678,7 +1678,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithUnresolvedSymbolsNotPresentInAnoth
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1734,7 +1734,7 @@ TEST_F(ModuleDynamicLinkTests, givenModuleWithUnresolvedSymbolsNotPresentInAnoth
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto linkerInput = std::make_unique<::WhiteBox<NEO::LinkerInput>>();
@ -1853,7 +1853,7 @@ TEST_F(ModuleFunctionPointerTests, givenModuleWithExportedSymbolThenGetFunctionP
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
auto kernelImmData = std::make_unique<WhiteBox<::L0::KernelImmutableData>>(device);
@ -1884,7 +1884,7 @@ TEST_F(ModuleFunctionPointerTests, givenModuleWithExportedSymbolButNoExportFlags
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = "kernelFunction";
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
module0->isFunctionSymbolExportEnabled = false;
@ -1918,7 +1918,7 @@ TEST_F(ModuleFunctionPointerTests, givenInvalidFunctionNameAndModuleWithExported
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = "kernelFunction";
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
module0->isFunctionSymbolExportEnabled = true;
@ -1952,7 +1952,7 @@ TEST_F(ModuleFunctionPointerTests, givenModuleWithExportedSymbolThenGetFunctionP
auto kernelInfo = std::make_unique<NEO::KernelInfo>();
kernelInfo->heapInfo.pKernelHeap = kernelHeap;
kernelInfo->heapInfo.KernelHeapSize = MemoryConstants::pageSize;
kernelInfo->heapInfo.kernelHeapSize = MemoryConstants::pageSize;
kernelInfo->kernelDescriptor.kernelMetadata.kernelName = "kernelFunction";
module0->isFunctionSymbolExportEnabled = true;
module0->getTranslationUnit()->programInfo.kernelInfos.push_back(kernelInfo.release());
@ -3125,7 +3125,7 @@ TEST_F(ModuleInitializeTest, whenModuleInitializeIsCalledThenCorrectResultIsRetu
argDescriptor.as<ArgDescPointer>().bindless = undefined<CrossThreadDataOffset>;
}
kernelInfo->kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
kernelInfo->heapInfo.KernelHeapSize = 0x1;
kernelInfo->heapInfo.kernelHeapSize = 0x1;
kernelInfo->heapInfo.pKernelHeap = reinterpret_cast<void *>(0xffff);
this->translationUnit->programInfo.kernelInfos.clear();
@ -3201,7 +3201,7 @@ TEST_F(ModuleDebugDataTest, GivenDebugDataWithRelocationsWhenCreatingRelocatedDe
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
kernelInfo->kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful = 0;
@ -3383,7 +3383,7 @@ TEST_F(ModuleTests, whenCopyingPatchedSegmentsThenAllocationsAreSetWritableForTb
char data[1]{};
auto kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3412,7 +3412,7 @@ TEST_F(ModuleTests, givenConstDataStringSectionWhenLinkingModuleThenSegmentIsPat
char data[64]{};
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3442,7 +3442,7 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationAndStackCallsWhenLinkingBuiltinMo
char data[64]{};
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3483,7 +3483,7 @@ TEST_F(ModuleTests, givenFullyLinkedModuleAndSlmSizeExceedingLocalMemorySizeWhen
char data[64]{};
std::unique_ptr<KernelInfo> kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
auto localMemSize = static_cast<uint32_t>(this->device->getNEODevice()->getDeviceInfo().localMemSize);
@ -3529,7 +3529,7 @@ TEST_F(ModuleTests, givenFullyLinkedModuleWhenCreatingKernelThenDebugMsgOnPrivat
char data[64]{};
std::unique_ptr<KernelInfo> kernelInfo = std::make_unique<KernelInfo>();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3572,7 +3572,7 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationAndStackCallsWhenLinkingModuleThe
char data[64]{};
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3609,7 +3609,7 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationAndDebuggerEnabledWhenLinkingModu
char data[64]{};
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3639,7 +3639,7 @@ TEST_F(ModuleTests, givenImplicitArgsRelocationAndNoDebuggerOrStackCallsWhenLink
char data[64]{};
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 64;
kernelInfo->heapInfo.kernelHeapSize = 64;
kernelInfo->heapInfo.pKernelHeap = data;
std::unique_ptr<WhiteBox<::L0::KernelImmutableData>> kernelImmData{new WhiteBox<::L0::KernelImmutableData>(this->device)};
@ -3676,7 +3676,7 @@ TEST_F(ModuleTests, givenModuleWithGlobalAndConstAllocationsWhenGettingModuleAll
uint32_t kernelHeap = 0;
auto kernelInfo = new KernelInfo();
kernelInfo->heapInfo.KernelHeapSize = 1;
kernelInfo->heapInfo.kernelHeapSize = 1;
kernelInfo->heapInfo.pKernelHeap = &kernelHeap;
// pass kernelInfo ownership to programInfo

4
level_zero/core/test/unit_tests/xe_hpg_core/dg2/test_module_dg2.cpp
View File

@ -54,7 +54,7 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerWhenKernelInitializeCalledThen
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernel;
@ -110,7 +110,7 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenNoDebuggerButDebuggerActiveSetWhenPatc
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
Mock<::L0::Kernel> kernel;

4
opencl/extensions/public/cl_ext_private.h
View File

@ -256,8 +256,8 @@ typedef cl_uint cl_resource_memory_scope;
#pragma pack(push, 1)
typedef struct _cl_resource_barrier_descriptor_intel {
void *svm_allocation_pointer;
cl_mem mem_object;
void *svmAllocationPointer;
cl_mem memObject;
cl_resource_barrier_type type;
cl_resource_memory_scope scope;
} cl_resource_barrier_descriptor_intel;

8
opencl/source/api/dispatch.h
View File

@ -1307,10 +1307,10 @@ struct SCRTDispatchTable {
// VAMedia sharing extension
#ifdef LIBVA
INTELpfn_clCreateFromVA_APIMediaSurfaceINTEL clCreateFromVA_APIMediaSurfaceINTEL;
INTELpfn_clGetDeviceIDsFromVA_APIMediaAdapterINTEL clGetDeviceIDsFromVA_APIMediaAdapterINTEL;
INTELpfn_clEnqueueReleaseVA_APIMediaSurfacesINTEL clEnqueueReleaseVA_APIMediaSurfacesINTEL;
INTELpfn_clEnqueueAcquireVA_APIMediaSurfacesINTEL clEnqueueAcquireVA_APIMediaSurfacesINTEL;
INTELpfn_clCreateFromVA_APIMediaSurfaceINTEL clCreateFromVA_APIMediaSurfaceINTEL; // NOLINT(readability-identifier-naming)
INTELpfn_clGetDeviceIDsFromVA_APIMediaAdapterINTEL clGetDeviceIDsFromVA_APIMediaAdapterINTEL; // NOLINT(readability-identifier-naming)
INTELpfn_clEnqueueReleaseVA_APIMediaSurfacesINTEL clEnqueueReleaseVA_APIMediaSurfacesINTEL; // NOLINT(readability-identifier-naming)
INTELpfn_clEnqueueAcquireVA_APIMediaSurfacesINTEL clEnqueueAcquireVA_APIMediaSurfacesINTEL; // NOLINT(readability-identifier-naming)
#else
void *placeholder14;
void *placeholder15;

2
opencl/source/command_queue/cl_local_work_size.cpp
View File

@ -30,7 +30,7 @@ Vec3<size_t> computeWorkgroupSize(const DispatchInfo &dispatchInfo) {
auto &gfxCoreHelper = device.getGfxCoreHelper();
if (DebugManager.flags.EnableComputeWorkSizeND.get()) {
WorkSizeInfo wsInfo = createWorkSizeInfoFromDispatchInfo(dispatchInfo);
if (wsInfo.slmTotalSize == 0 && !wsInfo.hasBarriers && !wsInfo.imgUsed && gfxCoreHelper.preferSmallWorkgroupSizeForKernel(kernel->getKernelInfo().heapInfo.KernelUnpaddedSize, rootDeviceEnvironment) &&
if (wsInfo.slmTotalSize == 0 && !wsInfo.hasBarriers && !wsInfo.imgUsed && gfxCoreHelper.preferSmallWorkgroupSizeForKernel(kernel->getKernelInfo().heapInfo.kernelUnpaddedSize, rootDeviceEnvironment) &&
((dispatchInfo.getDim() == 1) && (dispatchInfo.getGWS().x % wsInfo.simdSize * 2 == 0))) {
wsInfo.maxWorkGroupSize = wsInfo.simdSize * 2;
}

2
opencl/source/command_queue/enqueue_common.h
View File

@ -789,7 +789,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
auto requiresCoherency = false;
for (auto surface : createRange(surfaces, surfaceCount)) {
surface->makeResident(getGpgpuCommandStreamReceiver());
requiresCoherency |= surface->IsCoherent;
requiresCoherency |= surface->isCoherent;
if (!surface->allowsL3Caching()) {
anyUncacheableArgs = true;
}

2
opencl/source/command_queue/gpgpu_walker_xehp_and_later.inl
View File

@ -136,7 +136,7 @@ size_t EnqueueOperation<GfxFamily>::getSizeRequiredCSKernel(bool reserveProfilin
size_t size = sizeof(typename GfxFamily::COMPUTE_WALKER) +
(MemorySynchronizationCommands<GfxFamily>::getSizeForSingleBarrier(false) * numBarriers) +
HardwareCommandsHelper<GfxFamily>::getSizeRequiredCS() +
EncodeMemoryPrefetch<GfxFamily>::getSizeForMemoryPrefetch(pKernel->getKernelInfo().heapInfo.KernelHeapSize, commandQueue.getDevice().getRootDeviceEnvironment());
EncodeMemoryPrefetch<GfxFamily>::getSizeForMemoryPrefetch(pKernel->getKernelInfo().heapInfo.kernelHeapSize, commandQueue.getDevice().getRootDeviceEnvironment());
auto devices = commandQueue.getGpgpuCommandStreamReceiver().getOsContext().getDeviceBitfield();
auto partitionWalker = ImplicitScalingHelper::isImplicitScalingEnabled(devices, true);
if (partitionWalker) {

2
opencl/source/command_queue/hardware_interface_xehp_and_later.inl
View File

@ -88,7 +88,7 @@ inline void HardwareInterface<GfxFamily>::programWalker(
const auto &hwInfo = commandQueue.getDevice().getHardwareInfo();
if (auto kernelAllocation = kernelInfo.getGraphicsAllocation()) {
EncodeMemoryPrefetch<GfxFamily>::programMemoryPrefetch(commandStream, *kernelAllocation, kernelInfo.heapInfo.KernelHeapSize, 0, rootDeviceEnvironment);
EncodeMemoryPrefetch<GfxFamily>::programMemoryPrefetch(commandStream, *kernelAllocation, kernelInfo.heapInfo.kernelHeapSize, 0, rootDeviceEnvironment);
}
HardwareCommandsHelper<GfxFamily>::sendIndirectState(

6
opencl/source/command_queue/resource_barrier.cpp
View File

@ -20,12 +20,12 @@ namespace NEO {
BarrierCommand::BarrierCommand(CommandQueue *commandQueue, const cl_resource_barrier_descriptor_intel *descriptors, uint32_t numDescriptors) : numSurfaces(numDescriptors) {
for (auto description : createRange(descriptors, numDescriptors)) {
GraphicsAllocation *allocation;
if (description.mem_object) {
if (description.memObject) {
MemObj *memObj = nullptr;
withCastToInternal(description.mem_object, &memObj);
withCastToInternal(description.memObject, &memObj);
allocation = memObj->getGraphicsAllocation(commandQueue->getDevice().getRootDeviceIndex());
} else {
auto svmData = commandQueue->getContext().getSVMAllocsManager()->getSVMAlloc(description.svm_allocation_pointer);
auto svmData = commandQueue->getContext().getSVMAllocsManager()->getSVMAlloc(description.svmAllocationPointer);
UNRECOVERABLE_IF(svmData == nullptr);
allocation = svmData->gpuAllocations.getGraphicsAllocation(commandQueue->getDevice().getRootDeviceIndex());
}

2
opencl/source/helpers/task_information.cpp
View File

@ -157,7 +157,7 @@ CompletionStamp &CommandComputeKernel::submit(TaskCountType taskLevel, bool term
for (auto &surface : surfaces) {
DEBUG_BREAK_IF(!surface);
surface->makeResident(commandStreamReceiver);
requiresCoherency |= surface->IsCoherent;
requiresCoherency |= surface->isCoherent;
if (!surface->allowsL3Caching()) {
anyUncacheableArgs = true;
}

10
opencl/source/kernel/kernel.cpp
View File

@ -214,13 +214,13 @@ cl_int Kernel::initialize() {
}
// allocate our own SSH, if necessary
sshLocalSize = heapInfo.SurfaceStateHeapSize;
sshLocalSize = heapInfo.surfaceStateHeapSize;
if (sshLocalSize) {
pSshLocal = std::make_unique<char[]>(sshLocalSize);
// copy the ssh into our local copy
memcpy_s(pSshLocal.get(), sshLocalSize,
heapInfo.pSsh, heapInfo.SurfaceStateHeapSize);
heapInfo.pSsh, heapInfo.surfaceStateHeapSize);
}
numberOfBindingTableStates = kernelDescriptor.payloadMappings.bindingTable.numEntries;
localBindingTableOffset = kernelDescriptor.payloadMappings.bindingTable.tableOffset;
@ -752,7 +752,7 @@ const void *Kernel::getKernelHeap() const {
}
size_t Kernel::getKernelHeapSize() const {
return kernelInfo.heapInfo.KernelHeapSize;
return kernelInfo.heapInfo.kernelHeapSize;
}
void Kernel::substituteKernelHeap(void *newKernelHeap, size_t newKernelHeapSize) {
@ -760,7 +760,7 @@ void Kernel::substituteKernelHeap(void *newKernelHeap, size_t newKernelHeapSize)
void **pKernelHeap = const_cast<void **>(&pKernelInfo->heapInfo.pKernelHeap);
*pKernelHeap = newKernelHeap;
auto &heapInfo = pKernelInfo->heapInfo;
heapInfo.KernelHeapSize = static_cast<uint32_t>(newKernelHeapSize);
heapInfo.kernelHeapSize = static_cast<uint32_t>(newKernelHeapSize);
pKernelInfo->isKernelHeapSubstituted = true;
auto memoryManager = executionEnvironment.memoryManager.get();
@ -814,7 +814,7 @@ void *Kernel::getSurfaceStateHeap() const {
}
size_t Kernel::getDynamicStateHeapSize() const {
return kernelInfo.heapInfo.DynamicStateHeapSize;
return kernelInfo.heapInfo.dynamicStateHeapSize;
}
const void *Kernel::getDynamicStateHeap() const {

2
opencl/source/program/build.cpp
View File

@ -126,7 +126,7 @@ cl_int Program::build(
inputArgs.apiOptions = ArrayRef<const char>(options.c_str(), options.length());
inputArgs.internalOptions = ArrayRef<const char>(internalOptions.c_str(), internalOptions.length());
inputArgs.GTPinInput = gtpinGetIgcInit();
inputArgs.gtPinInput = gtpinGetIgcInit();
inputArgs.specializedValues = this->specConstantsValues;
DBG_LOG(LogApiCalls,
"Build Options", inputArgs.apiOptions.begin(),

2
opencl/source/program/link.cpp
View File

@ -137,7 +137,7 @@ cl_int Program::link(
inputArgs.src = ArrayRef<const char>(reinterpret_cast<const char *>(clLinkInput.data()), clLinkInput.size());
inputArgs.apiOptions = ArrayRef<const char>(options.c_str(), options.length());
inputArgs.internalOptions = ArrayRef<const char>(internalOptions.c_str(), internalOptions.length());
inputArgs.GTPinInput = gtpinGetIgcInit();
inputArgs.gtPinInput = gtpinGetIgcInit();
if (!isCreateLibrary) {
for (const auto &device : deviceVector) {

10
opencl/source/program/process_device_binary.cpp
View File

@ -119,9 +119,9 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, size_
for (const auto &kernelInfo : kernelInfoArray) {
auto &kernHeapInfo = kernelInfo->heapInfo;
const char *originalIsa = reinterpret_cast<const char *>(kernHeapInfo.pKernelHeap);
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.KernelHeapSize));
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.kernelHeapSize));
DEBUG_BREAK_IF(nullptr == kernelInfo->getGraphicsAllocation());
isaSegmentsForPatching.push_back(Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelInfo->getGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.KernelHeapSize});
isaSegmentsForPatching.push_back(Linker::PatchableSegment{patchedIsaTempStorage.rbegin()->data(), static_cast<uintptr_t>(kernelInfo->getGraphicsAllocation()->getGpuAddressToPatch()), kernHeapInfo.kernelHeapSize});
kernelDescriptors.push_back(&kernelInfo->kernelDescriptor);
}
}
@ -151,7 +151,7 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, size_
const auto &productHelper = pDevice->getProductHelper();
MemoryTransferHelper::transferMemoryToAllocation(productHelper.isBlitCopyRequiredForLocalMemory(rootDeviceEnvironment, *kernelInfo->getGraphicsAllocation()),
*pDevice, kernelInfo->getGraphicsAllocation(), 0, isaSegmentsForPatching[segmentId].hostPointer,
static_cast<size_t>(kernHeapInfo.KernelHeapSize));
static_cast<size_t>(kernHeapInfo.kernelHeapSize));
}
}
DBG_LOG(PrintRelocations, NEO::constructRelocationsDebugMessage(this->getSymbols(pDevice->getRootDeviceIndex())));
@ -274,7 +274,7 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
for (auto &kernelInfo : kernelInfoArray) {
cl_int retVal = CL_SUCCESS;
if (kernelInfo->heapInfo.KernelHeapSize) {
if (kernelInfo->heapInfo.kernelHeapSize) {
retVal = kernelInfo->createKernelAllocation(clDevice.getDevice(), isBuiltIn) ? CL_SUCCESS : CL_OUT_OF_HOST_MEMORY;
}
@ -365,7 +365,7 @@ void Program::notifyDebuggerWithDebugData(ClDevice *clDevice) {
clDevice->getSourceLevelDebugger()->notifyKernelDebugData(&kernelInfo->debugData,
kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
kernelInfo->heapInfo.pKernelHeap,
kernelInfo->heapInfo.KernelHeapSize);
kernelInfo->heapInfo.kernelHeapSize);
}
}
}

2
opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
View File

@ -38,7 +38,7 @@ class MediaImageSetArgTest : public ClDeviceFixture,
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
program->setContext(context);
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;

2
opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl
View File

@ -27,7 +27,7 @@ class KernelArgSvmApiFixture : public ApiFixture<> {
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->heapInfo.pSsh = pSshLocal;
pKernelInfo->addArgBuffer(0, 0x30, sizeof(void *));

6
opencl/test/unit_test/aub_tests/command_queue/aub_enqueue_resource_barrier_xehp_and_later.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -73,8 +73,8 @@ HWTEST2_F(ResourceBarrierAubTest, givenAllocationsWhenEnqueueResourceBarrierCall
cl_resource_barrier_descriptor_intel descriptor{};
cl_resource_barrier_descriptor_intel descriptor2{};
descriptor.mem_object = dstBuffer1.get();
descriptor2.mem_object = dstBuffer2.get();
descriptor.memObject = dstBuffer1.get();
descriptor2.memObject = dstBuffer2.get();
const cl_resource_barrier_descriptor_intel descriptors[] = {descriptor, descriptor2};

10
opencl/test/unit_test/command_queue/blit_enqueue_2_tests.cpp
View File

@ -500,7 +500,7 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWhenCreating
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
auto initialTaskCount = bcsMockContext->bcsCsr->peekTaskCount();
@ -522,7 +522,7 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWhenCreating
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
auto initialTaskCount = bcsMockContext->bcsCsr->peekTaskCount();
@ -542,7 +542,7 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWhenCreating
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.kernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
auto initialTaskCount = bcsMockContext->bcsCsr->peekTaskCount();
@ -589,7 +589,7 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWithoutCpuAc
MockKernelWithInternals kernel(*device);
const size_t initialHeapSize = 0x40;
kernel.kernelInfo.heapInfo.KernelHeapSize = initialHeapSize;
kernel.kernelInfo.heapInfo.kernelHeapSize = initialHeapSize;
kernel.kernelInfo.createKernelAllocation(device->getDevice(), false);
ASSERT_NE(nullptr, kernel.kernelInfo.kernelAllocation);
@ -620,7 +620,7 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWithoutCpuAc
std::vector<char> kernelHeap;
kernelHeap.resize(32, 7);
kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.heapInfo.kernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.createKernelAllocation(device->getDevice(), false);
ASSERT_NE(nullptr, kernelInfo.kernelAllocation);
EXPECT_TRUE(kernelInfo.kernelAllocation->isAllocatedInLocalMemoryPool());

6
opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp
View File

@ -55,16 +55,16 @@ struct DispatchWalkerTest : public CommandQueueFixture, public ClDeviceFixture,
kernelInfo.setCrossThreadDataSize(64);
kernelInfo.setLocalIds({1, 1, 1});
kernelInfo.heapInfo.pKernelHeap = kernelIsa;
kernelInfo.heapInfo.KernelHeapSize = sizeof(kernelIsa);
kernelInfo.heapInfo.kernelHeapSize = sizeof(kernelIsa);
kernelInfoWithSampler.kernelDescriptor.kernelAttributes.simdSize = 32;
kernelInfoWithSampler.setCrossThreadDataSize(64);
kernelInfoWithSampler.setLocalIds({1, 1, 1});
kernelInfoWithSampler.setSamplerTable(0, 1, 4);
kernelInfoWithSampler.heapInfo.pKernelHeap = kernelIsa;
kernelInfoWithSampler.heapInfo.KernelHeapSize = sizeof(kernelIsa);
kernelInfoWithSampler.heapInfo.kernelHeapSize = sizeof(kernelIsa);
kernelInfoWithSampler.heapInfo.pDsh = static_cast<const void *>(dsh);
kernelInfoWithSampler.heapInfo.DynamicStateHeapSize = sizeof(dsh);
kernelInfoWithSampler.heapInfo.dynamicStateHeapSize = sizeof(dsh);
}
void TearDown() override {

12
opencl/test/unit_test/command_queue/dispatch_walker_tests_xehp_and_later.cpp
View File

@ -1093,7 +1093,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, GivenPipeContr
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
DispatchInfo dispatchInfo{};
dispatchInfo.setNumberOfWorkgroups({32, 1, 1});
@ -1151,7 +1151,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, GivenPipeContr
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
DispatchInfo dispatchInfo{};
dispatchInfo.setNumberOfWorkgroups({32, 1, 1});
@ -1206,7 +1206,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, whenWalkerPart
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
auto returnedSize = EnqueueOperation<FamilyType>::getSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, false, false, *cmdQ.get(), kernel->mockKernel, dispatchInfo);
EXPECT_EQ(returnedSize, baseSize);
@ -1223,7 +1223,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, whenPipeContro
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
auto returnedSize = EnqueueOperation<FamilyType>::getSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, false, false, *cmdQ.get(), kernel->mockKernel, {});
EXPECT_EQ(returnedSize, baseSize);
@ -1241,7 +1241,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, GivenPipeContr
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
WalkerPartition::WalkerPartitionArgs testArgs = {};
testArgs.initializeWparidRegister = true;
@ -1272,7 +1272,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterDispatchWalkerBasicTest, GivenPipeContr
auto baseSize = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.KernelHeapSize, device->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(kernel->kernelInfo.heapInfo.kernelHeapSize, device->getRootDeviceEnvironment());
WalkerPartition::WalkerPartitionArgs testArgs = {};
testArgs.initializeWparidRegister = true;

8
opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp
View File

@ -119,11 +119,11 @@ HWTEST_F(EnqueueDebugKernelTest, givenDebugKernelWhenEnqueuedThenSurfaceStateFor
auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation();
SURFACE_STATE_BUFFER_LENGTH length;
length.Length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
length.length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
EXPECT_EQ(length.SurfaceState.Depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.SurfaceState.Height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(length.surfaceState.depth + 1u, debugSurfaceState->getDepth());
EXPECT_EQ(length.surfaceState.width + 1u, debugSurfaceState->getWidth());
EXPECT_EQ(length.surfaceState.height + 1u, debugSurfaceState->getHeight());
EXPECT_EQ(debugSurface->getGpuAddress(), debugSurfaceState->getSurfaceBaseAddress());
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, debugSurfaceState->getSurfaceType());

4
opencl/test/unit_test/command_queue/enqueue_handler_tests.cpp
View File

@ -692,7 +692,7 @@ HWTEST_F(EnqueueHandlerTest, givenKernelUsingSyncBufferWhenEnqueuingKernelThenSs
kernelInternals.kernelInfo.setSyncBuffer(sizeof(uint32_t), 0, 0);
constexpr auto bindingTableOffset = sizeof(RENDER_SURFACE_STATE);
kernelInternals.kernelInfo.setBindingTable(bindingTableOffset, 1);
kernelInternals.kernelInfo.heapInfo.SurfaceStateHeapSize = sizeof(RENDER_SURFACE_STATE) + sizeof(BINDING_TABLE_STATE);
kernelInternals.kernelInfo.heapInfo.surfaceStateHeapSize = sizeof(RENDER_SURFACE_STATE) + sizeof(BINDING_TABLE_STATE);
auto kernel = kernelInternals.mockKernel;
kernel->initialize();
@ -704,7 +704,7 @@ HWTEST_F(EnqueueHandlerTest, givenKernelUsingSyncBufferWhenEnqueuingKernelThenSs
mockCmdQ->enqueueKernel(kernel, 1, &offset, &size, &size, 0, nullptr, nullptr);
auto &surfaceStateHeap = mockCmdQ->getIndirectHeap(IndirectHeap::Type::SURFACE_STATE, 0);
EXPECT_EQ(sshUsageWithoutSyncBuffer + kernelInternals.kernelInfo.heapInfo.SurfaceStateHeapSize, surfaceStateHeap.getUsed());
EXPECT_EQ(sshUsageWithoutSyncBuffer + kernelInternals.kernelInfo.heapInfo.surfaceStateHeapSize, surfaceStateHeap.getUsed());
ClHardwareParse hwParser;
hwParser.parseCommands<FamilyType>(*mockCmdQ);

16
opencl/test/unit_test/command_queue/enqueue_resource_barier_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -26,8 +26,8 @@ HWTEST_F(ResourceBarrierTest, givenNullArgsAndHWCommandQueueWhenEnqueueResourceB
bufferSize,
nullptr,
retVal));
descriptor.mem_object = buffer.get();
descriptor.svm_allocation_pointer = nullptr;
descriptor.memObject = buffer.get();
descriptor.svmAllocationPointer = nullptr;
BarrierCommand barrierCommand(pCmdQ, &descriptor, 1);
auto surface = reinterpret_cast<ResourceSurface *>(barrierCommand.surfacePtrs.begin()[0]);
@ -48,8 +48,8 @@ HWTEST_F(ResourceBarrierTest, whenEnqueueResourceBarrierCalledThenUpdateQueueCom
ASSERT_EQ(CL_SUCCESS, retVal);
cl_resource_barrier_descriptor_intel descriptor{};
descriptor.mem_object = buffer.get();
descriptor.svm_allocation_pointer = nullptr;
descriptor.memObject = buffer.get();
descriptor.svmAllocationPointer = nullptr;
BarrierCommand barrierCommand(pCmdQ, &descriptor, 1);
@ -85,8 +85,8 @@ HWTEST_F(ResourceBarrierTest, GivenGpuHangAndBlockingCallsWhenEnqueueResourceBar
ASSERT_EQ(CL_SUCCESS, retVal);
cl_resource_barrier_descriptor_intel descriptor{};
descriptor.mem_object = buffer.get();
descriptor.svm_allocation_pointer = nullptr;
descriptor.memObject = buffer.get();
descriptor.svmAllocationPointer = nullptr;
BarrierCommand barrierCommand(&mockCommandQueueHw, &descriptor, 1);
@ -97,6 +97,6 @@ HWTEST_F(ResourceBarrierTest, GivenGpuHangAndBlockingCallsWhenEnqueueResourceBar
HWTEST_F(ResourceBarrierTest, whenBarierCommandCreatedWithInvalidSvmPointerThenExceptionIsThrown) {
cl_resource_barrier_descriptor_intel descriptor{};
descriptor.svm_allocation_pointer = nullptr;
descriptor.svmAllocationPointer = nullptr;
EXPECT_THROW(BarrierCommand barrierCommand(pCmdQ, &descriptor, 1), std::exception);
}

10
opencl/test/unit_test/command_queue/enqueue_resource_barier_tests_xehp_and_later.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -61,8 +61,8 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, EnqueueResourceBarrierTestXeHpCoreAndLater, GivenCo
cl_event waitlist[] = {&event1};
cl_resource_barrier_descriptor_intel descriptor{};
descriptor.mem_object = buffer.get();
descriptor.svm_allocation_pointer = nullptr;
descriptor.memObject = buffer.get();
descriptor.svmAllocationPointer = nullptr;
BarrierCommand barrierCommand(mockCmdQ.get(), &descriptor, 1);
@ -102,8 +102,8 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, EnqueueResourceBarrierTestXeHpCoreAndLater, GivenCo
cl_event waitlist[] = {&event1};
cl_resource_barrier_descriptor_intel descriptor{};
descriptor.mem_object = buffer.get();
descriptor.svm_allocation_pointer = nullptr;
descriptor.memObject = buffer.get();
descriptor.svmAllocationPointer = nullptr;
BarrierCommand barrierCommand(mockCmdQ.get(), &descriptor, 1);

8
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp
View File

@ -88,7 +88,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenFlushTas
EXPECT_EQ(cmdBuffer->batchBuffer.commandBufferAllocation, mockCsr->commandStream.getGraphicsAllocation());
EXPECT_EQ(cmdBuffer->batchBuffer.startOffset, 0u);
EXPECT_FALSE(cmdBuffer->batchBuffer.requiresCoherency);
EXPECT_FALSE(cmdBuffer->batchBuffer.low_priority);
EXPECT_FALSE(cmdBuffer->batchBuffer.lowPriority);
// find BB END
parseCommands<FamilyType>(commandStream, 0);
@ -402,8 +402,8 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenFlushTas
EXPECT_FALSE(cmdBuffer1->batchBuffer.requiresCoherency);
EXPECT_TRUE(cmdBuffer2->batchBuffer.requiresCoherency);
EXPECT_FALSE(cmdBuffer1->batchBuffer.low_priority);
EXPECT_TRUE(cmdBuffer2->batchBuffer.low_priority);
EXPECT_FALSE(cmdBuffer1->batchBuffer.lowPriority);
EXPECT_TRUE(cmdBuffer2->batchBuffer.lowPriority);
EXPECT_GT(cmdBuffer2->batchBuffer.startOffset, cmdBuffer1->batchBuffer.startOffset);
}
@ -465,7 +465,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatch
mockCsr->flushBatchedSubmissions();
EXPECT_FALSE(mockCsr->recordedCommandBuffer->batchBuffer.low_priority);
EXPECT_FALSE(mockCsr->recordedCommandBuffer->batchBuffer.lowPriority);
EXPECT_FALSE(mockCsr->recordedCommandBuffer->batchBuffer.requiresCoherency);
EXPECT_EQ(mockCsr->recordedCommandBuffer->batchBuffer.commandBufferAllocation, commandStream.getGraphicsAllocation());
EXPECT_EQ(4u, mockCsr->recordedCommandBuffer->batchBuffer.startOffset);

2
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp
View File

@ -727,7 +727,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, gi
mockCsr->flushBatchedSubmissions();
EXPECT_FALSE(mockCsr->recordedCommandBuffer->batchBuffer.low_priority);
EXPECT_FALSE(mockCsr->recordedCommandBuffer->batchBuffer.lowPriority);
EXPECT_TRUE(mockCsr->recordedCommandBuffer->batchBuffer.requiresCoherency);
EXPECT_EQ(mockCsr->recordedCommandBuffer->batchBuffer.commandBufferAllocation, commandStream.getGraphicsAllocation());
EXPECT_EQ(4u, mockCsr->recordedCommandBuffer->batchBuffer.startOffset);

2
opencl/test/unit_test/command_stream/command_stream_receiver_hw_2_tests.cpp
View File

@ -657,7 +657,7 @@ HWTEST_F(BcsTests, givenBufferWhenBlitCalledThenFlushCommandBuffer) {
EXPECT_EQ(0u, csr.latestFlushedBatchBuffer.chainedBatchBufferStartOffset);
EXPECT_EQ(nullptr, csr.latestFlushedBatchBuffer.chainedBatchBuffer);
EXPECT_FALSE(csr.latestFlushedBatchBuffer.requiresCoherency);
EXPECT_FALSE(csr.latestFlushedBatchBuffer.low_priority);
EXPECT_FALSE(csr.latestFlushedBatchBuffer.lowPriority);
EXPECT_EQ(QueueThrottle::MEDIUM, csr.latestFlushedBatchBuffer.throttle);
EXPECT_EQ(commandStream.getUsed(), csr.latestFlushedBatchBuffer.usedSize);
EXPECT_EQ(&commandStream, csr.latestFlushedBatchBuffer.stream);

10
opencl/test/unit_test/command_stream/command_stream_receiver_hw_tests_xehp_and_later.cpp
View File

@ -196,10 +196,10 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverHwTestXeHPAndLater, givenScrat
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_SCRATCH, scratchState->getSurfaceType());
SURFACE_STATE_BUFFER_LENGTH length = {0};
length.Length = static_cast<uint32_t>(computeUnits - 1);
EXPECT_EQ(length.SurfaceState.Depth + 1u, scratchState->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, scratchState->getWidth());
EXPECT_EQ(length.SurfaceState.Height + 1u, scratchState->getHeight());
length.length = static_cast<uint32_t>(computeUnits - 1);
EXPECT_EQ(length.surfaceState.depth + 1u, scratchState->getDepth());
EXPECT_EQ(length.surfaceState.width + 1u, scratchState->getWidth());
EXPECT_EQ(length.surfaceState.height + 1u, scratchState->getHeight());
EXPECT_EQ(kernel.kernelInfo.kernelDescriptor.kernelAttributes.perThreadScratchSize[0], scratchState->getSurfacePitch());
}
@ -663,7 +663,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverHwTestXeHPAndLater, givenBlock
cl_int retVal = CL_SUCCESS;
auto buffer = clUniquePtr(Buffer::create(&context, 0, MemoryConstants::pageSize, nullptr, retVal));
cl_resource_barrier_descriptor_intel descriptor = {};
descriptor.mem_object = buffer.get();
descriptor.memObject = buffer.get();
BarrierCommand barrierCommand(cmdQ0.get(), &descriptor, 1);
cmdQ0->enqueueResourceBarrier(&barrierCommand, numEventsOnWaitlist, waitlist, nullptr);

8
opencl/test/unit_test/command_stream/submissions_aggregator_tests.cpp
View File

@ -456,8 +456,8 @@ TEST(SubmissionsAggregator, givenCommandBuffersRequiringDifferentPrioritySetting
MockGraphicsAllocation alloc1(nullptr, 1);
MockGraphicsAllocation alloc7(nullptr, 7);
cmdBuffer->batchBuffer.low_priority = true;
cmdBuffer2->batchBuffer.low_priority = false;
cmdBuffer->batchBuffer.lowPriority = true;
cmdBuffer2->batchBuffer.lowPriority = false;
cmdBuffer->surfaces.push_back(&alloc1);
cmdBuffer2->surfaces.push_back(&alloc7);
@ -696,8 +696,8 @@ HWTEST_F(SubmissionsAggregatorTests, givenMultipleCmdBuffersWhenNotAggregatedDur
cmdQ2.enqueueKernel(kernel, 1, nullptr, &gws, nullptr, 0, nullptr, &event2);
// dont aggregate
mockCsr->peekSubmissionAggregator()->peekCmdBufferList().peekHead()->batchBuffer.low_priority = true;
mockCsr->peekSubmissionAggregator()->peekCmdBufferList().peekTail()->batchBuffer.low_priority = false;
mockCsr->peekSubmissionAggregator()->peekCmdBufferList().peekHead()->batchBuffer.lowPriority = true;
mockCsr->peekSubmissionAggregator()->peekCmdBufferList().peekTail()->batchBuffer.lowPriority = false;
mockCsr->flushBatchedSubmissions();

2
opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp
View File

@ -25,7 +25,7 @@ void KernelImageArgTest::SetUp() {
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
constexpr int numImages = 5;

4
opencl/test/unit_test/gtpin/gtpin_tests.cpp
View File

@ -1828,7 +1828,7 @@ TEST_F(GTPinTests, givenKernelWithSSHThenVerifyThatSSHResizeWorksWell) {
TEST_F(GTPinTests, givenKernelWithoutAllocatedSSHThenGTPinStillCanAllocateNewSSHAndProperlyAddNewSurfaceState) {
auto kernelInfo = std::make_unique<MockKernelInfo>();
ASSERT_EQ(nullptr, kernelInfo->heapInfo.pSsh);
ASSERT_EQ(0u, kernelInfo->heapInfo.SurfaceStateHeapSize);
ASSERT_EQ(0u, kernelInfo->heapInfo.surfaceStateHeapSize);
MockContext context(pDevice);
MockProgram program(&context, false, toClDeviceVector(*pDevice));
@ -1962,7 +1962,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCo
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
auto pProgramm = std::make_unique<MockProgram>(context.get(), false, toClDeviceVector(*pDevice));
std::unique_ptr<MockCommandQueue> cmdQ(new MockCommandQueue(context.get(), pDevice, nullptr, false));

10
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@ -684,12 +684,12 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenGettingBindingTableStateTh
bti[i].setSurfaceStatePointer(i * sizeof(typename FamilyType::RENDER_SURFACE_STATE));
}
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sshSize;
pKernelInfo->heapInfo.surfaceStateHeapSize = sshSize;
// setup kernel heap
uint32_t kernelIsa[32];
pKernelInfo->heapInfo.pKernelHeap = kernelIsa;
pKernelInfo->heapInfo.KernelHeapSize = sizeof(kernelIsa);
pKernelInfo->heapInfo.kernelHeapSize = sizeof(kernelIsa);
pKernelInfo->setBindingTable(btiOffset, 5);
pKernelInfo->setLocalIds({1, 1, 1});
@ -780,7 +780,7 @@ HWTEST_F(HardwareCommandsTest, GivenBuffersNotRequiringSshWhenSettingBindingTabl
// setup surface state heap
char surfaceStateHeap[256];
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->addArgBuffer(0, 0, 0, 0);
pKernelInfo->setAddressQualifier(0, KernelArgMetadata::AddrGlobal);
@ -826,7 +826,7 @@ HWTEST_F(HardwareCommandsTest, GivenZeroSurfaceStatesWhenSettingBindingTableStat
// setup surface state heap
char surfaceStateHeap[256];
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
// initialize kernel
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
@ -977,7 +977,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, GivenKernelWithSamplersWhenInd
memset(mockDsh, 6, samplerTableOffset);
memset(mockDsh + samplerTableOffset, 8, samplerTableOffset);
mockKernelWithInternal->kernelInfo.heapInfo.pDsh = mockDsh;
mockKernelWithInternal->kernelInfo.heapInfo.DynamicStateHeapSize = mockDshSize;
mockKernelWithInternal->kernelInfo.heapInfo.dynamicStateHeapSize = mockDshSize;
uint64_t interfaceDescriptorTableOffset = dsh.getUsed();
dsh.getSpace(sizeof(INTERFACE_DESCRIPTOR_DATA));
dsh.getSpace(4);

4
opencl/test/unit_test/helpers/task_information_tests.cpp
View File

@ -290,7 +290,7 @@ HWTEST_F(DispatchFlagsTests, givenCommandComputeKernelWhenSubmitThenPassCorrectD
bool ndRangeKernel = false;
bool requiresCoherency = false;
for (auto &surface : surfaces) {
requiresCoherency |= surface->IsCoherent;
requiresCoherency |= surface->isCoherent;
}
std::unique_ptr<Command> command(new CommandComputeKernel(*mockCmdQ, kernelOperation, surfaces, flushDC, slmUsed, ndRangeKernel, nullptr, preemptionMode, kernel, 1, nullptr));
command->submit(20, false);
@ -338,7 +338,7 @@ HWTEST_F(DispatchFlagsTests, givenClCommandCopyImageWhenSubmitThenFlushTextureCa
uint32_t commandType = CL_COMMAND_COPY_IMAGE;
bool requiresCoherency = false;
for (auto &surface : surfaces) {
requiresCoherency |= surface->IsCoherent;
requiresCoherency |= surface->isCoherent;
}
std::unique_ptr<Command> command(new CommandComputeKernel(*mockCmdQ, kernelOperation, surfaces, flushDC, slmUsed, commandType, nullptr, preemptionMode, kernel, 1, nullptr));
command->submit(20, false);

4
opencl/test/unit_test/kernel/cache_flush_tests.inl
View File

@ -407,9 +407,9 @@ class GivenCacheResourceSurfacesWhenprocessingCacheFlushThenExpectProperCacheFlu
nullptr,
retVal));
descriptor.svm_allocation_pointer = svm;
descriptor.svmAllocationPointer = svm;
descriptor2.mem_object = buffer.get();
descriptor2.memObject = buffer.get();
const cl_resource_barrier_descriptor_intel descriptors[] = {descriptor, descriptor2};
BarrierCommand bCmd(&cmdQ, descriptors, 2);

2
opencl/test/unit_test/kernel/clone_kernel_tests.cpp
View File

@ -50,7 +50,7 @@ class CloneKernelTest : public MultiRootDeviceWithSubDevicesFixture {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->kernelDescriptor.kernelAttributes.crossThreadDataSize = 72;
pKernelInfo->setPrivateMemory(0x10, false, 8, 64, 64);
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
KernelInfoContainer kernelInfos;

2
opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.cpp
View File

@ -37,7 +37,7 @@ void KernelArgBufferFixture::setUp() {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pSsh = pSshLocal;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->addArgBuffer(0, 0x30, sizeof(void *), 0x0);

2
opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp
View File

@ -74,7 +74,7 @@ struct MultiDeviceKernelArgBufferTest : public ::testing::Test {
for (auto i = 0u; i < 2; i++) {
pKernelInfosStorage[i]->heapInfo.pSsh = pSshLocal[i];
pKernelInfosStorage[i]->heapInfo.SurfaceStateHeapSize = sizeof(pSshLocal[i]);
pKernelInfosStorage[i]->heapInfo.surfaceStateHeapSize = sizeof(pSshLocal[i]);
pKernelInfosStorage[i]->kernelDescriptor.kernelAttributes.simdSize = gfxCoreHelper.getMinimalSIMDSize();
auto crossThreadDataPointer = &pCrossThreadData[i];

2
opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp
View File

@ -44,7 +44,7 @@ class KernelArgPipeFixture : public ContextFixture, public ClDeviceFixture {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pSsh = pSshLocal;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->addArgPipe(0, 0x30, sizeof(void *));

2
opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp
View File

@ -45,7 +45,7 @@ class KernelArgSvmFixture : public ContextFixture, public ClDeviceFixture {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pSsh = pSshLocal;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(pSshLocal);
pKernelInfo->addArgBuffer(0, 0x30, sizeof(void *));

2
opencl/test/unit_test/kernel/kernel_slm_tests.cpp
View File

@ -31,7 +31,7 @@ struct KernelSLMAndBarrierTest : public ClDeviceFixture,
kernelInfo.setLocalIds({1, 1, 1});
kernelInfo.heapInfo.pKernelHeap = kernelIsa;
kernelInfo.heapInfo.KernelHeapSize = sizeof(kernelIsa);
kernelInfo.heapInfo.kernelHeapSize = sizeof(kernelIsa);
kernelInfo.kernelDescriptor.kernelAttributes.simdSize = 32;
}

16
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@ -103,7 +103,7 @@ TEST(KernelTest, WhenKernelIsCreatedThenCorrectMembersAreMemObjects) {
TEST_F(KernelTests, WhenKernelIsCreatedThenKernelHeapIsCorrect) {
EXPECT_EQ(kernel->getKernelInfo().heapInfo.pKernelHeap, kernel->getKernelHeap());
EXPECT_EQ(kernel->getKernelInfo().heapInfo.KernelHeapSize, kernel->getKernelHeapSize());
EXPECT_EQ(kernel->getKernelInfo().heapInfo.kernelHeapSize, kernel->getKernelHeapSize());
}
TEST_F(KernelTests, GivenInvalidParamNameWhenGettingInfoThenInvalidValueErrorIsReturned) {
@ -724,7 +724,7 @@ HWTEST_F(KernelPrivateSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenPri
// setup surface state heap
char surfaceStateHeap[0x80];
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
ASSERT_EQ(CL_SUCCESS, kernel->initialize());
@ -921,7 +921,7 @@ HWTEST_F(KernelGlobalSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenGlob
// setup surface state heap
char surfaceStateHeap[0x80];
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
ASSERT_EQ(CL_SUCCESS, kernel->initialize());
@ -1038,7 +1038,7 @@ HWTEST_F(KernelConstantSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenCo
// setup surface state heap
char surfaceStateHeap[0x80];
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
ASSERT_EQ(CL_SUCCESS, kernel->initialize());
@ -2491,14 +2491,14 @@ TEST(KernelInfoTest, givenGfxCoreHelperWhenCreatingKernelAllocationThenCorrectPa
auto mockKernel = std::make_unique<MockKernelWithInternals>(*clDevice, context.get());
uint32_t kernelHeap = 0;
mockKernel->kernelInfo.heapInfo.KernelHeapSize = 1;
mockKernel->kernelInfo.heapInfo.kernelHeapSize = 1;
mockKernel->kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
mockKernel->kernelInfo.createKernelAllocation(clDevice->getDevice(), false);
auto graphicsAllocation = mockKernel->kernelInfo.getGraphicsAllocation();
auto &helper = clDevice->getRootDeviceEnvironment().getHelper<GfxCoreHelper>();
size_t isaPadding = helper.getPaddingForISAAllocation();
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), mockKernel->kernelInfo.heapInfo.KernelHeapSize + isaPadding);
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), mockKernel->kernelInfo.heapInfo.kernelHeapSize + isaPadding);
clDevice->getMemoryManager()->freeGraphicsMemory(mockKernel->kernelInfo.getGraphicsAllocation());
}
@ -3321,7 +3321,7 @@ HWTEST2_F(KernelConstantSurfaceTest, givenKernelWithConstantSurfaceWhenKernelIsC
// setup surface state heap
char surfaceStateHeap[0x80];
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
ASSERT_EQ(CL_SUCCESS, kernel->initialize());
@ -3520,7 +3520,7 @@ HWTEST2_F(KernelTest, GivenInlineSamplersWhenSettingInlineSamplerThenDshIsPatche
std::array<uint8_t, 64 + 16> dsh = {0};
kernel.kernelInfo.heapInfo.pDsh = dsh.data();
kernel.kernelInfo.heapInfo.DynamicStateHeapSize = static_cast<uint32_t>(dsh.size());
kernel.kernelInfo.heapInfo.dynamicStateHeapSize = static_cast<uint32_t>(dsh.size());
kernel.mockKernel->setInlineSamplers();
using SamplerState = typename FamilyType::SAMPLER_STATE;

2
opencl/test/unit_test/kernel/kernel_transformable_tests.cpp
View File

@ -28,7 +28,7 @@ class KernelTransformableTest : public ::testing::Test {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->addArgSampler(0, 0);
pKernelInfo->addArgSampler(1, 0);

8
opencl/test/unit_test/kernel/substitute_kernel_heap_tests.cpp
View File

@ -21,7 +21,7 @@ typedef Test<ClDeviceFixture> KernelSubstituteTest;
TEST_F(KernelSubstituteTest, givenKernelWhenSubstituteKernelHeapWithGreaterSizeThenAllocatesNewKernelAllocation) {
MockKernelWithInternals kernel(*pClDevice);
const size_t initialHeapSize = 0x40;
kernel.kernelInfo.heapInfo.KernelHeapSize = initialHeapSize;
kernel.kernelInfo.heapInfo.kernelHeapSize = initialHeapSize;
EXPECT_EQ(nullptr, kernel.kernelInfo.kernelAllocation);
kernel.kernelInfo.createKernelAllocation(*pDevice, false);
@ -53,7 +53,7 @@ TEST_F(KernelSubstituteTest, givenKernelWhenSubstituteKernelHeapWithGreaterSizeT
TEST_F(KernelSubstituteTest, givenKernelWhenSubstituteKernelHeapWithSameSizeThenDoesNotAllocateNewKernelAllocation) {
MockKernelWithInternals kernel(*pClDevice);
const size_t initialHeapSize = 0x40;
kernel.kernelInfo.heapInfo.KernelHeapSize = initialHeapSize;
kernel.kernelInfo.heapInfo.kernelHeapSize = initialHeapSize;
EXPECT_EQ(nullptr, kernel.kernelInfo.kernelAllocation);
kernel.kernelInfo.createKernelAllocation(*pDevice, false);
@ -84,7 +84,7 @@ TEST_F(KernelSubstituteTest, givenKernelWhenSubstituteKernelHeapWithSameSizeThen
TEST_F(KernelSubstituteTest, givenKernelWhenSubstituteKernelHeapWithSmallerSizeThenDoesNotAllocateNewKernelAllocation) {
MockKernelWithInternals kernel(*pClDevice);
const size_t initialHeapSize = 0x40;
kernel.kernelInfo.heapInfo.KernelHeapSize = initialHeapSize;
kernel.kernelInfo.heapInfo.kernelHeapSize = initialHeapSize;
EXPECT_EQ(nullptr, kernel.kernelInfo.kernelAllocation);
kernel.kernelInfo.createKernelAllocation(*pDevice, false);
@ -118,7 +118,7 @@ TEST_F(KernelSubstituteTest, givenKernelWithUsedKernelAllocationWhenSubstituteKe
auto &commandStreamReceiver = pDevice->getGpgpuCommandStreamReceiver();
const size_t initialHeapSize = 0x40;
kernel.kernelInfo.heapInfo.KernelHeapSize = initialHeapSize;
kernel.kernelInfo.heapInfo.kernelHeapSize = initialHeapSize;
kernel.kernelInfo.createKernelAllocation(*pDevice, false);
auto firstAllocation = kernel.kernelInfo.kernelAllocation;

2
opencl/test/unit_test/mem_obj/buffer_set_arg_tests.cpp
View File

@ -51,7 +51,7 @@ class BufferSetArgTest : public ContextFixture,
pKernelInfo->addArgBuffer(2, 0x30, sizeOfPointer);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));

8
opencl/test/unit_test/mem_obj/buffer_tests.cpp
View File

@ -1780,10 +1780,10 @@ HWTEST_F(BufferSetSurfaceTests, givenMisalignedPointerWhenSurfaceStateIsProgramm
EXPECT_EQ(castToUint64(svmPtr), surfaceState.getSurfaceBaseAddress());
SURFACE_STATE_BUFFER_LENGTH length = {};
length.SurfaceState.Width = surfaceState.getWidth() - 1;
length.SurfaceState.Height = surfaceState.getHeight() - 1;
length.SurfaceState.Depth = surfaceState.getDepth() - 1;
EXPECT_EQ(alignUp(5u, 4u), length.Length + 1);
length.surfaceState.width = surfaceState.getWidth() - 1;
length.surfaceState.height = surfaceState.getHeight() - 1;
length.surfaceState.depth = surfaceState.getDepth() - 1;
EXPECT_EQ(alignUp(5u, 4u), length.length + 1);
}
HWTEST_F(BufferSetSurfaceTests, givenBufferThatIsMisalignedWhenSurfaceStateIsBeingProgrammedThenL3CacheIsOff) {

4
opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
View File

@ -70,7 +70,7 @@ class ImageSetArgTest : public ClDeviceFixture,
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00);
@ -926,7 +926,7 @@ class ImageMediaBlockSetArgTest : public ImageSetArgTest {
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK);

2
opencl/test/unit_test/memory_manager/mem_obj_surface_tests.cpp
View File

@ -74,5 +74,5 @@ TEST_F(CoherentMemObjSurface, GivenCoherentMemObjWhenCreatingSurfaceFromMemObjTh
std::unique_ptr<Surface> surface{createSurface::create(this->data,
&this->buffer,
&this->gfxAllocation)};
EXPECT_TRUE(surface->IsCoherent);
EXPECT_TRUE(surface->isCoherent);
}

26
opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp
View File

@ -37,7 +37,7 @@ using SVMLocalMemoryAllocatorTest = Test<SVMMemoryAllocatorFixture<true>>;
TEST_F(SVMMemoryAllocatorTest, whenCreateZeroSizedSVMAllocationThenReturnNullptr) {
auto ptr = svmManager->createSVMAlloc(0, {}, rootDeviceIndices, deviceBitfields);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
EXPECT_EQ(ptr, nullptr);
}
@ -55,7 +55,7 @@ TEST_F(MultiDeviceSVMMemoryAllocatorTest, givenMultipleDevicesWhenCreatingSVMAll
auto ptr = svmManager->createSVMAlloc(MemoryConstants::pageSize, {}, context->getRootDeviceIndices(), context->getDeviceBitfields());
EXPECT_NE(nullptr, ptr);
auto svmData = svmManager->getSVMAlloc(ptr);
EXPECT_EQ(1u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(1u, svmManager->svmAllocs.getNumAllocs());
ASSERT_NE(nullptr, svmData);
for (auto &rootDeviceIndex : context->getRootDeviceIndices()) {
auto svmAllocation = svmManager->getSVMAlloc(ptr)->gpuAllocations.getGraphicsAllocation(rootDeviceIndex);
@ -66,7 +66,7 @@ TEST_F(MultiDeviceSVMMemoryAllocatorTest, givenMultipleDevicesWhenCreatingSVMAll
svmManager->freeSVMAlloc(ptr);
EXPECT_EQ(nullptr, svmManager->getSVMAlloc(ptr));
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
}
TEST_F(SVMMemoryAllocatorTest, whenSVMAllocationIsFreedThenCannotBeGotAgain) {
@ -78,13 +78,13 @@ TEST_F(SVMMemoryAllocatorTest, whenSVMAllocationIsFreedThenCannotBeGotAgain) {
svmData = svmManager->getSVMAlloc(ptr);
ASSERT_NE(nullptr, svmData);
EXPECT_NE(nullptr, svmData->gpuAllocations.getGraphicsAllocation(mockRootDeviceIndex));
EXPECT_EQ(1u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(1u, svmManager->svmAllocs.getNumAllocs());
auto svmAllocation = svmManager->getSVMAlloc(ptr)->gpuAllocations.getGraphicsAllocation(mockRootDeviceIndex);
EXPECT_FALSE(svmAllocation->isCoherent());
svmManager->freeSVMAlloc(ptr);
EXPECT_EQ(nullptr, svmManager->getSVMAlloc(ptr));
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
}
TEST_F(SVMMemoryAllocatorTest, givenSvmManagerWhenOperatedOnThenCorrectAllocationIsInsertedReturnedAndRemoved) {
@ -104,13 +104,13 @@ TEST_F(SVMMemoryAllocatorTest, givenSvmManagerWhenOperatedOnThenCorrectAllocatio
auto svmDataTemp = svmManager->getSVMAlloc(ptr);
ASSERT_NE(nullptr, svmDataTemp);
EXPECT_NE(nullptr, svmDataTemp->gpuAllocations.getGraphicsAllocation(mockRootDeviceIndex));
EXPECT_EQ(1u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(1u, svmManager->svmAllocs.getNumAllocs());
auto svmAllocation = svmManager->getSVMAlloc(ptr)->gpuAllocations.getGraphicsAllocation(mockRootDeviceIndex);
EXPECT_FALSE(svmAllocation->isCoherent());
svmManager->removeSVMAlloc(svmData);
EXPECT_EQ(nullptr, svmManager->getSVMAlloc(ptr));
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->memoryManager->freeGraphicsMemory(allocation);
}
@ -158,7 +158,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenReturnsNul
svmManager->memoryManager = &failMemoryManager;
auto ptr = svmManager->createSVMAlloc(MemoryConstants::pageSize, {}, rootDeviceIndices, deviceBitfields);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->freeSVMAlloc(ptr);
}
@ -172,7 +172,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateUnif
unifiedMemoryProperties.device = &device->getDevice();
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->freeSVMAlloc(ptr);
}
@ -282,7 +282,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateShar
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
auto ptr = svmManager->createSharedUnifiedMemoryAllocation(4096u, unifiedMemoryProperties, &cmdQ);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->freeSVMAlloc(ptr);
}
@ -485,7 +485,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateCpuAllocationInMemoryMan
svmManager->memoryManager = &failMemoryManager;
auto ptr = svmManager->createSVMAlloc(MemoryConstants::pageSize, {}, rootDeviceIndices, deviceBitfields);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->freeSVMAlloc(ptr);
}
@ -494,7 +494,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateGpuAllocationInMemoryMan
svmManager->memoryManager = &failMemoryManager;
auto ptr = svmManager->createSVMAlloc(MemoryConstants::pageSize, {}, rootDeviceIndices, deviceBitfields);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
svmManager->freeSVMAlloc(ptr);
}
@ -502,7 +502,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotReserveCpuAddressRangeInMemoryMa
memoryManager->failReserveAddress = true;
auto ptr = svmManager->createSVMAlloc(MemoryConstants::pageSize, {}, rootDeviceIndices, deviceBitfields);
EXPECT_EQ(nullptr, ptr);
EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs());
EXPECT_EQ(0u, svmManager->svmAllocs.getNumAllocs());
}
struct MemoryManagerPropertiesCheck : public MockMemoryManager {

6
opencl/test/unit_test/mocks/mock_debug_program.cpp
View File

@ -64,9 +64,9 @@ void MockDebugProgram::prepareKernelInfo() {
}
void MockDebugProgram::prepareSSHForDebugSurface() {
kernelInfo->heapInfo.SurfaceStateHeapSize = static_cast<uint32_t>(alignUp(64U + sizeof(int), 64U));
kernelSsh = std::make_unique<char[]>(kernelInfo->heapInfo.SurfaceStateHeapSize);
memset(kernelSsh.get(), 0U, kernelInfo->heapInfo.SurfaceStateHeapSize);
kernelInfo->heapInfo.surfaceStateHeapSize = static_cast<uint32_t>(alignUp(64U + sizeof(int), 64U));
kernelSsh = std::make_unique<char[]>(kernelInfo->heapInfo.surfaceStateHeapSize);
memset(kernelSsh.get(), 0U, kernelInfo->heapInfo.surfaceStateHeapSize);
kernelInfo->heapInfo.pSsh = kernelSsh.get();
kernelInfo->kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful = 0U;

6
opencl/test/unit_test/mocks/mock_kernel.h
View File

@ -272,11 +272,11 @@ class MockKernelWithInternals {
memset(&kernelHeader, 0, sizeof(SKernelBinaryHeaderCommon));
kernelInfo.heapInfo.pKernelHeap = kernelIsa;
kernelInfo.heapInfo.KernelHeapSize = sizeof(kernelIsa);
kernelInfo.heapInfo.kernelHeapSize = sizeof(kernelIsa);
kernelInfo.heapInfo.pSsh = sshLocal;
kernelInfo.heapInfo.SurfaceStateHeapSize = sizeof(sshLocal);
kernelInfo.heapInfo.surfaceStateHeapSize = sizeof(sshLocal);
kernelInfo.heapInfo.pDsh = dshLocal;
kernelInfo.heapInfo.DynamicStateHeapSize = sizeof(dshLocal);
kernelInfo.heapInfo.dynamicStateHeapSize = sizeof(dshLocal);
populateKernelDescriptor(kernelInfo.kernelDescriptor, execEnv);
kernelInfo.kernelDescriptor.kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber;

2
opencl/test/unit_test/profiling/profiling_tests.cpp
View File

@ -43,7 +43,7 @@ struct ProfilingTests : public CommandEnqueueFixture,
kernelInfo.setLocalIds({1, 1, 1});
kernelInfo.heapInfo.pKernelHeap = kernelIsa;
kernelInfo.heapInfo.KernelHeapSize = sizeof(kernelIsa);
kernelInfo.heapInfo.kernelHeapSize = sizeof(kernelIsa);
}
void TearDown() override {

12
opencl/test/unit_test/program/kernel_info_from_patchtokens_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -23,11 +23,11 @@ TEST(KernelInfoFromPatchTokens, GivenValidEmptyKernelFromPatchtokensThenReturnEm
expectedKernelInfo.kernelDescriptor.kernelMetadata.kernelName = std::string(src.name.begin()).c_str();
EXPECT_STREQ(expectedKernelInfo.kernelDescriptor.kernelMetadata.kernelName.c_str(), dst.kernelDescriptor.kernelMetadata.kernelName.c_str());
EXPECT_EQ(src.header->KernelHeapSize, dst.heapInfo.KernelHeapSize);
EXPECT_EQ(src.header->GeneralStateHeapSize, dst.heapInfo.GeneralStateHeapSize);
EXPECT_EQ(src.header->DynamicStateHeapSize, dst.heapInfo.DynamicStateHeapSize);
EXPECT_EQ(src.header->SurfaceStateHeapSize, dst.heapInfo.SurfaceStateHeapSize);
EXPECT_EQ(src.header->KernelUnpaddedSize, dst.heapInfo.KernelUnpaddedSize);
EXPECT_EQ(src.header->KernelHeapSize, dst.heapInfo.kernelHeapSize);
EXPECT_EQ(src.header->GeneralStateHeapSize, dst.heapInfo.generalStateHeapSize);
EXPECT_EQ(src.header->DynamicStateHeapSize, dst.heapInfo.dynamicStateHeapSize);
EXPECT_EQ(src.header->SurfaceStateHeapSize, dst.heapInfo.surfaceStateHeapSize);
EXPECT_EQ(src.header->KernelUnpaddedSize, dst.heapInfo.kernelUnpaddedSize);
}
TEST(KernelInfoFromPatchTokens, GivenDataParameterStreamWithEmptySizeThenTokenIsIgnored) {

12
opencl/test/unit_test/program/kernel_info_tests.cpp
View File

@ -34,7 +34,7 @@ TEST(KernelInfoTest, givenKernelInfoWhenCreateKernelAllocationThenCopyWholeKerne
auto device = factory.rootDevices[0];
const size_t heapSize = 0x40;
char heap[heapSize];
kernelInfo.heapInfo.KernelHeapSize = heapSize;
kernelInfo.heapInfo.kernelHeapSize = heapSize;
kernelInfo.heapInfo.pKernelHeap = &heap;
for (size_t i = 0; i < heapSize; i++) {
@ -57,7 +57,7 @@ TEST(KernelInfoTest, givenKernelInfoWhenCreatingKernelAllocationWithInternalIsaF
auto device = factory.rootDevices[0];
const size_t heapSize = 0x40;
char heap[heapSize];
kernelInfo.heapInfo.KernelHeapSize = heapSize;
kernelInfo.heapInfo.kernelHeapSize = heapSize;
kernelInfo.heapInfo.pKernelHeap = &heap;
auto retVal = kernelInfo.createKernelAllocation(*device, false);
@ -73,7 +73,7 @@ TEST(KernelInfoTest, givenKernelInfoWhenCreatingKernelAllocationWithInternalIsaT
auto device = factory.rootDevices[0];
const size_t heapSize = 0x40;
char heap[heapSize];
kernelInfo.heapInfo.KernelHeapSize = heapSize;
kernelInfo.heapInfo.kernelHeapSize = heapSize;
kernelInfo.heapInfo.pKernelHeap = &heap;
auto retVal = kernelInfo.createKernelAllocation(*device, true);
@ -110,10 +110,10 @@ TEST(KernelInfoTest, givenReuseKernelBinariesWhenCreateKernelAllocationThenReuse
const size_t heapSize = 0x40;
char heap[heapSize];
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = heapSize;
kernelInfo.heapInfo.kernelHeapSize = heapSize;
kernelInfo.heapInfo.pKernelHeap = &heap;
KernelInfo kernelInfo2;
kernelInfo2.heapInfo.KernelHeapSize = heapSize;
kernelInfo2.heapInfo.kernelHeapSize = heapSize;
kernelInfo2.heapInfo.pKernelHeap = &heap;
EXPECT_EQ(0u, device->getMemoryManager()->getKernelAllocationMap().size());
@ -135,7 +135,7 @@ TEST_F(KernelInfoMultiRootDeviceTests, WhenCreatingKernelAllocationThenItHasCorr
KernelInfo kernelInfo;
const size_t heapSize = 0x40;
char heap[heapSize];
kernelInfo.heapInfo.KernelHeapSize = heapSize;
kernelInfo.heapInfo.kernelHeapSize = heapSize;
kernelInfo.heapInfo.pKernelHeap = &heap;
auto retVal = kernelInfo.createKernelAllocation(device1->getDevice(), false);

14
opencl/test/unit_test/program/program_data_tests.cpp
View File

@ -574,7 +574,7 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
std::vector<char> kernelHeap;
kernelHeap.resize(32, 7);
kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.heapInfo.kernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.createKernelAllocation(device->getDevice(), false);
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
@ -613,7 +613,7 @@ TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
std::vector<char> kernelHeap;
kernelHeap.resize(32, 7);
kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.heapInfo.kernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
@ -662,7 +662,7 @@ TEST_F(ProgramDataTest, whenRelocationsAreNotNeededThenIsaIsPreserved) {
kernelHeapData.resize(32, 7);
std::vector<char> kernelHeap(kernelHeapData.begin(), kernelHeapData.end());
kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
kernelInfo.heapInfo.kernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
@ -700,7 +700,7 @@ TEST(ProgramStringSectionTest, WhenConstStringBufferIsPresentThenUseItForLinking
KernelInfo kernelInfo = {};
kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
kernelInfo.heapInfo.KernelHeapSize = 64;
kernelInfo.heapInfo.kernelHeapSize = 64;
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
@ -734,7 +734,7 @@ TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndStackCallsThenKernelRequ
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = true;
uint8_t kernelHeapData[64] = {};
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
kernelInfo.heapInfo.KernelHeapSize = 64;
kernelInfo.heapInfo.kernelHeapSize = 64;
MockGraphicsAllocation kernelIsa(kernelHeapData, 64);
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
@ -766,7 +766,7 @@ TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndEnabledDebuggerThenKerne
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = false;
uint8_t kernelHeapData[64] = {};
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
kernelInfo.heapInfo.KernelHeapSize = 64;
kernelInfo.heapInfo.kernelHeapSize = 64;
MockGraphicsAllocation kernelIsa(kernelHeapData, 64);
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
@ -792,7 +792,7 @@ TEST(ProgramImplicitArgsTest, givenImplicitRelocationAndNoStackCallsAndDisabledD
kernelInfo.kernelDescriptor.kernelAttributes.flags.useStackCalls = false;
uint8_t kernelHeapData[64] = {};
kernelInfo.heapInfo.pKernelHeap = kernelHeapData;
kernelInfo.heapInfo.KernelHeapSize = 64;
kernelInfo.heapInfo.kernelHeapSize = 64;
MockGraphicsAllocation kernelIsa(kernelHeapData, 64);
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);

6
opencl/test/unit_test/program/program_tests.cpp
View File

@ -511,11 +511,11 @@ TEST_F(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphi
EXPECT_TRUE(graphicsAllocation->is32BitAllocation());
auto &helper = pDevice->getRootDeviceEnvironment().getHelper<GfxCoreHelper>();
size_t isaPadding = helper.getPaddingForISAAllocation();
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), kernelInfo->heapInfo.KernelHeapSize + isaPadding);
EXPECT_EQ(graphicsAllocation->getUnderlyingBufferSize(), kernelInfo->heapInfo.kernelHeapSize + isaPadding);
auto kernelIsa = graphicsAllocation->getUnderlyingBuffer();
EXPECT_NE(kernelInfo->heapInfo.pKernelHeap, kernelIsa);
EXPECT_EQ(0, memcmp(kernelIsa, kernelInfo->heapInfo.pKernelHeap, kernelInfo->heapInfo.KernelHeapSize));
EXPECT_EQ(0, memcmp(kernelIsa, kernelInfo->heapInfo.pKernelHeap, kernelInfo->heapInfo.kernelHeapSize));
auto rootDeviceIndex = graphicsAllocation->getRootDeviceIndex();
auto gmmHelper = pDevice->getGmmHelper();
EXPECT_EQ(gmmHelper->decanonize(graphicsAllocation->getGpuBaseAddress()), pDevice->getMemoryManager()->getInternalHeapBaseAddress(rootDeviceIndex, graphicsAllocation->isAllocatedInLocalMemoryPool()));
@ -3143,7 +3143,7 @@ class MockCompilerInterfaceWithGtpinParam : public CompilerInterface {
const NEO::Device &device,
const TranslationInput &input,
TranslationOutput &output) override {
gtpinInfoPassed = input.GTPinInput;
gtpinInfoPassed = input.gtPinInput;
return CompilerInterface::link(device, input, output);
}
void *gtpinInfoPassed;

2
opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp
View File

@ -40,7 +40,7 @@ class SamplerSetArgFixture : public ClDeviceFixture {
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pDsh = samplerStateHeap;
pKernelInfo->heapInfo.DynamicStateHeapSize = sizeof(samplerStateHeap);
pKernelInfo->heapInfo.dynamicStateHeapSize = sizeof(samplerStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgSampler(0, 0x40, 0x8, 0x10, 0x4);

32
opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp
View File

@ -351,11 +351,11 @@ TEST(SourceLevelDebugger, givenKernelDebuggerLibraryActiveWhenNotifyKernelDebugD
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
debugger.callBaseNotifyKernelDebugData = true;
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
EXPECT_TRUE(interceptor.kernelDebugDataCalled);
@ -368,7 +368,7 @@ TEST(SourceLevelDebugger, givenKernelDebuggerLibraryActiveWhenNotifyKernelDebugD
EXPECT_EQ(visa, interceptor.kernelDebugDataArgIn.dbgVisaBuffer);
EXPECT_EQ(sizeof(visa), interceptor.kernelDebugDataArgIn.dbgVisaSize);
EXPECT_EQ(info.heapInfo.KernelHeapSize, interceptor.kernelDebugDataArgIn.KernelBinSize);
EXPECT_EQ(info.heapInfo.kernelHeapSize, interceptor.kernelDebugDataArgIn.KernelBinSize);
EXPECT_EQ(isa, interceptor.kernelDebugDataArgIn.kernelBinBuffer);
EXPECT_STREQ(info.kernelDescriptor.kernelMetadata.kernelName.c_str(), interceptor.kernelDebugDataArgIn.kernelName);
}
@ -387,11 +387,11 @@ TEST(SourceLevelDebugger, givenKernelDebuggerLibraryActiveWhenNullptrDebugDataIs
KernelInfo info;
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
debugger.callBaseNotifyKernelDebugData = true;
debugger.notifyKernelDebugData(nullptr, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger.notifyKernelDebugData(nullptr, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
EXPECT_TRUE(interceptor.kernelDebugDataCalled);
@ -404,7 +404,7 @@ TEST(SourceLevelDebugger, givenKernelDebuggerLibraryActiveWhenNullptrDebugDataIs
EXPECT_EQ(nullptr, interceptor.kernelDebugDataArgIn.dbgVisaBuffer);
EXPECT_EQ(0u, interceptor.kernelDebugDataArgIn.dbgVisaSize);
EXPECT_EQ(info.heapInfo.KernelHeapSize, interceptor.kernelDebugDataArgIn.KernelBinSize);
EXPECT_EQ(info.heapInfo.kernelHeapSize, interceptor.kernelDebugDataArgIn.KernelBinSize);
EXPECT_EQ(isa, interceptor.kernelDebugDataArgIn.kernelBinBuffer);
EXPECT_STREQ(info.kernelDescriptor.kernelMetadata.kernelName.c_str(), interceptor.kernelDebugDataArgIn.kernelName);
}
@ -429,11 +429,11 @@ TEST(SourceLevelDebugger, givenNoVisaWhenNotifyKernelDebugDataIsCalledThenDebugg
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
debugger.callBaseNotifyKernelDebugData = true;
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
EXPECT_TRUE(interceptor.kernelDebugDataCalled);
EXPECT_EQ(isa, interceptor.kernelDebugDataArgIn.kernelBinBuffer);
}
@ -458,7 +458,7 @@ TEST(SourceLevelDebugger, givenNoGenIsaWhenNotifyKernelDebugDataIsCalledThenDebu
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
debugger.callBaseNotifyKernelDebugData = true;
@ -756,11 +756,11 @@ TEST(SourceLevelDebugger, givenEnableMockSourceLevelDebuggerWhenInitializingExec
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
debugger->notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger->notifyKernelDebugData(nullptr, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger->notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
debugger->notifyKernelDebugData(nullptr, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
debugger->notifyKernelDebugData(nullptr, info.kernelDescriptor.kernelMetadata.kernelName, nullptr, 0);
EXPECT_TRUE(debugger->notifyDeviceDestruction());
@ -818,14 +818,14 @@ TEST(SourceLevelDebugger, givenDebugVarDumpElfWhenNotifyKernelDebugDataIsCalledT
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
std::string fileName = info.kernelDescriptor.kernelMetadata.kernelName + ".elf";
EXPECT_FALSE(fileExists(fileName));
debugger.callBaseNotifyKernelDebugData = true;
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
EXPECT_TRUE(fileExists(fileName));
std::remove(fileName.c_str());
}
@ -854,7 +854,7 @@ TEST(SourceLevelDebugger, givenDebugVarDumpElfWhenElfFileExistsWhileNotifyingDeb
info.kernelDescriptor.kernelMetadata.kernelName = "debugKernel";
info.heapInfo.KernelHeapSize = sizeof(isa);
info.heapInfo.kernelHeapSize = sizeof(isa);
info.heapInfo.pKernelHeap = isa;
std::string fileName = info.kernelDescriptor.kernelMetadata.kernelName + ".elf";
@ -864,7 +864,7 @@ TEST(SourceLevelDebugger, givenDebugVarDumpElfWhenElfFileExistsWhileNotifyingDeb
std::string fileName2 = info.kernelDescriptor.kernelMetadata.kernelName + "_0.elf";
debugger.callBaseNotifyKernelDebugData = true;
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.KernelHeapSize);
debugger.notifyKernelDebugData(&info.debugData, info.kernelDescriptor.kernelMetadata.kernelName, info.heapInfo.pKernelHeap, info.heapInfo.kernelHeapSize);
EXPECT_TRUE(fileExists(fileName2));

68
opencl/test/unit_test/test_files/patch_list.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2020 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,37 +14,37 @@
const uint32_t MAGIC_CL = 0x494E5443;
struct SProgramBinaryHeader
{
uint32_t Magic;
uint32_t Version;
uint32_t Magic; // NOLINT(readability-identifier-naming)
uint32_t Version; // NOLINT(readability-identifier-naming)
uint32_t Device;
uint32_t GPUPointerSizeInBytes;
uint32_t Device; // NOLINT(readability-identifier-naming)
uint32_t GPUPointerSizeInBytes; // NOLINT(readability-identifier-naming)
uint32_t NumberOfKernels;
uint32_t NumberOfKernels; // NOLINT(readability-identifier-naming)
uint32_t SteppingId;
uint32_t SteppingId; // NOLINT(readability-identifier-naming)
uint32_t PatchListSize;
uint32_t PatchListSize; // NOLINT(readability-identifier-naming)
};
static_assert( sizeof( SProgramBinaryHeader ) == 28 , "The size of SProgramBinaryHeader is not what is expected" );
struct SKernelBinaryHeader
{
uint32_t CheckSum;
uint64_t ShaderHashCode;
uint32_t KernelNameSize;
uint32_t PatchListSize;
uint32_t CheckSum; // NOLINT(readability-identifier-naming)
uint64_t ShaderHashCode; // NOLINT(readability-identifier-naming)
uint32_t KernelNameSize; // NOLINT(readability-identifier-naming)
uint32_t PatchListSize; // NOLINT(readability-identifier-naming)
};
static_assert( sizeof( SKernelBinaryHeader ) == 20 , "The size of SKernelBinaryHeader is not what is expected" );
struct SKernelBinaryHeaderCommon :
SKernelBinaryHeader
{
uint32_t KernelHeapSize;
uint32_t GeneralStateHeapSize;
uint32_t DynamicStateHeapSize;
uint32_t SurfaceStateHeapSize;
uint32_t KernelUnpaddedSize;
uint32_t KernelHeapSize; // NOLINT(readability-identifier-naming)
uint32_t GeneralStateHeapSize; // NOLINT(readability-identifier-naming)
uint32_t DynamicStateHeapSize; // NOLINT(readability-identifier-naming)
uint32_t SurfaceStateHeapSize; // NOLINT(readability-identifier-naming)
uint32_t KernelUnpaddedSize; // NOLINT(readability-identifier-naming)
};
static_assert( sizeof( SKernelBinaryHeaderCommon ) == ( 20 + sizeof( SKernelBinaryHeader ) ) , "The size of SKernelBinaryHeaderCommon is not what is expected" );
@ -109,48 +109,48 @@ enum PATCH_TOKEN
struct SPatchItemHeader
{
uint32_t Token;
uint32_t Size;
uint32_t Token; // NOLINT(readability-identifier-naming)
uint32_t Size; // NOLINT(readability-identifier-naming)
};
struct SPatchDataParameterBuffer :
SPatchItemHeader
{
uint32_t Type;
uint32_t ArgumentNumber;
uint32_t Offset;
uint32_t DataSize;
uint32_t SourceOffset;
uint32_t LocationIndex;
uint32_t LocationIndex2;
uint32_t IsEmulationArgument;
uint32_t Type; // NOLINT(readability-identifier-naming)
uint32_t ArgumentNumber; // NOLINT(readability-identifier-naming)
uint32_t Offset; // NOLINT(readability-identifier-naming)
uint32_t DataSize; // NOLINT(readability-identifier-naming)
uint32_t SourceOffset; // NOLINT(readability-identifier-naming)
uint32_t LocationIndex; // NOLINT(readability-identifier-naming)
uint32_t LocationIndex2; // NOLINT(readability-identifier-naming)
uint32_t IsEmulationArgument; // NOLINT(readability-identifier-naming)
};
struct SPatchMediaInterfaceDescriptorLoad :
SPatchItemHeader
{
uint32_t InterfaceDescriptorDataOffset;
uint32_t InterfaceDescriptorDataOffset; // NOLINT(readability-identifier-naming)
};
static_assert( sizeof( SPatchMediaInterfaceDescriptorLoad ) == ( 4 + sizeof( SPatchItemHeader ) ) , "The size of SPatchMediaInterfaceDescriptorLoad is not what is expected" );
struct SPatchStateSIP :
SPatchItemHeader
{
uint32_t SystemKernelOffset;
uint32_t SystemKernelOffset; // NOLINT(readability-identifier-naming)
};
struct SPatchSamplerStateArray :
SPatchItemHeader
{
uint32_t Offset;
uint32_t Count;
uint32_t BorderColorOffset;
uint32_t Offset; // NOLINT(readability-identifier-naming)
uint32_t Count; // NOLINT(readability-identifier-naming)
uint32_t BorderColorOffset; // NOLINT(readability-identifier-naming)
};
struct SPatchAllocateConstantMemorySurfaceProgramBinaryInfo :
SPatchItemHeader
{
uint32_t ConstantBufferIndex;
uint32_t InlineDataSize;
uint32_t ConstantBufferIndex; // NOLINT(readability-identifier-naming)
uint32_t InlineDataSize; // NOLINT(readability-identifier-naming)
};
static_assert( sizeof( SPatchAllocateConstantMemorySurfaceProgramBinaryInfo ) == ( 8 + sizeof( SPatchItemHeader ) ) , "The size of SPatchAllocateConstantMemorySurfaceProgramBinaryInfo is not what is expected" );
#pragma pack( pop )

2
opencl/test/unit_test/utilities/file_logger_tests.cpp
View File

@ -380,7 +380,7 @@ TEST(FileLogger, GivenImageNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
char surfaceStateHeap[0x80];
kernelInfo->heapInfo.pSsh = surfaceStateHeap;
kernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
kernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
kernelInfo->addArgImage(0);
kernelInfo->argAsImg(0).metadataPayload.imgWidth = 0x4;

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

@ -70,7 +70,7 @@ XE_HPC_CORETEST_F(MemoryPrefetchTestsXeHpcCore, givenKernelWhenWalkerIsProgramme
HardwareInterfaceWalkerArgs walkerArgs = createHardwareInterfaceWalkerArgs(workSize, wgInfo, PreemptionMode::Disabled);
mockKernel->kernelInfo.heapInfo.KernelHeapSize = 1;
mockKernel->kernelInfo.heapInfo.kernelHeapSize = 1;
HardwareInterface<FamilyType>::programWalker(commandStream, *mockKernel->mockKernel, *commandQueue,
heap, heap, heap, dispatchInfo, walkerArgs);
@ -97,7 +97,7 @@ XE_HPC_CORETEST_F(MemoryPrefetchTestsXeHpcCore, givenPrefetchEnabledWhenEstimati
size_t expected = sizeof(typename FamilyType::COMPUTE_WALKER) +
(sizeof(typename FamilyType::PIPE_CONTROL) * numPipeControls) +
HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() +
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(mockKernel->kernelInfo.heapInfo.KernelHeapSize, clDevice->getRootDeviceEnvironment());
EncodeMemoryPrefetch<FamilyType>::getSizeForMemoryPrefetch(mockKernel->kernelInfo.heapInfo.kernelHeapSize, clDevice->getRootDeviceEnvironment());
EXPECT_EQ(expected, EnqueueOperation<FamilyType>::getSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, false, false, *commandQueue, mockKernel->mockKernel, {}));
}

8
shared/source/aub_mem_dump/aub_mem_dump.h
View File

@ -52,11 +52,11 @@ union IAPageTableEntry {
uint64_t dirty : 1; //[6]
uint64_t pat : 1; //[7]
uint64_t global : 1; //[8]
uint64_t reserved_9 : 1; //[9]
uint64_t reserved_10 : 1; //[10]
uint64_t reserved_11 : 1; //[11]
uint64_t reserved9 : 1; //[9]
uint64_t reserved10 : 1; //[10]
uint64_t reserved11 : 1; //[11]
uint64_t physicalAddress : 27; //[38:12]
uint64_t reserved_51_39 : 13; //[51:39]
uint64_t reserved51To39 : 13; //[51:39]
uint64_t ignored : 11; //[62:52]
uint64_t executeDisable : 1; //[63]
} pageConfig;

10
shared/source/command_container/command_encoder.inl
View File

@ -407,11 +407,11 @@ void EncodeSurfaceState<Family>::encodeBuffer(EncodeSurfaceStateArgs &args) {
auto bufferSize = alignUp(args.size, getSurfaceBaseAddressAlignment());
SURFACE_STATE_BUFFER_LENGTH length = {0};
length.Length = static_cast<uint32_t>(bufferSize - 1);
length.length = static_cast<uint32_t>(bufferSize - 1);
surfaceState->setWidth(length.SurfaceState.Width + 1);
surfaceState->setHeight(length.SurfaceState.Height + 1);
surfaceState->setDepth(length.SurfaceState.Depth + 1);
surfaceState->setWidth(length.surfaceState.width + 1);
surfaceState->setHeight(length.surfaceState.height + 1);
surfaceState->setDepth(length.surfaceState.depth + 1);
surfaceState->setSurfaceType((args.graphicsAddress != 0) ? R_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER
: R_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_NULL);
@ -752,7 +752,7 @@ size_t EncodeDispatchKernel<Family>::getSizeRequiredDsh(const KernelDescriptor &
template <typename Family>
size_t EncodeDispatchKernel<Family>::getSizeRequiredSsh(const KernelInfo &kernelInfo) {
size_t requiredSshSize = kernelInfo.heapInfo.SurfaceStateHeapSize;
size_t requiredSshSize = kernelInfo.heapInfo.surfaceStateHeapSize;
requiredSshSize = alignUp(requiredSshSize, EncodeDispatchKernel<Family>::getDefaultSshAlignment());
return requiredSshSize;
}

12
shared/source/command_container/command_encoder_bdw_and_later.inl
View File

@ -409,12 +409,12 @@ inline void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &co
template <typename Family>
void EncodeStateBaseAddress<Family>::setSbaAddressesForDebugger(NEO::Debugger::SbaAddresses &sbaAddress, const STATE_BASE_ADDRESS &sbaCmd) {
sbaAddress.IndirectObjectBaseAddress = sbaCmd.getIndirectObjectBaseAddress();
sbaAddress.BindlessSurfaceStateBaseAddress = sbaCmd.getBindlessSurfaceStateBaseAddress();
sbaAddress.DynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.GeneralStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.InstructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.SurfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
sbaAddress.indirectObjectBaseAddress = sbaCmd.getIndirectObjectBaseAddress();
sbaAddress.bindlessSurfaceStateBaseAddress = sbaCmd.getBindlessSurfaceStateBaseAddress();
sbaAddress.dynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.generalStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.instructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.surfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
}
template <typename Family>

12
shared/source/command_container/command_encoder_xehp_and_later.inl
View File

@ -512,12 +512,12 @@ inline bool EncodeDispatchKernel<Family>::isDshNeeded(const DeviceInfo &deviceIn
template <typename Family>
void EncodeStateBaseAddress<Family>::setSbaAddressesForDebugger(NEO::Debugger::SbaAddresses &sbaAddress, const STATE_BASE_ADDRESS &sbaCmd) {
sbaAddress.BindlessSurfaceStateBaseAddress = sbaCmd.getBindlessSurfaceStateBaseAddress();
sbaAddress.DynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.GeneralStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.InstructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.SurfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
sbaAddress.IndirectObjectBaseAddress = 0;
sbaAddress.bindlessSurfaceStateBaseAddress = sbaCmd.getBindlessSurfaceStateBaseAddress();
sbaAddress.dynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.generalStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.instructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.surfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
sbaAddress.indirectObjectBaseAddress = 0;
}
template <typename Family>

2
shared/source/command_stream/command_stream_receiver.cpp
View File

@ -532,7 +532,7 @@ void CommandStreamReceiver::overwriteFlatBatchBufferHelper(FlatBatchBufferHelper
void CommandStreamReceiver::initProgrammingFlags() {
isPreambleSent = false;
GSBAFor32BitProgrammed = false;
gsbaFor32BitProgrammed = false;
bindingTableBaseAddressRequired = true;
mediaVfeStateDirty = true;
lastVmeSubslicesConfig = false;

8
shared/source/command_stream/command_stream_receiver.h
View File

@ -162,8 +162,8 @@ class CommandStreamReceiver {
void setMediaVFEStateDirty(bool dirty) { mediaVfeStateDirty = dirty; }
bool getMediaVFEStateDirty() const { return mediaVfeStateDirty; }
void setGSBAStateDirty(bool dirty) { GSBAStateDirty = dirty; }
bool getGSBAStateDirty() const { return GSBAStateDirty; }
void setGSBAStateDirty(bool dirty) { gsbaStateDirty = dirty; }
bool getGSBAStateDirty() const { return gsbaStateDirty; }
void setStateComputeModeDirty(bool dirty) { stateComputeModeDirty = dirty; }
bool getStateComputeModeDirty() const { return stateComputeModeDirty; }
@ -512,8 +512,8 @@ class CommandStreamReceiver {
bool isStateSipSent = false;
bool isEnginePrologueSent = false;
bool isPerDssBackedBufferSent = false;
bool GSBAFor32BitProgrammed = false;
bool GSBAStateDirty = true;
bool gsbaFor32BitProgrammed = false;
bool gsbaStateDirty = true;
bool bindingTableBaseAddressRequired = false;
bool heapStorageRequiresRecyclingTag = false;
bool mediaVfeStateDirty = true;

6
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@ -446,7 +446,7 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
dispatchRayTracingStateCommand(commandStreamCSR, device);
}
stateBaseAddressDirty |= ((GSBAFor32BitProgrammed ^ dispatchFlags.gsba32BitRequired) && force32BitAllocations);
stateBaseAddressDirty |= ((gsbaFor32BitProgrammed ^ dispatchFlags.gsba32BitRequired) && force32BitAllocations);
programVFEState(commandStreamCSR, dispatchFlags, device.getDeviceInfo().maxFrontEndThreads);
@ -501,13 +501,13 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(commandStreamCSR, dispatchFlags.pipelineSelectArgs, true, rootDeviceEnvironment, isRcs());
uint64_t newGshBase = 0;
GSBAFor32BitProgrammed = false;
gsbaFor32BitProgrammed = false;
if (is64bit && scratchSpaceController->getScratchSpaceAllocation() && !force32BitAllocations) {
newGshBase = scratchSpaceController->calculateNewGSH();
} else if (is64bit && force32BitAllocations && dispatchFlags.gsba32BitRequired) {
bool useLocalMemory = scratchSpaceController->getScratchSpaceAllocation() ? scratchSpaceController->getScratchSpaceAllocation()->isAllocatedInLocalMemoryPool() : false;
newGshBase = getMemoryManager()->getExternalHeapBaseAddress(rootDeviceIndex, useLocalMemory);
GSBAFor32BitProgrammed = true;
gsbaFor32BitProgrammed = true;
}
auto stateBaseAddressCmdOffset = commandStreamCSR.getUsed();

4
shared/source/command_stream/submissions_aggregator.cpp
View File

@ -45,7 +45,7 @@ void NEO::SubmissionAggregator::aggregateCommandBuffers(ResourcePackage &resourc
return;
}
if (primaryCommandBuffer->next->batchBuffer.low_priority != primaryCommandBuffer->batchBuffer.low_priority) {
if (primaryCommandBuffer->next->batchBuffer.lowPriority != primaryCommandBuffer->batchBuffer.lowPriority) {
return;
}
@ -105,7 +105,7 @@ NEO::BatchBuffer::BatchBuffer(GraphicsAllocation *commandBufferAllocation, size_
bool hasRelaxedOrderingDependencies)
: commandBufferAllocation(commandBufferAllocation), startOffset(startOffset),
chainedBatchBufferStartOffset(chainedBatchBufferStartOffset), taskStartAddress(taskStartAddress), chainedBatchBuffer(chainedBatchBuffer),
requiresCoherency(requiresCoherency), low_priority(lowPriority),
requiresCoherency(requiresCoherency), lowPriority(lowPriority),
throttle(throttle), sliceCount(sliceCount),
usedSize(usedSize), stream(stream), endCmdPtr(endCmdPtr), numCsrClients(numCsrClients), hasStallingCmds(hasStallingCmds),
hasRelaxedOrderingDependencies(hasRelaxedOrderingDependencies) {}

2
shared/source/command_stream/submissions_aggregator.h
View File

@ -43,7 +43,7 @@ struct BatchBuffer {
GraphicsAllocation *chainedBatchBuffer = nullptr;
bool requiresCoherency = false;
bool low_priority = false;
bool lowPriority = false;
QueueThrottle throttle = QueueThrottle::MEDIUM;
uint64_t sliceCount = QueueSliceCount::defaultSliceCount;
size_t usedSize = 0u;

4
shared/source/compiler_interface/compiler_interface.cpp
View File

@ -146,7 +146,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
auto igcTranslationCtx = createIgcTranslationCtx(device, intermediateCodeType, IGC::CodeType::oclGenBin);
auto igcOutput = translate(igcTranslationCtx.get(), intermediateRepresentation.get(), idsBuffer.get(), valuesBuffer.get(),
fclOptions.get(), fclInternalOptions.get(), input.GTPinInput);
fclOptions.get(), fclInternalOptions.get(), input.gtPinInput);
if (igcOutput == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
@ -239,7 +239,7 @@ TranslationOutput::ErrorCode CompilerInterface::link(
auto igcTranslationCtx = createIgcTranslationCtx(device, inType, outType);
currOut = translate(igcTranslationCtx.get(), currSrc.get(),
igcOptions.get(), igcInternalOptions.get(), input.GTPinInput);
igcOptions.get(), igcInternalOptions.get(), input.gtPinInput);
if (currOut == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;

2
shared/source/compiler_interface/compiler_interface.h
View File

@ -40,7 +40,7 @@ struct TranslationInput {
IGC::CodeType::CodeType_t srcType = IGC::CodeType::invalid;
IGC::CodeType::CodeType_t preferredIntermediateType = IGC::CodeType::invalid;
IGC::CodeType::CodeType_t outType = IGC::CodeType::invalid;
void *GTPinInput = nullptr;
void *gtPinInput = nullptr;
specConstValuesMap specializedValues;
};

14
shared/source/debugger/debugger.h
View File

@ -19,13 +19,13 @@ class Debugger {
public:
struct SbaAddresses {
constexpr static size_t trackedAddressCount = 6;
uint64_t GeneralStateBaseAddress = 0;
uint64_t SurfaceStateBaseAddress = 0;
uint64_t DynamicStateBaseAddress = 0;
uint64_t IndirectObjectBaseAddress = 0;
uint64_t InstructionBaseAddress = 0;
uint64_t BindlessSurfaceStateBaseAddress = 0;
uint64_t BindlessSamplerStateBaseAddress = 0;
uint64_t generalStateBaseAddress = 0;
uint64_t surfaceStateBaseAddress = 0;
uint64_t dynamicStateBaseAddress = 0;
uint64_t indirectObjectBaseAddress = 0;
uint64_t instructionBaseAddress = 0;
uint64_t bindlessSurfaceStateBaseAddress = 0;
uint64_t bindlessSamplerStateBaseAddress = 0;
};
static std::unique_ptr<Debugger> create(const NEO::RootDeviceEnvironment &rootDeviceEnvironment);

42
shared/source/debugger/debugger_l0.inl
View File

@ -24,13 +24,13 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
const auto gmmHelper = device->getGmmHelper();
const auto gpuAddress = gmmHelper->decanonize(sbaTrackingGpuVa.address);
SbaAddresses sbaCanonized = sba;
sbaCanonized.GeneralStateBaseAddress = gmmHelper->canonize(sba.GeneralStateBaseAddress);
sbaCanonized.SurfaceStateBaseAddress = gmmHelper->canonize(sba.SurfaceStateBaseAddress);
sbaCanonized.DynamicStateBaseAddress = gmmHelper->canonize(sba.DynamicStateBaseAddress);
sbaCanonized.IndirectObjectBaseAddress = gmmHelper->canonize(sba.IndirectObjectBaseAddress);
sbaCanonized.InstructionBaseAddress = gmmHelper->canonize(sba.InstructionBaseAddress);
sbaCanonized.BindlessSurfaceStateBaseAddress = gmmHelper->canonize(sba.BindlessSurfaceStateBaseAddress);
sbaCanonized.BindlessSamplerStateBaseAddress = gmmHelper->canonize(sba.BindlessSamplerStateBaseAddress);
sbaCanonized.generalStateBaseAddress = gmmHelper->canonize(sba.generalStateBaseAddress);
sbaCanonized.surfaceStateBaseAddress = gmmHelper->canonize(sba.surfaceStateBaseAddress);
sbaCanonized.dynamicStateBaseAddress = gmmHelper->canonize(sba.dynamicStateBaseAddress);
sbaCanonized.indirectObjectBaseAddress = gmmHelper->canonize(sba.indirectObjectBaseAddress);
sbaCanonized.instructionBaseAddress = gmmHelper->canonize(sba.instructionBaseAddress);
sbaCanonized.bindlessSurfaceStateBaseAddress = gmmHelper->canonize(sba.bindlessSurfaceStateBaseAddress);
sbaCanonized.bindlessSamplerStateBaseAddress = gmmHelper->canonize(sba.bindlessSamplerStateBaseAddress);
PRINT_DEBUGGER_INFO_LOG("Debugger: SBA stored ssh = %" SCNx64
" gsba = %" SCNx64
@ -38,14 +38,14 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
" ioba = %" SCNx64
" iba = %" SCNx64
" bsurfsba = %" SCNx64 "\n",
sbaCanonized.SurfaceStateBaseAddress, sbaCanonized.GeneralStateBaseAddress, sbaCanonized.DynamicStateBaseAddress,
sbaCanonized.IndirectObjectBaseAddress, sbaCanonized.InstructionBaseAddress, sbaCanonized.BindlessSurfaceStateBaseAddress);
sbaCanonized.surfaceStateBaseAddress, sbaCanonized.generalStateBaseAddress, sbaCanonized.dynamicStateBaseAddress,
sbaCanonized.indirectObjectBaseAddress, sbaCanonized.instructionBaseAddress, sbaCanonized.bindlessSurfaceStateBaseAddress);
if (singleAddressSpaceSbaTracking) {
programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaCanonized, useFirstLevelBB);
} else {
if (sbaCanonized.GeneralStateBaseAddress) {
auto generalStateBaseAddress = sbaCanonized.GeneralStateBaseAddress;
if (sbaCanonized.generalStateBaseAddress) {
auto generalStateBaseAddress = sbaCanonized.generalStateBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, generalStateBaseAddress),
static_cast<uint32_t>(generalStateBaseAddress & 0x0000FFFFFFFFULL),
@ -53,8 +53,8 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
true,
false);
}
if (sbaCanonized.SurfaceStateBaseAddress) {
auto surfaceStateBaseAddress = sbaCanonized.SurfaceStateBaseAddress;
if (sbaCanonized.surfaceStateBaseAddress) {
auto surfaceStateBaseAddress = sbaCanonized.surfaceStateBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, surfaceStateBaseAddress),
static_cast<uint32_t>(surfaceStateBaseAddress & 0x0000FFFFFFFFULL),
@ -62,8 +62,8 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
true,
false);
}
if (sbaCanonized.DynamicStateBaseAddress) {
auto dynamicStateBaseAddress = sbaCanonized.DynamicStateBaseAddress;
if (sbaCanonized.dynamicStateBaseAddress) {
auto dynamicStateBaseAddress = sbaCanonized.dynamicStateBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, dynamicStateBaseAddress),
static_cast<uint32_t>(dynamicStateBaseAddress & 0x0000FFFFFFFFULL),
@ -71,8 +71,8 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
true,
false);
}
if (sbaCanonized.IndirectObjectBaseAddress) {
auto indirectObjectBaseAddress = sbaCanonized.IndirectObjectBaseAddress;
if (sbaCanonized.indirectObjectBaseAddress) {
auto indirectObjectBaseAddress = sbaCanonized.indirectObjectBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, indirectObjectBaseAddress),
static_cast<uint32_t>(indirectObjectBaseAddress & 0x0000FFFFFFFFULL),
@ -80,8 +80,8 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
true,
false);
}
if (sbaCanonized.InstructionBaseAddress) {
auto instructionBaseAddress = sbaCanonized.InstructionBaseAddress;
if (sbaCanonized.instructionBaseAddress) {
auto instructionBaseAddress = sbaCanonized.instructionBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, instructionBaseAddress),
static_cast<uint32_t>(instructionBaseAddress & 0x0000FFFFFFFFULL),
@ -89,8 +89,8 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
true,
false);
}
if (sbaCanonized.BindlessSurfaceStateBaseAddress) {
auto bindlessSurfaceStateBaseAddress = sbaCanonized.BindlessSurfaceStateBaseAddress;
if (sbaCanonized.bindlessSurfaceStateBaseAddress) {
auto bindlessSurfaceStateBaseAddress = sbaCanonized.bindlessSurfaceStateBaseAddress;
NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
gpuAddress + offsetof(SbaTrackedAddresses, bindlessSurfaceStateBaseAddress),
static_cast<uint32_t>(bindlessSurfaceStateBaseAddress & 0x0000FFFFFFFFULL),

24
shared/source/debugger/debugger_l0_tgllp_and_later.inl
View File

@ -37,23 +37,23 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
std::vector<std::pair<size_t, uint64_t>> fieldOffsetAndValue;
if (sba.GeneralStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, generalStateBaseAddress), sba.GeneralStateBaseAddress});
if (sba.generalStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, generalStateBaseAddress), sba.generalStateBaseAddress});
}
if (sba.SurfaceStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, surfaceStateBaseAddress), sba.SurfaceStateBaseAddress});
if (sba.surfaceStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, surfaceStateBaseAddress), sba.surfaceStateBaseAddress});
}
if (sba.DynamicStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, dynamicStateBaseAddress), sba.DynamicStateBaseAddress});
if (sba.dynamicStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, dynamicStateBaseAddress), sba.dynamicStateBaseAddress});
}
if (sba.IndirectObjectBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, indirectObjectBaseAddress), sba.IndirectObjectBaseAddress});
if (sba.indirectObjectBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, indirectObjectBaseAddress), sba.indirectObjectBaseAddress});
}
if (sba.InstructionBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, instructionBaseAddress), sba.InstructionBaseAddress});
if (sba.instructionBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, instructionBaseAddress), sba.instructionBaseAddress});
}
if (sba.BindlessSurfaceStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, bindlessSurfaceStateBaseAddress), sba.BindlessSurfaceStateBaseAddress});
if (sba.bindlessSurfaceStateBaseAddress) {
fieldOffsetAndValue.push_back({offsetof(SbaTrackedAddresses, bindlessSurfaceStateBaseAddress), sba.bindlessSurfaceStateBaseAddress});
}
const auto cmdStreamGpuBase = cmdStream.getGpuBase();
const auto cmdStreamCpuBase = reinterpret_cast<uint64_t>(cmdStream.getCpuBase());

8
shared/source/device_binary_format/zebin/zebin_decoder.cpp
View File

@ -404,16 +404,16 @@ DecodeError decodeZebin(ProgramInfo &dst, NEO::Elf::Elf<numBits> &elf, std::stri
}
kernelInfo->heapInfo.pKernelHeap = kernelInstructions.begin();
kernelInfo->heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelInstructions.size());
kernelInfo->heapInfo.KernelUnpaddedSize = static_cast<uint32_t>(kernelInstructions.size());
kernelInfo->heapInfo.kernelHeapSize = static_cast<uint32_t>(kernelInstructions.size());
kernelInfo->heapInfo.kernelUnpaddedSize = static_cast<uint32_t>(kernelInstructions.size());
auto &kernelSSH = kernelInfo->kernelDescriptor.generatedSsh;
kernelInfo->heapInfo.pSsh = kernelSSH.data();
kernelInfo->heapInfo.SurfaceStateHeapSize = static_cast<uint32_t>(kernelSSH.size());
kernelInfo->heapInfo.surfaceStateHeapSize = static_cast<uint32_t>(kernelSSH.size());
auto &kernelDSH = kernelInfo->kernelDescriptor.generatedDsh;
kernelInfo->heapInfo.pDsh = kernelDSH.data();
kernelInfo->heapInfo.DynamicStateHeapSize = static_cast<uint32_t>(kernelDSH.size());
kernelInfo->heapInfo.dynamicStateHeapSize = static_cast<uint32_t>(kernelDSH.size());
}
return DecodeError::Success;

16
shared/source/direct_submission/direct_submission_hw.h
View File

@ -19,16 +19,16 @@ struct RootDeviceEnvironment;
#pragma pack(1)
struct RingSemaphoreData {
uint32_t QueueWorkCount;
uint8_t ReservedCacheline0[60];
uint32_t queueWorkCount;
uint8_t reservedCacheline0[60];
uint32_t tagAllocation;
uint8_t ReservedCacheline1[60];
uint32_t DiagnosticModeCounter;
uint32_t Reserved0Uint32;
uint64_t Reserved1Uint64;
uint8_t ReservedCacheline2[48];
uint8_t reservedCacheline1[60];
uint32_t diagnosticModeCounter;
uint32_t reserved0Uint32;
uint64_t reserved1Uint64;
uint8_t reservedCacheline2[48];
uint64_t miFlushSpace;
uint8_t ReservedCacheline3[56];
uint8_t reservedCacheline3[56];
};
static_assert((64u * 4) == sizeof(RingSemaphoreData), "Invalid size for RingSemaphoreData");
#pragma pack()

6
shared/source/direct_submission/direct_submission_hw.inl
View File

@ -383,9 +383,9 @@ bool DirectSubmissionHw<GfxFamily, Dispatcher>::allocateResources() {
semaphoreGpuVa = semaphores->getGpuAddress();
semaphoreData = static_cast<volatile RingSemaphoreData *>(semaphorePtr);
memset(semaphorePtr, 0, sizeof(RingSemaphoreData));
semaphoreData->QueueWorkCount = 0;
semaphoreData->queueWorkCount = 0;
cpuCachelineFlush(semaphorePtr, MemoryConstants::cacheLineSize);
workloadModeOneStoreAddress = static_cast<volatile void *>(&semaphoreData->DiagnosticModeCounter);
workloadModeOneStoreAddress = static_cast<volatile void *>(&semaphoreData->diagnosticModeCounter);
*static_cast<volatile uint32_t *>(workloadModeOneStoreAddress) = 0u;
this->gpuVaForMiFlush = this->semaphoreGpuVa + offsetof(RingSemaphoreData, miFlushSpace);
@ -412,7 +412,7 @@ inline void DirectSubmissionHw<GfxFamily, Dispatcher>::unblockGpu() {
*this->pciBarrierPtr = 0u;
}
semaphoreData->QueueWorkCount = currentQueueWorkCount;
semaphoreData->queueWorkCount = currentQueueWorkCount;
if (sfenceMode == DirectSubmissionSfenceMode::BeforeAndAfterSemaphore) {
CpuIntrinsics::sfence();

10
shared/source/gen8/command_encoder_gen8.cpp
View File

@ -45,11 +45,11 @@ void EncodeComputeMode<Family>::programComputeModeCommand(LinearStream &csr, Sta
template <>
void EncodeStateBaseAddress<Family>::setSbaAddressesForDebugger(NEO::Debugger::SbaAddresses &sbaAddress, const STATE_BASE_ADDRESS &sbaCmd) {
sbaAddress.IndirectObjectBaseAddress = sbaCmd.getIndirectObjectBaseAddress();
sbaAddress.DynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.GeneralStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.InstructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.SurfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
sbaAddress.indirectObjectBaseAddress = sbaCmd.getIndirectObjectBaseAddress();
sbaAddress.dynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddress.generalStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddress.instructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddress.surfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
}
template struct EncodeDispatchKernel<Family>;

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

@ -457,12 +457,12 @@ struct MemorySynchronizationCommands {
};
union SURFACE_STATE_BUFFER_LENGTH {
uint32_t Length;
uint32_t length;
struct SurfaceState {
uint32_t Width : BITFIELD_RANGE(0, 6);
uint32_t Height : BITFIELD_RANGE(7, 20);
uint32_t Depth : BITFIELD_RANGE(21, 31);
} SurfaceState;
uint32_t width : BITFIELD_RANGE(0, 6);
uint32_t height : BITFIELD_RANGE(7, 20);
uint32_t depth : BITFIELD_RANGE(21, 31);
} surfaceState;
};
} // namespace NEO

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

@ -109,11 +109,11 @@ void GfxCoreHelperHw<Family>::setRenderSurfaceStateForScratchResource(const Root
auto surfaceSize = alignUp(bufferSize, 4);
SURFACE_STATE_BUFFER_LENGTH length = {0};
length.Length = static_cast<uint32_t>(surfaceSize - 1);
length.length = static_cast<uint32_t>(surfaceSize - 1);
state.setWidth(length.SurfaceState.Width + 1);
state.setHeight(length.SurfaceState.Height + 1);
state.setDepth(length.SurfaceState.Depth + 1);
state.setWidth(length.surfaceState.width + 1);
state.setHeight(length.surfaceState.height + 1);
state.setDepth(length.surfaceState.depth + 1);
if (pitch) {
state.setSurfacePitch(pitch);
}

2
shared/source/memory_manager/surface.cpp
View File

@ -51,7 +51,7 @@ void GeneralSurface::makeResident(CommandStreamReceiver &csr) {
void GeneralSurface::setGraphicsAllocation(GraphicsAllocation *newAllocation) {
gfxAllocation = newAllocation;
IsCoherent = newAllocation->isCoherent();
isCoherent = newAllocation->isCoherent();
}
} // namespace NEO

4
shared/source/memory_manager/surface.h
View File

@ -15,12 +15,12 @@ class CommandStreamReceiver;
class Surface {
public:
Surface(bool isCoherent = false) : IsCoherent(isCoherent) {}
Surface(bool isCoherent = false) : isCoherent(isCoherent) {}
virtual ~Surface() = default;
virtual void makeResident(CommandStreamReceiver &csr) = 0;
virtual Surface *duplicate() = 0;
virtual bool allowsL3Caching() { return true; }
bool IsCoherent;
bool isCoherent;
};
class NullSurface : public Surface {

42
shared/source/memory_manager/unified_memory_manager.cpp
View File

@ -128,7 +128,7 @@ void SVMAllocsManager::addInternalAllocationsToResidencyContainer(uint32_t rootD
ResidencyContainer &residencyContainer,
uint32_t requestedTypesMask) {
std::shared_lock<std::shared_mutex> lock(mtx);
for (auto &allocation : this->SVMAllocs.allocations) {
for (auto &allocation : this->svmAllocs.allocations) {
if (rootDeviceIndex >= allocation.second.gpuAllocations.getGraphicsAllocations().size()) {
continue;
}
@ -145,7 +145,7 @@ void SVMAllocsManager::addInternalAllocationsToResidencyContainer(uint32_t rootD
void SVMAllocsManager::makeInternalAllocationsResident(CommandStreamReceiver &commandStreamReceiver, uint32_t requestedTypesMask) {
std::shared_lock<std::shared_mutex> lock(mtx);
for (auto &allocation : this->SVMAllocs.allocations) {
for (auto &allocation : this->svmAllocs.allocations) {
if (allocation.second.memoryType & requestedTypesMask) {
auto gpuAllocation = allocation.second.gpuAllocations.getGraphicsAllocation(commandStreamReceiver.getRootDeviceIndex());
if (gpuAllocation == nullptr) {
@ -230,7 +230,7 @@ void *SVMAllocsManager::createHostUnifiedMemoryAllocation(size_t size,
allocData.setAllocId(this->allocationsCounter++);
std::unique_lock<std::shared_mutex> lock(mtx);
this->SVMAllocs.insert(allocData);
this->svmAllocs.insert(allocData);
return usmPtr;
}
@ -313,7 +313,7 @@ void *SVMAllocsManager::createUnifiedMemoryAllocation(size_t size,
allocData.setAllocId(this->allocationsCounter++);
std::unique_lock<std::shared_mutex> lock(mtx);
this->SVMAllocs.insert(allocData);
this->svmAllocs.insert(allocData);
auto retPtr = reinterpret_cast<void *>(unifiedMemoryAllocation->getGpuAddress());
UNRECOVERABLE_IF(useExternalHostPtrForCpu && (externalPtr != retPtr));
@ -400,7 +400,7 @@ void *SVMAllocsManager::createUnifiedKmdMigratedAllocation(size_t size, const Sv
allocData.setAllocId(this->allocationsCounter++);
std::unique_lock<std::shared_mutex> lock(mtx);
this->SVMAllocs.insert(allocData);
this->svmAllocs.insert(allocData);
return allocationGpu->getUnderlyingBuffer();
}
@ -411,26 +411,26 @@ void SVMAllocsManager::setUnifiedAllocationProperties(GraphicsAllocation *alloca
SvmAllocationData *SVMAllocsManager::getSVMAlloc(const void *ptr) {
std::shared_lock<std::shared_mutex> lock(mtx);
return SVMAllocs.get(ptr);
return svmAllocs.get(ptr);
}
SvmAllocationData *SVMAllocsManager::getSVMDeferFreeAlloc(const void *ptr) {
std::shared_lock<std::shared_mutex> lock(mtx);
return SVMDeferFreeAllocs.get(ptr);
return svmDeferFreeAllocs.get(ptr);
}
void SVMAllocsManager::insertSVMAlloc(const SvmAllocationData &svmAllocData) {
std::unique_lock<std::shared_mutex> lock(mtx);
SVMAllocs.insert(svmAllocData);
svmAllocs.insert(svmAllocData);
}
void SVMAllocsManager::removeSVMAlloc(const SvmAllocationData &svmAllocData) {
std::unique_lock<std::shared_mutex> lock(mtx);
SVMAllocs.remove(svmAllocData);
svmAllocs.remove(svmAllocData);
}
bool SVMAllocsManager::freeSVMAlloc(void *ptr, bool blocking) {
if (SVMDeferFreeAllocs.allocations.size() > 0) {
if (svmDeferFreeAllocs.allocations.size() > 0) {
this->freeSVMAllocDeferImpl();
}
@ -453,7 +453,7 @@ bool SVMAllocsManager::freeSVMAlloc(void *ptr, bool blocking) {
bool SVMAllocsManager::freeSVMAllocDefer(void *ptr) {
if (SVMDeferFreeAllocs.allocations.size() > 0) {
if (svmDeferFreeAllocs.allocations.size() > 0) {
this->freeSVMAllocDeferImpl();
}
@ -487,7 +487,7 @@ void SVMAllocsManager::freeSVMAllocImpl(void *ptr, FreePolicyType policy, SvmAll
if (svmData->cpuAllocation) {
if (this->memoryManager->allocInUse(*svmData->cpuAllocation)) {
if (getSVMDeferFreeAlloc(svmData) == nullptr) {
this->SVMDeferFreeAllocs.insert(*svmData);
this->svmDeferFreeAllocs.insert(*svmData);
}
return;
}
@ -496,7 +496,7 @@ void SVMAllocsManager::freeSVMAllocImpl(void *ptr, FreePolicyType policy, SvmAll
if (gpuAllocation) {
if (this->memoryManager->allocInUse(*gpuAllocation)) {
if (getSVMDeferFreeAlloc(svmData) == nullptr) {
this->SVMDeferFreeAllocs.insert(*svmData);
this->svmDeferFreeAllocs.insert(*svmData);
}
return;
}
@ -516,7 +516,7 @@ void SVMAllocsManager::freeSVMAllocImpl(void *ptr, FreePolicyType policy, SvmAll
void SVMAllocsManager::freeSVMAllocDeferImpl() {
std::vector<void *> freedPtr;
for (auto iter = SVMDeferFreeAllocs.allocations.begin(); iter != SVMDeferFreeAllocs.allocations.end(); ++iter) {
for (auto iter = svmDeferFreeAllocs.allocations.begin(); iter != svmDeferFreeAllocs.allocations.end(); ++iter) {
void *ptr = reinterpret_cast<void *>(iter->second.gpuAllocations.getDefaultGraphicsAllocation()->getGpuAddress());
this->freeSVMAllocImpl(ptr, FreePolicyType::POLICY_DEFER, this->getSVMAlloc(ptr));
@ -525,7 +525,7 @@ void SVMAllocsManager::freeSVMAllocDeferImpl() {
}
}
for (uint32_t i = 0; i < freedPtr.size(); ++i) {
SVMDeferFreeAllocs.allocations.erase(freedPtr[i]);
svmDeferFreeAllocs.allocations.erase(freedPtr[i]);
}
}
@ -564,7 +564,7 @@ void *SVMAllocsManager::createZeroCopySvmAllocation(size_t size, const SvmAlloca
allocData.size = size;
std::unique_lock<std::shared_mutex> lock(mtx);
this->SVMAllocs.insert(allocData);
this->svmAllocs.insert(allocData);
return usmPtr;
}
@ -633,14 +633,14 @@ void *SVMAllocsManager::createUnifiedAllocationWithDeviceStorage(size_t size, co
allocData.setAllocId(this->allocationsCounter++);
std::unique_lock<std::shared_mutex> lock(mtx);
this->SVMAllocs.insert(allocData);
this->svmAllocs.insert(allocData);
return svmPtr;
}
void SVMAllocsManager::freeSVMData(SvmAllocationData *svmData) {
std::unique_lock<std::mutex> lockForIndirect(mtxForIndirectAccess);
std::unique_lock<std::shared_mutex> lock(mtx);
SVMAllocs.remove(*svmData);
svmAllocs.remove(*svmData);
}
void SVMAllocsManager::freeZeroCopySvmAllocation(SvmAllocationData *svmData) {
@ -668,7 +668,7 @@ void SVMAllocsManager::freeSvmAllocationWithDeviceStorage(SvmAllocationData *svm
bool SVMAllocsManager::hasHostAllocations() {
std::shared_lock<std::shared_mutex> lock(mtx);
for (auto &allocation : this->SVMAllocs.allocations) {
for (auto &allocation : this->svmAllocs.allocations) {
if (allocation.second.memoryType == InternalMemoryType::HOST_UNIFIED_MEMORY) {
return true;
}
@ -698,7 +698,7 @@ void SVMAllocsManager::makeIndirectAllocationsResident(CommandStreamReceiver &co
entry->second.latestSentTaskCount = taskCount;
}
if (parseAllAllocations) {
for (auto &allocation : this->SVMAllocs.allocations) {
for (auto &allocation : this->svmAllocs.allocations) {
auto gpuAllocation = allocation.second.gpuAllocations.getGraphicsAllocation(commandStreamReceiver.getRootDeviceIndex());
if (gpuAllocation == nullptr) {
continue;
@ -804,7 +804,7 @@ void SVMAllocsManager::prefetchMemory(Device &device, CommandStreamReceiver &com
void SVMAllocsManager::prefetchSVMAllocs(Device &device, CommandStreamReceiver &commandStreamReceiver) {
std::shared_lock<std::shared_mutex> lock(mtx);
for (auto &allocation : this->SVMAllocs.allocations) {
for (auto &allocation : this->svmAllocs.allocations) {
NEO::SvmAllocationData allocData = allocation.second;
this->prefetchMemory(device, commandStreamReceiver, allocData);
}

10
shared/source/memory_manager/unified_memory_manager.h
View File

@ -179,9 +179,9 @@ class SVMAllocsManager {
void trimUSMDeviceAllocCache();
void insertSVMAlloc(const SvmAllocationData &svmData);
void removeSVMAlloc(const SvmAllocationData &svmData);
size_t getNumAllocs() const { return SVMAllocs.getNumAllocs(); }
MOCKABLE_VIRTUAL size_t getNumDeferFreeAllocs() const { return SVMDeferFreeAllocs.getNumAllocs(); }
MapBasedAllocationTracker *getSVMAllocs() { return &SVMAllocs; }
size_t getNumAllocs() const { return svmAllocs.getNumAllocs(); }
MOCKABLE_VIRTUAL size_t getNumDeferFreeAllocs() const { return svmDeferFreeAllocs.getNumAllocs(); }
MapBasedAllocationTracker *getSVMAllocs() { return &svmAllocs; }
MOCKABLE_VIRTUAL void insertSvmMapOperation(void *regionSvmPtr, size_t regionSize, void *baseSvmPtr, size_t offset, bool readOnlyMap);
void removeSvmMapOperation(const void *regionSvmPtr);
@ -216,9 +216,9 @@ class SVMAllocsManager {
void initUsmDeviceAllocationsCache();
void freeSVMData(SvmAllocationData *svmData);
MapBasedAllocationTracker SVMAllocs;
MapBasedAllocationTracker svmAllocs;
MapOperationsTracker svmMapOperations;
MapBasedAllocationTracker SVMDeferFreeAllocs;
MapBasedAllocationTracker svmDeferFreeAllocs;
MemoryManager *memoryManager;
std::shared_mutex mtx;
std::mutex mtxForIndirectAccess;

172
shared/source/os_interface/windows/sharedata_wrapper.h
View File

@ -48,123 +48,123 @@ static constexpr COMMAND_BUFFER_HEADER initCommandBufferHeader(uint32_t umdConte
#else
struct SKU_FEATURE_TABLE_KMD : SKU_FEATURE_TABLE_GMM { // NOLINT(readability-identifier-naming)
bool FtrGpGpuMidBatchPreempt : 1;
bool FtrGpGpuThreadGroupLevelPreempt : 1;
bool FtrGpGpuMidThreadLevelPreempt : 1;
bool FtrGpGpuMidBatchPreempt : 1; // NOLINT(readability-identifier-naming)
bool FtrGpGpuThreadGroupLevelPreempt : 1; // NOLINT(readability-identifier-naming)
bool FtrGpGpuMidThreadLevelPreempt : 1; // NOLINT(readability-identifier-naming)
bool FtrWddm2Svm : 1;
bool FtrPooledEuEnabled : 1;
bool FtrWddm2Svm : 1; // NOLINT(readability-identifier-naming)
bool FtrPooledEuEnabled : 1; // NOLINT(readability-identifier-naming)
bool FtrPPGTT : 1;
bool FtrSVM : 1;
bool FtrEDram : 1;
bool FtrL3IACoherency : 1;
bool FtrIA32eGfxPTEs : 1;
bool FtrPPGTT : 1; // NOLINT(readability-identifier-naming)
bool FtrSVM : 1; // NOLINT(readability-identifier-naming)
bool FtrEDram : 1; // NOLINT(readability-identifier-naming)
bool FtrL3IACoherency : 1; // NOLINT(readability-identifier-naming)
bool FtrIA32eGfxPTEs : 1; // NOLINT(readability-identifier-naming)
bool FtrTileY : 1;
bool FtrDisplayYTiling : 1;
bool FtrTranslationTable : 1;
bool FtrUserModeTranslationTable : 1;
bool FtrTileY : 1; // NOLINT(readability-identifier-naming)
bool FtrDisplayYTiling : 1; // NOLINT(readability-identifier-naming)
bool FtrTranslationTable : 1; // NOLINT(readability-identifier-naming)
bool FtrUserModeTranslationTable : 1; // NOLINT(readability-identifier-naming)
bool FtrFbc : 1;
bool FtrFbc : 1; // NOLINT(readability-identifier-naming)
bool FtrULT : 1;
bool FtrLCIA : 1;
bool FtrTileMappedResource : 1;
bool FtrAstcHdr2D : 1;
bool FtrAstcLdr2D : 1;
bool FtrULT : 1; // NOLINT(readability-identifier-naming)
bool FtrLCIA : 1; // NOLINT(readability-identifier-naming)
bool FtrTileMappedResource : 1; // NOLINT(readability-identifier-naming)
bool FtrAstcHdr2D : 1; // NOLINT(readability-identifier-naming)
bool FtrAstcLdr2D : 1; // NOLINT(readability-identifier-naming)
bool FtrStandardMipTailFormat : 1;
bool FtrFrameBufferLLC : 1;
bool FtrLLCBypass : 1;
bool FtrDisplayEngineS3d : 1;
bool FtrWddm2GpuMmu : 1;
bool FtrWddm2_1_64kbPages : 1;
bool FtrWddmHwQueues : 1;
bool FtrMemTypeMocsDeferPAT : 1;
bool FtrStandardMipTailFormat : 1; // NOLINT(readability-identifier-naming)
bool FtrFrameBufferLLC : 1; // NOLINT(readability-identifier-naming)
bool FtrLLCBypass : 1; // NOLINT(readability-identifier-naming)
bool FtrDisplayEngineS3d : 1; // NOLINT(readability-identifier-naming)
bool FtrWddm2GpuMmu : 1; // NOLINT(readability-identifier-naming)
bool FtrWddm2_1_64kbPages : 1; // NOLINT(readability-identifier-naming)
bool FtrWddmHwQueues : 1; // NOLINT(readability-identifier-naming)
bool FtrMemTypeMocsDeferPAT : 1; // NOLINT(readability-identifier-naming)
bool FtrKmdDaf : 1;
bool FtrKmdDaf : 1; // NOLINT(readability-identifier-naming)
bool FtrE2ECompression : 1;
bool FtrLinearCCS : 1;
bool FtrCCSRing : 1;
bool FtrCCSNode : 1;
bool FtrRcsNode : 1;
bool FtrLocalMemory : 1;
bool FtrLocalMemoryAllows4KB : 1;
bool FtrE2ECompression : 1; // NOLINT(readability-identifier-naming)
bool FtrLinearCCS : 1; // NOLINT(readability-identifier-naming)
bool FtrCCSRing : 1; // NOLINT(readability-identifier-naming)
bool FtrCCSNode : 1; // NOLINT(readability-identifier-naming)
bool FtrRcsNode : 1; // NOLINT(readability-identifier-naming)
bool FtrLocalMemory : 1; // NOLINT(readability-identifier-naming)
bool FtrLocalMemoryAllows4KB : 1; // NOLINT(readability-identifier-naming)
};
struct WA_TABLE_KMD : WA_TABLE_GMM { // NOLINT(readability-identifier-naming)
bool WaSendMIFLUSHBeforeVFE = false;
bool WaDisableLSQCROPERFforOCL = false;
bool WaMsaa8xTileYDepthPitchAlignment = false;
bool WaLosslessCompressionSurfaceStride = false;
bool WaFbcLinearSurfaceStride = false;
bool Wa4kAlignUVOffsetNV12LinearSurface = false;
bool WaEncryptedEdramOnlyPartials = false;
bool WaDisableEdramForDisplayRT = false;
bool WaCompressedResourceRequiresConstVA21 = false;
bool WaDisablePerCtxtPreemptionGranularityControl = false;
bool WaLLCCachingUnsupported = false;
bool WaUseVAlign16OnTileXYBpp816 = false;
bool WaModifyVFEStateAfterGPGPUPreemption = false;
bool WaCSRUncachable = false;
bool WaSamplerCacheFlushBetweenRedescribedSurfaceReads = false;
bool WaRestrictPitch128KB = false;
bool WaLimit128BMediaCompr = false;
bool WaUntypedBufferCompression = false;
bool WaAuxTable16KGranular = false;
bool WaDisableFusedThreadScheduling = false;
bool WaSendMIFLUSHBeforeVFE = false; // NOLINT(readability-identifier-naming)
bool WaDisableLSQCROPERFforOCL = false; // NOLINT(readability-identifier-naming)
bool WaMsaa8xTileYDepthPitchAlignment = false; // NOLINT(readability-identifier-naming)
bool WaLosslessCompressionSurfaceStride = false; // NOLINT(readability-identifier-naming)
bool WaFbcLinearSurfaceStride = false; // NOLINT(readability-identifier-naming)
bool Wa4kAlignUVOffsetNV12LinearSurface = false; // NOLINT(readability-identifier-naming)
bool WaEncryptedEdramOnlyPartials = false; // NOLINT(readability-identifier-naming)
bool WaDisableEdramForDisplayRT = false; // NOLINT(readability-identifier-naming)
bool WaCompressedResourceRequiresConstVA21 = false; // NOLINT(readability-identifier-naming)
bool WaDisablePerCtxtPreemptionGranularityControl = false; // NOLINT(readability-identifier-naming)
bool WaLLCCachingUnsupported = false; // NOLINT(readability-identifier-naming)
bool WaUseVAlign16OnTileXYBpp816 = false; // NOLINT(readability-identifier-naming)
bool WaModifyVFEStateAfterGPGPUPreemption = false; // NOLINT(readability-identifier-naming)
bool WaCSRUncachable = false; // NOLINT(readability-identifier-naming)
bool WaSamplerCacheFlushBetweenRedescribedSurfaceReads = false; // NOLINT(readability-identifier-naming)
bool WaRestrictPitch128KB = false; // NOLINT(readability-identifier-naming)
bool WaLimit128BMediaCompr = false; // NOLINT(readability-identifier-naming)
bool WaUntypedBufferCompression = false; // NOLINT(readability-identifier-naming)
bool WaAuxTable16KGranular = false; // NOLINT(readability-identifier-naming)
bool WaDisableFusedThreadScheduling = false; // NOLINT(readability-identifier-naming)
};
typedef struct COMMAND_BUFFER_HEADER_REC { // NOLINT(readability-identifier-naming)
uint32_t UmdContextType : 4;
uint32_t UmdPatchList : 1;
uint32_t UmdContextType : 4; // NOLINT(readability-identifier-naming)
uint32_t UmdPatchList : 1; // NOLINT(readability-identifier-naming)
uint32_t UmdRequestedSliceState : 3;
uint32_t UmdRequestedSubsliceCount : 3;
uint32_t UmdRequestedEUCount : 5;
uint32_t UmdRequestedSliceState : 3; // NOLINT(readability-identifier-naming)
uint32_t UmdRequestedSubsliceCount : 3; // NOLINT(readability-identifier-naming)
uint32_t UmdRequestedEUCount : 5; // NOLINT(readability-identifier-naming)
uint32_t UsesResourceStreamer : 1;
uint32_t NeedsMidBatchPreEmptionSupport : 1;
uint32_t UsesGPGPUPipeline : 1;
uint32_t RequiresCoherency : 1;
uint32_t UsesResourceStreamer : 1; // NOLINT(readability-identifier-naming)
uint32_t NeedsMidBatchPreEmptionSupport : 1; // NOLINT(readability-identifier-naming)
uint32_t UsesGPGPUPipeline : 1; // NOLINT(readability-identifier-naming)
uint32_t RequiresCoherency : 1; // NOLINT(readability-identifier-naming)
uint32_t PerfTag;
uint64_t MonitorFenceVA;
uint64_t MonitorFenceValue;
uint32_t PerfTag; // NOLINT(readability-identifier-naming)
uint64_t MonitorFenceVA; // NOLINT(readability-identifier-naming)
uint64_t MonitorFenceValue; // NOLINT(readability-identifier-naming)
} COMMAND_BUFFER_HEADER;
typedef struct __GMM_GFX_PARTITIONING {
struct
{
uint64_t Base, Limit;
} Standard,
Standard64KB,
Reserved0,
Reserved1,
SVM,
TR,
Heap32[4];
uint64_t Base, Limit; // NOLINT(readability-identifier-naming)
} Standard, // NOLINT(readability-identifier-naming)
Standard64KB, // NOLINT(readability-identifier-naming)
Reserved0, // NOLINT(readability-identifier-naming)
Reserved1, // NOLINT(readability-identifier-naming)
SVM, // NOLINT(readability-identifier-naming)
TR, // NOLINT(readability-identifier-naming)
Heap32[4]; // NOLINT(readability-identifier-naming)
} GMM_GFX_PARTITIONING;
struct CREATECONTEXT_PVTDATA { // NOLINT(readability-identifier-naming)
unsigned long *pHwContextId;
uint32_t NumberOfHwContextIds;
uint32_t NumberOfHwContextIds; // NOLINT(readability-identifier-naming)
uint32_t ProcessID;
uint8_t IsProtectedProcess;
uint8_t IsDwm;
uint8_t IsMediaUsage;
uint8_t GpuVAContext;
BOOLEAN NoRingFlushes;
uint32_t ProcessID; // NOLINT(readability-identifier-naming)
uint8_t IsProtectedProcess; // NOLINT(readability-identifier-naming)
uint8_t IsDwm; // NOLINT(readability-identifier-naming)
uint8_t IsMediaUsage; // NOLINT(readability-identifier-naming)
uint8_t GpuVAContext; // NOLINT(readability-identifier-naming)
BOOLEAN NoRingFlushes; // NOLINT(readability-identifier-naming)
};
struct ADAPTER_INFO_KMD : ADAPTER_INFO_GMM { // NOLINT(readability-identifier-naming)
SKU_FEATURE_TABLE_KMD SkuTable;
WA_TABLE_KMD WaTable;
GMM_GFX_PARTITIONING GfxPartition;
SKU_FEATURE_TABLE_KMD SkuTable; // NOLINT(readability-identifier-naming)
WA_TABLE_KMD WaTable; // NOLINT(readability-identifier-naming)
GMM_GFX_PARTITIONING GfxPartition; // NOLINT(readability-identifier-naming)
ADAPTER_BDF stAdapterBDF;
};

12
shared/source/program/heap_info.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -17,11 +17,11 @@ struct HeapInfo {
const void *pDsh = nullptr;
const void *pSsh = nullptr;
uint32_t KernelHeapSize = 0U;
uint32_t GeneralStateHeapSize = 0U;
uint32_t DynamicStateHeapSize = 0U;
uint32_t SurfaceStateHeapSize = 0U;
uint32_t KernelUnpaddedSize = 0U;
uint32_t kernelHeapSize = 0U;
uint32_t generalStateHeapSize = 0U;
uint32_t dynamicStateHeapSize = 0U;
uint32_t surfaceStateHeapSize = 0U;
uint32_t kernelUnpaddedSize = 0U;
};
} // namespace NEO

2
shared/source/program/kernel_info.cpp
View File

@ -56,7 +56,7 @@ int32_t KernelInfo::getArgNumByName(const char *name) const {
bool KernelInfo::createKernelAllocation(const Device &device, bool internalIsa) {
UNRECOVERABLE_IF(kernelAllocation);
auto kernelIsaSize = heapInfo.KernelHeapSize;
auto kernelIsaSize = heapInfo.kernelHeapSize;
const auto allocType = internalIsa ? AllocationType::KERNEL_ISA_INTERNAL : AllocationType::KERNEL_ISA;
if (device.getMemoryManager()->isKernelBinaryReuseEnabled()) {

12
shared/source/program/kernel_info_from_patchtokens.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -20,11 +20,11 @@ using namespace iOpenCL;
void populateKernelInfo(KernelInfo &dst, const PatchTokenBinary::KernelFromPatchtokens &src, uint32_t gpuPointerSizeInBytes) {
UNRECOVERABLE_IF(nullptr == src.header);
dst.heapInfo.DynamicStateHeapSize = src.header->DynamicStateHeapSize;
dst.heapInfo.GeneralStateHeapSize = src.header->GeneralStateHeapSize;
dst.heapInfo.SurfaceStateHeapSize = src.header->SurfaceStateHeapSize;
dst.heapInfo.KernelHeapSize = src.header->KernelHeapSize;
dst.heapInfo.KernelUnpaddedSize = src.header->KernelUnpaddedSize;
dst.heapInfo.dynamicStateHeapSize = src.header->DynamicStateHeapSize;
dst.heapInfo.generalStateHeapSize = src.header->GeneralStateHeapSize;
dst.heapInfo.surfaceStateHeapSize = src.header->SurfaceStateHeapSize;
dst.heapInfo.kernelHeapSize = src.header->KernelHeapSize;
dst.heapInfo.kernelUnpaddedSize = src.header->KernelUnpaddedSize;
dst.shaderHashCode = src.header->ShaderHashCode;
dst.heapInfo.pKernelHeap = src.isa.begin();

4
shared/source/sku_info/sku_info_base.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -48,7 +48,7 @@ struct FeatureTableBase {
uint32_t ftrLLCBypass : 1;
uint32_t ftrDisplayEngineS3d : 1;
uint32_t ftrWddm2GpuMmu : 1;
uint32_t ftrWddm2_1_64kbPages : 1;
uint32_t ftrWddm2_1_64kbPages : 1; // NOLINT(readability-identifier-naming)
uint32_t ftrWddmHwQueues : 1;
uint32_t ftrMemTypeMocsDeferPAT : 1;
uint32_t ftrKmdDaf : 1;

2
shared/test/common/libult/ult_command_stream_receiver.h
View File

@ -92,7 +92,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
using BaseClass::CommandStreamReceiver::flushStamp;
using BaseClass::CommandStreamReceiver::globalFenceAllocation;
using BaseClass::CommandStreamReceiver::gpuHangCheckPeriod;
using BaseClass::CommandStreamReceiver::GSBAFor32BitProgrammed;
using BaseClass::CommandStreamReceiver::gsbaFor32BitProgrammed;
using BaseClass::CommandStreamReceiver::initDirectSubmission;
using BaseClass::CommandStreamReceiver::internalAllocationStorage;
using BaseClass::CommandStreamReceiver::isBlitterDirectSubmissionEnabled;

2
shared/test/common/mocks/mock_csr.h
View File

@ -62,7 +62,7 @@ class MockCsrBase : public UltCommandStreamReceiver<GfxFamily> {
}
bool getGSBAFor32BitProgrammed() {
return this->GSBAFor32BitProgrammed;
return this->gsbaFor32BitProgrammed;
}
void processEviction() override {

Some files were not shown because too many files have changed in this diff Show More