feature: assign secondary BCS engines at queue creation

Related-To: NEO-7824

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

level_zero/core/source/device/device_imp.cpp

@@ -1694,6 +1694,9 @@ ze_result_t DeviceImp::getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr
         }
     }
 
+    const NEO::GfxCoreHelper &gfxCoreHelper = neoDevice->getGfxCoreHelper();
+    bool secondaryContextsEnabled = gfxCoreHelper.areSecondaryContextsSupported();
+
     if (ordinal < numEngineGroups) {
         auto &engines = engineGroups[ordinal].engines;
         if (index >= engines.size()) {
@@ -1703,19 +1706,10 @@ ze_result_t DeviceImp::getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr
 
         auto &osContext = (*csr)->getOsContext();
 
-        const NEO::GfxCoreHelper &gfxCoreHelper = neoDevice->getGfxCoreHelper();
-        bool secondaryContextsEnabled = gfxCoreHelper.areSecondaryContextsSupported();
-
         if (neoDevice->isMultiRegularContextSelectionAllowed(osContext.getEngineType(), osContext.getEngineUsage())) {
             *csr = neoDevice->getNextEngineForMultiRegularContextMode(osContext.getEngineType()).commandStreamReceiver;
-        } else if (secondaryContextsEnabled && neoDevice->isSecondaryContextEngineType(osContext.getEngineType())) {
+        } else if (secondaryContextsEnabled) {
-            NEO::EngineTypeUsage engineTypeUsage;
+            tryAssignSecondaryContext(osContext.getEngineType(), NEO::EngineUsage::regular, csr);
-            engineTypeUsage.first = osContext.getEngineType();
-            engineTypeUsage.second = NEO::EngineUsage::regular;
-            auto engine = neoDevice->getSecondaryEngineCsr(engineTypeUsage);
-            if (engine) {
-                *csr = engine->commandStreamReceiver;
-            }
         }
     } else {
         auto subDeviceOrdinal = ordinal - numEngineGroups;
@@ -1723,11 +1717,30 @@ ze_result_t DeviceImp::getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr
             return ZE_RESULT_ERROR_INVALID_ARGUMENT;
         }
         *csr = this->subDeviceCopyEngineGroups[subDeviceOrdinal].engines[index].commandStreamReceiver;
+
+        if (secondaryContextsEnabled) {
+            tryAssignSecondaryContext((*csr)->getOsContext().getEngineType(), NEO::EngineUsage::regular, csr);
+        }
     }
 
     return ZE_RESULT_SUCCESS;
 }
 
+bool DeviceImp::tryAssignSecondaryContext(aub_stream::EngineType engineType, NEO::EngineUsage engineUsage, NEO::CommandStreamReceiver **csr) {
+    if (neoDevice->isSecondaryContextEngineType(engineType)) {
+        NEO::EngineTypeUsage engineTypeUsage;
+        engineTypeUsage.first = engineType;
+        engineTypeUsage.second = engineUsage;
+        auto engine = neoDevice->getSecondaryEngineCsr(engineTypeUsage);
+        if (engine) {
+            *csr = engine->commandStreamReceiver;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 ze_result_t DeviceImp::getCsrForOrdinalAndIndexWithPriority(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index, ze_command_queue_priority_t priority) {
 
     if (!this->isQueueGroupOrdinalValid(ordinal)) {
@@ -1750,15 +1763,8 @@ ze_result_t DeviceImp::getCsrForOrdinalAndIndexWithPriority(NEO::CommandStreamRe
             *csr = engines[index].commandStreamReceiver;
             auto &osContext = (*csr)->getOsContext();
 
-            if (neoDevice->isSecondaryContextEngineType(osContext.getEngineType())) {
+            if (tryAssignSecondaryContext(osContext.getEngineType(), NEO::EngineUsage::highPriority, csr)) {
-                NEO::EngineTypeUsage engineTypeUsage;
+                return ZE_RESULT_SUCCESS;
-                engineTypeUsage.first = osContext.getEngineType();
-                engineTypeUsage.second = NEO::EngineUsage::highPriority;
-                auto engine = neoDevice->getSecondaryEngineCsr(engineTypeUsage);
-                if (engine) {
-                    *csr = engine->commandStreamReceiver;
-                    return ZE_RESULT_SUCCESS;
-                }
             }
         }
     } else if (isSuitableForLowPriority(priority, NEO::EngineHelper::isCopyOnlyEngineType(

level_zero/core/source/device/device_imp.h

@@ -177,6 +177,7 @@ struct DeviceImp : public Device, NEO::NonCopyableOrMovableClass {
     NEO::EngineGroupType getEngineGroupTypeForOrdinal(uint32_t ordinal) const;
     void getP2PPropertiesDirectFabricConnection(DeviceImp *peerDeviceImp,
                                                 ze_device_p2p_bandwidth_exp_properties_t *bandwidthPropertiesDesc);
+    bool tryAssignSecondaryContext(aub_stream::EngineType engineType, NEO::EngineUsage engineUsage, NEO::CommandStreamReceiver **csr);
     NEO::EngineGroupsT subDeviceCopyEngineGroups{};
 
     NEO::GraphicsAllocation *debugSurface = nullptr;

level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_7.cpp

@@ -1981,5 +1981,68 @@ TEST(CommandList, givenContextGroupEnabledWhenCreatingImmediateCommandListThenEa
     commandList2->destroy();
 }
 
+TEST(CommandList, givenCopyContextGroupEnabledWhenCreatingImmediateCommandListThenEachCmdListHasDifferentCsr) {
+
+    HardwareInfo hwInfo = *defaultHwInfo;
+
+    DebugManagerStateRestore dbgRestorer;
+    debugManager.flags.ContextGroupSize.set(5);
+
+    hwInfo.featureTable.ftrBcsInfo = 0b111;
+    hwInfo.capabilityTable.blitterOperationsSupported = true;
+
+    auto neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo);
+    NEO::DeviceVector devices;
+    devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
+    auto driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
+    driverHandle->initialize(std::move(devices));
+    auto device = static_cast<DeviceImp *>(driverHandle->devices[0]);
+
+    auto &regularEngines = device->getNEODevice()->getRegularEngineGroups();
+
+    auto iter = std::find_if(regularEngines.begin(), regularEngines.end(), [](const auto &engine) {
+        return (engine.engineGroupType == EngineGroupType::copy || engine.engineGroupType == EngineGroupType::linkedCopy);
+    });
+
+    if (iter == regularEngines.end()) {
+        GTEST_SKIP();
+    }
+
+    ze_command_queue_desc_t desc = {};
+    desc.ordinal = device->getCopyEngineOrdinal();
+    desc.index = 0;
+    ze_command_list_handle_t commandListHandle1, commandListHandle2;
+
+    auto result = device->createCommandListImmediate(&desc, &commandListHandle1);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = device->createCommandListImmediate(&desc, &commandListHandle2);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    auto commandList1 = static_cast<CommandListImp *>(L0::CommandList::fromHandle(commandListHandle1));
+    auto commandList2 = static_cast<CommandListImp *>(L0::CommandList::fromHandle(commandListHandle2));
+
+    EXPECT_NE(commandList1->getCsr(), commandList2->getCsr());
+
+    commandList1->destroy();
+    commandList2->destroy();
+
+    desc.priority = ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH;
+
+    result = device->createCommandListImmediate(&desc, &commandListHandle1);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = device->createCommandListImmediate(&desc, &commandListHandle2);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    commandList1 = static_cast<CommandListImp *>(L0::CommandList::fromHandle(commandListHandle1));
+    commandList2 = static_cast<CommandListImp *>(L0::CommandList::fromHandle(commandListHandle2));
+
+    EXPECT_NE(commandList1->getCsr(), commandList2->getCsr());
+
+    commandList1->destroy();
+    commandList2->destroy();
+}
+
 } // namespace ult
 } // namespace L0

opencl/source/command_queue/command_queue.cpp

@@ -356,6 +356,11 @@ void CommandQueue::constructBcsEngine(bool internalUsage) {
 
         if (bcsEngines[bcsIndex]) {
             bcsQueueEngineType = bcsEngineType;
+
+            if (gfxCoreHelper.areSecondaryContextsSupported() && !internalUsage) {
+                bcsEngines[bcsIndex] = device->getDevice().getSecondaryEngineCsr({bcsEngineType, engineUsage});
+            }
+
             bcsEngines[bcsIndex]->osContext->ensureContextInitialized();
             bcsEngines[bcsIndex]->commandStreamReceiver->initDirectSubmission();
         }
@@ -1218,6 +1223,10 @@ void CommandQueue::overrideEngine(aub_stream::EngineType engineType, EngineUsage
         }
         if (bcsEngines[engineIndex]) {
             bcsQueueEngineType = engineType;
+
+            if (secondaryContextsEnabled) {
+                bcsEngines[engineIndex] = device->getDevice().getSecondaryEngineCsr({engineType, engineUsage});
+            }
         }
         timestampPacketContainer = std::make_unique<TimestampPacketContainer>();
         deferredTimestampPackets = std::make_unique<TimestampPacketContainer>();

opencl/test/unit_test/command_queue/command_queue_tests.cpp

@@ -2718,6 +2718,41 @@ HWTEST_F(CommandQueueOnSpecificEngineTests, givenMultipleFamiliesWhenCreatingQue
     EXPECT_NE(nullptr, queueBcs.getTimestampPacketContainer());
 }
 
+HWTEST_F(CommandQueueOnSpecificEngineTests, givenContextGroupWhenCreatingQueuesThenAssignDifferentCsr) {
+    DebugManagerStateRestore restore;
+    debugManager.flags.ContextGroupSize.set(8);
+
+    HardwareInfo hwInfo = *defaultHwInfo;
+    hwInfo.capabilityTable.blitterOperationsSupported = true;
+
+    MockExecutionEnvironment mockExecutionEnvironment{&hwInfo};
+    auto raiiGfxCoreHelper = overrideGfxCoreHelper<FamilyType, MockGfxCoreHelper<FamilyType, 0, 1, 1>>(*mockExecutionEnvironment.rootDeviceEnvironments[0]);
+
+    MockDevice *device = MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0);
+    MockClDevice clDevice{device};
+    MockContext context{&clDevice};
+    cl_command_queue_properties properties[5] = {};
+
+    fillProperties(properties, 1, 0);
+
+    MockCommandQueue queueBcs0(&context, context.getDevice(0), properties, false);
+    MockCommandQueue queueBcs1(&context, context.getDevice(0), properties, false);
+    MockCommandQueue queueBcs2(&context, context.getDevice(0), properties, false);
+
+    EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, queueBcs1.bcsEngines[0]->osContext->getEngineType());
+    EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, queueBcs2.bcsEngines[0]->osContext->getEngineType());
+
+    auto csr1 = static_cast<UltCommandStreamReceiver<FamilyType> *>(queueBcs1.bcsEngines[0]->commandStreamReceiver);
+    auto csr2 = static_cast<UltCommandStreamReceiver<FamilyType> *>(queueBcs2.bcsEngines[0]->commandStreamReceiver);
+
+    EXPECT_NE(csr1, csr2);
+
+    EXPECT_NE(nullptr, csr1->primaryCsr);
+    EXPECT_NE(nullptr, csr2->primaryCsr);
+
+    EXPECT_EQ(csr1->primaryCsr, csr2->primaryCsr);
+}
+
 HWTEST_F(CommandQueueOnSpecificEngineTests, givenRootDeviceAndMultipleFamiliesWhenCreatingQueueOnSpecificEngineThenUseDefaultEngine) {
     VariableBackup<HardwareInfo> backupHwInfo(defaultHwInfo.get());
     defaultHwInfo->capabilityTable.blitterOperationsSupported = true;

shared/source/device/device.h

@@ -195,7 +195,7 @@ class Device : public ReferenceTrackedObject<Device> {
 
     MOCKABLE_VIRTUAL EngineControl *getSecondaryEngineCsr(EngineTypeUsage engineTypeUsage);
     bool isSecondaryContextEngineType(aub_stream::EngineType type) {
-        return EngineHelpers::isCcs(type);
+        return EngineHelpers::isCcs(type) || EngineHelpers::isBcs(type);
     }
 
     std::atomic<uint32_t> debugExecutionCounter = 0;

shared/test/common/libult/ult_command_stream_receiver.h

@@ -78,6 +78,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
     using BaseClass::pageTableManagerInitialized;
     using BaseClass::perDssBackedBuffer;
     using BaseClass::postInitFlagsSetup;
+    using BaseClass::primaryCsr;
     using BaseClass::programActivePartitionConfig;
     using BaseClass::programEnginePrologue;
     using BaseClass::programPerDssBackedBuffer;

shared/test/unit_test/device/neo_device_tests.cpp

@@ -1107,17 +1107,18 @@ TEST_F(DeviceTests, whenCheckingPreferredPlatformNameThenNullIsReturned) {
     EXPECT_EQ(nullptr, defaultHwInfo->capabilityTable.preferredPlatformName);
 }
 
-TEST(Device, givenDifferentEngineTypesWhenIsSecondaryContextEngineTypeCalledThenTrueReturnedForCCS) {
+TEST(Device, givenDifferentEngineTypesWhenIsSecondaryContextEngineTypeCalledThenTrueReturnedForCcsOrBcs) {
     auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
 
-    EXPECT_TRUE(device->isSecondaryContextEngineType(aub_stream::ENGINE_CCS));
+    for (uint32_t i = 0; i < static_cast<uint32_t>(aub_stream::EngineType::NUM_ENGINES); i++) {
-    EXPECT_TRUE(device->isSecondaryContextEngineType(aub_stream::ENGINE_CCS1));
+        auto type = static_cast<aub_stream::EngineType>(i);
-    EXPECT_TRUE(device->isSecondaryContextEngineType(aub_stream::ENGINE_CCS2));
-    EXPECT_TRUE(device->isSecondaryContextEngineType(aub_stream::ENGINE_CCS3));
 
-    EXPECT_FALSE(device->isSecondaryContextEngineType(aub_stream::ENGINE_RCS));
+        if (EngineHelpers::isBcs(type) || EngineHelpers::isCcs(type)) {
-    EXPECT_FALSE(device->isSecondaryContextEngineType(aub_stream::ENGINE_CCCS));
+            EXPECT_TRUE(device->isSecondaryContextEngineType(type));
-    EXPECT_FALSE(device->isSecondaryContextEngineType(aub_stream::ENGINE_BCS));
+        } else {
+            EXPECT_FALSE(device->isSecondaryContextEngineType(type));
+        }
+    }
 }
 
 HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenCCSEngineAndContextGroupSizeEnabledWhenCreatingEngineThenItsContextHasContextGroupFlagSet) {