feat(zebin): add thread scheduling mode support

KrystianChmielewski · Compute-Runtime-Automation · commit 18adbed2333f · 2022-08-18T16:10:18.000+02:00
Resolves: NEO-7197

Signed-off-by: Krystian Chmielewski &lt;krystian.chmielewski@intel.com&gt;
diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -2285,7 +2285,7 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel
     if (!containsAnyKernel) {
         requiredStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, disableOverdispatch, -1, hwInfo);
         finalStreamState = requiredStreamState;
-        requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernel.getSchedulingHintExp(), device->getDevicePreemptionMode(), hwInfo);
+        requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo);
         containsAnyKernel = true;
     }
 
@@ -2298,7 +2298,7 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel
         commandsToPatch.push_back({pVfeStateAddress, pVfeState, CommandToPatch::FrontEndState});
     }
 
-    finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernel.getSchedulingHintExp(), device->getDevicePreemptionMode(), hwInfo);
+    finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo);
 
     if (finalStreamState.stateComputeMode.isDirty() && !getLogicalStateHelper()) {
         bool isRcs = (this->engineGroupType == NEO::EngineGroupType::RenderCompute);
diff --git a/level_zero/core/source/kernel/kernel_imp.cpp b/level_zero/core/source/kernel/kernel_imp.cpp
@@ -1066,18 +1066,14 @@ NEO::GraphicsAllocation *KernelImp::getIsaAllocation() const {
 }
 
 ze_result_t KernelImp::setSchedulingHintExp(ze_scheduling_hint_exp_desc_t *pHint) {
-
+    auto &threadArbitrationPolicy = const_cast<NEO::ThreadArbitrationPolicy &>(getKernelDescriptor().kernelAttributes.threadArbitrationPolicy);
     if (pHint->flags == ZE_SCHEDULING_HINT_EXP_FLAG_OLDEST_FIRST) {
-        this->schedulingHintExpFlag = NEO::ThreadArbitrationPolicy::AgeBased;
+        threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::AgeBased;
     } else if (pHint->flags == ZE_SCHEDULING_HINT_EXP_FLAG_ROUND_ROBIN) {
-        this->schedulingHintExpFlag = NEO::ThreadArbitrationPolicy::RoundRobin;
+        threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobin;
     } else {
-        this->schedulingHintExpFlag = NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency;
+        threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency;
     }
     return ZE_RESULT_SUCCESS;
-}
-
-int32_t KernelImp::getSchedulingHintExp() const {
-    return this->schedulingHintExpFlag;
-}
+} // namespace L0
 } // namespace L0
diff --git a/level_zero/core/source/kernel/kernel_imp.h b/level_zero/core/source/kernel/kernel_imp.h
@@ -160,7 +160,6 @@ struct KernelImp : Kernel {
     }
 
     ze_result_t setSchedulingHintExp(ze_scheduling_hint_exp_desc_t *pHint) override;
-    int32_t getSchedulingHintExp() const override;
 
     NEO::ImplicitArgs *getImplicitArgs() const override { return pImplicitArgs.get(); }
 
@@ -222,7 +221,6 @@ struct KernelImp : Kernel {
 
     bool kernelHasIndirectAccess = true;
 
-    int32_t schedulingHintExpFlag = NEO::ThreadArbitrationPolicy::NotPresent;
     std::unique_ptr<NEO::ImplicitArgs> pImplicitArgs;
 
     std::unique_ptr<KernelExt> pExtension;
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
@@ -66,23 +66,23 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithOldestFirstThreadArbitrat
     ze_scheduling_hint_exp_desc_t pHint{};
     pHint.flags = ZE_SCHEDULING_HINT_EXP_FLAG_OLDEST_FIRST;
     kernel->setSchedulingHintExp(&pHint);
-    ASSERT_EQ(kernel->getSchedulingHintExp(), NEO::ThreadArbitrationPolicy::AgeBased);
+    ASSERT_EQ(kernel->getKernelDescriptor().kernelAttributes.threadArbitrationPolicy, NEO::ThreadArbitrationPolicy::AgeBased);
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithRRThreadArbitrationPolicySetUsingSchedulingHintExtensionThenCorrectInternalPolicyIsReturned) {
     createKernel();
     ze_scheduling_hint_exp_desc_t pHint{};
     pHint.flags = ZE_SCHEDULING_HINT_EXP_FLAG_ROUND_ROBIN;
     kernel->setSchedulingHintExp(&pHint);
-    ASSERT_EQ(kernel->getSchedulingHintExp(), NEO::ThreadArbitrationPolicy::RoundRobin);
+    ASSERT_EQ(kernel->getKernelDescriptor().kernelAttributes.threadArbitrationPolicy, NEO::ThreadArbitrationPolicy::RoundRobin);
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithStallRRThreadArbitrationPolicySetUsingSchedulingHintExtensionThenCorrectInternalPolicyIsReturned) {
     createKernel();
     ze_scheduling_hint_exp_desc_t pHint{};
     pHint.flags = ZE_SCHEDULING_HINT_EXP_FLAG_STALL_BASED_ROUND_ROBIN;
     kernel->setSchedulingHintExp(&pHint);
-    ASSERT_EQ(kernel->getSchedulingHintExp(), NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency);
+    ASSERT_EQ(kernel->getKernelDescriptor().kernelAttributes.threadArbitrationPolicy, NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency);
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithThreadArbitrationPolicySetUsingSchedulingHintExtensionTheSameFlagIsUsedToSetCmdListThreadArbitrationPolicy) {
diff --git a/opencl/source/command_queue/enqueue_common.h b/opencl/source/command_queue/enqueue_common.h
@@ -768,7 +768,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         ClPreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo),                     // preemptionMode
         numGrfRequired,                                                                             // numGrfRequired
         L3CachingSettings::l3CacheOn,                                                               // l3CacheSettings
-        kernel->getThreadArbitrationPolicy(),                                                       // threadArbitrationPolicy
+        kernel->getDescriptor().kernelAttributes.threadArbitrationPolicy,                           // threadArbitrationPolicy
         kernel->getAdditionalKernelExecInfo(),                                                      // additionalKernelExecInfo
         kernel->getExecutionType(),                                                                 // kernelExecutionType
         memoryCompressionState,                                                                     // memoryCompressionState
diff --git a/opencl/source/helpers/hardware_commands_helper_base.inl b/opencl/source/helpers/hardware_commands_helper_base.inl
@@ -144,7 +144,7 @@ size_t HardwareCommandsHelper<GfxFamily>::sendInterfaceDescriptorData(
                                                 sizeCrossThreadData, sizePerThreadData, hardwareInfo);
     auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily);
     hwInfoConfig.updateIddCommand(&interfaceDescriptor, kernelDescriptor.kernelAttributes.numGrfRequired,
-                                  kernel.getThreadArbitrationPolicy());
+                                  kernelDescriptor.kernelAttributes.threadArbitrationPolicy);
 
     EncodeDispatchKernel<GfxFamily>::appendAdditionalIDDFields(&interfaceDescriptor, hardwareInfo, threadsPerThreadGroup,
                                                                slmTotalSize, SlmPolicy::SlmPolicyNone);
diff --git a/opencl/source/helpers/task_information.cpp b/opencl/source/helpers/task_information.cpp
@@ -188,7 +188,7 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
         preemptionMode,                                                                   // preemptionMode
         kernelDescriptor.kernelAttributes.numGrfRequired,                                 // numGrfRequired
         L3CachingSettings::l3CacheOn,                                                     // l3CacheSettings
-        kernel->getThreadArbitrationPolicy(),                                             // threadArbitrationPolicy
+        kernelDescriptor.kernelAttributes.threadArbitrationPolicy,                        // threadArbitrationPolicy
         kernel->getAdditionalKernelExecInfo(),                                            // additionalKernelExecInfo
         kernel->getExecutionType(),                                                       // kernelExecutionType
         memoryCompressionState,                                                           // memoryCompressionState
diff --git a/opencl/source/kernel/kernel.cpp b/opencl/source/kernel/kernel.cpp
@@ -232,9 +232,12 @@ cl_int Kernel::initialize() {
         Buffer::setSurfaceState(&pClDevice->getDevice(), surfaceState, false, false, 0, nullptr, 0, nullptr, 0, 0, useGlobalAtomics, areMultipleSubDevicesInContext());
     }
 
-    setThreadArbitrationPolicy(hwHelper.getDefaultThreadArbitrationPolicy());
+    auto &threadArbitrationPolicy = const_cast<ThreadArbitrationPolicy &>(kernelInfo.kernelDescriptor.kernelAttributes.threadArbitrationPolicy);
+    if (threadArbitrationPolicy == ThreadArbitrationPolicy::NotPresent) {
+        threadArbitrationPolicy = static_cast<ThreadArbitrationPolicy>(hwHelper.getDefaultThreadArbitrationPolicy());
+    }
     if (false == kernelInfo.kernelDescriptor.kernelAttributes.flags.requiresSubgroupIndependentForwardProgress) {
-        setThreadArbitrationPolicy(ThreadArbitrationPolicy::AgeBased);
+        threadArbitrationPolicy = ThreadArbitrationPolicy::AgeBased;
     }
 
     auto &clHwHelper = ClHwHelper::get(hwInfo.platform.eRenderCoreFamily);
@@ -2230,18 +2233,19 @@ void Kernel::updateAuxTranslationRequired() {
 int Kernel::setKernelThreadArbitrationPolicy(uint32_t policy) {
     auto &hwInfo = clDevice.getHardwareInfo();
     auto &hwHelper = NEO::ClHwHelper::get(hwInfo.platform.eRenderCoreFamily);
+    auto &threadArbitrationPolicy = const_cast<ThreadArbitrationPolicy &>(getDescriptor().kernelAttributes.threadArbitrationPolicy);
     if (!hwHelper.isSupportedKernelThreadArbitrationPolicy()) {
-        this->threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
+        threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
         return CL_INVALID_DEVICE;
     } else if (policy == CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_ROUND_ROBIN_INTEL) {
-        this->threadArbitrationPolicy = ThreadArbitrationPolicy::RoundRobin;
+        threadArbitrationPolicy = ThreadArbitrationPolicy::RoundRobin;
     } else if (policy == CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_OLDEST_FIRST_INTEL) {
-        this->threadArbitrationPolicy = ThreadArbitrationPolicy::AgeBased;
+        threadArbitrationPolicy = ThreadArbitrationPolicy::AgeBased;
     } else if (policy == CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_AFTER_DEPENDENCY_ROUND_ROBIN_INTEL ||
                policy == CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_STALL_BASED_ROUND_ROBIN_INTEL) {
-        this->threadArbitrationPolicy = ThreadArbitrationPolicy::RoundRobinAfterDependency;
+        threadArbitrationPolicy = ThreadArbitrationPolicy::RoundRobinAfterDependency;
     } else {
-        this->threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
+        threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
         return CL_INVALID_VALUE;
     }
     return CL_SUCCESS;
diff --git a/opencl/source/kernel/kernel.h b/opencl/source/kernel/kernel.h
@@ -310,9 +310,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
 
     bool isBuiltIn = false;
 
-    int32_t getThreadArbitrationPolicy() const {
-        return threadArbitrationPolicy;
-    }
     KernelExecutionType getExecutionType() const {
         return executionType;
     }
@@ -353,9 +350,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
     bool areStatelessWritesUsed() { return containsStatelessWrites; }
     int setKernelThreadArbitrationPolicy(uint32_t propertyValue);
     cl_int setKernelExecutionType(cl_execution_info_kernel_type_intel executionType);
-    void setThreadArbitrationPolicy(int32_t policy) {
-        this->threadArbitrationPolicy = policy;
-    }
     void getSuggestedLocalWorkSize(const cl_uint workDim, const size_t *globalWorkSize, const size_t *globalWorkOffset,
                                    size_t *localWorkSize);
     uint32_t getMaxWorkGroupCount(const cl_uint workDim, const size_t *localWorkSize, const CommandQueue *commandQueue) const;
@@ -521,8 +515,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
     AuxTranslationDirection auxTranslationDirection = AuxTranslationDirection::None;
     KernelExecutionType executionType = KernelExecutionType::Default;
 
-    int32_t threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
-
     uint32_t patchedArgumentsNum = 0;
     uint32_t startOffset = 0;
     uint32_t statelessUncacheableArgsCount = 0;
diff --git a/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl b/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
@@ -318,8 +318,7 @@ HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhe
         &newThreadArbitrationPolicy                          // const void *param_value
     );
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->threadArbitrationPolicy);
-    EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->getThreadArbitrationPolicy());
+    EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->getDescriptor().kernelAttributes.threadArbitrationPolicy);
 }
 
 HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhenNotSupportedAndSettingAdditionalKernelInfoThenClInvalidDeviceIsReturned) {
diff --git a/opencl/test/unit_test/helpers/task_information_tests.cpp b/opencl/test/unit_test/helpers/task_information_tests.cpp
@@ -430,5 +430,6 @@ HWTEST_F(DispatchFlagsTests, givenCommandComputeKernelWhenSubmitThenPassCorrectD
 
     EXPECT_TRUE(mockCsr->passedDispatchFlags.epilogueRequired);
     EXPECT_EQ(1234u, mockCsr->passedDispatchFlags.engineHints);
-    EXPECT_EQ(kernel.mockKernel->getThreadArbitrationPolicy(), mockCsr->passedDispatchFlags.threadArbitrationPolicy);
+    auto expectedThreadArbitrationPolicy = kernel.mockKernel->getDescriptor().kernelAttributes.threadArbitrationPolicy;
+    EXPECT_EQ(expectedThreadArbitrationPolicy, mockCsr->passedDispatchFlags.threadArbitrationPolicy);
 }
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -2931,7 +2931,7 @@ TEST(KernelTest, whenKernelIsInitializedThenThreadArbitrationPolicyIsSetToDefaul
 
     auto &mockKernel = *mockKernelWithInternals.mockKernel;
     auto &hwHelper = HwHelper::get(deviceFactory.rootDevices[0]->getHardwareInfo().platform.eRenderCoreFamily);
-    EXPECT_EQ(hwHelper.getDefaultThreadArbitrationPolicy(), mockKernel.threadArbitrationPolicy);
+    EXPECT_EQ(hwHelper.getDefaultThreadArbitrationPolicy(), mockKernel.getDescriptor().kernelAttributes.threadArbitrationPolicy);
 }
 
 TEST(KernelTest, givenKernelWhenSettingAdditinalKernelExecInfoThenCorrectValueIsSet) {
diff --git a/opencl/test/unit_test/mocks/mock_kernel.h b/opencl/test/unit_test/mocks/mock_kernel.h
@@ -128,7 +128,6 @@ class MockKernel : public Kernel {
     using Kernel::privateSurface;
     using Kernel::singleSubdevicePreferredInCurrentEnqueue;
     using Kernel::svmAllocationsRequireCacheFlush;
-    using Kernel::threadArbitrationPolicy;
     using Kernel::unifiedMemoryControls;
 
     using Kernel::slmSizes;
diff --git a/shared/source/command_container/command_encoder_xehp_and_later.inl b/shared/source/command_container/command_encoder_xehp_and_later.inl
@@ -77,7 +77,7 @@ void EncodeDispatchKernel<Family>::encode(CommandContainer &container, EncodeDis
                                              sizePerThreadData, hwInfo);
     auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
     hwInfoConfig.updateIddCommand(&idd, kernelDescriptor.kernelAttributes.numGrfRequired,
-                                  args.dispatchInterface->getSchedulingHintExp());
+                                  kernelDescriptor.kernelAttributes.threadArbitrationPolicy);
 
     bool localIdsGenerationByRuntime = args.dispatchInterface->requiresGenerationOfLocalIdsByRuntime();
     auto requiredWorkgroupOrder = args.dispatchInterface->getRequiredWorkgroupOrder();
diff --git a/shared/source/device_binary_format/elf/zebin_elf.h b/shared/source/device_binary_format/elf/zebin_elf.h
@@ -151,6 +151,12 @@ static constexpr ConstStringRef simdSize("simd_size");
 static constexpr ConstStringRef slmSize("slm_size");
 static constexpr ConstStringRef subgroupIndependentForwardProgress("subgroup_independent_forward_progress");
 static constexpr ConstStringRef workGroupWalkOrderDimensions("work_group_walk_order_dimensions");
+static constexpr ConstStringRef threadSchedulingMode("thread_scheduling_mode");
+namespace ThreadSchedulingMode {
+static constexpr ConstStringRef ageBased("age_based");
+static constexpr ConstStringRef roundRobin("round_robin");
+static constexpr ConstStringRef roundRobinStall("round_robin_stall");
+} // namespace ThreadSchedulingMode
 } // namespace ExecutionEnv
 
 namespace DebugEnv {
@@ -325,6 +331,14 @@ struct Version {
 
 namespace Kernel {
 namespace ExecutionEnv {
+enum ThreadSchedulingMode : uint8_t {
+    ThreadSchedulingModeUnknown,
+    ThreadSchedulingModeAgeBased,
+    ThreadSchedulingModeRoundRobin,
+    ThreadSchedulingModeRoundRobinStall,
+    ThreadSchedulingModeMax
+};
+
 using ActualKernelStartOffsetT = int32_t;
 using BarrierCountT = int32_t;
 using DisableMidThreadPreemptionT = bool;
@@ -350,6 +364,7 @@ using SimdSizeT = int32_t;
 using SlmSizeT = int32_t;
 using SubgroupIndependentForwardProgressT = bool;
 using WorkgroupWalkOrderDimensionsT = int32_t[3];
+using ThreadSchedulingModeT = ThreadSchedulingMode;
 
 namespace Defaults {
 static constexpr BarrierCountT barrierCount = 0;
@@ -374,6 +389,7 @@ static constexpr RequireDisableEUFusionT requireDisableEUFusion = false;
 static constexpr SlmSizeT slmSize = 0;
 static constexpr SubgroupIndependentForwardProgressT subgroupIndependentForwardProgress = false;
 static constexpr WorkgroupWalkOrderDimensionsT workgroupWalkOrderDimensions = {0, 1, 2};
+static constexpr ThreadSchedulingModeT threadSchedulingMode = ThreadSchedulingModeUnknown;
 } // namespace Defaults
 
 static constexpr ConstStringRef required[] = {
@@ -402,6 +418,7 @@ struct ExecutionEnvBaseT {
     SlmSizeT slmSize = Defaults::slmSize;
     SubgroupIndependentForwardProgressT subgroupIndependentForwardProgress = Defaults::subgroupIndependentForwardProgress;
     WorkgroupWalkOrderDimensionsT workgroupWalkOrderDimensions{Defaults::workgroupWalkOrderDimensions[0], Defaults::workgroupWalkOrderDimensions[1], Defaults::workgroupWalkOrderDimensions[2]};
+    ThreadSchedulingModeT threadSchedulingMode = Defaults::threadSchedulingMode;
 };
 
 struct ExperimentalPropertiesBaseT {
diff --git a/shared/source/device_binary_format/elf/zeinfo_enum_lookup.h b/shared/source/device_binary_format/elf/zeinfo_enum_lookup.h
diff --git a/shared/source/device_binary_format/zebin_decoder.cpp b/shared/source/device_binary_format/zebin_decoder.cpp
diff --git a/shared/source/device_binary_format/zebin_decoder.h b/shared/source/device_binary_format/zebin_decoder.h
diff --git a/shared/source/kernel/dispatch_kernel_encoder_interface.h b/shared/source/kernel/dispatch_kernel_encoder_interface.h
diff --git a/shared/source/kernel/kernel_descriptor.h b/shared/source/kernel/kernel_descriptor.h
diff --git a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
diff --git a/shared/test/unit_test/mocks/mock_dispatch_kernel_encoder_interface.h b/shared/test/unit_test/mocks/mock_dispatch_kernel_encoder_interface.h

Original file line number	Diff line number	Diff line change
`@@ -2285,7 +2285,7 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel`
`2285`	`2285`	`if (!containsAnyKernel) {`
`2286`	`2286`	`requiredStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, disableOverdispatch, -1, hwInfo);`
`2287`	`2287`	`finalStreamState = requiredStreamState;`
`2288`		`- requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernel.getSchedulingHintExp(), device->getDevicePreemptionMode(), hwInfo);`
	`2288`	`+ requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo);`
`2289`	`2289`	`containsAnyKernel = true;`
`2290`	`2290`	`}`
`2291`	`2291`
`@@ -2298,7 +2298,7 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel`
`2298`	`2298`	`commandsToPatch.push_back({pVfeStateAddress, pVfeState, CommandToPatch::FrontEndState});`
`2299`	`2299`	`}`
`2300`	`2300`
`2301`		`- finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernel.getSchedulingHintExp(), device->getDevicePreemptionMode(), hwInfo);`
	`2301`	`+ finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo);`
`2302`	`2302`
`2303`	`2303`	`if (finalStreamState.stateComputeMode.isDirty() && !getLogicalStateHelper()) {`
`2304`	`2304`	`bool isRcs = (this->engineGroupType == NEO::EngineGroupType::RenderCompute);`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,6 @@ struct KernelImp : Kernel {`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`ze_result_t setSchedulingHintExp(ze_scheduling_hint_exp_desc_t *pHint) override;`
`163`		`- int32_t getSchedulingHintExp() const override;`
`164`	`163`
`165`	`164`	`NEO::ImplicitArgs *getImplicitArgs() const override { return pImplicitArgs.get(); }`
`166`	`165`
`@@ -222,7 +221,6 @@ struct KernelImp : Kernel {`
`222`	`221`
`223`	`222`	`bool kernelHasIndirectAccess = true;`
`224`	`223`
`225`		`- int32_t schedulingHintExpFlag = NEO::ThreadArbitrationPolicy::NotPresent;`
`226`	`224`	`std::unique_ptr<NEO::ImplicitArgs> pImplicitArgs;`
`227`	`225`
`228`	`226`	`std::unique_ptr<KernelExt> pExtension;`
Original file line number	Diff line number	Diff line change
`@@ -318,8 +318,7 @@ HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhe`
`318`	`318`	`&newThreadArbitrationPolicy // const void *param_value`
`319`	`319`	`);`
`320`	`320`	`EXPECT_EQ(CL_SUCCESS, retVal);`
`321`		`- EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->threadArbitrationPolicy);`
`322`		`- EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->getThreadArbitrationPolicy());`
	`321`	`+ EXPECT_EQ(getNewKernelArbitrationPolicy(newThreadArbitrationPolicy), pMockKernel->getDescriptor().kernelAttributes.threadArbitrationPolicy);`
`323`	`322`	`}`
`324`	`323`
`325`	`324`	`HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhenNotSupportedAndSettingAdditionalKernelInfoThenClInvalidDeviceIsReturned) {`