Zebin - Improving binding table generation

Allowing N:1 kernel_arg:bti mappings

Signed-off-by: Jaroslaw Chodor <[email protected]>

Author: jchodor

shared/source/device_binary_format/zebin_decoder.cpp

@@ -878,10 +878,14 @@ NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<N
 
         auto generatedBindingTablePos = kernelDescriptor.generatedHeaps.size();
         kernelDescriptor.generatedHeaps.resize(generatedBindingTablePos + numEntries * btiSize, 0U);
+
         auto bindingTableIt = reinterpret_cast<int *>(kernelDescriptor.generatedHeaps.data() + generatedBindingTablePos);
-        for (auto &bti : bindingTableIndices) {
-            *bindingTableIt = bti.btiValue * 64U;
+        for (int i = 0; i < numEntries; ++i) {
+            *bindingTableIt = i * maxSurfaceStateSize;
             ++bindingTableIt;
+        }
+
+        for (auto &bti : bindingTableIndices) {
             auto &explicitArg = kernelDescriptor.payloadMappings.explicitArgs[bti.argIndex];
             switch (explicitArg.type) {
             default:

shared/source/kernel/kernel_arg_descriptor.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -282,7 +282,7 @@ inline bool patchPointer(ArrayRef<uint8_t> buffer, const ArgDescPointer &arg, ui
     if (arg.pointerSize == 8) {
         return patchNonPointer(buffer, arg.stateless, static_cast<uint64_t>(value));
     } else {
-        UNRECOVERABLE_IF(arg.pointerSize != 4);
+        UNRECOVERABLE_IF((arg.pointerSize != 4) && isValidOffset(arg.stateless));
         return patchNonPointer(buffer, arg.stateless, static_cast<uint32_t>(value));
     }
 }

shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

@@ -2362,8 +2362,8 @@ TEST(PopulateKernelDescriptor, GivenValidBindingTableEntriesThenGeneratesSsh) {
     EXPECT_EQ(512U, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.bindingTable.tableOffset);
     ASSERT_EQ(576U, programInfo.kernelInfos[0]->heapInfo.SurfaceStateHeapSize);
     ASSERT_NE(nullptr, programInfo.kernelInfos[0]->heapInfo.pSsh);
-    EXPECT_EQ(128U, reinterpret_cast<const uint32_t *>(ptrOffset(programInfo.kernelInfos[0]->heapInfo.pSsh, 512U))[0]);
-    EXPECT_EQ(448U, reinterpret_cast<const uint32_t *>(ptrOffset(programInfo.kernelInfos[0]->heapInfo.pSsh, 512U))[1]);
+    EXPECT_EQ(128U, reinterpret_cast<const uint32_t *>(ptrOffset(programInfo.kernelInfos[0]->heapInfo.pSsh, 512U))[2]);
+    EXPECT_EQ(448U, reinterpret_cast<const uint32_t *>(ptrOffset(programInfo.kernelInfos[0]->heapInfo.pSsh, 512U))[7]);
 }
 
 TEST(PopulateKernelDescriptor, GivenBtiEntryForWrongArgTypeThenFail) {

shared/test/unit_test/kernel/kernel_arg_descriptor_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -486,9 +486,20 @@ TEST(PatchPointer, GivenUnhandledPointerSizeThenAborts) {
     NEO::ArgDescPointer ptrArg;
     uintptr_t ptrValue = reinterpret_cast<uintptr_t>(&ptrArg);
     ptrArg.pointerSize = 5;
+    ptrArg.stateless = 0U;
     EXPECT_THROW(patchPointer(buffer, ptrArg, ptrValue), std::exception);
 }
 
+TEST(PatchPointer, GivenUnhandledPointerSizeWhenStatelessOffsetIsUndefinedThenIgnoresPointerSize) {
+    alignas(8) uint8_t buffer[64];
+    memset(buffer, 3, sizeof(buffer));
+    NEO::ArgDescPointer ptrArg;
+    uintptr_t ptrValue = reinterpret_cast<uintptr_t>(&ptrArg);
+    ptrArg.pointerSize = 5;
+    ptrArg.stateless = NEO::undefined<NEO::CrossThreadDataOffset>;
+    EXPECT_NO_THROW(patchPointer(buffer, ptrArg, ptrValue));
+}
+
 TEST(PatchPointer, Given32bitPointerSizeThenPatchesOnly32bits) {
     alignas(8) uint8_t buffer[64];
     memset(buffer, 3, sizeof(buffer));