fix: Move first submission programming to a separate function

Call the new function after debugger and sip kernel are initialized.

Related-To: HSD-18038645398, HSD-18038819112

Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>

opencl/test/unit_test/command_queue/command_queue_tests.cpp

@@ -2995,8 +2995,8 @@ struct CopyOnlyQueueTests : ::testing::Test {
         device->regularEngineGroups.clear();
         device->allEngines.clear();
 
-        device->createEngine(0, typeUsageRcs);
-        device->createEngine(1, typeUsageBcs);
+        device->createEngine(typeUsageRcs);
+        device->createEngine(typeUsageBcs);
         bcsEngine = &device->getAllEngines().back();
 
         clDevice = std::make_unique<MockClDevice>(device);

shared/source/device/device.cpp

@@ -245,6 +245,10 @@ bool Device::createDeviceImpl() {
         UNRECOVERABLE_IF(!ret);
     }
 
+    if (!initializeEngines()) {
+        return false;
+    }
+
     getDefaultEngine().osContext->setDefaultContext(true);
 
     for (auto &engine : allEngines) {
@@ -303,15 +307,14 @@ bool Device::createDeviceImpl() {
 
 bool Device::createEngines() {
     if (engineInstanced) {
-        return createEngine(0, {engineInstancedType, EngineUsage::regular});
+        return createEngine({engineInstancedType, EngineUsage::regular});
     }
 
     auto &gfxCoreHelper = getGfxCoreHelper();
     auto gpgpuEngines = gfxCoreHelper.getGpgpuEngineInstances(getRootDeviceEnvironment());
 
-    uint32_t deviceCsrIndex = 0;
     for (auto &engine : gpgpuEngines) {
-        if (!createEngine(deviceCsrIndex++, engine)) {
+        if (!createEngine(engine)) {
             return false;
         }
     }
@@ -401,7 +404,7 @@ std::unique_ptr<CommandStreamReceiver> Device::createCommandStreamReceiver() con
     return std::unique_ptr<CommandStreamReceiver>(createCommandStream(*executionEnvironment, getRootDeviceIndex(), getDeviceBitfield()));
 }
 
-bool Device::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage) {
+bool Device::createEngine(EngineTypeUsage engineTypeUsage) {
     const auto &hwInfo = getHardwareInfo();
     auto &gfxCoreHelper = getGfxCoreHelper();
     const auto engineType = engineTypeUsage.first;
@@ -439,6 +442,8 @@ bool Device::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsa
 
     auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(commandStreamReceiver.get(), engineDescriptor);
     osContext->setContextGroup(useContextGroup);
+    osContext->setIsPrimaryEngine(isPrimaryEngine);
+    osContext->setIsDefaultEngine(isDefaultEngine);
 
     commandStreamReceiver->setupContext(*osContext);
 
@@ -460,34 +465,6 @@ bool Device::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsa
         return false;
     }
 
-    bool firstSubmissionDone = false;
-    if (isDefaultEngine) {
-        bool defaultEngineAlreadySet = (allEngines.size() > defaultEngineIndex) && (allEngines[defaultEngineIndex].getEngineType() == engineType);
-
-        if (!defaultEngineAlreadySet) {
-            defaultEngineIndex = deviceCsrIndex;
-
-            if (osContext->isDebuggableContext() ||
-                this->isInitDeviceWithFirstSubmissionSupported(commandStreamReceiver->getType())) {
-                if (SubmissionStatus::success != commandStreamReceiver->initializeDeviceWithFirstSubmission(*this)) {
-                    return false;
-                }
-                firstSubmissionDone = true;
-            }
-        }
-    }
-
-    auto &compilerProductHelper = this->getCompilerProductHelper();
-    auto heaplessEnabled = compilerProductHelper.isHeaplessModeEnabled();
-
-    bool isHeaplessStateInit = isPrimaryEngine && compilerProductHelper.isHeaplessStateInitEnabled(heaplessEnabled);
-    bool initializeDevice = (useContextGroup || isHeaplessStateInit) && !firstSubmissionDone;
-
-    if (initializeDevice) {
-        commandStreamReceiver->initializeResources(false);
-        commandStreamReceiver->initializeDeviceWithFirstSubmission(*this);
-    }
-
     EngineControl engine{commandStreamReceiver.get(), osContext};
     allEngines.push_back(engine);
     if (engineUsage == EngineUsage::regular) {
@@ -499,6 +476,39 @@ bool Device::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsa
     return true;
 }
 
+bool Device::initializeEngines() {
+    uint32_t deviceCsrIndex = 0;
+    bool defaultEngineAlreadySet = false;
+    for (auto &engine : allEngines) {
+        bool firstSubmissionDone = false;
+        if (engine.osContext->getIsDefaultEngine() && !defaultEngineAlreadySet) {
+            defaultEngineAlreadySet = true;
+            defaultEngineIndex = deviceCsrIndex;
+
+            if (engine.osContext->isDebuggableContext() ||
+                this->isInitDeviceWithFirstSubmissionSupported(engine.commandStreamReceiver->getType())) {
+                if (SubmissionStatus::success != engine.commandStreamReceiver->initializeDeviceWithFirstSubmission(*this)) {
+                    return false;
+                }
+                firstSubmissionDone = true;
+            }
+        }
+
+        auto &compilerProductHelper = this->getCompilerProductHelper();
+        auto heaplessEnabled = compilerProductHelper.isHeaplessModeEnabled();
+
+        bool isHeaplessStateInit = engine.osContext->getIsPrimaryEngine() && compilerProductHelper.isHeaplessStateInitEnabled(heaplessEnabled);
+        bool initializeDevice = (engine.osContext->isPartOfContextGroup() || isHeaplessStateInit) && !firstSubmissionDone;
+
+        if (initializeDevice) {
+            engine.commandStreamReceiver->initializeResources(false);
+            engine.commandStreamReceiver->initializeDeviceWithFirstSubmission(*this);
+        }
+        deviceCsrIndex++;
+    }
+    return true;
+}
+
 bool Device::createSecondaryEngine(CommandStreamReceiver *primaryCsr, EngineTypeUsage engineTypeUsage) {
     auto engineUsage = engineTypeUsage.second;
     std::unique_ptr<CommandStreamReceiver> commandStreamReceiver = createCommandStreamReceiver();

shared/source/device/device.h

@@ -216,7 +216,8 @@ class Device : public ReferenceTrackedObject<Device> {
     virtual bool createEngines();
 
     void addEngineToEngineGroup(EngineControl &engine);
-    MOCKABLE_VIRTUAL bool createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage);
+    MOCKABLE_VIRTUAL bool createEngine(EngineTypeUsage engineTypeUsage);
+    MOCKABLE_VIRTUAL bool initializeEngines();
     MOCKABLE_VIRTUAL bool createSecondaryEngine(CommandStreamReceiver *primaryCsr, EngineTypeUsage engineTypeUsage);
 
     MOCKABLE_VIRTUAL std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const;

shared/source/os_interface/os_context.h

@@ -79,6 +79,18 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
     const OsContext *getPrimaryContext() const {
         return primaryContext;
     }
+    void setIsPrimaryEngine(const bool isPrimaryEngine) {
+        this->isPrimaryEngine = isPrimaryEngine;
+    }
+    bool getIsPrimaryEngine() const {
+        return this->isPrimaryEngine;
+    }
+    void setIsDefaultEngine(const bool isDefaultEngine) {
+        this->isDefaultEngine = isDefaultEngine;
+    }
+    bool getIsDefaultEngine() const {
+        return this->isDefaultEngine;
+    }
     void setContextGroup(bool value) {
         isContextGroup = value;
     }
@@ -110,5 +122,7 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
 
     bool isContextGroup = false;
     const OsContext *primaryContext = nullptr;
+    bool isPrimaryEngine = false;
+    bool isDefaultEngine = false;
 };
 } // namespace NEO

shared/test/common/helpers/sip_init.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -22,6 +22,7 @@ SipKernelType calledType = SipKernelType::count;
 bool called = false;
 bool returned = true;
 bool useMockSip = false;
+bool uninitializedSipRequested = false;
 
 void clearUseFlags() {
     calledType = SipKernelType::count;
@@ -159,6 +160,9 @@ bool SipKernel::initSipKernel(SipKernelType type, Device &device) {
 
 const SipKernel &SipKernel::getSipKernel(Device &device, OsContext *context) {
     if (MockSipData::useMockSip) {
+        if (!MockSipData::called) {
+            MockSipData::uninitializedSipRequested = true;
+        }
         return *MockSipData::mockSipKernel.get();
     } else {
         if (context && device.getExecutionEnvironment()->getDebuggingMode() == NEO::DebuggingMode::offline) {

shared/test/common/mocks/mock_device.cpp

@@ -157,11 +157,11 @@ ExecutionEnvironment *MockDevice::prepareExecutionEnvironment(const HardwareInfo
     return executionEnvironment;
 }
 
-bool MockSubDevice::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage) {
+bool MockSubDevice::createEngine(EngineTypeUsage engineTypeUsage) {
     if (failOnCreateEngine) {
         return false;
     }
-    return SubDevice::createEngine(deviceCsrIndex, engineTypeUsage);
+    return SubDevice::createEngine(engineTypeUsage);
 }
 
 MockAlignedMallocManagerDevice::MockAlignedMallocManagerDevice(ExecutionEnvironment *executionEnvironment, uint32_t internalDeviceIndex) : MockDevice(executionEnvironment, internalDeviceIndex) {

shared/test/common/mocks/mock_device.h

@@ -42,7 +42,7 @@ struct MockSubDevice : public SubDevice {
     static decltype(&createCommandStream) createCommandStreamReceiverFunc;
 
     bool failOnCreateEngine = false;
-    bool createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage) override;
+    bool createEngine(EngineTypeUsage engineTypeUsage) override;
 };
 
 class MockDevice : public RootDevice {

shared/test/common/mocks/mock_sip.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -44,6 +44,7 @@ extern SipKernelType calledType;
 extern bool called;
 extern bool returned;
 extern bool useMockSip;
+extern bool uninitializedSipRequested;
 
 void clearUseFlags();
 std::vector<char> createStateSaveAreaHeader(uint32_t version);

shared/test/unit_test/device/neo_device_tests.cpp

@@ -53,7 +53,7 @@ TEST(DeviceBlitterTest, givenForceBCSForInternalCopyEngineToIndexZeroWhenGetInte
     defaultHwInfo->capabilityTable.blitterOperationsSupported = true;
 
     UltDeviceFactory factory{1, 0};
-    factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS, EngineUsage::internal});
+    factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS, EngineUsage::internal});
     auto engine = factory.rootDevices[0]->getInternalCopyEngine();
     EXPECT_NE(nullptr, engine);
 
@@ -69,7 +69,7 @@ TEST(DeviceBlitterTest, givenForceBCSForInternalCopyEngineToIndexOneWhenGetInter
     defaultHwInfo->capabilityTable.blitterOperationsSupported = true;
 
     UltDeviceFactory factory{1, 0};
-    factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS1, EngineUsage::internal});
+    factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS1, EngineUsage::internal});
     auto engine = factory.rootDevices[0]->getInternalCopyEngine();
     EXPECT_NE(nullptr, engine);
 
@@ -82,10 +82,10 @@ TEST(DeviceBlitterTest, givenBlitterOperationsDisabledWhenCreatingBlitterEngineT
     defaultHwInfo->capabilityTable.blitterOperationsSupported = false;
 
     UltDeviceFactory factory{1, 0};
-    EXPECT_THROW(factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS, EngineUsage::regular}), std::runtime_error);
-    EXPECT_THROW(factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS, EngineUsage::cooperative}), std::runtime_error);
-    EXPECT_THROW(factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS, EngineUsage::internal}), std::runtime_error);
-    EXPECT_THROW(factory.rootDevices[0]->createEngine(0, {aub_stream::EngineType::ENGINE_BCS, EngineUsage::lowPriority}), std::runtime_error);
+    EXPECT_THROW(factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS, EngineUsage::regular}), std::runtime_error);
+    EXPECT_THROW(factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS, EngineUsage::cooperative}), std::runtime_error);
+    EXPECT_THROW(factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS, EngineUsage::internal}), std::runtime_error);
+    EXPECT_THROW(factory.rootDevices[0]->createEngine({aub_stream::EngineType::ENGINE_BCS, EngineUsage::lowPriority}), std::runtime_error);
 }
 
 TEST(Device, givenNoDebuggerWhenGettingDebuggerThenNullptrIsReturned) {