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

refactor: remove not needed code related to device enqueue

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-07-11 08:54:44 +00:00
committed by Compute-Runtime-Automation
parent d77ba50455
commit 500ae54fc1
11 changed files with 6 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -110,9 +110,6 @@ inline void assignArg(KernelFromPatchtokens &kernel, const SPatchItemHeader *src
case PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT:
argNum = getArgNum<SPatchStatelessConstantMemoryObjectKernelArgument>(src);
break;
case PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT:
argNum = getArgNum<SPatchStatelessDeviceQueueKernelArgument>(src);
break;
}
getKernelArg(kernel, argNum, type).objectArg = src;
@@ -356,9 +353,6 @@ inline bool decodeToken(const SPatchItemHeader *token, KernelFromPatchtokens &ou
break;
case PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE:
break;
case PATCH_TOKEN_ALLOCATE_STATELESS_DEFAULT_DEVICE_QUEUE_SURFACE:
assignToken(out.tokens.allocateStatelessDefaultDeviceQueueSurface, token);
break;
case PATCH_TOKEN_STRING:
assignToken(out.tokens.strings, token);
break;
@@ -395,7 +389,6 @@ inline bool decodeToken(const SPatchItemHeader *token, KernelFromPatchtokens &ou
case PATCH_TOKEN_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT:
case PATCH_TOKEN_STATELESS_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT:
case PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT:
case PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT:
assignArg(out, token);
break;

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -122,7 +122,6 @@ struct KernelFromPatchtokens {
const SPatchAllocateStatelessConstantMemorySurfaceWithInitialization *allocateStatelessConstantMemorySurfaceWithInitialization = nullptr;
const SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization *allocateStatelessGlobalMemorySurfaceWithInitialization = nullptr;
const SPatchAllocateStatelessPrintfSurface *allocateStatelessPrintfSurface = nullptr;
const SPatchAllocateStatelessDefaultDeviceQueueSurface *allocateStatelessDefaultDeviceQueueSurface = nullptr;
const SPatchAllocateSyncBuffer *allocateSyncBuffer = nullptr;
const SPatchAllocateRTGlobalBuffer *allocateRTGlobalBuffer = nullptr;
const SPatchItemHeader *inlineVmeSamplerInfo = nullptr;

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -569,34 +569,6 @@ void dump(const SPatchMediaVFEState &value, std::stringstream &out, const std::s
out << indent << "}\n";
}
void dump(const SPatchAllocateStatelessDefaultDeviceQueueSurface &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchAllocateStatelessDefaultDeviceQueueSurface :\n";
out << indent << " SPatchItemHeader (";
dumpPatchItemHeaderInline(value, out, "");
out << ")\n"
<< indent << "{\n";
out << indent << " uint32_t SurfaceStateHeapOffset;// = " << value.SurfaceStateHeapOffset << "\n";
out << indent << " uint32_t DataParamOffset;// = " << value.DataParamOffset << "\n";
out << indent << " uint32_t DataParamSize;// = " << value.DataParamSize << "\n";
out << indent << "}\n";
}
void dump(const SPatchStatelessDeviceQueueKernelArgument &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchStatelessDeviceQueueKernelArgument :\n";
out << indent << " SPatchItemHeader (";
dumpPatchItemHeaderInline(value, out, "");
out << ")\n"
<< indent << "{\n";
out << indent << " uint32_t ArgumentNumber;// = " << value.ArgumentNumber << "\n";
out << indent << " uint32_t SurfaceStateHeapOffset;// = " << value.SurfaceStateHeapOffset << "\n";
out << indent << " uint32_t DataParamOffset;// = " << value.DataParamOffset << "\n";
out << indent << " uint32_t DataParamSize;// = " << value.DataParamSize << "\n";
out << indent << " uint32_t LocationIndex;// = " << value.LocationIndex << "\n";
out << indent << " uint32_t LocationIndex2;// = " << value.LocationIndex2 << "\n";
out << indent << " uint32_t IsEmulationArgument;// = " << value.IsEmulationArgument << "\n";
out << indent << "}\n";
}
void dump(const SPatchGtpinFreeGRFInfo &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchGtpinFreeGRFInfo :\n";
out << indent << " SPatchItemHeader (";
@@ -650,9 +622,6 @@ void dumpOrNullObjArg(const T *value, std::stringstream &out, const std::string
case PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT:
dumpOrNull(reinterpret_cast<const SPatchStatelessConstantMemoryObjectKernelArgument *>(value), "", out, indent);
break;
case PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT:
dumpOrNull(reinterpret_cast<const SPatchStatelessDeviceQueueKernelArgument *>(value), "", out, indent);
break;
}
}
@@ -727,7 +696,6 @@ std::string asString(const KernelFromPatchtokens &kern) {
dumpOrNull(kern.tokens.allocateStatelessConstantMemorySurfaceWithInitialization, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessGlobalMemorySurfaceWithInitialization, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessPrintfSurface, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessDefaultDeviceQueueSurface, "", stream, indentLevel1);
dumpOrNull(kern.tokens.inlineVmeSamplerInfo, "", stream, indentLevel1);
dumpOrNull(kern.tokens.gtpinFreeGrfInfo, "", stream, indentLevel1);
dumpOrNull(kern.tokens.stateSip, "", stream, indentLevel1);

1
shared/source/kernel/kernel_arg_descriptor.h
View File

@@ -146,7 +146,6 @@ struct ArgDescriptor final {
}
union {
struct {
bool isDeviceQueue : 1;
bool isMediaImage : 1;
bool isMediaBlockImage : 1;
bool isTransformable : 1;

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

@@ -196,10 +196,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateStatele
populatePointerKernelArg(dst, dst.payloadMappings.implicitArgs.printfSurfaceAddress, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateStatelessDefaultDeviceQueueSurface &token) {
populatePointerKernelArg(dst, dst.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateSystemThreadSurface &token) {
dst.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful = token.Offset;
dst.kernelAttributes.perThreadSystemThreadSurfaceSize = token.PerThreadSystemThreadSurfaceSize;
@@ -317,17 +313,6 @@ void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPa
populatePointerKernelArg(dst, argPointer, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPatchStatelessDeviceQueueKernelArgument &token) {
markArgAsPatchable(dst, argNum);
auto &argPointer = dst.payloadMappings.explicitArgs[argNum].as<ArgDescPointer>(true);
dst.payloadMappings.explicitArgs[argNum].getTraits().addressQualifier = KernelArgMetadata::AddrGlobal;
dst.payloadMappings.explicitArgs[argNum].getExtendedTypeInfo().isDeviceQueue = true;
populatePointerKernelArg(dst, argPointer, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelArgDescriptor(KernelDescriptor &dst, size_t argNum, const SPatchDataParameterBuffer &token) {
markArgAsPatchable(dst, argNum);
@@ -396,9 +381,6 @@ void populateArgDescriptor(KernelDescriptor &dst, size_t argNum, const PatchToke
case PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT:
populateKernelArgDescriptor(dst, argNum, *reinterpret_cast<const SPatchStatelessConstantMemoryObjectKernelArgument *>(src.objectArg));
break;
case PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT:
populateKernelArgDescriptor(dst, argNum, *reinterpret_cast<const SPatchStatelessDeviceQueueKernelArgument *>(src.objectArg));
break;
}
}
@@ -485,7 +467,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const PatchTokenBinary::Ker
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateStatelessConstantMemorySurfaceWithInitialization);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateStatelessGlobalMemorySurfaceWithInitialization);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateStatelessPrintfSurface);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateStatelessDefaultDeviceQueueSurface);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateSyncBuffer);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateRTGlobalBuffer);

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

@@ -22,11 +22,6 @@ void MockKernelInfo::addArgBuffer(uint32_t index, CrossThreadDataOffset stateles
populatePointerKernelArg(kernelDescriptor, argAt(index).as<ArgDescPointer>(true), stateless, pointerSize, bindful, bindless, kernelDescriptor.kernelAttributes.bufferAddressingMode);
}
void MockKernelInfo::addArgDevQueue(uint32_t index, CrossThreadDataOffset stateless, uint8_t pointerSize, SurfaceStateHeapOffset bindful) {
addArgBuffer(index, stateless, pointerSize, bindful);
argAt(index).getExtendedTypeInfo().isDeviceQueue = true;
}
void MockKernelInfo::addArgImage(uint32_t index, SurfaceStateHeapOffset offset, uint32_t type, bool isTransformable) {
resizeArgsIfIndexTooBig(index);

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

@@ -20,7 +20,6 @@ namespace NEO {
class MockKernelInfo : public KernelInfo {
public:
void addArgBuffer(uint32_t index, CrossThreadDataOffset stateless = undefined<CrossThreadDataOffset>, uint8_t pointerSize = 0, SurfaceStateHeapOffset bindful = undefined<SurfaceStateHeapOffset>, CrossThreadDataOffset bindless = undefined<CrossThreadDataOffset>);
void addArgDevQueue(uint32_t index, CrossThreadDataOffset stateless = undefined<CrossThreadDataOffset>, uint8_t pointerSize = 0, SurfaceStateHeapOffset bindful = undefined<SurfaceStateHeapOffset>);
void addArgImage(uint32_t index, SurfaceStateHeapOffset offset = undefined<CrossThreadDataOffset>, uint32_t type = iOpenCL::IMAGE_MEMORY_OBJECT_2D, bool isTransformable = false);
void addArgImmediate(uint32_t index, uint16_t size = 0, CrossThreadDataOffset offset = undefined<CrossThreadDataOffset>, uint16_t sourceOffset = 0, bool isDataParameterKernelArgument = false);
void addArgLocal(uint32_t index, CrossThreadDataOffset slmOffset, uint8_t requiredSlmAlignment);

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

@@ -35,7 +35,6 @@ bool hasEmptyTokensInfo(const NEO::PatchTokenBinary::KernelFromPatchtokens &kern
empty &= nullptr == toks.allocateStatelessConstantMemorySurfaceWithInitialization;
empty &= nullptr == toks.allocateStatelessGlobalMemorySurfaceWithInitialization;
empty &= nullptr == toks.allocateStatelessPrintfSurface;
empty &= nullptr == toks.allocateStatelessDefaultDeviceQueueSurface;
empty &= nullptr == toks.inlineVmeSamplerInfo;
empty &= nullptr == toks.gtpinFreeGrfInfo;
empty &= nullptr == toks.stateSip;
@@ -327,7 +326,6 @@ TEST(KernelDecoder, GivenKernelWithValidKernelPatchtokensThenDecodingSucceedsAnd
auto allocateStatelessConstantMemorySurfaceWithInitializationOff = pushBackToken<SPatchAllocateStatelessConstantMemorySurfaceWithInitialization>(PATCH_TOKEN_ALLOCATE_STATELESS_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION, storage);
auto allocateStatelessGlobalMemorySurfaceWithInitializationOff = pushBackToken<SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization>(PATCH_TOKEN_ALLOCATE_STATELESS_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION, storage);
auto allocateStatelessPrintfSurfaceOff = pushBackToken<SPatchAllocateStatelessPrintfSurface>(PATCH_TOKEN_ALLOCATE_STATELESS_PRINTF_SURFACE, storage);
auto allocateStatelessDefaultDeviceQueueSurfaceOff = pushBackToken<SPatchAllocateStatelessDefaultDeviceQueueSurface>(PATCH_TOKEN_ALLOCATE_STATELESS_DEFAULT_DEVICE_QUEUE_SURFACE, storage);
auto inlineVmeSamplerInfoOff = pushBackToken<SPatchInlineVMESamplerInfo>(PATCH_TOKEN_INLINE_VME_SAMPLER_INFO, storage);
auto gtpinFreeGrfInfoOff = pushBackToken<SPatchGtpinFreeGRFInfo>(PATCH_TOKEN_GTPIN_FREE_GRF_INFO, storage);
auto gtpinInfoOff = pushBackToken<SPatchItemHeader>(PATCH_TOKEN_GTPIN_INFO, storage);
@@ -362,7 +360,6 @@ TEST(KernelDecoder, GivenKernelWithValidKernelPatchtokensThenDecodingSucceedsAnd
EXPECT_TRUE(tokenOffsetMatched(base, allocateStatelessConstantMemorySurfaceWithInitializationOff, decodedKernel.tokens.allocateStatelessConstantMemorySurfaceWithInitialization));
EXPECT_TRUE(tokenOffsetMatched(base, allocateStatelessGlobalMemorySurfaceWithInitializationOff, decodedKernel.tokens.allocateStatelessGlobalMemorySurfaceWithInitialization));
EXPECT_TRUE(tokenOffsetMatched(base, allocateStatelessPrintfSurfaceOff, decodedKernel.tokens.allocateStatelessPrintfSurface));
EXPECT_TRUE(tokenOffsetMatched(base, allocateStatelessDefaultDeviceQueueSurfaceOff, decodedKernel.tokens.allocateStatelessDefaultDeviceQueueSurface));
EXPECT_TRUE(tokenOffsetMatched(base, inlineVmeSamplerInfoOff, decodedKernel.tokens.inlineVmeSamplerInfo));
EXPECT_TRUE(tokenOffsetMatched(base, gtpinFreeGrfInfoOff, decodedKernel.tokens.gtpinFreeGrfInfo));
EXPECT_TRUE(tokenOffsetMatched(base, gtpinInfoOff, decodedKernel.tokens.gtpinInfo));
@@ -479,17 +476,11 @@ TEST(KernelDecoder, GivenKernelWithValidObjectArgPatchtokensThenDecodingSucceeds
statelessConstantMemTok.Size = sizeof(statelessConstantMemTok);
statelessConstantMemTok.ArgumentNumber = 5;
iOpenCL::SPatchStatelessDeviceQueueKernelArgument statelessDeviceQueueTok = {};
statelessDeviceQueueTok.Token = iOpenCL::PATCH_TOKEN::PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT;
statelessDeviceQueueTok.Size = sizeof(iOpenCL::SPatchGlobalMemoryObjectKernelArgument);
statelessDeviceQueueTok.ArgumentNumber = 4;
auto samplerOff = pushBackToken(samplerTok, storage);
auto imageOff = pushBackToken(imageTok, storage);
auto globalMemOff = pushBackToken(globalMemTok, storage);
auto statelessGlobalMemOff = pushBackToken(statelessGlobalMemTok, storage);
auto statelessConstantMemOff = pushBackToken(statelessConstantMemTok, storage);
auto statelessDeviceQueueOff = pushBackToken(statelessDeviceQueueTok, storage);
ASSERT_EQ(storage.data(), kernelToEncode.blobs.kernelInfo.begin());
auto kernelHeader = reinterpret_cast<iOpenCL::SKernelBinaryHeaderCommon *>(storage.data());
@@ -523,10 +514,6 @@ TEST(KernelDecoder, GivenKernelWithValidObjectArgPatchtokensThenDecodingSucceeds
EXPECT_EQ(NEO::PatchTokenBinary::ArgObjectType::buffer, decodedKernel.tokens.kernelArgs[statelessConstantMemTok.ArgumentNumber].objectType);
EXPECT_EQ(NEO::PatchTokenBinary::ArgObjectTypeSpecialized::none, decodedKernel.tokens.kernelArgs[statelessConstantMemTok.ArgumentNumber].objectTypeSpecialized);
EXPECT_TRUE(tokenOffsetMatched(base, statelessDeviceQueueOff, decodedKernel.tokens.kernelArgs[statelessDeviceQueueTok.ArgumentNumber].objectArg));
EXPECT_EQ(NEO::PatchTokenBinary::ArgObjectType::buffer, decodedKernel.tokens.kernelArgs[statelessDeviceQueueTok.ArgumentNumber].objectType);
EXPECT_EQ(NEO::PatchTokenBinary::ArgObjectTypeSpecialized::none, decodedKernel.tokens.kernelArgs[statelessDeviceQueueTok.ArgumentNumber].objectTypeSpecialized);
for (int i = 0; i < 6; ++i) {
EXPECT_EQ(nullptr, decodedKernel.tokens.kernelArgs[i].argInfo);
EXPECT_EQ(0U, decodedKernel.tokens.kernelArgs[i].byValMap.size());

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -534,7 +534,6 @@ TEST(KernelDumper, givenKernelWithNonCrossthreadDataPatchtokensThenProperlyCreat
auto allocateStatelessConstantMemorySurfaceWithInitialization = initToken<SPatchAllocateStatelessConstantMemorySurfaceWithInitialization>(PATCH_TOKEN_ALLOCATE_CONSTANT_MEMORY_SURFACE_WITH_INITIALIZATION);
auto allocateStatelessGlobalMemorySurfaceWithInitialization = initToken<SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization>(PATCH_TOKEN_ALLOCATE_GLOBAL_MEMORY_SURFACE_WITH_INITIALIZATION);
auto allocateStatelessPrintfSurface = initToken<SPatchAllocateStatelessPrintfSurface>(PATCH_TOKEN_ALLOCATE_PRINTF_SURFACE);
auto allocateStatelessDefaultDeviceQueueSurface = initToken<SPatchAllocateStatelessDefaultDeviceQueueSurface>(PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT);
auto inlineVmeSamplerInfo = initToken<SPatchItemHeader>(PATCH_TOKEN_INLINE_VME_SAMPLER_INFO);
auto gtpinFreeGrfInfo = initToken<SPatchGtpinFreeGRFInfo>(PATCH_TOKEN_GTPIN_FREE_GRF_INFO);
auto stateSip = initToken<SPatchStateSIP>(PATCH_TOKEN_STATE_SIP);
@@ -559,7 +558,6 @@ TEST(KernelDumper, givenKernelWithNonCrossthreadDataPatchtokensThenProperlyCreat
kernel.tokens.allocateStatelessConstantMemorySurfaceWithInitialization = &allocateStatelessConstantMemorySurfaceWithInitialization;
kernel.tokens.allocateStatelessGlobalMemorySurfaceWithInitialization = &allocateStatelessGlobalMemorySurfaceWithInitialization;
kernel.tokens.allocateStatelessPrintfSurface = &allocateStatelessPrintfSurface;
kernel.tokens.allocateStatelessDefaultDeviceQueueSurface = &allocateStatelessDefaultDeviceQueueSurface;
kernel.tokens.inlineVmeSamplerInfo = &inlineVmeSamplerInfo;
kernel.tokens.gtpinFreeGrfInfo = &gtpinFreeGrfInfo;
kernel.tokens.stateSip = &stateSip;
@@ -734,14 +732,6 @@ Kernel-scope tokens section size : )==="
uint32_t DataParamOffset;// = 0
uint32_t DataParamSize;// = 0
}
struct SPatchAllocateStatelessDefaultDeviceQueueSurface :
SPatchItemHeader (Token=46(PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT), Size=)==="
<< sizeof(SPatchAllocateStatelessDefaultDeviceQueueSurface) << R"===()
{
uint32_t SurfaceStateHeapOffset;// = 0
uint32_t DataParamOffset;// = 0
uint32_t DataParamSize;// = 0
}
struct SPatchItemHeader {
uint32_t Token;// = 50(PATCH_TOKEN_INLINE_VME_SAMPLER_INFO)
uint32_t Size;// = )==="
@@ -1550,31 +1540,6 @@ TEST(KernelArgDumper, givenStatelessConstantMemoryObjectKernelArgThenProperlyCre
EXPECT_STREQ(expected.str().c_str(), generated.c_str());
}
TEST(KernelArgDumper, givenStatelessDeviceQueueObjectKernelArgThenProperlyCreatesDump) {
NEO::PatchTokenBinary::KernelArgFromPatchtokens kernelArg = {};
auto objectArg = PatchTokensTestData::initToken<iOpenCL::SPatchStatelessDeviceQueueKernelArgument>(iOpenCL::PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT);
kernelArg.objectArg = &objectArg;
kernelArg.objectType = NEO::PatchTokenBinary::ArgObjectType::buffer;
auto generated = NEO::PatchTokenBinary::asString(kernelArg, " | ");
std::stringstream expected;
expected << R"===( | Kernel argument of type BUFFER
| struct SPatchStatelessDeviceQueueKernelArgument :
| SPatchItemHeader (Token=46(PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT), Size=)==="
<< sizeof(objectArg) << R"===()
| {
| uint32_t ArgumentNumber;// = 0
| uint32_t SurfaceStateHeapOffset;// = 0
| uint32_t DataParamOffset;// = 0
| uint32_t DataParamSize;// = 0
| uint32_t LocationIndex;// = 0
| uint32_t LocationIndex2;// = 0
| uint32_t IsEmulationArgument;// = 0
| }
| Buffer Metadata:
)===";
EXPECT_STREQ(expected.str().c_str(), generated.c_str());
}
TEST(KernelArgDumper, givenBufferKernelArgWithMetadataTokensThenProperlyCreatesDump) {
NEO::PatchTokenBinary::KernelArgFromPatchtokens kernelArg = {};
kernelArg.objectType = NEO::PatchTokenBinary::ArgObjectType::buffer;

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

@@ -329,20 +329,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenImplicitArgsThenSetsProperPartsOfDesc
kernelDescriptor.kernelAttributes.numArgsStateful = 0;
kernelTokens.tokens.allocateStatelessPrintfSurface = nullptr;
iOpenCL::SPatchAllocateStatelessDefaultDeviceQueueSurface defaultDeviceQueueSurface = {};
defaultDeviceQueueSurface.DataParamOffset = 2;
defaultDeviceQueueSurface.DataParamSize = 3;
defaultDeviceQueueSurface.SurfaceStateHeapOffset = 7;
kernelTokens.tokens.allocateStatelessDefaultDeviceQueueSurface = &defaultDeviceQueueSurface;
NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
EXPECT_EQ(defaultDeviceQueueSurface.DataParamOffset, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.stateless);
EXPECT_EQ(defaultDeviceQueueSurface.DataParamSize, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.pointerSize);
EXPECT_EQ(defaultDeviceQueueSurface.SurfaceStateHeapOffset, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindless));
EXPECT_EQ(1u, kernelDescriptor.kernelAttributes.numArgsStateful);
kernelDescriptor.kernelAttributes.numArgsStateful = 0;
kernelTokens.tokens.allocateStatelessDefaultDeviceQueueSurface = nullptr;
EXPECT_EQ(0U, kernelDescriptor.kernelAttributes.perThreadSystemThreadSurfaceSize);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.stateless));
EXPECT_EQ(0U, kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.pointerSize);
@@ -374,9 +360,7 @@ TEST(KernelDescriptorFromPatchtokens, GivenImplicitArgsThenSetsProperPartsOfDesc
kernelTokens.tokens.allocateSyncBuffer = &syncBuffer;
NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.usesSyncBuffer);
EXPECT_EQ(defaultDeviceQueueSurface.DataParamOffset, kernelDescriptor.payloadMappings.implicitArgs.syncBufferAddress.stateless);
EXPECT_EQ(defaultDeviceQueueSurface.DataParamSize, kernelDescriptor.payloadMappings.implicitArgs.syncBufferAddress.pointerSize);
EXPECT_EQ(defaultDeviceQueueSurface.SurfaceStateHeapOffset, kernelDescriptor.payloadMappings.implicitArgs.syncBufferAddress.bindful);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.syncBufferAddress.bindless));
EXPECT_EQ(1u, kernelDescriptor.kernelAttributes.numArgsStateful);
kernelDescriptor.kernelAttributes.numArgsStateful = 0;
@@ -767,35 +751,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenKernelWithStatelessConstantMemoryObje
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().needsPatch);
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithStatelessDeviceQueueKernelArgumentThenKernelDescriptorIsProperlyPopulated) {
std::vector<uint8_t> storage;
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens = PatchTokensTestData::ValidEmptyKernel::create(storage);
iOpenCL::SPatchStatelessDeviceQueueKernelArgument deviceQueueArg = {};
deviceQueueArg.Token = iOpenCL::PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT;
deviceQueueArg.ArgumentNumber = 1;
deviceQueueArg.DataParamOffset = 2;
deviceQueueArg.DataParamSize = 4;
deviceQueueArg.SurfaceStateHeapOffset = 128;
kernelTokens.tokens.kernelArgs.resize(2);
kernelTokens.tokens.kernelArgs[1].objectArg = &deviceQueueArg;
NEO::KernelDescriptor dst = {};
NEO::populateKernelDescriptor(dst, kernelTokens, sizeof(void *));
EXPECT_EQ(1U, dst.kernelAttributes.numArgsToPatch);
ASSERT_EQ(2U, dst.payloadMappings.explicitArgs.size());
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].is<NEO::ArgDescriptor::argTPointer>());
EXPECT_EQ(deviceQueueArg.DataParamOffset, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescPointer>().stateless);
EXPECT_EQ(deviceQueueArg.DataParamSize, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescPointer>().pointerSize);
EXPECT_EQ(deviceQueueArg.SurfaceStateHeapOffset, dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescPointer>().bindful);
EXPECT_TRUE(NEO::isUndefinedOffset(dst.payloadMappings.explicitArgs[1].as<NEO::ArgDescPointer>().bindless));
EXPECT_EQ(NEO::KernelArgMetadata::AddrGlobal, dst.payloadMappings.explicitArgs[1].getTraits().addressQualifier);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().needsPatch);
EXPECT_FALSE(dst.payloadMappings.explicitArgs[0].getExtendedTypeInfo().isDeviceQueue);
EXPECT_TRUE(dst.payloadMappings.explicitArgs[1].getExtendedTypeInfo().isDeviceQueue);
}
TEST(KernelDescriptorFromPatchtokens, GivenKernelWithByValueArgumentsThenKernelDescriptorIsProperlyPopulated) {
std::vector<uint8_t> storage;
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens = PatchTokensTestData::ValidEmptyKernel::create(storage);