Dont use default engine in immediate cmdlist

Related-To: NEO-4913

Change-Id: I15b5bb700e37ea49c34931bc81de7314ec1ac4dc
Signed-off-by: Maciej Plewka <maciej.plewka@intel.com>

level_zero/core/source/cmdlist/cmdlist_imp.cpp

@@ -68,16 +68,8 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
                                           const ze_command_queue_desc_t *desc,
                                           bool internalUsage, bool isCopyOnly) {
 
-    auto deviceImp = static_cast<DeviceImp *>(device);
     NEO::CommandStreamReceiver *csr = nullptr;
-    if (internalUsage) {
+    device->getCsrForOrdinalAndIndex(&csr, desc->ordinal, desc->index);
-        csr = deviceImp->neoDevice->getInternalEngine().commandStreamReceiver;
-    } else if (isCopyOnly) {
-        auto &selectorCopyEngine = deviceImp->neoDevice->getDeviceById(0)->getSelectorCopyEngine();
-        csr = deviceImp->neoDevice->getDeviceById(0)->getEngine(NEO::EngineHelpers::getBcsEngineType(deviceImp->neoDevice->getHardwareInfo(), selectorCopyEngine), false).commandStreamReceiver;
-    } else {
-        csr = deviceImp->neoDevice->getDefaultEngine().commandStreamReceiver;
-    }
 
     auto commandQueue = CommandQueue::create(productFamily, device, csr, desc, isCopyOnly);
     if (!commandQueue) {

level_zero/core/source/device/device.h

@@ -122,6 +122,8 @@ struct Device : _ze_device_handle_t {
     virtual NEO::GraphicsAllocation *allocateMemoryFromHostPtr(const void *buffer, size_t size) = 0;
     virtual void setSysmanHandle(SysmanDevice *pSysmanDevice) = 0;
     virtual SysmanDevice *getSysmanHandle() = 0;
+    virtual ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) = 0;
+    virtual ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) = 0;
 };
 
 } // namespace L0

level_zero/core/source/device/device_imp.cpp

@@ -95,11 +95,9 @@ ze_result_t DeviceImp::createCommandList(const ze_command_list_desc_t *desc,
 ze_result_t DeviceImp::createCommandListImmediate(const ze_command_queue_desc_t *desc,
                                                   ze_command_list_handle_t *phCommandList) {
     auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
-
+    uint32_t engineGroupIndex = desc->ordinal;
-    bool useBliter = false;
+    mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
-    if (desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
+    bool useBliter = engineGroupIndex == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
-        useBliter = true;
-    }
     *phCommandList = CommandList::createImmediate(productFamily, this, desc, false, useBliter);
 
     return ZE_RESULT_SUCCESS;
@@ -110,22 +108,12 @@ ze_result_t DeviceImp::createCommandQueue(const ze_command_queue_desc_t *desc,
     auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
 
     NEO::CommandStreamReceiver *csr = nullptr;
-    bool useBliter = desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
+    uint32_t engineGroupIndex = desc->ordinal;
-
+    mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
-    if (desc->ordinal >= static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups)) {
+    bool useBliter = engineGroupIndex == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    auto ret = getCsrForOrdinalAndIndex(&csr, desc->ordinal, desc->index);
-    }
+    if (ret != ZE_RESULT_SUCCESS) {
-
+        return ret;
-    if (this->getNEODevice()->getNumAvailableDevices() > 1) {
-        if (desc->index >= this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal].size()) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        csr = this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
-    } else {
-        if (desc->index >= this->neoDevice->getEngineGroups()[desc->ordinal].size()) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        csr = this->neoDevice->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
     }
 
     UNRECOVERABLE_IF(csr == nullptr);
@@ -725,4 +713,41 @@ NEO::GraphicsAllocation *DeviceImp::allocateMemoryFromHostPtr(const void *buffer
     return allocation;
 }
 
+ze_result_t DeviceImp::getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) {
+    if (ordinal >= static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups)) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    uint32_t engineGroupIndex = ordinal;
+    auto ret = mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
+    if (ret != ZE_RESULT_SUCCESS) {
+        return ret;
+    }
+    if (this->getNEODevice()->getNumAvailableDevices() > 1) {
+        if (index >= this->neoDevice->getDeviceById(0)->getEngineGroups()[engineGroupIndex].size()) {
+            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *csr = this->neoDevice->getDeviceById(0)->getEngineGroups()[engineGroupIndex][index].commandStreamReceiver;
+    } else {
+        if (index >= this->neoDevice->getEngineGroups()[engineGroupIndex].size()) {
+            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        *csr = this->neoDevice->getEngineGroups()[engineGroupIndex][index].commandStreamReceiver;
+    }
+    return ZE_RESULT_SUCCESS;
+}
+ze_result_t DeviceImp::mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) {
+    auto engines = this->getNEODevice()->getEngineGroups();
+    uint32_t numNonEmptyGroups = 0;
+    uint32_t i = 0;
+    for (; i < engines.size() && numNonEmptyGroups <= *ordinal; i++) {
+        if (!engines[i].empty()) {
+            numNonEmptyGroups++;
+        }
+    }
+    if (*ordinal + 1 > numNonEmptyGroups) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    *ordinal = i - 1;
+    return ZE_RESULT_SUCCESS;
+};
 } // namespace L0

level_zero/core/source/device/device_imp.h

@@ -67,6 +67,7 @@ struct DeviceImp : public Device {
     void setDriverHandle(DriverHandle *driverHandle) override;
     NEO::PreemptionMode getDevicePreemptionMode() const override;
     const NEO::DeviceInfo &getDeviceInfo() const override;
+
     NEO::Device *getNEODevice() override;
     void activateMetricGroups() override;
     void processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_module_properties_t *pKernelProperties);
@@ -77,6 +78,8 @@ struct DeviceImp : public Device {
     NEO::GraphicsAllocation *allocateMemoryFromHostPtr(const void *buffer, size_t size) override;
     void setSysmanHandle(SysmanDevice *pSysman) override;
     SysmanDevice *getSysmanHandle() override;
+    ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) override;
+    ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) override;
 
     NEO::Device *neoDevice = nullptr;
     bool isSubdevice = false;

level_zero/core/test/unit_tests/mocks/mock_device.h

@@ -252,6 +252,13 @@ struct Mock<Device> : public Device {
                 getSysmanHandle,
                 (),
                 (override));
+    ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) override {
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) override {
+        return ZE_RESULT_SUCCESS;
+    }
 };
 
 template <>

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

@@ -179,6 +179,31 @@ TEST_F(CommandListCreate, whenCreatingImmediateCommandListThenItHasImmediateComm
     EXPECT_NE(nullptr, commandList->cmdQImmediate);
 }
 
+TEST_F(CommandListCreate, givenQueueDescriptionwhenCreatingImmediateCommandListForEveryEnigneThenItHasImmediateCommandQueueCreated) {
+    auto engines = neoDevice->getEngineGroups();
+    uint32_t numaAvailableEngineGroups = 0;
+    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
+        if (engines[ordinal].size()) {
+            numaAvailableEngineGroups++;
+        }
+    }
+    for (uint32_t ordinal = 0; ordinal < numaAvailableEngineGroups; ordinal++) {
+        uint32_t engineGroupIndex = ordinal;
+        device->mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
+        for (uint32_t index = 0; index < engines[engineGroupIndex].size(); index++) {
+            ze_command_queue_desc_t desc = {};
+            desc.ordinal = ordinal;
+            desc.index = index;
+            std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, false));
+            ASSERT_NE(nullptr, commandList);
+
+            EXPECT_EQ(device, commandList->device);
+            EXPECT_EQ(CommandList::CommandListType::TYPE_IMMEDIATE, commandList->cmdListType);
+            EXPECT_NE(nullptr, commandList->cmdQImmediate);
+        }
+    }
+}
+
 TEST_F(CommandListCreate, givenInvalidProductFamilyThenReturnsNullPointer) {
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(IGFX_UNKNOWN, device, false));
     EXPECT_EQ(nullptr, commandList);

level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp

@@ -273,9 +273,17 @@ TEST_F(ContextCreateCommandQueueTest, givenCallToContextCreateCommandQueueThenCa
 
 HWTEST_F(ContextCreateCommandQueueTest, givenEveryPossibleGroupIndexWhenCreatingCommandQueueThenCommandQueueIsCreated) {
     ze_command_queue_handle_t commandQueue = {};
-    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
     auto engines = neoDevice->getEngineGroups();
-        for (uint32_t index = 0; index < engines[ordinal].size(); index++) {
+    uint32_t numaAvailableEngineGroups = 0;
+    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
+        if (engines[ordinal].size()) {
+            numaAvailableEngineGroups++;
+        }
+    }
+    for (uint32_t ordinal = 0; ordinal < numaAvailableEngineGroups; ordinal++) {
+        uint32_t engineGroupIndex = ordinal;
+        device->mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
+        for (uint32_t index = 0; index < engines[engineGroupIndex].size(); index++) {
             ze_command_queue_desc_t desc = {};
             desc.ordinal = ordinal;
             desc.index = index;
@@ -288,6 +296,23 @@ HWTEST_F(ContextCreateCommandQueueTest, givenEveryPossibleGroupIndexWhenCreating
     }
 }
 
+HWTEST_F(ContextCreateCommandQueueTest, givenOrdinalBigerThanAvailableEnginesWhenCreatingCommandQueueThenInvalidArgReturned) {
+    ze_command_queue_handle_t commandQueue = {};
+    auto engines = neoDevice->getEngineGroups();
+    uint32_t numaAvailableEngineGroups = 0;
+    for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
+        if (engines[ordinal].size()) {
+            numaAvailableEngineGroups++;
+        }
+    }
+    ze_command_queue_desc_t desc = {};
+    desc.ordinal = numaAvailableEngineGroups;
+    desc.index = 0;
+    ze_result_t res = context->createCommandQueue(device, &desc, &commandQueue);
+    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, res);
+    EXPECT_EQ(nullptr, commandQueue);
+}
+
 using CommandQueueSynchronizeTest = Test<ContextFixture>;
 
 HWTEST_F(CommandQueueSynchronizeTest, givenCallToSynchronizeThenCorrectEnableTimeoutAndTimeoutValuesAreUsed) {