Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: Re-enable external semaphore MT test 

Related-To: NEO-11488

Signed-off-by: Raiyan Latif <raiyan.latif@intel.com>
This commit is contained in:
Raiyan Latif 2025-04-23 18:07:11 +00:00 committed by Compute-Runtime-Automation
parent f36e3c7d23
commit e0808523ee
5 changed files with 25 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1037,16 +1037,22 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
for (uint32_t i = 0; i < numExternalSemaphores; i++) {
std::lock_guard<std::mutex> lock(driverHandleImp->externalSemaphoreController->semControllerMutex);
ze_event_handle_t proxyWaitEvent = nullptr;
ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxyWaitEvent, ExternalSemaphoreController::SemaphoreOperation::Wait);
ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(this->device->toHandle(), this->hContext, &proxyWaitEvent);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
ret = this->appendWaitOnEvents(1u, &proxyWaitEvent, nullptr, false, false, false, false, false, false);
if (ret != ZE_RESULT_SUCCESS) {
auto event = Event::fromHandle(proxyWaitEvent);
event->destroy();
return ret;
}
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyWaitEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphores[i])), params[i].value, ExternalSemaphoreController::SemaphoreOperation::Wait));
}
driverHandleImp->externalSemaphoreController->semControllerCv.notify_one();
@ -1082,16 +1088,22 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalS
auto driverHandleImp = static_cast<DriverHandleImp *>(this->device->getDriverHandle());
for (size_t i = 0; i < numExternalSemaphores; i++) {
std::lock_guard<std::mutex> lock(driverHandleImp->externalSemaphoreController->semControllerMutex);
ze_event_handle_t proxySignalEvent = nullptr;
ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxySignalEvent, ExternalSemaphoreController::SemaphoreOperation::Signal);
ret = driverHandleImp->externalSemaphoreController->allocateProxyEvent(this->device->toHandle(), this->hContext, &proxySignalEvent);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
ret = this->appendSignalEvent(proxySignalEvent, false);
if (ret != ZE_RESULT_SUCCESS) {
auto event = Event::fromHandle(proxySignalEvent);
event->destroy();
return ret;
}
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxySignalEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphores[i])), params[i].value, ExternalSemaphoreController::SemaphoreOperation::Signal));
}
driverHandleImp->externalSemaphoreController->semControllerCv.notify_one();

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

@ -118,9 +118,7 @@ std::unique_ptr<ExternalSemaphoreController> ExternalSemaphoreController::create
return std::make_unique<ExternalSemaphoreController>();
}
ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_external_semaphore_ext_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);
ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_device_handle_t hDevice, ze_context_handle_t hContext, ze_event_handle_t *phEvent) {
if (this->eventPoolsMap.find(hDevice) == this->eventPoolsMap.end()) {
this->eventPoolsMap[hDevice] = std::vector<EventPool *>();
this->eventsCreatedFromLatestPoolMap[hDevice] = 0u;
@ -151,8 +149,6 @@ ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_external_semaphor
ze_event_handle_t hEvent{};
pool->createEvent(&desc, &hEvent);
this->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hExtSemaphore)), fenceValue, operation));
*phEvent = hEvent;
return ZE_RESULT_SUCCESS;

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

@ -85,7 +85,7 @@ class ExternalSemaphoreController : NEO::NonCopyableAndNonMovableClass {
}
}
ze_result_t allocateProxyEvent(ze_external_semaphore_ext_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, SemaphoreOperation operation);
ze_result_t allocateProxyEvent(ze_device_handle_t hDevice, ze_context_handle_t hContext, ze_event_handle_t *phEvent);
void processProxyEvents();
std::mutex semControllerMutex;

2
level_zero/core/test/unit_tests/mt_tests/semaphore/windows/test_mt_semaphore_windows.cpp
View File

@ -296,7 +296,7 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
bool failingSignalEvent = false;
};
HWTEST2_F(WddmExternalSemaphoreMTTest, DISABLED_givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
HWTEST2_F(WddmExternalSemaphoreMTTest, givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;

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

@ -450,12 +450,14 @@ HWTEST2_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerWhenAllocatePro
ze_event_handle_t proxyEvent1 = {};
ze_event_handle_t proxyEvent2 = {};
ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent1);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent1), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore1->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 1u);
result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent2);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent2), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore2->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 2u);
}
@ -475,14 +477,16 @@ HWTEST2_F(ExternalSemaphoreTest, givenMaxEventsInPoolCreatedWhenAllocateProxyEve
ze_event_handle_t proxyEvent1 = {};
ze_event_handle_t proxyEvent2 = {};
ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent1, ExternalSemaphoreController::SemaphoreOperation::Wait);
ze_result_t result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent1);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent1), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore1->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 1u);
EXPECT_EQ(driverHandleImp->externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 1u);
driverHandleImp->externalSemaphoreController->eventsCreatedFromLatestPoolMap[l0Device->toHandle()] = 20;
result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device->toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
result = driverHandleImp->externalSemaphoreController->allocateProxyEvent(l0Device->toHandle(), context->toHandle(), &proxyEvent2);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(proxyEvent2), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore2->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Wait));
EXPECT_EQ(driverHandleImp->externalSemaphoreController->proxyEvents.size(), 2u);
EXPECT_EQ(driverHandleImp->externalSemaphoreController->eventPoolsMap[l0Device->toHandle()].size(), 2u);
}