diff --git a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
index 7f6c5edb3e..5d8a5d376f 100644
--- a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
+++ b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
@@ -982,7 +982,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
         return ret;
     }
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
+    auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
 
     for (uint32_t i = 0; i < numExternalSemaphores; i++) {
         ze_event_handle_t proxyWaitEvent = nullptr;
@@ -1027,7 +1028,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalS
         return ret;
     }
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
+    auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
 
     for (size_t i = 0; i < numExternalSemaphores; i++) {
         ze_event_handle_t proxySignalEvent = nullptr;
diff --git a/level_zero/core/source/driver/driver_handle_imp.cpp b/level_zero/core/source/driver/driver_handle_imp.cpp
index 8014d1f310..9981c7dc3d 100644
--- a/level_zero/core/source/driver/driver_handle_imp.cpp
+++ b/level_zero/core/source/driver/driver_handle_imp.cpp
@@ -184,9 +184,9 @@ ze_result_t DriverHandleImp::getExtensionProperties(uint32_t *pCount,
 }
 
 DriverHandleImp::~DriverHandleImp() {
-    if (this->externalSemaphoreControllerCreated) {
-        ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-        externalSemaphoreController->releaseResources();
+    if (this->externalSemaphoreController) {
+        this->externalSemaphoreController->releaseResources();
+        this->externalSemaphoreController = nullptr;
     }
 
     if (memoryManager != nullptr) {
diff --git a/level_zero/core/source/driver/driver_handle_imp.h b/level_zero/core/source/driver/driver_handle_imp.h
index ad1bc996bd..411b02c647 100644
--- a/level_zero/core/source/driver/driver_handle_imp.h
+++ b/level_zero/core/source/driver/driver_handle_imp.h
@@ -25,6 +25,7 @@ class HostPointerManager;
 struct FabricVertex;
 struct FabricEdge;
 struct Image;
+class ExternalSemaphoreController;
 
 enum L0DeviceHierarchyMode {
     L0_DEVICE_HIERARCHY_COMPOSITE,
@@ -154,7 +155,8 @@ struct DriverHandleImp : public DriverHandle {
     std::unique_ptr<NEO::OsLibrary> rtasLibraryHandle;
     bool rtasLibraryUnavailable = false;
 
-    bool externalSemaphoreControllerCreated = false;
+    ExternalSemaphoreController *externalSemaphoreController = nullptr;
+    std::mutex externalSemaphoreControllerMutex;
 
     uint32_t numDevices = 0;
 
diff --git a/level_zero/core/source/semaphore/external_semaphore_imp.cpp b/level_zero/core/source/semaphore/external_semaphore_imp.cpp
index 170d66d446..7d0aebddb9 100644
--- a/level_zero/core/source/semaphore/external_semaphore_imp.cpp
+++ b/level_zero/core/source/semaphore/external_semaphore_imp.cpp
@@ -15,9 +15,6 @@
 
 namespace L0 {
 
-ExternalSemaphoreController *ExternalSemaphoreController::instance = nullptr;
-std::mutex ExternalSemaphoreController::instanceMutex;
-
 ze_result_t
 ExternalSemaphore::importExternalSemaphore(ze_device_handle_t device, const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc, ze_intel_external_semaphore_exp_handle_t *phSemaphore) {
     auto externalSemaphore = new ExternalSemaphoreImp();
@@ -31,11 +28,14 @@ ExternalSemaphore::importExternalSemaphore(ze_device_handle_t device, const ze_i
         return result;
     }
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    externalSemaphoreController->startThread();
+    auto driverHandle = Device::fromHandle(device)->getDriverHandle();
+    auto driverHandleImp = static_cast<DriverHandleImp *>(driverHandle);
 
-    auto driverHandleImp = static_cast<DriverHandleImp *>(L0::Device::fromHandle(device)->getDriverHandle());
-    driverHandleImp->externalSemaphoreControllerCreated = true;
+    std::lock_guard<std::mutex> lock(driverHandleImp->externalSemaphoreControllerMutex);
+    if (driverHandleImp->externalSemaphoreController == nullptr) {
+        driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+        driverHandleImp->externalSemaphoreController->startThread();
+    }
 
     *phSemaphore = externalSemaphore;
 
@@ -114,6 +114,12 @@ ze_result_t ExternalSemaphoreImp::releaseExternalSemaphore() {
     return ZE_RESULT_SUCCESS;
 }
 
+ExternalSemaphoreController *ExternalSemaphoreController::create() {
+    auto externalSemaphoreController = new ExternalSemaphoreController();
+
+    return externalSemaphoreController;
+}
+
 ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_intel_external_semaphore_exp_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, ExternalSemaphoreController::SemaphoreOperation operation) {
     std::lock_guard<std::mutex> lock(this->semControllerMutex);
 
diff --git a/level_zero/core/source/semaphore/external_semaphore_imp.h b/level_zero/core/source/semaphore/external_semaphore_imp.h
index 5c79e48252..be23cca6f8 100644
--- a/level_zero/core/source/semaphore/external_semaphore_imp.h
+++ b/level_zero/core/source/semaphore/external_semaphore_imp.h
@@ -41,13 +41,7 @@ class ExternalSemaphoreController {
         Signal
     };
 
-    static ExternalSemaphoreController *getInstance() {
-        std::lock_guard<std::mutex> lock(instanceMutex);
-        if (instance == nullptr) {
-            instance = new ExternalSemaphoreController();
-        }
-        return instance;
-    }
+    static ExternalSemaphoreController *create();
 
     void startThread() {
         if (!extSemThread.joinable()) {
@@ -81,8 +75,7 @@ class ExternalSemaphoreController {
             }
         }
 
-        delete instance;
-        instance = nullptr;
+        delete this;
     }
 
     ze_result_t allocateProxyEvent(ze_intel_external_semaphore_exp_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, SemaphoreOperation operation);
@@ -98,15 +91,8 @@ class ExternalSemaphoreController {
     bool continueRunning = true;
 
   private:
-    ExternalSemaphoreController() = default;
-
-    ExternalSemaphoreController(const ExternalSemaphoreController &) = delete;
-    ExternalSemaphoreController &operator=(const ExternalSemaphoreController &) = delete;
-
     void runController();
 
-    static ExternalSemaphoreController *instance;
-    static std::mutex instanceMutex;
     std::thread extSemThread;
 };
 
diff --git a/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp b/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
index cd9fad607a..ee392c84d8 100644
--- a/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
+++ b/level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
@@ -50,21 +50,19 @@ HWTEST_F(ExternalSemaphoreTest, givenInvalidDescriptorWhenInitializeIsCalledThen
 }
 
 HWTEST_F(ExternalSemaphoreTest, DISABLED_givenExternalSemaphoreGetInstanceCalledThenExternalSemaphoreControllerInstanceIsNotNull) {
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandle->externalSemaphoreControllerCreated = true;
-    externalSemaphoreController->startThread();
+    driverHandle->externalSemaphoreController = ExternalSemaphoreController::create();
+    driverHandle->externalSemaphoreController->startThread();
 
-    EXPECT_NE(externalSemaphoreController, nullptr);
+    EXPECT_NE(driverHandle->externalSemaphoreController, nullptr);
 }
 
 HWTEST_F(ExternalSemaphoreTest, DISABLED_givenExternalSemaphoreControllerStartCalledMultipleTimesThenExternalSemaphoreControllerInstanceIsNotNull) {
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandle->externalSemaphoreControllerCreated = true;
+    driverHandle->externalSemaphoreController = ExternalSemaphoreController::create();
 
-    externalSemaphoreController->startThread();
-    externalSemaphoreController->startThread();
+    driverHandle->externalSemaphoreController->startThread();
+    driverHandle->externalSemaphoreController->startThread();
 
-    EXPECT_NE(externalSemaphoreController, nullptr);
+    EXPECT_NE(driverHandle->externalSemaphoreController, nullptr);
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenRegularCommandListWhenAppendWaitExternalSemaphoresIsCalledThenInvalidArgumentIsReturned, MatchAny) {
@@ -127,20 +125,21 @@ using MockDriverHandleImp = Mock<L0::DriverHandleImp>;
 HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendSignalExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
 
     ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
@@ -151,27 +150,27 @@ HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendSignalExtern
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 1u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendSignalExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
+
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failingWaitOnEvents = true;
 
@@ -188,20 +187,21 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendSignalExte
 HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalInternalProxyEventFailsWhenAppendSignalExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failingSignalEvent = true;
 
@@ -213,27 +213,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalInternalProxyEventFailsWhenApp
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 1u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendSignalExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failOnSecondSignalEvent = true;
 
@@ -248,27 +247,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendSignalExte
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 2u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendSignalExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto failMemoryManager = std::make_unique<FailMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
 
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(failMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(&l0Device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
 
     ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
@@ -277,27 +275,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendSignalExtern
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 0u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
@@ -307,27 +304,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendWaitExternal
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 0u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failingWaitOnEvents = true;
 
@@ -343,20 +339,21 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendWaitExtern
 HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnInternalProxyEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failingWaitOnEvents = true;
 
@@ -367,27 +364,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnInternalProxyEventFailsWhenApp
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 0u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
     cmdList.failingSignalEvent = true;
 
@@ -401,27 +397,26 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendWaitExtern
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 2u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 1u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto failMemoryManager = std::make_unique<FailMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
-    driverHandleImp->setMemoryManager(failMemoryManager.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->setMemoryManager(failMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
+
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(&l0Device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
@@ -430,8 +425,6 @@ HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendWaitExternal
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
     EXPECT_EQ(cmdList.appendSignalEventCalledTimes, 0u);
-
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerWhenAllocateProxyEventMultipleIsCalledMultipleTimesThenSuccessIsReturned, MatchAny) {
@@ -439,60 +432,53 @@ HWTEST2_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerWhenAllocatePro
     auto externalSemaphore2 = std::make_unique<ExternalSemaphoreImp>();
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
     ze_event_handle_t proxyEvent1 = {};
     ze_event_handle_t proxyEvent2 = {};
 
-    ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
 
-    result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 2u);
-
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, givenMaxEventsInPoolCreatedWhenAllocateProxyEventCalledThenEventPoolSizeIncreases, MatchAny) {
     auto externalSemaphore1 = std::make_unique<ExternalSemaphoreImp>();
     auto externalSemaphore2 = std::make_unique<ExternalSemaphoreImp>();
 
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
-
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
-    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device.toHandle()].size(), 0u);
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
+    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 0u);
 
     ze_event_handle_t proxyEvent1 = {};
     ze_event_handle_t proxyEvent2 = {};
 
-    ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
-    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device.toHandle()].size(), 1u);
+    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 1u);
 
-    externalSemaphoreController->eventsCreatedFromLatestPoolMap[l0Device.toHandle()] = 20;
-    result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
+    externalSemaphoreController->eventsCreatedFromLatestPoolMap[l0Device->toHandle()] = 20;
+    result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 2u);
-    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device.toHandle()].size(), 2u);
-
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
+    EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 2u);
 }
 
 class MockNEOExternalSemaphore : public NEO::ExternalSemaphore {
@@ -536,14 +522,14 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEventWhen
     externalSemaphore->neoExternalSemaphore = std::make_unique<MockNEOExternalSemaphore>();
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
     auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
     auto hProxyEvent = proxyEvent->toHandle();
 
@@ -559,9 +545,6 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEventWhen
     externalSemaphoreController->semControllerCv.wait(lock, [&] { return (mockNEOExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Signaled); });
     EXPECT_EQ(mockNEOExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Signaled);
     lock.unlock();
-
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenHostSynchronizeFailsWhenExternalSemaphoreControllerIsRunningThenExpectedStateIsReturned, MatchAny) {
@@ -569,14 +552,14 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenHostSynchronizeFailsWhenExternalS
     externalSemaphore->neoExternalSemaphore = std::make_unique<MockNEOExternalSemaphore>();
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
     auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
     auto hProxyEvent = proxyEvent->toHandle();
     proxyEvent->failHostSynchronize = true;
@@ -595,34 +578,30 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenHostSynchronizeFailsWhenExternalS
     lock.unlock();
 
     EXPECT_EQ(proxyEvent->hostSynchronizeCalledTimes, 1u);
-
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
 }
 
 HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenNEOExternalSemaphoreWhenAppendWaitExternalSemaphoresExpIsCalledThenExpectedSemaphoreStateIsReturned, MatchAny) {
     auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
 
     externalSemaphore->neoExternalSemaphore = std::make_unique<MockNEOExternalSemaphore>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
     cmdList.cmdQImmediate = queue.get();
-    cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
+    cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
     cmdList.setCmdListContext(context);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
     externalSemaphoreController->startThread();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
 
     auto mockNEOExternalSemaphore = static_cast<MockNEOExternalSemaphore *>(externalSemaphore->neoExternalSemaphore.get());
     EXPECT_EQ(mockNEOExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Initial);
@@ -644,9 +623,6 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenNEOExternalSemaphoreWhenAppendWai
     externalSemaphoreController->semControllerCv.notify_all();
 
     EXPECT_EQ(mockNEOExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Signaled);
-
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
 }
 
 } // namespace ult
diff --git a/level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp b/level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp
index ebd343ac3e..617f81ce50 100644
--- a/level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp
+++ b/level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp
@@ -48,13 +48,13 @@ using WddmExternalSemaphoreTest = Test<WddmSemaphoreFixture>;
 using MockDriverHandleImp = Mock<L0::DriverHandleImp>;
 
 HWTEST_F(WddmExternalSemaphoreTest, DISABLED_givenValidExternalSemaphoreWhenImportExternalSemaphoreExpIsCalledThenSuccessIsReturned) {
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     ze_intel_external_semaphore_exp_desc_t desc = {};
     ze_intel_external_semaphore_exp_handle_t hSemaphore;
     HANDLE extSemaphoreHandle = 0;
 
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
 
@@ -65,7 +65,7 @@ HWTEST_F(WddmExternalSemaphoreTest, DISABLED_givenValidExternalSemaphoreWhenImpo
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
@@ -101,13 +101,12 @@ class MockExternalSemaphoreEvent : public MockEvent {
 HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExternalSemaphoreControllerIsRunningThenExpectedStateIsReturned, MatchAny) {
     auto mockGdi = new MockFailGdi();
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
-
-    static_cast<OsEnvironmentWin *>(l0Device.neoDevice->getExecutionEnvironment()->osEnvironment.get())->gdi.reset(mockGdi);
+    static_cast<OsEnvironmentWin *>(l0Device->neoDevice->getExecutionEnvironment()->osEnvironment.get())->gdi.reset(mockGdi);
 
     ze_intel_external_semaphore_exp_desc_t desc = {};
     ze_intel_external_semaphore_exp_handle_t hSemaphore;
@@ -121,11 +120,11 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExterna
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
     auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
     auto hProxyEvent = proxyEvent->toHandle();
 
@@ -143,20 +142,16 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExterna
     EXPECT_EQ(neoExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Initial);
     lock.unlock();
 
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
 
 HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEventWhenExternalSemaphoreControllerIsRunningThenExpectedStateIsReturned, MatchAny) {
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_intel_external_semaphore_exp_desc_t desc = {};
     ze_intel_external_semaphore_exp_handle_t hSemaphore;
@@ -170,11 +165,11 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEvent
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    driverHandleImp->externalSemaphoreControllerCreated = true;
+    driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
+    auto externalSemaphoreController = driverHandleImp->externalSemaphoreController;
     auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
     auto hProxyEvent = proxyEvent->toHandle();
 
@@ -188,13 +183,10 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEvent
     auto neoExternalSemaphore = externalSemaphore->neoExternalSemaphore.get();
 
     std::unique_lock<std::mutex> lock(externalSemaphoreController->semControllerMutex);
-    externalSemaphoreController->semControllerCv.wait(lock, [&] { return (neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Signaled); });
+    externalSemaphoreController->semControllerCv.wait(lock, [&] { return (externalSemaphoreController->proxyEvents.empty()); });
     EXPECT_EQ(neoExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Signaled);
     lock.unlock();
 
-    externalSemaphoreController->releaseResources();
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
@@ -205,20 +197,18 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenImmediateCommandListWhenAppen
     HANDLE extSemaphoreHandle = 0;
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     std::unique_ptr<L0::CommandList> commandList;
     ze_result_t returnValue;
 
-    commandList.reset(CommandList::createImmediate(productFamily, &l0Device, &queueDesc, false, NEO::EngineGroupType::renderCompute, returnValue));
+    commandList.reset(CommandList::createImmediate(productFamily, l0Device.get(), &queueDesc, false, NEO::EngineGroupType::renderCompute, returnValue));
     commandList->setCmdListContext(context);
     auto &cmdList = static_cast<MockCommandListImmediate<gfxCoreFamily> &>(*commandList);
 
@@ -231,20 +221,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenImmediateCommandListWhenAppen
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
     result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    if (externalSemaphoreController) {
-        externalSemaphoreController->releaseResources();
-    }
-
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
@@ -255,12 +238,10 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenRegularCommandListWhenAppendW
     HANDLE extSemaphoreHandle = 0;
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     MockCommandListCoreFamily<gfxCoreFamily> cmdList;
     cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
@@ -274,20 +255,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenRegularCommandListWhenAppendW
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
     result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
     EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    if (externalSemaphoreController) {
-        externalSemaphoreController->releaseResources();
-    }
-
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
@@ -326,15 +300,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenInternalProxyEventFailsToAppe
     HANDLE extSemaphoreHandle = 0;
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
@@ -352,20 +324,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenInternalProxyEventFailsToAppe
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
     result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    if (externalSemaphoreController) {
-        externalSemaphoreController->releaseResources();
-    }
-
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
@@ -376,15 +341,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenApp
     HANDLE extSemaphoreHandle = 0;
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
@@ -402,7 +365,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenApp
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
@@ -410,13 +373,6 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenApp
     result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 1, &waitEvent);
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    if (externalSemaphoreController) {
-        externalSemaphoreController->releaseResources();
-    }
-
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }
@@ -427,15 +383,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWai
     HANDLE extSemaphoreHandle = 0;
 
     auto mockMemoryManager = std::make_unique<MockMemoryManager>();
-
+    auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
     auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
     driverHandleImp->setMemoryManager(mockMemoryManager.get());
-
-    MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
-    l0Device.setDriverHandle(driverHandleImp.get());
+    l0Device->setDriverHandle(driverHandleImp.get());
 
     ze_command_queue_desc_t queueDesc = {};
-    auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, l0Device.getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
+    auto queue = std::make_unique<Mock<CommandQueue>>(l0Device.get(), l0Device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
 
     MockCommandListImmediateExtSem<gfxCoreFamily> cmdList;
     cmdList.cmdListType = CommandList::CommandListType::typeImmediate;
@@ -453,7 +407,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWai
 
     desc.pNext = &win32Desc;
 
-    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
+    ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
     ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
@@ -462,13 +416,6 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWai
     result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, signalEvent.toHandle(), 0, nullptr);
     EXPECT_NE(result, ZE_RESULT_SUCCESS);
 
-    ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
-    if (externalSemaphoreController) {
-        externalSemaphoreController->releaseResources();
-    }
-
-    driverHandleImp->externalSemaphoreControllerCreated = false;
-
     result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 }