Add stateless arguments checker for single kernel

Related-To: NEO-5055

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>

shared/source/helpers/addressing_mode_helper.cpp

@@ -5,7 +5,7 @@
  *
  */
 
-#include "addressing_mode_helper.h"
+#include "shared/source/helpers/addressing_mode_helper.h"
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
 #include "shared/source/execution_environment/root_device_environment.h"
@@ -27,21 +27,29 @@ bool failBuildProgramWithStatefulAccess(const RootDeviceEnvironment &rootDeviceE
     return failBuildProgram && forceToStatelessRequired;
 }
 
+inline bool argPointerIsStateful(const ArgDescriptor &arg) {
+    return arg.is<NEO::ArgDescriptor::ArgTPointer>() &&
+           (NEO::isValidOffset(arg.as<NEO::ArgDescPointer>().bindless) ||
+            NEO::isValidOffset(arg.as<NEO::ArgDescPointer>().bindful));
+}
+
+bool containsStatefulAccess(const KernelDescriptor &kernelDescriptor, bool skipLastExplicitArg) {
+    auto size = static_cast<int32_t>(kernelDescriptor.payloadMappings.explicitArgs.size());
+    if (skipLastExplicitArg) {
+        size--;
+    }
+    for (auto i = 0; i < size; i++) {
+        if (argPointerIsStateful(kernelDescriptor.payloadMappings.explicitArgs[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
 bool containsStatefulAccess(const std::vector<KernelInfo *> &kernelInfos, bool skipLastExplicitArg) {
     for (const auto &kernelInfo : kernelInfos) {
-        auto size = static_cast<int32_t>(kernelInfo->kernelDescriptor.payloadMappings.explicitArgs.size());
+        if (containsStatefulAccess(kernelInfo->kernelDescriptor, skipLastExplicitArg)) {
-        if (skipLastExplicitArg) {
+            return true;
-            size--;
-        }
-        for (auto i = 0; i < size; i++) {
-
-            auto &arg = kernelInfo->kernelDescriptor.payloadMappings.explicitArgs[i];
-            auto isStatefulAccess = arg.is<NEO::ArgDescriptor::ArgTPointer>() &&
-                                    (NEO::isValidOffset(arg.as<NEO::ArgDescPointer>().bindless) ||
-                                     NEO::isValidOffset(arg.as<NEO::ArgDescPointer>().bindful));
-            if (isStatefulAccess) {
-                return true;
-            }
         }
     }
     return false;

shared/source/helpers/addressing_mode_helper.h

@@ -9,11 +9,13 @@
 #include <vector>
 
 namespace NEO {
+struct KernelDescriptor;
 struct KernelInfo;
 struct RootDeviceEnvironment;
 
 namespace AddressingModeHelper {
 bool failBuildProgramWithStatefulAccess(const RootDeviceEnvironment &rootDeviceEnvironment);
+bool containsStatefulAccess(const KernelDescriptor &kernelDescriptor, bool skipLastExplicitArg);
 bool containsStatefulAccess(const std::vector<KernelInfo *> &kernelInfos, bool skipLastExplicitArg);
 
 } // namespace AddressingModeHelper

shared/test/unit_test/helpers/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 target_sources(neo_shared_tests PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/addressing_mode_helper_tests.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/aligned_memory_tests.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/app_resource_tests.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/array_count_tests.cpp

shared/test/unit_test/helpers/addressing_mode_helper_tests.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/addressing_mode_helper.h"
+#include "shared/source/program/kernel_info.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(AddressingModeHelperTest, GivenArgIsNotPointerWhenCheckingForStatefulAccessThenReturnFalse) {
+    auto argDescriptor = ArgDescriptor(ArgDescriptor::ArgTValue);
+
+    KernelDescriptor kernelDescriptor;
+    kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
+
+    EXPECT_FALSE(AddressingModeHelper::containsStatefulAccess(kernelDescriptor, false));
+}
+
+TEST(AddressingModeHelperTest, GivenArgIsPointerWithInvalidStatefulOffsetWhenCheckingForStatefulAccessThenReturnFalse) {
+    auto argDescriptor = ArgDescriptor(ArgDescriptor::ArgTPointer);
+    argDescriptor.as<ArgDescPointer>().bindful = undefined<SurfaceStateHeapOffset>;
+    argDescriptor.as<ArgDescPointer>().bindless = undefined<CrossThreadDataOffset>;
+
+    KernelDescriptor kernelDescriptor;
+    kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
+
+    EXPECT_FALSE(AddressingModeHelper::containsStatefulAccess(kernelDescriptor, false));
+}
+
+TEST(AddressingModeHelperTest, GivenArgIsPointerWithValidBindfulOffsetWhenCheckingForStatefulAccessThenReturnTrue) {
+    auto argDescriptor = ArgDescriptor(ArgDescriptor::ArgTPointer);
+    argDescriptor.as<ArgDescPointer>().bindful = 0x40;
+    argDescriptor.as<ArgDescPointer>().bindless = undefined<CrossThreadDataOffset>;
+
+    KernelDescriptor kernelDescriptor;
+    kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
+
+    EXPECT_TRUE(AddressingModeHelper::containsStatefulAccess(kernelDescriptor, false));
+}
+
+TEST(AddressingModeHelperTest, GivenArgIsPointerWithValidBindlessOffsetWhenCheckingForStatefulAccessThenReturnTrue) {
+    auto argDescriptor = ArgDescriptor(ArgDescriptor::ArgTPointer);
+    argDescriptor.as<ArgDescPointer>().bindful = undefined<SurfaceStateHeapOffset>;
+    argDescriptor.as<ArgDescPointer>().bindless = 0x40;
+
+    KernelDescriptor kernelDescriptor;
+    kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
+
+    EXPECT_TRUE(AddressingModeHelper::containsStatefulAccess(kernelDescriptor, false));
+}
+
+TEST(AddressingModeHelperTest, GivenLastArgIsPointerWithValidBindlessOffsetWhenIgnoreLastArgAndCheckingForStatefulAccessThenReturnFalse) {
+    auto argDescriptor = ArgDescriptor(ArgDescriptor::ArgTPointer);
+    argDescriptor.as<ArgDescPointer>().bindful = undefined<SurfaceStateHeapOffset>;
+    argDescriptor.as<ArgDescPointer>().bindless = 0x40;
+
+    KernelDescriptor kernelDescriptor;
+    kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptor);
+
+    EXPECT_FALSE(AddressingModeHelper::containsStatefulAccess(kernelDescriptor, true));
+}