Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Move Ext Semaphore Controller to Driver Handle

Browse Source 
Related-To: NEO-11488

Signed-off-by: Raiyan Latif <raiyan.latif@intel.com>
This commit is contained in:
Raiyan Latif
2025-01-10 18:52:44 +00:00
committed by Compute-Runtime-Automation
parent cf8551ca06
commit 84b8622c16
7 changed files with 150 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@ -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;

6
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@ -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) {

4
level_zero/core/source/driver/driver_handle_imp.h
View File

@ -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;

20
level_zero/core/source/semaphore/external_semaphore_imp.cpp
View File

@ -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);

18
level_zero/core/source/semaphore/external_semaphore_imp.h
View File

@ -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;
};

204
level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
View File

@ -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

123
level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp
View File

@ -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);
}