Enable blitterOperationsSupported on DG1

JablonskiMateusz · Compute-Runtime-Automation · commit 3a2b018eb697 · 2021-10-28T14:16:19.000+02:00
Signed-off-by: Mateusz Jablonski &lt;mateusz.jablonski@intel.com&gt;
diff --git a/opencl/source/command_queue/command_queue.cpp b/opencl/source/command_queue/command_queue.cpp
@@ -72,11 +72,12 @@ CommandQueue::CommandQueue(Context *context, ClDevice *device, const cl_queue_pr
     if (device) {
         auto &hwInfo = device->getHardwareInfo();
         auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
+        auto hwInfoConfig = HwInfoConfig::get(hwInfo.platform.eProductFamily);
 
         gpgpuEngine = &device->getDefaultEngine();
         UNRECOVERABLE_IF(gpgpuEngine->getEngineType() >= aub_stream::EngineType::NUM_ENGINES);
 
-        bool bcsAllowed = hwInfo.capabilityTable.blitterOperationsSupported &&
+        bool bcsAllowed = hwInfoConfig->isBlitterFullySupported(hwInfo) &&
                           hwHelper.isSubDeviceEngineSupported(hwInfo, device->getDeviceBitfield(), aub_stream::EngineType::ENGINE_BCS);
 
         if (bcsAllowed || gpgpuEngine->commandStreamReceiver->peekTimestampPacketWriteEnabled()) {
diff --git a/opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp b/opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp
@@ -89,6 +89,9 @@ struct BlitEnqueueTests : public ::testing::Test {
         bool createBcsEngine = !capabilityTable.blitterOperationsSupported;
         capabilityTable.blitterOperationsSupported = true;
 
+        if (!HwInfoConfig::get(defaultHwInfo->platform.eProductFamily)->isBlitterFullySupported(device->getHardwareInfo())) {
+            GTEST_SKIP();
+        }
         if (createBcsEngine) {
             auto &engine = device->getEngine(getChosenEngineType(device->getHardwareInfo()), EngineUsage::LowPriority);
             bcsOsContext.reset(OsContext::create(nullptr, 1,
diff --git a/opencl/test/unit_test/command_queue/command_queue_hw_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_hw_tests.cpp
@@ -1506,7 +1506,7 @@ struct CommandQueueHwBlitTest : ClDeviceFixture, ContextFixture, CommandQueueHwF
     using ContextFixture::SetUp;
 
     void SetUp() override {
-        REQUIRE_BLITTER_OR_SKIP(defaultHwInfo.get());
+        REQUIRE_FULL_BLITTER_OR_SKIP(defaultHwInfo.get());
 
         DebugManager.flags.EnableBlitterOperationsSupport.set(1);
         DebugManager.flags.EnableTimestampPacket.set(1);
diff --git a/opencl/test/unit_test/command_queue/command_queue_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_tests.cpp
@@ -250,7 +250,7 @@ TEST(CommandQueue, givenDeviceWithSubDevicesSupportingBlitOperationsWhenQueueIsC
     DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
     HardwareInfo hwInfo = *defaultHwInfo;
     hwInfo.capabilityTable.blitterOperationsSupported = true;
-    REQUIRE_BLITTER_OR_SKIP(&hwInfo);
+    REQUIRE_FULL_BLITTER_OR_SKIP(&hwInfo);
 
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
     EXPECT_EQ(2u, device->getNumGenericSubDevices());
@@ -1193,7 +1193,7 @@ TEST(CommandQueue, givenBlitterOperationsSupportedWhenCreatingQueueThenTimestamp
 
     MockContext context{};
     HardwareInfo *hwInfo = context.getDevice(0)->getRootDeviceEnvironment().getMutableHardwareInfo();
-    if (!HwInfoConfig::get(defaultHwInfo->platform.eProductFamily)->obtainBlitterPreference(*defaultHwInfo.get())) {
+    if (!HwInfoConfig::get(defaultHwInfo->platform.eProductFamily)->isBlitterFullySupported(*defaultHwInfo.get())) {
         GTEST_SKIP();
     }
 
diff --git a/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp
@@ -267,7 +267,7 @@ HWTEST_F(DispatchFlagsBlitTests, givenBlitEnqueueWhenDispatchingCommandsWithoutK
     DebugManager.flags.EnableTimestampPacket.set(1);
 
     SetUpImpl<CsrType>();
-    REQUIRE_BLITTER_OR_SKIP(&device->getHardwareInfo());
+    REQUIRE_FULL_BLITTER_OR_SKIP(&device->getHardwareInfo());
 
     auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context.get(), device.get(), nullptr);
     auto mockCsr = static_cast<CsrType *>(&mockCmdQ->getGpgpuCommandStreamReceiver());
@@ -312,7 +312,7 @@ HWTEST_F(DispatchFlagsBlitTests, givenN1EnabledWhenDispatchingWithoutKernelThenA
     DebugManager.flags.ForceGpgpuSubmissionForBcsEnqueue.set(1);
 
     SetUpImpl<CsrType>();
-    REQUIRE_BLITTER_OR_SKIP(&device->getHardwareInfo());
+    REQUIRE_FULL_BLITTER_OR_SKIP(&device->getHardwareInfo());
 
     auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context.get(), device.get(), nullptr);
     auto mockCsr = static_cast<CsrType *>(&mockCmdQ->getGpgpuCommandStreamReceiver());
diff --git a/opencl/test/unit_test/command_queue/enqueue_copy_image_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_copy_image_tests.cpp
@@ -218,6 +218,7 @@ HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImage
     auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
     const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
     hwInfo->capabilityTable.blitterOperationsSupported = true;
+
     size_t srcOrigin[] = {0, 0, 0};
     size_t dstOrigin[] = {0, 0, 0};
 
@@ -240,7 +241,7 @@ HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImage
     {
         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
-        EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);
+        EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);
     }
     {
         DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
diff --git a/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
@@ -933,7 +933,7 @@ HWTEST_F(EnqueueAuxKernelTests, givenDebugVariableDisablingBuiltinTranslationWhe
 
     auto hwInfo = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex]->getMutableHardwareInfo();
     hwInfo->capabilityTable.blitterOperationsSupported = true;
-    REQUIRE_BLITTER_OR_SKIP(hwInfo);
+    REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
 
     MockKernelWithInternals mockKernel(*pClDevice, context);
     MyCmdQ<FamilyType> cmdQ(context, pClDevice);
diff --git a/opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp
@@ -865,7 +865,7 @@ HWTEST_F(EnqueueReadImageTest, givenDeviceWithBlitterSupportWhenEnqueueReadImage
     auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
     const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
     hwInfo->capabilityTable.blitterOperationsSupported = true;
-    REQUIRE_BLITTER_OR_SKIP(hwInfo);
+    REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
     size_t origin[] = {0, 0, 0};
     auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
     std::unique_ptr<Image> image(Image2dHelper<>::create(context));
diff --git a/opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp
@@ -228,7 +228,7 @@ HWTEST_F(EnqueueWriteImageTest, givenDeviceWithBlitterSupportWhenEnqueueWriteIma
     {
         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
         EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
-        EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);
+        EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);
     }
     {
         DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_4_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_4_tests.cpp
@@ -503,7 +503,7 @@ HWTEST_F(CrossDeviceDependenciesTests, givenWaitListWithEventBlockedByUserEventW
 
     for (auto &rootDeviceEnvironment : deviceFactory->rootDevices[0]->getExecutionEnvironment()->rootDeviceEnvironments) {
         rootDeviceEnvironment->getMutableHardwareInfo()->capabilityTable.blitterOperationsSupported = true;
-        REQUIRE_BLITTER_OR_SKIP(rootDeviceEnvironment->getHardwareInfo());
+        REQUIRE_FULL_BLITTER_OR_SKIP(rootDeviceEnvironment->getHardwareInfo());
     }
 
     auto clCmdQ1 = clCreateCommandQueue(context.get(), deviceFactory->rootDevices[1], {}, nullptr);
diff --git a/opencl/test/unit_test/event/event_tests.cpp b/opencl/test/unit_test/event/event_tests.cpp
@@ -137,7 +137,7 @@ TEST(Event, WhenGettingEventInfoThenCqIsReturned) {
 TEST(Event, givenBcsCsrSetInEventWhenPeekingBcsTaskCountThenReturnCorrectTaskCount) {
     HardwareInfo hwInfo = *defaultHwInfo;
     hwInfo.capabilityTable.blitterOperationsSupported = true;
-    REQUIRE_BLITTER_OR_SKIP(&hwInfo);
+    REQUIRE_FULL_BLITTER_OR_SKIP(&hwInfo);
 
     auto device = ReleaseableObjectPtr<MockClDevice>{
         new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockAlignedMallocManagerDevice>(&hwInfo)}};
diff --git a/opencl/test/unit_test/gen12lp/dg1/test_hw_info_config_dg1.cpp b/opencl/test/unit_test/gen12lp/dg1/test_hw_info_config_dg1.cpp
@@ -107,9 +107,26 @@ DG1TEST_F(Dg1HwInfo, whenPlatformIsDg1ThenExpectSvmIsSet) {
     EXPECT_TRUE(hardwareInfo.capabilityTable.ftrSvm);
 }
 
-DG1TEST_F(Dg1HwInfo, givenDg1WhenObtainingBlitterPreferenceThenReturnFalse) {
+DG1TEST_F(Dg1HwInfo, givenDg1WhenObtainingBlitterPreferenceThenReturnTrue) {
     const auto &hwInfoConfig = *HwInfoConfig::get(defaultHwInfo->platform.eProductFamily);
     const auto &hardwareInfo = DG1::hwInfo;
 
-    EXPECT_FALSE(hwInfoConfig.obtainBlitterPreference(hardwareInfo));
+    EXPECT_TRUE(hwInfoConfig.obtainBlitterPreference(hardwareInfo));
 }
+
+DG1TEST_F(Dg1HwInfo, givenDg1WhenObtainingFullBlitterSupportThenReturnFalse) {
+    const auto &hwInfoConfig = *HwInfoConfig::get(defaultHwInfo->platform.eProductFamily);
+    const auto &hardwareInfo = DG1::hwInfo;
+
+    EXPECT_FALSE(hwInfoConfig.isBlitterFullySupported(hardwareInfo));
+}
+
+DG1TEST_F(Dg1HwInfo, whenConfigureHwInfoThenBlitterSupportIsEnabled) {
+    auto &hwInfoConfig = *HwInfoConfig::get(defaultHwInfo->platform.eProductFamily);
+    auto hardwareInfo = *defaultHwInfo;
+
+    hardwareInfo.capabilityTable.blitterOperationsSupported = false;
+    hwInfoConfig.configureHardwareCustom(&hardwareInfo, nullptr);
+
+    EXPECT_TRUE(hardwareInfo.capabilityTable.blitterOperationsSupported);
+}
diff --git a/opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp b/opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp
@@ -104,6 +104,9 @@ struct BcsBufferTests : public ::testing::Test {
         bool createBcsEngine = !capabilityTable.blitterOperationsSupported;
         capabilityTable.blitterOperationsSupported = true;
 
+        if (!HwInfoConfig::get(defaultHwInfo->platform.eProductFamily)->isBlitterFullySupported(device->getHardwareInfo())) {
+            GTEST_SKIP();
+        }
         if (createBcsEngine) {
             auto &engine = device->getEngine(getChosenEngineType(device->getHardwareInfo()), EngineUsage::LowPriority);
             bcsOsContext.reset(OsContext::create(nullptr, 1, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::Regular}, device->getDeviceBitfield())));
@@ -1202,6 +1205,9 @@ struct BcsSvmTests : public BcsBufferTests {
         }
         REQUIRE_SVM_OR_SKIP(defaultHwInfo);
         BcsBufferTests::SetUpT<FamilyType>();
+        if (IsSkipped()) {
+            GTEST_SKIP();
+        }
 
         deviceMemAlloc = clDeviceMemAllocINTEL(bcsMockContext.get(), device.get(), nullptr, allocSize, 0u, &retVal);
         ASSERT_NE(nullptr, deviceMemAlloc);
diff --git a/shared/source/gen12lp/os_agnostic_hw_info_config_dg1.inl b/shared/source/gen12lp/os_agnostic_hw_info_config_dg1.inl
@@ -51,3 +51,8 @@ template <>
 bool HwInfoConfigHw<gfxProduct>::isStorageInfoAdjustmentRequired() const {
     return true;
 }
+
+template <>
+bool HwInfoConfigHw<gfxProduct>::obtainBlitterPreference(const HardwareInfo &hwInfo) const {
+    return true;
+}
diff --git a/shared/source/os_interface/hw_info_config.h b/shared/source/os_interface/hw_info_config.h
@@ -48,6 +48,7 @@ class HwInfoConfig {
     virtual uint32_t getMaxThreadsForWorkgroup(const HardwareInfo &hwInfo, uint32_t maxNumEUsPerSubSlice) const = 0;
     virtual void setForceNonCoherent(void *const commandPtr, const StateComputeModeProperties &properties) = 0;
     virtual bool obtainBlitterPreference(const HardwareInfo &hwInfo) const = 0;
+    virtual bool isBlitterFullySupported(const HardwareInfo &hwInfo) const = 0;
     virtual bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const = 0;
     virtual uint32_t getHwRevIdFromStepping(uint32_t stepping, const HardwareInfo &hwInfo) const = 0;
     virtual uint32_t getSteppingFromHwRevId(const HardwareInfo &hwInfo) const = 0;
@@ -109,6 +110,7 @@ class HwInfoConfigHw : public HwInfoConfig {
     uint32_t getMaxThreadsForWorkgroup(const HardwareInfo &hwInfo, uint32_t maxNumEUsPerSubSlice) const override;
     void setForceNonCoherent(void *const commandPtr, const StateComputeModeProperties &properties) override;
     bool obtainBlitterPreference(const HardwareInfo &hwInfo) const override;
+    bool isBlitterFullySupported(const HardwareInfo &hwInfo) const override;
     bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const override;
     uint32_t getHwRevIdFromStepping(uint32_t stepping, const HardwareInfo &hwInfo) const override;
     uint32_t getSteppingFromHwRevId(const HardwareInfo &hwInfo) const override;
diff --git a/shared/source/os_interface/hw_info_config_bdw_and_later.inl b/shared/source/os_interface/hw_info_config_bdw_and_later.inl
@@ -35,6 +35,11 @@ bool HwInfoConfigHw<gfxProduct>::obtainBlitterPreference(const HardwareInfo &hwI
     return false;
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+bool HwInfoConfigHw<gfxProduct>::isBlitterFullySupported(const HardwareInfo &hwInfo) const {
+    return false;
+}
+
 template <PRODUCT_FAMILY gfxProduct>
 bool HwInfoConfigHw<gfxProduct>::isNewResidencyModelSupported() const {
     return false;
diff --git a/shared/source/os_interface/hw_info_config_xehp_and_later.inl b/shared/source/os_interface/hw_info_config_xehp_and_later.inl
@@ -37,6 +37,11 @@ bool HwInfoConfigHw<gfxProduct>::obtainBlitterPreference(const HardwareInfo &hwI
     return true;
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+bool HwInfoConfigHw<gfxProduct>::isBlitterFullySupported(const HardwareInfo &hwInfo) const {
+    return hwInfo.capabilityTable.blitterOperationsSupported;
+}
+
 template <PRODUCT_FAMILY gfxProduct>
 bool HwInfoConfigHw<gfxProduct>::isNewResidencyModelSupported() const {
     return true;
diff --git a/shared/test/common/mocks/mock_hw_info_config.cpp b/shared/test/common/mocks/mock_hw_info_config.cpp
@@ -86,6 +86,11 @@ bool HwInfoConfigHw<IGFX_UNKNOWN>::obtainBlitterPreference(const HardwareInfo &h
     return false;
 }
 
+template <>
+bool HwInfoConfigHw<IGFX_UNKNOWN>::isBlitterFullySupported(const HardwareInfo &hwInfo) const {
+    return false;
+}
+
 template <>
 bool HwInfoConfigHw<IGFX_UNKNOWN>::isPageTableManagerSupported(const HardwareInfo &hwInfo) const {
     return false;
diff --git a/shared/test/common/test_macros/test_checks_shared.cpp b/shared/test/common/test_macros/test_checks_shared.cpp
@@ -9,6 +9,7 @@
 
 #include "shared/source/device/device.h"
 #include "shared/source/helpers/hw_helper.h"
+#include "shared/source/os_interface/hw_info_config.h"
 #include "shared/test/common/helpers/default_hw_info.h"
 
 #include "test.h"
@@ -25,6 +26,16 @@ bool TestChecks::supportsBlitter(const HardwareInfo *pHardwareInfo) {
     return false;
 }
 
+bool TestChecks::fullySupportsBlitter(const HardwareInfo *pHardwareInfo) {
+    auto engines = HwHelper::get(::renderCoreFamily).getGpgpuEngineInstances(*pHardwareInfo);
+    for (const auto &engine : engines) {
+        if (engine.first == aub_stream::EngineType::ENGINE_BCS) {
+            return HwInfoConfig::get(pHardwareInfo->platform.eProductFamily)->isBlitterFullySupported(*pHardwareInfo);
+        }
+    }
+    return false;
+}
+
 bool TestChecks::supportsImages(const HardwareInfo &hardwareInfo) {
     return hardwareInfo.capabilityTable.supportsImages;
 }
diff --git a/shared/test/common/test_macros/test_checks_shared.h b/shared/test/common/test_macros/test_checks_shared.h
@@ -18,6 +18,7 @@ struct HardwareInfo;
 
 namespace TestChecks {
 bool supportsBlitter(const HardwareInfo *pHardwareInfo);
+bool fullySupportsBlitter(const HardwareInfo *pHardwareInfo);
 bool supportsImages(const HardwareInfo &hardwareInfo);
 bool supportsImages(const std::unique_ptr<HardwareInfo> &pHardwareInfo);
 bool supportsSvm(const HardwareInfo *pHardwareInfo);
@@ -47,6 +48,11 @@ bool supportsSvm(const Device *pDevice);
         GTEST_SKIP();                                       \
     }
 
+#define REQUIRE_FULL_BLITTER_OR_SKIP(param)                      \
+    if (NEO::TestChecks::fullySupportsBlitter(param) == false) { \
+        GTEST_SKIP();                                            \
+    }
+
 #define REQUIRE_IMAGES_OR_SKIP(param)                      \
     if (NEO::TestChecks::supportsImages(param) == false) { \
         GTEST_SKIP();                                      \

Original file line number	Diff line number	Diff line change
`@@ -218,6 +218,7 @@ HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImage`
`218`	`218`	`auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();`
`219`	`219`	`const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);`
`220`	`220`	`hwInfo->capabilityTable.blitterOperationsSupported = true;`
	`221`	`+`
`221`	`222`	`size_t srcOrigin[] = {0, 0, 0};`
`222`	`223`	`size_t dstOrigin[] = {0, 0, 0};`
`223`	`224`
`@@ -240,7 +241,7 @@ HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImage`
`240`	`241`	`{`
`241`	`242`	`size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};`
`242`	`243`	`EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);`
`243`		`- EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);`
	`244`	`+ EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);`
`244`	`245`	`}`
`245`	`246`	`{`
`246`	`247`	`DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ HWTEST_F(EnqueueWriteImageTest, givenDeviceWithBlitterSupportWhenEnqueueWriteIma`
`228`	`228`	`{`
`229`	`229`	`size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};`
`230`	`230`	`EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);`
`231`		`- EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);`
	`231`	`+ EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);`
`232`	`232`	`}`
`233`	`233`	`{`
`234`	`234`	`DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);`
Original file line number	Diff line number	Diff line change
`@@ -503,7 +503,7 @@ HWTEST_F(CrossDeviceDependenciesTests, givenWaitListWithEventBlockedByUserEventW`
`503`	`503`
`504`	`504`	`for (auto &rootDeviceEnvironment : deviceFactory->rootDevices[0]->getExecutionEnvironment()->rootDeviceEnvironments) {`
`505`	`505`	`rootDeviceEnvironment->getMutableHardwareInfo()->capabilityTable.blitterOperationsSupported = true;`
`506`		`- REQUIRE_BLITTER_OR_SKIP(rootDeviceEnvironment->getHardwareInfo());`
	`506`	`+ REQUIRE_FULL_BLITTER_OR_SKIP(rootDeviceEnvironment->getHardwareInfo());`
`507`	`507`	`}`
`508`	`508`
`509`	`509`	`auto clCmdQ1 = clCreateCommandQueue(context.get(), deviceFactory->rootDevices[1], {}, nullptr);`