performance(ocl): add bcsEngineCount to cmdq

Related-To: NEO-8155

Signed-off-by: Dominik Dabek <dominik.dabek@intel.com>

opencl/source/command_queue/command_queue.cpp

@@ -1269,7 +1269,8 @@ WaitStatus CommandQueue::waitForAllEngines(bool blockedQueue, PrintfHandler *pri
     }
 
     StackVec<CopyEngineState, bcsInfoMaskSize> activeBcsStates{};
-    for (CopyEngineState &state : this->bcsStates) {
+    for (auto currentBcsIndex = 0u; currentBcsIndex < bcsEngineCount; currentBcsIndex++) {
+        CopyEngineState &state = this->bcsStates[currentBcsIndex];
         if (state.isValid()) {
             activeBcsStates.push_back(state);
         }
@@ -1315,7 +1316,7 @@ void CommandQueue::setupBarrierTimestampForBcsEngines(aub_stream::EngineType eng
 
     if (isOOQEnabled()) {
         // Barrier node will be signalled on gpgpuCsr. Save it for later use on blitters.
-        for (auto currentBcsIndex = 0u; currentBcsIndex < bcsTimestampPacketContainers.size(); currentBcsIndex++) {
+        for (auto currentBcsIndex = 0u; currentBcsIndex < bcsEngineCount; currentBcsIndex++) {
             const auto currentBcsEngineType = EngineHelpers::mapBcsIndexToEngineType(currentBcsIndex, true);
             if (currentBcsEngineType == engineType) {
                 // Node is already added to barrierNodes for this engine, no need to save it.
@@ -1351,7 +1352,8 @@ void CommandQueue::setLastBcsPacket(aub_stream::EngineType bcsEngineType) {
 }
 
 void CommandQueue::fillCsrDependenciesWithLastBcsPackets(CsrDependencies &csrDeps) {
-    for (BcsTimestampPacketContainers &bcsContainers : bcsTimestampPacketContainers) {
+    for (auto currentBcsIndex = 0u; currentBcsIndex < bcsEngineCount; currentBcsIndex++) {
+        BcsTimestampPacketContainers &bcsContainers = bcsTimestampPacketContainers[currentBcsIndex];
         if (bcsContainers.lastSignalledPacket.peekNodes().empty()) {
             continue;
         }
@@ -1360,7 +1362,8 @@ void CommandQueue::fillCsrDependenciesWithLastBcsPackets(CsrDependencies &csrDep
 }
 
 void CommandQueue::clearLastBcsPackets() {
-    for (BcsTimestampPacketContainers &bcsContainers : bcsTimestampPacketContainers) {
+    for (auto currentBcsIndex = 0u; currentBcsIndex < bcsEngineCount; currentBcsIndex++) {
+        BcsTimestampPacketContainers &bcsContainers = bcsTimestampPacketContainers[currentBcsIndex];
         bcsContainers.lastSignalledPacket.moveNodesToNewContainer(*deferredTimestampPackets);
     }
 }

opencl/source/command_queue/command_queue.h

@@ -426,6 +426,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
     mutable EngineControl *gpgpuEngine = nullptr;
     std::array<EngineControl *, bcsInfoMaskSize> bcsEngines = {};
     std::optional<aub_stream::EngineType> bcsQueueEngineType{};
+    size_t bcsEngineCount = bcsInfoMaskSize;
 
     cl_command_queue_properties commandQueueProperties = 0;
     std::vector<uint64_t> propertiesVector;

opencl/source/command_queue/command_queue_hw.h

@@ -93,6 +93,8 @@ class CommandQueueHw : public CommandQueue {
                 engine->commandStreamReceiver->initDirectSubmission();
             }
         }
+
+        bcsEngineCount = GfxFamily::bcsEngineCount;
     }
 
     static CommandQueue *create(Context *context,

opencl/test/unit_test/api/cl_create_command_queue_tests.inl

@@ -10,6 +10,7 @@
 
 #include "opencl/source/context/context.h"
 #include "opencl/test/unit_test/mocks/mock_cl_device.h"
+#include "opencl/test/unit_test/mocks/mock_command_queue.h"
 
 #include "cl_api_tests.h"
 
@@ -19,7 +20,7 @@ using ClCreateCommandQueueTest = ApiTests;
 
 namespace ULT {
 
-TEST_F(ClCreateCommandQueueTest, GivenCorrectParametersWhenCreatingCommandQueueThenCommandQueueIsCreatedAndSuccessIsReturned) {
+TEST_F(ClCreateCommandQueueTest, givenCorrectParametersWhenCreatingCommandQueueThenCommandQueueIsCreatedAndSuccessIsReturned) {
     cl_command_queue cmdQ = nullptr;
     cl_queue_properties properties = 0;
 
@@ -32,24 +33,24 @@ TEST_F(ClCreateCommandQueueTest, GivenCorrectParametersWhenCreatingCommandQueueT
     EXPECT_EQ(CL_SUCCESS, retVal);
 }
 
-TEST_F(ClCreateCommandQueueTest, GivenNullContextWhenCreatingCommandQueueThenInvalidContextErrorIsReturned) {
+TEST_F(ClCreateCommandQueueTest, givenNullContextWhenCreatingCommandQueueThenInvalidContextErrorIsReturned) {
     clCreateCommandQueue(nullptr, testedClDevice, 0, &retVal);
     EXPECT_EQ(CL_INVALID_CONTEXT, retVal);
 }
 
-TEST_F(ClCreateCommandQueueTest, GivenNullDeviceWhenCreatingCommandQueueThenInvalidDeviceErrorIsReturned) {
+TEST_F(ClCreateCommandQueueTest, givenNullDeviceWhenCreatingCommandQueueThenInvalidDeviceErrorIsReturned) {
     clCreateCommandQueue(pContext, nullptr, 0, &retVal);
     EXPECT_EQ(CL_INVALID_DEVICE, retVal);
 }
 
-TEST_F(ClCreateCommandQueueTest, GivenDeviceNotAssociatedWithContextWhenCreatingCommandQueueThenInvalidDeviceErrorIsReturned) {
+TEST_F(ClCreateCommandQueueTest, givenDeviceNotAssociatedWithContextWhenCreatingCommandQueueThenInvalidDeviceErrorIsReturned) {
     UltClDeviceFactory deviceFactory{1, 0};
     EXPECT_FALSE(pContext->isDeviceAssociated(*deviceFactory.rootDevices[0]));
     clCreateCommandQueue(pContext, deviceFactory.rootDevices[0], 0, &retVal);
     EXPECT_EQ(CL_INVALID_DEVICE, retVal);
 }
 
-TEST_F(ClCreateCommandQueueTest, GivenInvalidPropertiesWhenCreatingCommandQueueThenInvalidValueErrorIsReturned) {
+TEST_F(ClCreateCommandQueueTest, givenInvalidPropertiesWhenCreatingCommandQueueThenInvalidValueErrorIsReturned) {
     cl_command_queue cmdQ = nullptr;
     cl_queue_properties properties = 0xf0000;
 
@@ -59,7 +60,7 @@ TEST_F(ClCreateCommandQueueTest, GivenInvalidPropertiesWhenCreatingCommandQueueT
     ASSERT_EQ(CL_INVALID_VALUE, retVal);
 }
 
-TEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenQueueIsSucesfullyCreated) {
+TEST_F(ClCreateCommandQueueTest, givenOoqParametersWhenQueueIsCreatedThenQueueIsSucesfullyCreated) {
     cl_int retVal = CL_SUCCESS;
     cl_queue_properties ooq = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
     auto cmdq = clCreateCommandQueue(pContext, testedClDevice, ooq, &retVal);
@@ -68,7 +69,7 @@ TEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenQueueIs
     retVal = clReleaseCommandQueue(cmdq);
 }
 
-HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverSwitchesToBatchingMode) {
+HWTEST_F(ClCreateCommandQueueTest, givenOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverSwitchesToBatchingMode) {
     using BaseType = typename CommandQueue::BaseType;
     cl_int retVal = CL_SUCCESS;
     cl_queue_properties ooq = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
@@ -83,7 +84,7 @@ HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenComma
     retVal = clReleaseCommandQueue(cmdq);
 }
 
-HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedAndUpdateTaskCountFromWaitEnabledThenCommandStreamReceiverDoesntSwitchToBatchingMode) {
+HWTEST_F(ClCreateCommandQueueTest, givenOoqParametersWhenQueueIsCreatedAndUpdateTaskCountFromWaitEnabledThenCommandStreamReceiverDoesntSwitchToBatchingMode) {
     DebugManagerStateRestore restorer;
     DebugManager.flags.UpdateTaskCountFromWait.set(3);
 
@@ -101,7 +102,7 @@ HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedAndUpdate
     retVal = clReleaseCommandQueue(cmdq);
 }
 
-HWTEST_F(ClCreateCommandQueueTest, GivenForcedDispatchModeAndOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverDoesntSwitchToBatchingMode) {
+HWTEST_F(ClCreateCommandQueueTest, givenForcedDispatchModeAndOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverDoesntSwitchToBatchingMode) {
     DebugManagerStateRestore restorer;
     DebugManager.flags.CsrDispatchMode.set(static_cast<int32_t>(DispatchMode::ImmediateDispatch));
 
@@ -117,7 +118,7 @@ HWTEST_F(ClCreateCommandQueueTest, GivenForcedDispatchModeAndOoqParametersWhenQu
     retVal = clReleaseCommandQueue(cmdq);
 }
 
-HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverSwitchesToNTo1SubmissionModel) {
+HWTEST_F(ClCreateCommandQueueTest, givenOoqParametersWhenQueueIsCreatedThenCommandStreamReceiverSwitchesToNTo1SubmissionModel) {
     using BaseType = typename CommandQueue::BaseType;
     cl_int retVal = CL_SUCCESS;
     cl_queue_properties ooq = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
@@ -132,4 +133,18 @@ HWTEST_F(ClCreateCommandQueueTest, GivenOoqParametersWhenQueueIsCreatedThenComma
     retVal = clReleaseCommandQueue(cmdq);
 }
 
+HWTEST_F(ClCreateCommandQueueTest, givenGfxFamilyWhenQueueIsCreatedThenBcsEngineCountSetToValueFromGfxFamily) {
+    using BaseType = typename CommandQueue::BaseType;
+    cl_int retVal = CL_SUCCESS;
+    cl_queue_properties properties{};
+
+    auto cmdq = clCreateCommandQueue(pContext, testedClDevice, properties, &retVal);
+    auto queue = castToObject<CommandQueue>(static_cast<BaseType *>(cmdq));
+    auto mockQueue = static_cast<MockCommandQueue *>(queue);
+
+    EXPECT_EQ(FamilyType::bcsEngineCount, mockQueue->bcsEngineCount);
+
+    retVal = clReleaseCommandQueue(cmdq);
+}
+
 } // namespace ULT

opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp

@@ -650,6 +650,7 @@ HWTEST_F(OoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueReadWithRequeste
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
     cmdQHw->setStallingCommandsOnNextFlush(true);
     cmdQHw->splitBarrierRequired = true;
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
 
     std::unique_ptr<OsContext> osContext1(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), pDevice->getRootDeviceIndex(), 0,
                                                             EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS1, EngineUsage::Regular},
@@ -700,6 +701,7 @@ HWTEST_F(OoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueBarrierNonSplitC
     auto memoryManager = static_cast<MockMemoryManager *>(pDevice->getMemoryManager());
     memoryManager->returnFakeAllocation = true;
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
     cmdQHw->setStallingCommandsOnNextFlush(true);
     cmdQHw->splitBarrierRequired = true;
 
@@ -763,6 +765,7 @@ HWTEST_F(OoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueReadThenDoNotEnq
     auto memoryManager = static_cast<MockMemoryManager *>(pDevice->getMemoryManager());
     memoryManager->returnFakeAllocation = true;
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
 
     std::unique_ptr<OsContext> osContext1(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), pDevice->getRootDeviceIndex(), 0,
                                                             EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS1, EngineUsage::Regular},
@@ -816,6 +819,7 @@ HWTEST_F(IoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueReadWithRequeste
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
     cmdQHw->setStallingCommandsOnNextFlush(true);
     cmdQHw->splitBarrierRequired = true;
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
 
     std::unique_ptr<OsContext> osContext1(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), pDevice->getRootDeviceIndex(), 0,
                                                             EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS1, EngineUsage::Regular},
@@ -869,6 +873,7 @@ HWTEST_F(OoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueReadWithNoReques
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
     cmdQHw->setStallingCommandsOnNextFlush(false);
     cmdQHw->splitBarrierRequired = true;
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
 
     std::unique_ptr<OsContext> osContext1(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), pDevice->getRootDeviceIndex(), 0,
                                                             EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS1, EngineUsage::Regular},
@@ -920,6 +925,7 @@ HWTEST_F(IoqCommandQueueHwBlitTest, givenSplitBcsCopyWhenEnqueueBlockingReadThen
     auto memoryManager = static_cast<MockMemoryManager *>(pDevice->getMemoryManager());
     memoryManager->returnFakeAllocation = true;
     auto cmdQHw = static_cast<MockCommandQueueHw<FamilyType> *>(this->pCmdQ);
+    cmdQHw->bcsEngineCount = bcsInfoMaskSize;
 
     std::unique_ptr<OsContext> osContext1(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), pDevice->getRootDeviceIndex(), 0,
                                                             EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS1, EngineUsage::Regular},

opencl/test/unit_test/mocks/mock_command_queue.h

@@ -22,6 +22,7 @@
 namespace NEO {
 class MockCommandQueue : public CommandQueue {
   public:
+    using CommandQueue::bcsEngineCount;
     using CommandQueue::bcsEngines;
     using CommandQueue::bcsInitialized;
     using CommandQueue::bcsQueueEngineType;
@@ -253,6 +254,7 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
     using BaseClass = CommandQueueHw<GfxFamily>;
 
   public:
+    using BaseClass::bcsEngineCount;
     using BaseClass::bcsEngines;
     using BaseClass::bcsQueueEngineType;
     using BaseClass::bcsStates;

shared/source/gen11/hw_cmds_base.h

@@ -27,6 +27,7 @@ struct Gen11 {
     static constexpr bool isUsingMiMemFence = false;
     static constexpr bool isUsingMiSetPredicate = false;
     static constexpr bool isUsingMiMathMocs = false;
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     struct FrontEndStateSupport {
         static constexpr bool scratchSize = true;

shared/source/gen12lp/hw_cmds_base.h

@@ -26,6 +26,7 @@ struct Gen12Lp {
     static constexpr bool isUsingMiMemFence = false;
     static constexpr bool isUsingMiSetPredicate = false;
     static constexpr bool isUsingMiMathMocs = false;
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     struct FrontEndStateSupport {
         static constexpr bool scratchSize = true;

shared/source/gen8/hw_cmds_base.h

@@ -28,6 +28,7 @@ struct Gen8 {
     static constexpr bool isUsingMiMemFence = false;
     static constexpr bool isUsingMiSetPredicate = false;
     static constexpr bool isUsingMiMathMocs = false;
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     struct FrontEndStateSupport {
         static constexpr bool scratchSize = true;

shared/source/gen9/hw_cmds_base.h

@@ -27,6 +27,7 @@ struct Gen9 {
     static constexpr bool isUsingMiMemFence = false;
     static constexpr bool isUsingMiSetPredicate = false;
     static constexpr bool isUsingMiMathMocs = false;
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     struct FrontEndStateSupport {
         static constexpr bool scratchSize = true;

shared/source/xe_hp_core/hw_cmds_base.h

@@ -24,6 +24,7 @@ struct XeHpCore {
     static constexpr uint32_t stateComputeModeLargeGrfModeMask = (1u << 15);
     static constexpr uint32_t stateComputeModeForceDisableSupportMultiGpuPartialWrites = (1u << 2);
     static constexpr uint32_t stateComputeModeForceDisableSupportMultiGpuAtomics = (1u << 1);
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     static constexpr bool isUsingL3Control = true;
     static constexpr bool isUsingMediaSamplerDopClockGate = true;

shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h

@@ -26,6 +26,7 @@ struct XeHpcCore {
     static constexpr uint32_t stateComputeModeForceNonCoherentMask = (0b11u << 3);
     static constexpr uint32_t stateComputeModeEuThreadSchedulingModeOverrideMask = (0b11u << 13);
     static constexpr uint32_t stateComputeModeLargeGrfModeMask = (1u << 15);
+    static constexpr uint32_t bcsEngineCount = 9u;
 
     static constexpr bool isUsingL3Control = false;
     static constexpr bool isUsingMediaSamplerDopClockGate = false;

shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h

@@ -26,6 +26,7 @@ struct XeHpgCore {
     static constexpr uint32_t stateComputeModeForceNonCoherentMask = (0b11u << 3);
     static constexpr uint32_t stateComputeModePixelAsyncComputeThreadLimitMask = (0b111u << 7);
     static constexpr uint32_t stateComputeModeLargeGrfModeMask = (1u << 15);
+    static constexpr uint32_t bcsEngineCount = 1u;
 
     static constexpr bool isUsingL3Control = true;
     static constexpr bool isUsingMediaSamplerDopClockGate = false;