Handle patch token for implicit args buffer

Related-To: NEO-5081, IGC-4710
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

shared/source/device_binary_format/patchtokens_decoder.cpp

@@ -290,6 +290,9 @@ inline void decodeKernelDataParameterToken(const SPatchDataParameterBuffer *toke
     case DATA_PARAMETER_PREFERRED_WORKGROUP_MULTIPLE:
         crossthread.preferredWorkgroupMultiple = token;
         break;
+    case DATA_PARAMETER_IMPL_ARG_BUFFER:
+        out.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset = token;
+        break;
 
     case DATA_PARAMETER_NUM_HARDWARE_THREADS:
     case DATA_PARAMETER_PRINTF_SURFACE_SIZE:
@@ -300,6 +303,7 @@ inline void decodeKernelDataParameterToken(const SPatchDataParameterBuffer *toke
     case DATA_PARAMETER_EXECUTION_MASK:
     case DATA_PARAMETER_VME_IMAGE_TYPE:
     case DATA_PARAMETER_VME_MB_SKIP_BLOCK_TYPE:
+    case DATA_PARAMETER_LOCAL_ID_BUFFER:
         // ignored intentionally
         break;
     }

shared/source/device_binary_format/patchtokens_decoder.h

@@ -157,6 +157,7 @@ struct KernelFromPatchtokens {
             const SPatchDataParameterBuffer *localMemoryStatelessWindowStartAddress = nullptr;
             const SPatchDataParameterBuffer *preferredWorkgroupMultiple = nullptr;
             StackVec<const SPatchDataParameterBuffer *, 4> childBlockSimdSize;
+            const SPatchDataParameterBuffer *implicitArgsBufferOffset = nullptr;
         } crossThreadPayloadArgs;
     } tokens;
 

shared/source/device_binary_format/patchtokens_dumper.cpp

@@ -135,6 +135,7 @@ std::string asString(DATA_PARAMETER_TOKEN dataParameter) {
         CASE_TOK_STR(DATA_PARAMETER_STAGE_IN_GRID_SIZE);
         CASE_TOK_STR(DATA_PARAMETER_BUFFER_OFFSET);
         CASE_TOK_STR(DATA_PARAMETER_BUFFER_STATEFUL);
+        CASE_TOK_STR(DATA_PARAMETER_IMPL_ARG_BUFFER);
     }
 }
 #undef CASE_TOK_STR
@@ -764,6 +765,7 @@ std::string asString(const KernelFromPatchtokens &kern) {
     dumpOrNull(kern.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowStartAddress, "", stream, indentLevel1);
     dumpOrNull(kern.tokens.crossThreadPayloadArgs.preferredWorkgroupMultiple, "", stream, indentLevel1);
     dumpVecIfNotEmpty(kern.tokens.crossThreadPayloadArgs.childBlockSimdSize, "Child block simd size(s)", stream, indentLevel1);
+    dumpOrNull(kern.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset, "", stream, indentLevel1);
 
     if (kern.tokens.kernelArgs.size() != 0) {
         stream << "Kernel arguments [" << kern.tokens.kernelArgs.size() << "] :\n";

shared/source/kernel/kernel_descriptor.h

@@ -266,6 +266,7 @@ struct KernelDescriptor {
             CrossThreadDataOffset preferredWkgMultiple = undefined<CrossThreadDataOffset>;
             CrossThreadDataOffset localMemoryStatelessWindowSize = undefined<CrossThreadDataOffset>;
             CrossThreadDataOffset localMemoryStatelessWindowStartAddres = undefined<CrossThreadDataOffset>;
+            CrossThreadDataOffset implcitArgsBuffer = undefined<CrossThreadDataOffset>;
         } implicitArgs;
 
         std::vector<std::unique_ptr<ArgDescriptorExtended>> explicitArgsExtendedDescriptors;

shared/source/kernel/kernel_descriptor_from_patchtokens.cpp

@@ -510,13 +510,15 @@ 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);
+    dst.payloadMappings.implicitArgs.implcitArgsBuffer = getOffset(src.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset);
 
     if (src.tokens.gtpinInfo) {
         dst.external.igcInfoForGtpin = (src.tokens.gtpinInfo + 1);
     }
 
     dst.kernelAttributes.binaryFormat = DeviceBinaryFormat::Patchtokens;
     dst.kernelAttributes.gpuPointerSize = gpuPointerSizeInBytes;
+    dst.kernelAttributes.flags.requiresImplicitArgs = src.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset != nullptr;
 
     if (DebugManager.flags.UpdateCrossThreadDataSize.get()) {
         dst.updateCrossThreadDataSize();

shared/test/unit_test/device_binary_format/patchtokens_decoder_tests.cpp

@@ -578,6 +578,7 @@ TEST(KernelDecoder, GivenKernelWithValidNonArgCrossThreadDataPatchtokensThenDeco
     auto childBlockSimdSize0Off = pushBackDataParameterToken(DATA_PARAMETER_CHILD_BLOCK_SIMD_SIZE, storage);
     auto childBlockSimdSize1Off = pushBackDataParameterToken(DATA_PARAMETER_CHILD_BLOCK_SIMD_SIZE, storage);
     auto childBlockSimdSize2Off = pushBackDataParameterToken(DATA_PARAMETER_CHILD_BLOCK_SIMD_SIZE, storage);
+    auto implictArgBufferOffset = pushBackDataParameterToken(DATA_PARAMETER_IMPL_ARG_BUFFER, storage);
 
     ASSERT_EQ(storage.data(), kernelToEncode.blobs.kernelInfo.begin());
     auto kernelHeader = reinterpret_cast<iOpenCL::SKernelBinaryHeaderCommon *>(storage.data());
@@ -620,6 +621,7 @@ TEST(KernelDecoder, GivenKernelWithValidNonArgCrossThreadDataPatchtokensThenDeco
     EXPECT_TRUE(tokenOffsetMatched(base, childBlockSimdSize0Off, decodedKernel.tokens.crossThreadPayloadArgs.childBlockSimdSize[0]));
     EXPECT_TRUE(tokenOffsetMatched(base, childBlockSimdSize1Off, decodedKernel.tokens.crossThreadPayloadArgs.childBlockSimdSize[1]));
     EXPECT_TRUE(tokenOffsetMatched(base, childBlockSimdSize2Off, decodedKernel.tokens.crossThreadPayloadArgs.childBlockSimdSize[2]));
+    EXPECT_TRUE(tokenOffsetMatched(base, implictArgBufferOffset, decodedKernel.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset));
 }
 
 TEST(KernelDecoder, GivenKernelWithArgCrossThreadDataPatchtokensWhenSourceIndexIsGreaterThan2ThenThenDecodingSucceedsButTokenIsMarkedAsUnhandled) {

shared/test/unit_test/device_binary_format/patchtokens_dumper_tests.cpp

@@ -2094,7 +2094,7 @@ TEST(PatchTokenDumper, GivenAnyTokenThenDumpingIsHandled) {
     auto kernelDataParamToken = static_cast<iOpenCL::SPatchDataParameterBuffer *>(kernelToken);
     *kernelDataParamToken = PatchTokensTestData::initDataParameterBufferToken(iOpenCL::DATA_PARAMETER_BUFFER_OFFSET);
     kernelDataParamToken->Size = maxTokenSize;
-    std::unordered_set<int> dataParamTokensPasslist{6, 7, 17, 19, 36, 37, 39, 40, 41};
+    std::unordered_set<int> dataParamTokensPasslist{6, 7, 17, 19, 36, 37, 39, 40, 41, iOpenCL::DATA_PARAMETER_LOCAL_ID_BUFFER};
     for (int i = 0; i < iOpenCL::NUM_DATA_PARAMETER_TOKENS; ++i) {
         if (dataParamTokensPasslist.count(i) != 0) {
             continue;

shared/test/unit_test/kernel/kernel_descriptor_from_patchtokens_tests.cpp

@@ -1571,4 +1571,30 @@ TEST(KernelDescriptorFromPatchtokens, GivenUpdateCrossThreadDataSizeFalseWhenPop
     NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 8);
 
     EXPECT_EQ(32u, kernelDescriptor.kernelAttributes.crossThreadDataSize);
+}
+
+TEST(KernelDescriptorFromPatchtokens, givenDataParameterImplArgBufferTokenWhenPopulateKernelDescriptorThenProperOffsetIsSetAndImplicitArgsAreRequired) {
+    NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens;
+    iOpenCL::SKernelBinaryHeaderCommon kernelHeader;
+    kernelTokens.header = &kernelHeader;
+
+    NEO::KernelDescriptor kernelDescriptor;
+
+    uint16_t offset = 0x30;
+
+    iOpenCL::SPatchDataParameterBuffer dataParameterToken{};
+    dataParameterToken.Token = iOpenCL::PATCH_TOKEN_DATA_PARAMETER_BUFFER;
+    dataParameterToken.Size = sizeof(iOpenCL::SPatchDataParameterBuffer);
+    dataParameterToken.Type = iOpenCL::DATA_PARAMETER_IMPL_ARG_BUFFER;
+    dataParameterToken.ArgumentNumber = 0;
+    dataParameterToken.Offset = offset;
+    dataParameterToken.DataSize = sizeof(uint32_t);
+    dataParameterToken.SourceOffset = 0;
+
+    kernelTokens.tokens.crossThreadPayloadArgs.implicitArgsBufferOffset = &dataParameterToken;
+
+    NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 8);
+
+    EXPECT_EQ(offset, kernelDescriptor.payloadMappings.implicitArgs.implcitArgsBuffer);
+    EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
 }