Remove isInitialized() method from OsContext

We can fail early, instead of constructing an invalid object

Signed-off-by: Maciej Dziuban <[email protected]>

Author: DziubanMaciejIntel

opencl/test/unit_test/os_interface/os_context_tests.cpp

@@ -13,7 +13,6 @@ using namespace NEO;
 
 TEST(OSContext, whenCreatingDefaultOsContextThenExpectInitializedAlways) {
     OsContext *osContext = OsContext::create(nullptr, 0, 0, EngineTypeUsage{aub_stream::ENGINE_RCS, EngineUsage::Regular}, PreemptionMode::Disabled, false);
-    EXPECT_TRUE(osContext->isInitialized());
     EXPECT_FALSE(osContext->isLowPriority());
     EXPECT_FALSE(osContext->isInternalEngine());
     EXPECT_FALSE(osContext->isRootDevice());

opencl/test/unit_test/os_interface/windows/os_context_win_tests.cpp

@@ -26,36 +26,30 @@ struct OsContextWinTest : public WddmTestWithMockGdiDll {
 };
 
 TEST_F(OsContextWinTest, givenWddm20WhenCreatingOsContextThenOsContextIsInitialized) {
-    osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false);
-    EXPECT_TRUE(osContext->isInitialized());
+    EXPECT_NO_THROW(osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false));
+    EXPECT_NE(nullptr, osContext);
 }
 
-TEST_F(OsContextWinTest, givenWddm20WhenCreatingWddmContextFailThenOsContextIsNotInitialized) {
+TEST_F(OsContextWinTest, givenWddm20WhenCreatingWddmContextFailThenOsContextCreationFails) {
     wddm->device = INVALID_HANDLE;
-
-    osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false);
-    EXPECT_FALSE(osContext->isInitialized());
+    EXPECT_ANY_THROW(osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false));
 }
 
-TEST_F(OsContextWinTest, givenWddm20WhenCreatingWddmMonitorFenceFailThenOsContextIsNotInitialized) {
+TEST_F(OsContextWinTest, givenWddm20WhenCreatingWddmMonitorFenceFailThenOsContextCreationFails) {
     *getCreateSynchronizationObject2FailCallFcn() = true;
-
-    osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false);
-    EXPECT_FALSE(osContext->isInitialized());
+    EXPECT_ANY_THROW(osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false));
 }
 
-TEST_F(OsContextWinTest, givenWddm20WhenRegisterTrimCallbackFailThenOsContextIsNotInitialized) {
+TEST_F(OsContextWinTest, givenWddm20WhenRegisterTrimCallbackFailThenOsContextCreationFails) {
     *getRegisterTrimNotificationFailCallFcn() = true;
-
-    osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false);
-    EXPECT_FALSE(osContext->isInitialized());
+    EXPECT_ANY_THROW(osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false));
 }
 
 TEST_F(OsContextWinTest, givenWddm20WhenRegisterTrimCallbackIsDisabledThenOsContextIsInitialized) {
     DebugManagerStateRestore stateRestore;
     DebugManager.flags.DoNotRegisterTrimCallback.set(true);
     *getRegisterTrimNotificationFailCallFcn() = true;
 
-    osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false);
-    EXPECT_TRUE(osContext->isInitialized());
+    EXPECT_NO_THROW(osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engineTypeUsage, preemptionMode, false));
+    EXPECT_NE(nullptr, osContext);
 }

opencl/test/unit_test/os_interface/windows/os_interface_win_tests.cpp

@@ -34,7 +34,6 @@ TEST(OsContextTest, givenWddmWhenCreateOsContextAfterInitWddmThenOsContextIsInit
     auto osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1,
                                                     HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
                                                     preemptionMode, false);
-    EXPECT_TRUE(osContext->isInitialized());
     EXPECT_EQ(osContext->getWddm(), wddm);
     EXPECT_EQ(1u, wddm->registerTrimCallbackResult.called);
 }

opencl/test/unit_test/os_interface/windows/wddm23_tests.cpp

@@ -217,8 +217,7 @@ TEST_F(Wddm23TestsWithoutWddmInit, whenInitCalledThenInitializeNewGdiDDIsAndCall
 
 TEST_F(Wddm23TestsWithoutWddmInit, whenCreateHwQueueFailedThenReturnFalseFromInit) {
     wddmMockInterface->forceCreateHwQueueFail = true;
-    init();
-    EXPECT_FALSE(osContext->isInitialized());
+    EXPECT_ANY_THROW(init());
 }
 
 TEST_F(Wddm23TestsWithoutWddmInit, givenFailureOnGdiInitializationWhenCreatingHwQueueThenReturnFailure) {
@@ -229,8 +228,7 @@ TEST_F(Wddm23TestsWithoutWddmInit, givenFailureOnGdiInitializationWhenCreatingHw
     };
     auto myMockGdi = new MyMockGdi();
     wddm->resetGdi(myMockGdi);
-    init();
-    EXPECT_FALSE(osContext->isInitialized());
+    EXPECT_ANY_THROW(init());
     EXPECT_EQ(1u, wddmMockInterface->createHwQueueCalled);
     EXPECT_FALSE(wddmMockInterface->createHwQueueResult);
 }

shared/source/memory_manager/memory_manager.cpp

@@ -258,7 +258,6 @@ OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *comm
     auto contextId = ++latestContextId;
     auto osContext = OsContext::create(peekExecutionEnvironment().rootDeviceEnvironments[commandStreamReceiver->getRootDeviceIndex()]->osInterface.get(),
                                        contextId, deviceBitfield, typeUsage, preemptionMode, rootDevice);
-    UNRECOVERABLE_IF(!osContext->isInitialized());
     osContext->incRefInternal();
 
     registeredEngines.emplace_back(commandStreamReceiver, osContext);

shared/source/os_interface/os_context.h

@@ -35,7 +35,6 @@ class OsContext : public ReferenceTrackedObject<OsContext> {
     bool isLowPriority() const { return engineUsage == EngineUsage::LowPriority; }
     bool isInternalEngine() const { return engineUsage == EngineUsage::Internal; }
     bool isRootDevice() const { return rootDevice; }
-    virtual bool isInitialized() const { return true; }
     virtual bool isDirectSubmissionSupported(const HardwareInfo &hwInfo) const { return false; }
     bool isDefaultContext() const { return defaultContext; }
     void setDefaultContext(bool value) { defaultContext = value; }

shared/source/os_interface/windows/os_context_win.cpp

@@ -28,22 +28,17 @@ OsContextWin::OsContextWin(Wddm &wddm, uint32_t contextId, DeviceBitfield device
       residencyController(wddm, contextId) {
 
     auto wddmInterface = wddm.getWddmInterface();
-    if (!wddm.createContext(*this)) {
-        return;
-    }
+    UNRECOVERABLE_IF(!wddm.createContext(*this));
+
     if (wddmInterface->hwQueuesSupported()) {
-        if (!wddmInterface->createHwQueue(*this)) {
-            return;
-        }
+        UNRECOVERABLE_IF(!wddmInterface->createHwQueue(*this));
     }
-    initialized = wddmInterface->createMonitoredFence(*this);
+    UNRECOVERABLE_IF(!wddmInterface->createMonitoredFence(*this));
+
     residencyController.registerCallback();
+    UNRECOVERABLE_IF(!residencyController.isInitialized());
 };
 
-bool OsContextWin::isInitialized() const {
-    return (initialized && residencyController.isInitialized());
-}
-
 OsContextWin::~OsContextWin() {
     wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle);
     wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence());

shared/source/os_interface/windows/os_context_win.h

@@ -32,12 +32,10 @@ class OsContextWin : public OsContext {
     void setWddmContextHandle(D3DKMT_HANDLE wddmContextHandle) { this->wddmContextHandle = wddmContextHandle; }
     HardwareQueue getHwQueue() const { return hardwareQueue; }
     void setHwQueue(HardwareQueue hardwareQueue) { this->hardwareQueue = hardwareQueue; }
-    bool isInitialized() const override;
     Wddm *getWddm() const { return &wddm; }
     MOCKABLE_VIRTUAL WddmResidencyController &getResidencyController() { return residencyController; }
 
   protected:
-    bool initialized = false;
     D3DKMT_HANDLE wddmContextHandle = 0;
     HardwareQueue hardwareQueue;
     Wddm &wddm;