intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove device side enqueue info from kernel descriptor

Browse Source 
Related-To: NEO-6559
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
This commit is contained in:
Katarzyna Cencelewska
2022-02-21 15:33:05 +00:00
committed by Compute-Runtime-Automation
parent e984760423
commit 4994eb18c2
11 changed files with 6 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
shared/source/device_binary_format/patchtokens_decoder.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -331,9 +331,6 @@ inline bool decodeToken(const SPatchItemHeader *token, KernelFromPatchtokens &ou
case PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD:
assignToken(out.tokens.mediaInterfaceDescriptorLoad, token);
break;
case PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA:
assignToken(out.tokens.interfaceDescriptorData, token);
break;
case PATCH_TOKEN_THREAD_PAYLOAD:
assignToken(out.tokens.threadPayload, token);
break;

3
shared/source/device_binary_format/patchtokens_decoder.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -120,7 +120,6 @@ struct KernelFromPatchtokens {
const SPatchAllocateLocalSurface *allocateLocalSurface = nullptr;
const SPatchMediaVFEState *mediaVfeState[2] = {nullptr, nullptr};
const SPatchMediaInterfaceDescriptorLoad *mediaInterfaceDescriptorLoad = nullptr;
const SPatchInterfaceDescriptorData *interfaceDescriptorData = nullptr;
const SPatchThreadPayload *threadPayload = nullptr;
const SPatchExecutionEnvironment *executionEnvironment = nullptr;
const SPatchDataParameterStream *dataParameterStream = nullptr;

14
shared/source/device_binary_format/patchtokens_dumper.cpp
View File

@@ -285,19 +285,6 @@ void dump(const SPatchMediaInterfaceDescriptorLoad &value, std::stringstream &ou
out << indent << "}\n";
}
void dump(const SPatchInterfaceDescriptorData &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchInterfaceDescriptorData :\n";
out << indent << " SPatchItemHeader (";
dumpPatchItemHeaderInline(value, out, "");
out << ")\n"
<< indent << "{\n";
out << indent << " uint32_t Offset;// = " << value.Offset << "\n";
out << indent << " uint32_t SamplerStateOffset;// = " << value.SamplerStateOffset << "\n";
out << indent << " uint32_t KernelOffset;// = " << value.KernelOffset << "\n";
out << indent << " uint32_t BindingTableOffset;// = " << value.BindingTableOffset << "\n";
out << indent << "}\n";
}
void dump(const SPatchDataParameterStream &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchDataParameterStream :\n";
out << indent << " SPatchItemHeader (";
@@ -746,7 +733,6 @@ std::string asString(const KernelFromPatchtokens &kern) {
dumpOrNull(kern.tokens.allocateLocalSurface, "", stream, indentLevel1);
dumpOrNullArrayIfNotEmpty(kern.tokens.mediaVfeState, "mediaVfeState", stream, indentLevel1);
dumpOrNull(kern.tokens.mediaInterfaceDescriptorLoad, "", stream, indentLevel1);
dumpOrNull(kern.tokens.interfaceDescriptorData, "", stream, indentLevel1);
dumpOrNull(kern.tokens.kernelAttributesInfo, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessPrivateSurface, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessConstantMemorySurfaceWithInitialization, "", stream, indentLevel1);

2
shared/source/kernel/kernel_descriptor.h
View File

@@ -277,8 +277,6 @@ struct KernelDescriptor {
std::string kernelName;
std::string kernelLanguageAttributes;
StringMap printfStringsMap;
std::vector<std::pair<uint32_t, uint32_t>> deviceSideEnqueueChildrenKernelsIdOffset;
uint32_t deviceSideEnqueueBlockInterfaceDescriptorOffset = 0U;
struct ByValueArgument {
ArgDescValue::Element byValueElement;

8
shared/source/kernel/kernel_descriptor_from_patchtokens.cpp
View File

@@ -87,10 +87,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const SPatchMediaVFEState &
dst.kernelAttributes.perThreadScratchSize[slot] = token.PerThreadScratchSpace;
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchInterfaceDescriptorData &token) {
dst.kernelMetadata.deviceSideEnqueueBlockInterfaceDescriptorOffset = token.Offset;
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchThreadPayload &token) {
dst.kernelAttributes.flags.perThreadDataHeaderIsPresent = (0U != token.HeaderPresent);
dst.kernelAttributes.numLocalIdChannels = token.LocalIDXPresent + token.LocalIDYPresent + token.LocalIDZPresent;
@@ -470,7 +466,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const PatchTokenBinary::Ker
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateLocalSurface);
populateKernelDescriptorIfNotNull(dst, src.tokens.mediaVfeState[0], 0);
populateKernelDescriptorIfNotNull(dst, src.tokens.mediaVfeState[1], 1);
populateKernelDescriptorIfNotNull(dst, src.tokens.interfaceDescriptorData);
populateKernelDescriptorIfNotNull(dst, src.tokens.threadPayload);
populateKernelDescriptorIfNotNull(dst, src.tokens.dataParameterStream);
populateKernelDescriptorIfNotNull(dst, src.tokens.kernelAttributesInfo);
@@ -515,9 +510,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const PatchTokenBinary::Ker
dst.payloadMappings.implicitArgs.privateMemorySize = getOffset(src.tokens.crossThreadPayloadArgs.privateMemoryStatelessSize);
dst.payloadMappings.implicitArgs.localMemoryStatelessWindowSize = getOffset(src.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowSize);
dst.payloadMappings.implicitArgs.localMemoryStatelessWindowStartAddres = getOffset(src.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowStartAddress);
for (auto &childSimdSize : src.tokens.crossThreadPayloadArgs.childBlockSimdSize) {
dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset.push_back({childSimdSize->ArgumentNumber, childSimdSize->Offset});
}
if (src.tokens.gtpinInfo) {
dst.external.igcInfoForGtpin = (src.tokens.gtpinInfo + 1);

6
shared/test/common/mocks/mock_kernel_info.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -193,10 +193,6 @@ void MockKernelInfo::setSamplerTable(DynamicStateHeapOffset borderColor, uint8_t
samplerTable.tableOffset = tableOffset;
}
void MockKernelInfo::setDeviceSideEnqueueBlockInterfaceDescriptorOffset(uint32_t offset) {
kernelDescriptor.kernelMetadata.deviceSideEnqueueBlockInterfaceDescriptorOffset = offset;
}
void MockKernelInfo::setPerThreadScratchSize(uint32_t perThreadScratchSize, uint32_t slot) {
kernelDescriptor.kernelAttributes.perThreadScratchSize[slot] = perThreadScratchSize;
}

3
shared/test/common/mocks/mock_kernel_info.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -64,7 +64,6 @@ class MockKernelInfo : public KernelInfo {
void setSyncBuffer(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setPrivateMemory(uint32_t perThreadPrivateMemorySize, bool isSimtThread, uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setSamplerTable(DynamicStateHeapOffset borderColor, uint8_t numSamplers, DynamicStateHeapOffset tableOffset);
void setDeviceSideEnqueueBlockInterfaceDescriptorOffset(uint32_t offset);
void setPerThreadScratchSize(uint32_t perThreadScratchSize, uint32_t slot);
void setLocalIds(const std::array<uint8_t, 3> &localIds);

5
shared/test/unit_test/device_binary_format/patchtokens_decoder_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -26,7 +26,6 @@ bool hasEmptyTokensInfo(const NEO::PatchTokenBinary::KernelFromPatchtokens &kern
empty &= nullptr == toks.mediaVfeState[0];
empty &= nullptr == toks.mediaVfeState[1];
empty &= nullptr == toks.mediaInterfaceDescriptorLoad;
empty &= nullptr == toks.interfaceDescriptorData;
empty &= nullptr == toks.threadPayload;
empty &= nullptr == toks.executionEnvironment;
empty &= nullptr == toks.dataParameterStream;
@@ -322,7 +321,6 @@ TEST(KernelDecoder, GivenKernelWithValidKernelPatchtokensThenDecodingSucceedsAnd
auto mediaVfeState0Off = pushBackToken<SPatchMediaVFEState>(PATCH_TOKEN_MEDIA_VFE_STATE, storage);
auto mediaVfeState1Off = pushBackToken<SPatchMediaVFEState>(PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1, storage);
auto mediaInterfaceDescriptorLoadOff = pushBackToken<SPatchMediaInterfaceDescriptorLoad>(PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD, storage);
auto interfaceDescriptorDataOff = pushBackToken<SPatchInterfaceDescriptorData>(PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA, storage);
auto threadPayloadOff = pushBackToken<SPatchThreadPayload>(PATCH_TOKEN_THREAD_PAYLOAD, storage);
auto executionEnvironmentOff = pushBackToken<SPatchExecutionEnvironment>(PATCH_TOKEN_EXECUTION_ENVIRONMENT, storage);
auto kernelAttributesInfoOff = pushBackToken<SPatchKernelAttributesInfo>(PATCH_TOKEN_KERNEL_ATTRIBUTES_INFO, storage);
@@ -359,7 +357,6 @@ TEST(KernelDecoder, GivenKernelWithValidKernelPatchtokensThenDecodingSucceedsAnd
EXPECT_TRUE(tokenOffsetMatched(base, mediaVfeState0Off, decodedKernel.tokens.mediaVfeState[0]));
EXPECT_TRUE(tokenOffsetMatched(base, mediaVfeState1Off, decodedKernel.tokens.mediaVfeState[1]));
EXPECT_TRUE(tokenOffsetMatched(base, mediaInterfaceDescriptorLoadOff, decodedKernel.tokens.mediaInterfaceDescriptorLoad));
EXPECT_TRUE(tokenOffsetMatched(base, interfaceDescriptorDataOff, decodedKernel.tokens.interfaceDescriptorData));
EXPECT_TRUE(tokenOffsetMatched(base, threadPayloadOff, decodedKernel.tokens.threadPayload));
EXPECT_TRUE(tokenOffsetMatched(base, executionEnvironmentOff, decodedKernel.tokens.executionEnvironment));
EXPECT_TRUE(tokenOffsetMatched(base, kernelAttributesInfoOff, decodedKernel.tokens.kernelAttributesInfo));

11
shared/test/unit_test/device_binary_format/patchtokens_dumper_tests.cpp
View File

@@ -509,7 +509,6 @@ TEST(KernelDumper, GivenKernelWithNonCrossthreadDataPatchtokensThenProperlyCreat
auto allocateLocalSurface = initToken<SPatchAllocateLocalSurface>(PATCH_TOKEN_ALLOCATE_LOCAL_SURFACE);
SPatchMediaVFEState mediaVfeState[2] = {initToken<SPatchMediaVFEState>(PATCH_TOKEN_MEDIA_VFE_STATE), initToken<SPatchMediaVFEState>(PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1)};
auto mediaInterfaceDescriptorLoad = initToken<SPatchMediaInterfaceDescriptorLoad>(PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD);
auto interfaceDescriptorData = initToken<SPatchInterfaceDescriptorData>(PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA);
auto threadPayload = initToken<SPatchThreadPayload>(PATCH_TOKEN_THREAD_PAYLOAD);
auto executionEnvironment = initToken<SPatchExecutionEnvironment>(PATCH_TOKEN_EXECUTION_ENVIRONMENT);
auto dataParameterStream = initToken<SPatchDataParameterStream>(PATCH_TOKEN_DATA_PARAMETER_STREAM);
@@ -536,7 +535,6 @@ TEST(KernelDumper, GivenKernelWithNonCrossthreadDataPatchtokensThenProperlyCreat
kernel.tokens.mediaVfeState[0] = &mediaVfeState[0];
kernel.tokens.mediaVfeState[1] = &mediaVfeState[1];
kernel.tokens.mediaInterfaceDescriptorLoad = &mediaInterfaceDescriptorLoad;
kernel.tokens.interfaceDescriptorData = &interfaceDescriptorData;
kernel.tokens.threadPayload = &threadPayload;
kernel.tokens.executionEnvironment = &executionEnvironment;
kernel.tokens.dataParameterStream = &dataParameterStream;
@@ -677,15 +675,6 @@ Kernel-scope tokens section size : )==="
{
uint32_t InterfaceDescriptorDataOffset;// = 0
}
struct SPatchInterfaceDescriptorData :
SPatchItemHeader (Token=21(PATCH_TOKEN_INTERFACE_DESCRIPTOR_DATA), Size=)==="
<< sizeof(SPatchInterfaceDescriptorData) << R"===()
{
uint32_t Offset;// = 0
uint32_t SamplerStateOffset;// = 0
uint32_t KernelOffset;// = 0
uint32_t BindingTableOffset;// = 0
}
struct SPatchKernelAttributesInfo :
SPatchItemHeader (Token=27(PATCH_TOKEN_KERNEL_ATTRIBUTES_INFO), Size=)==="
<< sizeof(SPatchKernelAttributesInfo) << R"===()

30
shared/test/unit_test/kernel/kernel_descriptor_from_patchtokens_tests.cpp
View File

@@ -244,14 +244,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenImplicitArgsThenSetsProperPartsOfDesc
kernelTokens.tokens.mediaVfeState[0] = nullptr;
kernelTokens.tokens.mediaVfeState[1] = nullptr;
EXPECT_EQ(0U, kernelDescriptor.kernelMetadata.deviceSideEnqueueBlockInterfaceDescriptorOffset);
iOpenCL::SPatchInterfaceDescriptorData interfaceDescriptorData = {};
interfaceDescriptorData.Offset = 4096;
kernelTokens.tokens.interfaceDescriptorData = &interfaceDescriptorData;
NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
EXPECT_EQ(interfaceDescriptorData.Offset, kernelDescriptor.kernelMetadata.deviceSideEnqueueBlockInterfaceDescriptorOffset);
kernelTokens.tokens.interfaceDescriptorData = nullptr;
EXPECT_EQ(0U, kernelDescriptor.kernelAttributes.crossThreadDataSize);
iOpenCL::SPatchDataParameterStream dataParameterStream = {};
dataParameterStream.DataParameterStreamSize = 4096;
@@ -1289,28 +1281,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithDitpatchMetadataImplicitArg
}
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithChildBlocksMetadataImplicitArgsThenKernelDescriptorIsProperlyPopulated) {
std::vector<uint8_t> storage;
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens = PatchTokensTestData::ValidEmptyKernel::create(storage);
NEO::KernelDescriptor dst;
NEO::populateKernelDescriptor(dst, kernelTokens, 4);
EXPECT_TRUE(dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset.empty());
iOpenCL::SPatchDataParameterBuffer childBlocks[2] = {};
childBlocks[0].ArgumentNumber = 0;
childBlocks[1].ArgumentNumber = 1;
childBlocks[0].Offset = 4096;
childBlocks[1].Offset = 8192;
kernelTokens.tokens.crossThreadPayloadArgs.childBlockSimdSize.push_back(&childBlocks[0]);
kernelTokens.tokens.crossThreadPayloadArgs.childBlockSimdSize.push_back(&childBlocks[1]);
NEO::populateKernelDescriptor(dst, kernelTokens, 4);
ASSERT_EQ(2U, dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset.size());
EXPECT_EQ(childBlocks[0].ArgumentNumber, dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset[0].first);
EXPECT_EQ(childBlocks[1].ArgumentNumber, dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset[1].first);
EXPECT_EQ(childBlocks[0].Offset, dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset[0].second);
EXPECT_EQ(childBlocks[1].Offset, dst.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset[1].second);
}
TEST(KernelDescriptorFromPatchtokens, GivenDispatchTraitsImplicitArgsAndExplicitArgsWhenPopulatingKernelDescriptorThenCrossThreadDataSizeIsSetToMaxOffsetAndAligned) {
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens;
iOpenCL::SKernelBinaryHeaderCommon kernelHeader;

4
shared/test/unit_test/kernel/kernel_descriptor_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -82,8 +82,6 @@ TEST(KernelDescriptor, WhenDefaultInitializedThenValuesAreCleared) {
EXPECT_TRUE(desc.kernelMetadata.kernelName.empty());
EXPECT_TRUE(desc.kernelMetadata.kernelLanguageAttributes.empty());
EXPECT_TRUE(desc.kernelMetadata.printfStringsMap.empty());
EXPECT_TRUE(desc.kernelMetadata.deviceSideEnqueueChildrenKernelsIdOffset.empty());
EXPECT_EQ(0U, desc.kernelMetadata.deviceSideEnqueueBlockInterfaceDescriptorOffset);
EXPECT_TRUE(desc.kernelMetadata.allByValueKernelArguments.empty());
EXPECT_EQ(0U, desc.kernelMetadata.compiledSubGroupsNumber);
EXPECT_EQ(0U, desc.kernelMetadata.requiredSubGroupSize);