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

refactor: remove not needed code. 

Signed-off-by: Michal Mrozek <michal.mrozek@intel.com>
This commit is contained in:
Michal Mrozek 2024-09-19 12:55:46 +00:00 committed by Compute-Runtime-Automation
parent 18a7a5f6fa
commit 363aca782f
14 changed files with 6 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -284,12 +284,6 @@ cl_int Kernel::initialize() {
patchWithImplicitSurface(globalMemory, *program->getGlobalSurface(rootDeviceIndex), arg);
}
if (isValidOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful)) {
auto surfaceState = ptrOffset(reinterpret_cast<uintptr_t *>(getSurfaceStateHeap()),
kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful);
Buffer::setSurfaceState(&pClDevice->getDevice(), surfaceState, false, false, 0, nullptr, 0, nullptr, 0, 0, areMultipleSubDevicesInContext());
}
if (isValidOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful)) {
auto surfaceState = ptrOffset(reinterpret_cast<uintptr_t *>(getSurfaceStateHeap()),
kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful);

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

@ -674,7 +674,6 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, HardwareCommandsTest, WhenGettingBindingTableStat
pKernelInfo->setGlobalVariablesSurface(8, 0, 0);
pKernelInfo->setGlobalConstantsSurface(8, 8, 64);
pKernelInfo->setPrivateMemory(32, false, 8, 16, 128);
pKernelInfo->setDeviceSideEnqueueEventPoolSurface(8, 24, 192);
pKernelInfo->setDeviceSideEnqueueDefaultQueueSurface(8, 32, 256);
// create program with valid context

22
opencl/test/unit_test/program/kernel_data_OCL2_0.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,26 +11,6 @@
#include "patch_g7.h"
TEST_F(KernelDataTest, givenPatchTokenAllocateStatelessEventPoolSurfaceWhenDecodeTokensThenTokenLocatedInPatchInfo) {
iOpenCL::SPatchAllocateStatelessEventPoolSurface allocateStatelessEventPoolSurface;
allocateStatelessEventPoolSurface.Token = PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE;
allocateStatelessEventPoolSurface.Size = sizeof(SPatchAllocateStatelessEventPoolSurface);
allocateStatelessEventPoolSurface.DataParamSize = 7;
allocateStatelessEventPoolSurface.DataParamOffset = 0xABC;
allocateStatelessEventPoolSurface.SurfaceStateHeapOffset = 0xDEF;
pPatchList = &allocateStatelessEventPoolSurface;
patchListSize = allocateStatelessEventPoolSurface.Size;
buildAndDecode();
const auto &eventPoolArg = pKernelInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress;
EXPECT_EQ_VAL(allocateStatelessEventPoolSurface.DataParamOffset, eventPoolArg.stateless);
EXPECT_EQ_VAL(allocateStatelessEventPoolSurface.DataParamSize, eventPoolArg.pointerSize);
EXPECT_EQ_VAL(allocateStatelessEventPoolSurface.SurfaceStateHeapOffset, eventPoolArg.bindful);
}
TEST_F(KernelDataTest, givenDataParameterPreferredWorkgroupMultipleTokenWhenBinaryIsdecodedThenCorrectOffsetIsAssigned) {
const uint32_t offset = 0x100;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -355,7 +355,6 @@ inline bool decodeToken(const SPatchItemHeader *token, KernelFromPatchtokens &ou
assignToken(out.tokens.allocateStatelessPrintfSurface, token);
break;
case PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE:
assignToken(out.tokens.allocateStatelessEventPoolSurface, token);
break;
case PATCH_TOKEN_ALLOCATE_STATELESS_DEFAULT_DEVICE_QUEUE_SURFACE:
assignToken(out.tokens.allocateStatelessDefaultDeviceQueueSurface, token);

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 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 SPatchAllocateStatelessEventPoolSurface *allocateStatelessEventPoolSurface = nullptr;
const SPatchAllocateStatelessDefaultDeviceQueueSurface *allocateStatelessDefaultDeviceQueueSurface = nullptr;
const SPatchAllocateSyncBuffer *allocateSyncBuffer = nullptr;
const SPatchAllocateRTGlobalBuffer *allocateRTGlobalBuffer = nullptr;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -569,19 +569,6 @@ void dump(const SPatchMediaVFEState &value, std::stringstream &out, const std::s
out << indent << "}\n";
}
void dump(const SPatchAllocateStatelessEventPoolSurface &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchAllocateStatelessEventPoolSurface :\n";
out << indent << " SPatchItemHeader (";
dumpPatchItemHeaderInline(value, out, "");
out << ")\n"
<< indent << "{\n";
out << indent << " uint32_t EventPoolSurfaceIndex;// = " << value.EventPoolSurfaceIndex << "\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 SPatchAllocateStatelessDefaultDeviceQueueSurface &value, std::stringstream &out, const std::string &indent) {
out << indent << "struct SPatchAllocateStatelessDefaultDeviceQueueSurface :\n";
out << indent << " SPatchItemHeader (";
@ -740,7 +727,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.allocateStatelessEventPoolSurface, "", stream, indentLevel1);
dumpOrNull(kern.tokens.allocateStatelessDefaultDeviceQueueSurface, "", stream, indentLevel1);
dumpOrNull(kern.tokens.inlineVmeSamplerInfo, "", stream, indentLevel1);
dumpOrNull(kern.tokens.gtpinFreeGrfInfo, "", stream, indentLevel1);

1
shared/source/kernel/kernel_descriptor.cpp
View File

@ -42,7 +42,6 @@ void KernelDescriptor::updateCrossThreadDataSize() {
&payloadMappings.implicitArgs.globalVariablesSurfaceAddress,
&payloadMappings.implicitArgs.globalConstantsSurfaceAddress,
&payloadMappings.implicitArgs.privateMemoryAddress,
&payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress,
&payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress,
&payloadMappings.implicitArgs.systemThreadSurfaceAddress,
&payloadMappings.implicitArgs.syncBufferAddress});

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

@ -179,7 +179,6 @@ struct KernelDescriptor {
ArgDescPointer globalVariablesSurfaceAddress;
ArgDescPointer globalConstantsSurfaceAddress;
ArgDescPointer privateMemoryAddress;
ArgDescPointer deviceSideEnqueueEventPoolSurfaceAddress;
ArgDescPointer deviceSideEnqueueDefaultQueueSurfaceAddress;
ArgDescPointer systemThreadSurfaceAddress;
ArgDescPointer syncBufferAddress;

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

@ -184,10 +184,6 @@ void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateStatele
populatePointerKernelArg(dst, dst.payloadMappings.implicitArgs.printfSurfaceAddress, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateStatelessEventPoolSurface &token) {
populatePointerKernelArg(dst, dst.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress, token, dst.kernelAttributes.bufferAddressingMode);
}
void populateKernelDescriptor(KernelDescriptor &dst, const SPatchAllocateStatelessDefaultDeviceQueueSurface &token) {
populatePointerKernelArg(dst, dst.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress, token, dst.kernelAttributes.bufferAddressingMode);
}
@ -478,7 +474,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.allocateStatelessEventPoolSurface);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateStatelessDefaultDeviceQueueSurface);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateSyncBuffer);
populateKernelDescriptorIfNotNull(dst, src.tokens.allocateRTGlobalBuffer);

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

@ -144,10 +144,6 @@ void MockKernelInfo::setGlobalVariablesSurface(uint8_t pointerSize, CrossThreadD
populatePointerArg(kernelDescriptor.payloadMappings.implicitArgs.globalVariablesSurfaceAddress, pointerSize, stateless, bindful);
}
void MockKernelInfo::setDeviceSideEnqueueEventPoolSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful) {
populatePointerArg(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress, pointerSize, stateless, bindful);
}
void MockKernelInfo::setDeviceSideEnqueueDefaultQueueSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful) {
populatePointerArg(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress, pointerSize, stateless, bindful);
}

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

@ -58,7 +58,6 @@ class MockKernelInfo : public KernelInfo {
void setPrintfSurface(uint8_t dataParamSize = sizeof(uintptr_t), CrossThreadDataOffset crossThreadDataOffset = undefined<CrossThreadDataOffset>, SurfaceStateHeapOffset sshOffset = undefined<SurfaceStateHeapOffset>);
void setBindingTable(SurfaceStateHeapOffset tableOffset, uint8_t numEntries);
void setGlobalVariablesSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setDeviceSideEnqueueEventPoolSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setDeviceSideEnqueueDefaultQueueSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setGlobalConstantsSurface(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);
void setSyncBuffer(uint8_t pointerSize, CrossThreadDataOffset stateless, SurfaceStateHeapOffset bindful = undefined<CrossThreadDataOffset>);

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -34,7 +34,6 @@ bool hasEmptyTokensInfo(const NEO::PatchTokenBinary::KernelFromPatchtokens &kern
empty &= nullptr == toks.allocateStatelessConstantMemorySurfaceWithInitialization;
empty &= nullptr == toks.allocateStatelessGlobalMemorySurfaceWithInitialization;
empty &= nullptr == toks.allocateStatelessPrintfSurface;
empty &= nullptr == toks.allocateStatelessEventPoolSurface;
empty &= nullptr == toks.allocateStatelessDefaultDeviceQueueSurface;
empty &= nullptr == toks.inlineVmeSamplerInfo;
empty &= nullptr == toks.gtpinFreeGrfInfo;
@ -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 allocateStatelessEventPoolSurfaceOff = pushBackToken<SPatchAllocateStatelessEventPoolSurface>(PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_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);
@ -363,7 +361,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, allocateStatelessEventPoolSurfaceOff, decodedKernel.tokens.allocateStatelessEventPoolSurface));
EXPECT_TRUE(tokenOffsetMatched(base, allocateStatelessDefaultDeviceQueueSurfaceOff, decodedKernel.tokens.allocateStatelessDefaultDeviceQueueSurface));
EXPECT_TRUE(tokenOffsetMatched(base, inlineVmeSamplerInfoOff, decodedKernel.tokens.inlineVmeSamplerInfo));
EXPECT_TRUE(tokenOffsetMatched(base, gtpinFreeGrfInfoOff, decodedKernel.tokens.gtpinFreeGrfInfo));

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 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 allocateStatelessEventPoolSurface = initToken<SPatchAllocateStatelessEventPoolSurface>(PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_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);
@ -560,7 +559,6 @@ TEST(KernelDumper, givenKernelWithNonCrossthreadDataPatchtokensThenProperlyCreat
kernel.tokens.allocateStatelessConstantMemorySurfaceWithInitialization = &allocateStatelessConstantMemorySurfaceWithInitialization;
kernel.tokens.allocateStatelessGlobalMemorySurfaceWithInitialization = &allocateStatelessGlobalMemorySurfaceWithInitialization;
kernel.tokens.allocateStatelessPrintfSurface = &allocateStatelessPrintfSurface;
kernel.tokens.allocateStatelessEventPoolSurface = &allocateStatelessEventPoolSurface;
kernel.tokens.allocateStatelessDefaultDeviceQueueSurface = &allocateStatelessDefaultDeviceQueueSurface;
kernel.tokens.inlineVmeSamplerInfo = &inlineVmeSamplerInfo;
kernel.tokens.gtpinFreeGrfInfo = &gtpinFreeGrfInfo;
@ -736,15 +734,6 @@ Kernel-scope tokens section size : )==="
uint32_t DataParamOffset;// = 0
uint32_t DataParamSize;// = 0
}
struct SPatchAllocateStatelessEventPoolSurface :
SPatchItemHeader (Token=36(PATCH_TOKEN_ALLOCATE_STATELESS_EVENT_POOL_SURFACE), Size=)==="
<< sizeof(SPatchAllocateStatelessEventPoolSurface) << R"===()
{
uint32_t EventPoolSurfaceIndex;// = 0
uint32_t SurfaceStateHeapOffset;// = 0
uint32_t DataParamOffset;// = 0
uint32_t DataParamSize;// = 0
}
struct SPatchAllocateStatelessDefaultDeviceQueueSurface :
SPatchItemHeader (Token=46(PATCH_TOKEN_STATELESS_DEVICE_QUEUE_KERNEL_ARGUMENT), Size=)==="
<< sizeof(SPatchAllocateStatelessDefaultDeviceQueueSurface) << R"===()

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

@ -329,28 +329,6 @@ TEST(KernelDescriptorFromPatchtokens, GivenImplicitArgsThenSetsProperPartsOfDesc
kernelDescriptor.kernelAttributes.numArgsStateful = 0;
kernelTokens.tokens.allocateStatelessPrintfSurface = nullptr;
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.stateless));
EXPECT_EQ(0U, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.pointerSize);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful));
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindless));
iOpenCL::SPatchAllocateStatelessEventPoolSurface eventPoolSurface = {};
eventPoolSurface.DataParamOffset = 2;
eventPoolSurface.DataParamSize = 3;
eventPoolSurface.SurfaceStateHeapOffset = 7;
kernelTokens.tokens.allocateStatelessEventPoolSurface = &eventPoolSurface;
NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
EXPECT_EQ(eventPoolSurface.DataParamOffset, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.stateless);
EXPECT_EQ(eventPoolSurface.DataParamSize, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.pointerSize);
EXPECT_EQ(eventPoolSurface.SurfaceStateHeapOffset, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindless));
EXPECT_EQ(1u, kernelDescriptor.kernelAttributes.numArgsStateful);
kernelDescriptor.kernelAttributes.numArgsStateful = 0;
kernelTokens.tokens.allocateStatelessEventPoolSurface = nullptr;
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.stateless));
EXPECT_EQ(0U, kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.pointerSize);
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful));
EXPECT_TRUE(NEO::isUndefinedOffset(kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindless));
iOpenCL::SPatchAllocateStatelessDefaultDeviceQueueSurface defaultDeviceQueueSurface = {};
defaultDeviceQueueSurface.DataParamOffset = 2;
defaultDeviceQueueSurface.DataParamSize = 3;