Update StreamProperties

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>

Author: BartoszDunajski

shared/source/command_stream/definitions/stream_properties.inl

@@ -12,6 +12,8 @@ namespace NEO {
 struct StateComputeModeProperties {
     StreamProperty isCoherencyRequired{};
     StreamProperty largeGrfMode{};
+    StreamProperty zPassAsyncComputeThreadLimit{};
+    StreamProperty pixelAsyncComputeThreadLimit{};
 
     void setProperties(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy);
     void setProperties(const StateComputeModeProperties &properties);

shared/source/command_stream/stream_properties.cpp

@@ -19,22 +19,39 @@ void StateComputeModeProperties::setProperties(bool requiresCoherency, uint32_t
 
     int32_t largeGrfMode = (numGrfRequired == GrfConfig::LargeGrfNumber ? 1 : 0);
     this->largeGrfMode.set(largeGrfMode);
+
+    int32_t zPassAsyncComputeThreadLimit = -1;
+    if (DebugManager.flags.ForceZPassAsyncComputeThreadLimit.get() != -1) {
+        zPassAsyncComputeThreadLimit = DebugManager.flags.ForceZPassAsyncComputeThreadLimit.get();
+    }
+    this->zPassAsyncComputeThreadLimit.set(zPassAsyncComputeThreadLimit);
+
+    int32_t pixelAsyncComputeThreadLimit = -1;
+    if (DebugManager.flags.ForcePixelAsyncComputeThreadLimit.get() != -1) {
+        pixelAsyncComputeThreadLimit = DebugManager.flags.ForcePixelAsyncComputeThreadLimit.get();
+    }
+    this->pixelAsyncComputeThreadLimit.set(pixelAsyncComputeThreadLimit);
 }
 
 void StateComputeModeProperties::setProperties(const StateComputeModeProperties &properties) {
     clearIsDirty();
 
     isCoherencyRequired.set(properties.isCoherencyRequired.value);
     largeGrfMode.set(properties.largeGrfMode.value);
+    zPassAsyncComputeThreadLimit.set(properties.zPassAsyncComputeThreadLimit.value);
+    pixelAsyncComputeThreadLimit.set(properties.pixelAsyncComputeThreadLimit.value);
 }
 
 bool StateComputeModeProperties::isDirty() {
-    return isCoherencyRequired.isDirty || largeGrfMode.isDirty;
+    return isCoherencyRequired.isDirty || largeGrfMode.isDirty || zPassAsyncComputeThreadLimit.isDirty ||
+           pixelAsyncComputeThreadLimit.isDirty;
 }
 
 void StateComputeModeProperties::clearIsDirty() {
     isCoherencyRequired.isDirty = false;
     largeGrfMode.isDirty = false;
+    zPassAsyncComputeThreadLimit.isDirty = false;
+    pixelAsyncComputeThreadLimit.isDirty = false;
 }
 
 void FrontEndProperties::setProperties(bool isCooperativeKernel, bool disableOverdispatch, int32_t engineInstancedDevice,

shared/test/unit_test/command_stream/stream_properties_tests.cpp

@@ -17,6 +17,8 @@ std::vector<StreamProperty *> getAllStateComputeModeProperties(StateComputeModeP
     std::vector<StreamProperty *> allProperties;
     allProperties.push_back(&properties.isCoherencyRequired);
     allProperties.push_back(&properties.largeGrfMode);
+    allProperties.push_back(&properties.zPassAsyncComputeThreadLimit);
+    allProperties.push_back(&properties.pixelAsyncComputeThreadLimit);
     return allProperties;
 }
 

shared/test/unit_test/command_stream/stream_properties_tests_common.cpp

@@ -42,14 +42,29 @@ TEST(StreamPropertiesTests, whenPropertyValueIsChangedThenProperStateIsSet) {
 }
 
 TEST(StreamPropertiesTests, whenSettingStateComputeModePropertiesThenCorrectValuesAreSet) {
+    DebugManagerStateRestore restorer;
     StreamProperties properties;
     for (auto requiresCoherency : ::testing::Bool()) {
         for (auto largeGrf : ::testing::Bool()) {
             properties.stateComputeMode.setProperties(requiresCoherency, largeGrf ? 256 : 128, 0u);
             EXPECT_EQ(largeGrf, properties.stateComputeMode.largeGrfMode.value);
             EXPECT_EQ(requiresCoherency, properties.stateComputeMode.isCoherencyRequired.value);
+            EXPECT_EQ(-1, properties.stateComputeMode.zPassAsyncComputeThreadLimit.value);
+            EXPECT_EQ(-1, properties.stateComputeMode.pixelAsyncComputeThreadLimit.value);
         }
     }
+
+    for (auto forceZPassAsyncComputeThreadLimit : ::testing::Bool()) {
+        DebugManager.flags.ForceZPassAsyncComputeThreadLimit.set(forceZPassAsyncComputeThreadLimit);
+        properties.stateComputeMode.setProperties(false, 0u, 0u);
+        EXPECT_EQ(forceZPassAsyncComputeThreadLimit, properties.stateComputeMode.zPassAsyncComputeThreadLimit.value);
+    }
+
+    for (auto forcePixelAsyncComputeThreadLimit : ::testing::Bool()) {
+        DebugManager.flags.ForcePixelAsyncComputeThreadLimit.set(forcePixelAsyncComputeThreadLimit);
+        properties.stateComputeMode.setProperties(false, 0u, 0u);
+        EXPECT_EQ(forcePixelAsyncComputeThreadLimit, properties.stateComputeMode.pixelAsyncComputeThreadLimit.value);
+    }
 }
 
 template <typename PropertiesT>