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

fix: Fix ULTs & signal path in External Semaphore

Browse Source 
- Temporarily disables Multi-Threaded ULTs, to be
re-enabled in a separate dedicated test binary

Related-To: NEO-11488

Signed-off-by: Raiyan Latif <raiyan.latif@intel.com>
This commit is contained in:
Raiyan Latif
2025-01-06 23:55:38 +00:00
committed by Compute-Runtime-Automation
parent 9f07f56f7f
commit b8157a2547
14 changed files with 529 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/api/driver_experimental/public/zex_cmdlist.cpp
View File

@ -94,5 +94,5 @@ zeIntelCommandListAppendSignalExternalSemaphoresExp(
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return L0::CommandList::fromHandle(hCmdList)->appendSignalExternalSemaphores(numExternalSemaphores, hSemaphores, params, hSignalEvent, numWaitEvents, phWaitEvents);
}

3
level_zero/core/source/cmdlist/cmdlist.h
View File

@ -175,6 +175,9 @@ struct CommandList : _ze_command_list_handle_t {
virtual ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
virtual ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;
virtual ze_result_t getDeviceHandle(ze_device_handle_t *phDevice) = 0;

3
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@ -177,6 +177,9 @@ struct CommandListCoreFamily : public CommandListImp {
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendQueryKernelTimestamps(uint32_t numEvents, ze_event_handle_t *phEvents, void *dstptr,
const size_t *pOffsets, ze_event_handle_t hSignalEvent,

7
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@ -3861,6 +3861,13 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitExternalSemaphores(u
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
template <GFXCORE_FAMILY gfxCoreFamily>
void CommandListCoreFamily<gfxCoreFamily>::allocateOrReuseKernelPrivateMemoryIfNeeded(Kernel *kernel, uint32_t sizePerHwThread) {
L0::KernelImp *kernelImp = static_cast<KernelImp *>(kernel);

3
level_zero/core/source/cmdlist/cmdlist_hw_immediate.h
View File

@ -176,6 +176,9 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t hostSynchronize(uint64_t timeout) override;

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

@ -986,7 +986,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
for (uint32_t i = 0; i < numExternalSemaphores; i++) {
ze_event_handle_t proxyWaitEvent = nullptr;
ret = externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxyWaitEvent);
ret = externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxyWaitEvent, ExternalSemaphoreController::SemaphoreOperation::Wait);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
@ -1011,6 +1011,51 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
return ZE_RESULT_SUCCESS;
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
checkAvailableSpace(0, false, commonImmediateCommandSize);
auto ret = ZE_RESULT_SUCCESS;
if (numWaitEvents) {
ret = this->appendWaitOnEvents(numWaitEvents, phWaitEvents, nullptr, false, false, true, false, true, false);
}
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
for (size_t i = 0; i < numExternalSemaphores; i++) {
ze_event_handle_t proxySignalEvent = nullptr;
ret = externalSemaphoreController->allocateProxyEvent(hSemaphores[i], this->device->toHandle(), this->hContext, params[i].value, &proxySignalEvent, ExternalSemaphoreController::SemaphoreOperation::Signal);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
ret = this->appendSignalEvent(proxySignalEvent, false);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
}
externalSemaphoreController->semControllerCv.notify_one();
bool relaxedOrderingDispatch = false;
if (hSignalEvent) {
ret = this->appendSignalEvent(hSignalEvent, relaxedOrderingDispatch);
}
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
return ZE_RESULT_SUCCESS;
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::hostSynchronize(uint64_t timeout, bool handlePostWaitOperations) {
ze_result_t status = ZE_RESULT_SUCCESS;

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

@ -16,8 +16,10 @@
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) {
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();
if (externalSemaphore == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@ -112,7 +114,7 @@ ze_result_t ExternalSemaphoreImp::releaseExternalSemaphore() {
return ZE_RESULT_SUCCESS;
}
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) {
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);
if (this->eventPoolsMap.find(hDevice) == this->eventPoolsMap.end()) {
@ -145,29 +147,39 @@ ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_intel_external_se
ze_event_handle_t hEvent{};
pool->createEvent(&desc, &hEvent);
this->proxyWaitEvents.push_back(std::make_tuple(Event::fromHandle(hEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hExtSemaphore)), fenceValue));
this->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hExtSemaphore)), fenceValue, operation));
*phEvent = hEvent;
return ZE_RESULT_SUCCESS;
}
void ExternalSemaphoreController::processWaitEvents() {
for (auto it = proxyWaitEvents.rbegin(); it != proxyWaitEvents.rend();) {
void ExternalSemaphoreController::processProxyEvents() {
for (auto it = proxyEvents.rbegin(); it != proxyEvents.rend();) {
Event *event = std::get<0>(*it);
ExternalSemaphoreImp *externalSemaphoreImp = static_cast<ExternalSemaphoreImp *>(std::get<1>(*it));
uint64_t fenceValue = std::get<2>(*it);
SemaphoreOperation operation = std::get<3>(*it);
if (externalSemaphoreImp->neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Initial) {
externalSemaphoreImp->neoExternalSemaphore->enqueueWait(&fenceValue);
}
if (externalSemaphoreImp->neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Signaled) {
event->hostSignal(false);
event->destroy();
it = std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t>>::reverse_iterator(this->proxyWaitEvents.erase((++it).base()));
if (operation == SemaphoreOperation::Wait) {
if (externalSemaphoreImp->neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Initial) {
externalSemaphoreImp->neoExternalSemaphore->enqueueWait(&fenceValue);
}
if (externalSemaphoreImp->neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Signaled) {
event->hostSignal(false);
event->destroy();
it = std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t, SemaphoreOperation>>::reverse_iterator(this->proxyEvents.erase((++it).base()));
} else {
++it;
}
} else {
++it;
ze_result_t ret = event->hostSynchronize(std::numeric_limits<uint64_t>::max());
if (ret == ZE_RESULT_SUCCESS) {
externalSemaphoreImp->neoExternalSemaphore->enqueueSignal(&fenceValue);
}
event->destroy();
it = std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t, SemaphoreOperation>>::reverse_iterator(this->proxyEvents.erase((++it).base()));
}
}
}
@ -175,12 +187,12 @@ void ExternalSemaphoreController::processWaitEvents() {
void ExternalSemaphoreController::runController() {
while (this->continueRunning) {
std::unique_lock<std::mutex> lock(this->semControllerMutex);
this->semControllerCv.wait(lock, [this] { return (!this->proxyWaitEvents.empty() || !this->continueRunning); });
this->semControllerCv.wait(lock, [this] { return (!this->proxyEvents.empty() || !this->continueRunning); });
if (!this->continueRunning) {
lock.unlock();
} else {
this->processWaitEvents();
this->processProxyEvents();
lock.unlock();
this->semControllerCv.notify_all();

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

@ -36,7 +36,13 @@ class ExternalSemaphoreImp : public ExternalSemaphore {
class ExternalSemaphoreController {
public:
enum SemaphoreOperation {
Wait,
Signal
};
static ExternalSemaphoreController *getInstance() {
std::lock_guard<std::mutex> lock(instanceMutex);
if (instance == nullptr) {
instance = new ExternalSemaphoreController();
}
@ -64,7 +70,7 @@ class ExternalSemaphoreController {
joinThread();
for (auto it = proxyWaitEvents.begin(); it != proxyWaitEvents.end(); ++it) {
for (auto it = proxyEvents.begin(); it != proxyEvents.end(); ++it) {
Event *event = std::get<0>(*it);
event->destroy();
}
@ -79,8 +85,8 @@ class ExternalSemaphoreController {
instance = nullptr;
}
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);
void processWaitEvents();
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);
void processProxyEvents();
std::mutex semControllerMutex;
std::condition_variable semControllerCv;
@ -88,8 +94,7 @@ class ExternalSemaphoreController {
std::unordered_map<ze_device_handle_t, std::vector<EventPool *>> eventPoolsMap;
std::unordered_map<ze_device_handle_t, size_t> eventsCreatedFromLatestPoolMap;
const size_t maxEventCountInPool = 20u;
std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t>> proxyWaitEvents;
std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t>> proxySignalEvents;
std::vector<std::tuple<Event *, ExternalSemaphore *, uint64_t, SemaphoreOperation>> proxyEvents;
bool continueRunning = true;
private:
@ -101,6 +106,7 @@ class ExternalSemaphoreController {
void runController();
static ExternalSemaphoreController *instance;
static std::mutex instanceMutex;
std::thread extSemThread;
};

4
level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
View File

@ -568,6 +568,10 @@ struct MockCommandList : public CommandList {
(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents));
ADDMETHOD_NOBASE(appendSignalExternalSemaphores, ze_result_t, ZE_RESULT_SUCCESS,
(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents));
ADDMETHOD_NOBASE(appendWriteToMemory, ze_result_t, ZE_RESULT_SUCCESS,
(void *desc, void *ptr,

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

@ -49,7 +49,7 @@ HWTEST_F(ExternalSemaphoreTest, givenInvalidDescriptorWhenInitializeIsCalledThen
delete externalSemaphoreImp;
}
HWTEST_F(ExternalSemaphoreTest, givenExternalSemaphoreGetInstanceCalledThenExternalSemaphoreControllerInstanceIsNotNull) {
HWTEST_F(ExternalSemaphoreTest, DISABLED_givenExternalSemaphoreGetInstanceCalledThenExternalSemaphoreControllerInstanceIsNotNull) {
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandle->externalSemaphoreControllerCreated = true;
externalSemaphoreController->startThread();
@ -57,7 +57,7 @@ HWTEST_F(ExternalSemaphoreTest, givenExternalSemaphoreGetInstanceCalledThenExter
EXPECT_NE(externalSemaphoreController, nullptr);
}
HWTEST_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerStartCalledMultipleTimesThenExternalSemaphoreControllerInstanceIsNotNull) {
HWTEST_F(ExternalSemaphoreTest, DISABLED_givenExternalSemaphoreControllerStartCalledMultipleTimesThenExternalSemaphoreControllerInstanceIsNotNull) {
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandle->externalSemaphoreControllerCreated = true;
@ -76,6 +76,17 @@ HWTEST2_F(ExternalSemaphoreTest, givenRegularCommandListWhenAppendWaitExternalSe
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
HWTEST2_F(ExternalSemaphoreTest, givenRegularCommandListWhenAppendSignalExternalSemaphoresIsCalledThenInvalidArgumentIsReturned, MatchAny) {
MockCommandListCoreFamily<gfxCoreFamily> cmdList;
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = reinterpret_cast<ze_intel_external_semaphore_exp_handle_t>(0x1);
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
template <GFXCORE_FAMILY gfxCoreFamily>
struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFamilyImmediate<gfxCoreFamily>> {
MockCommandListImmediateExtSem() : WhiteBox<::L0::CommandListCoreFamilyImmediate<gfxCoreFamily>>() {}
@ -95,6 +106,9 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
ze_result_t appendSignalEvent(ze_event_handle_t hEvent, bool relaxedOrderingDispatch) override {
appendSignalEventCalledTimes++;
if (failOnSecondSignalEvent && appendSignalEventCalledTimes == 2) {
return ZE_RESULT_ERROR_UNKNOWN;
}
if (failingSignalEvent) {
return ZE_RESULT_ERROR_UNKNOWN;
}
@ -105,10 +119,168 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
uint32_t appendSignalEventCalledTimes = 0;
bool failingWaitOnEvents = false;
bool failingSignalEvent = false;
bool failOnSecondSignalEvent = false;
};
using MockDriverHandleImp = Mock<L0::DriverHandleImp>;
HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendSignalExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, 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.setCmdListContext(context);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
signalParams.value = 1u;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
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 driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, 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.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
signalParams.value = 1u;
ze_event_handle_t event;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 1, &event);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
}
HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalInternalProxyEventFailsWhenAppendSignalExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, 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.setCmdListContext(context);
cmdList.failingSignalEvent = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
signalParams.value = 1u;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
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 driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, 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.setCmdListContext(context);
cmdList.failOnSecondSignalEvent = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
signalParams.value = 1u;
ze_event_handle_t waitEvent = {};
MockEvent signalEvent;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_event_handle_t hSignalEvent = signalEvent.toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, hSignalEvent, 1, &waitEvent);
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 driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(failMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(&l0Device, 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.setCmdListContext(context);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
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>();
@ -278,13 +450,13 @@ HWTEST2_F(ExternalSemaphoreTest, givenExternalSemaphoreControllerWhenAllocatePro
ze_event_handle_t proxyEvent1 = {};
ze_event_handle_t proxyEvent2 = {};
ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent1);
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->proxyWaitEvents.size(), 1u);
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent2);
result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(externalSemaphoreController->proxyWaitEvents.size(), 2u);
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 2u);
externalSemaphoreController->releaseResources();
driverHandleImp->externalSemaphoreControllerCreated = false;
@ -308,15 +480,15 @@ HWTEST2_F(ExternalSemaphoreTest, givenMaxEventsInPoolCreatedWhenAllocateProxyEve
ze_event_handle_t proxyEvent1 = {};
ze_event_handle_t proxyEvent2 = {};
ze_result_t result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent1);
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->proxyWaitEvents.size(), 1u);
EXPECT_EQ(externalSemaphoreController->proxyEvents.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);
result = externalSemaphoreController->allocateProxyEvent(externalSemaphore1->toHandle(), l0Device.toHandle(), context->toHandle(), 1u, &proxyEvent2, ExternalSemaphoreController::SemaphoreOperation::Wait);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(externalSemaphoreController->proxyWaitEvents.size(), 2u);
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 2u);
EXPECT_EQ(externalSemaphoreController->eventPoolsMap[l0Device.toHandle()].size(), 2u);
externalSemaphoreController->releaseResources();
@ -337,12 +509,98 @@ class MockNEOExternalSemaphore : public NEO::ExternalSemaphore {
return true;
}
bool enqueueSignal() override {
bool enqueueSignal(uint64_t *fenceValue) override {
this->state = NEO::ExternalSemaphore::SemaphoreState::Signaled;
return true;
}
};
HWTEST2_F(ExternalSemaphoreTest, givenNEOExternalSemaphoreWhenAppendWaitExternalSemaphoresExpIsCalledThenExpectedSemaphoreStateIsReturned, MatchAny) {
class MockExternalSemaphoreEvent : public MockEvent {
public:
MockExternalSemaphoreEvent() : MockEvent() {}
ze_result_t hostSynchronize(uint64_t timeout) override {
hostSynchronizeCalledTimes++;
if (failHostSynchronize) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
bool failHostSynchronize = false;
uint32_t hostSynchronizeCalledTimes = 0;
};
HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEventWhenExternalSemaphoreControllerIsRunningThenExpectedStateIsReturned, MatchAny) {
auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
externalSemaphore->neoExternalSemaphore = std::make_unique<MockNEOExternalSemaphore>();
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandleImp->externalSemaphoreControllerCreated = true;
auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
auto hProxyEvent = proxyEvent->toHandle();
externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hProxyEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Signal));
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
proxyEvent->hostSignal(false);
externalSemaphoreController->startThread();
auto mockNEOExternalSemaphore = static_cast<MockNEOExternalSemaphore *>(externalSemaphore->neoExternalSemaphore.get());
std::unique_lock<std::mutex> lock(externalSemaphoreController->semControllerMutex);
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) {
auto externalSemaphore = std::make_unique<ExternalSemaphoreImp>();
externalSemaphore->neoExternalSemaphore = std::make_unique<MockNEOExternalSemaphore>();
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandleImp->externalSemaphoreControllerCreated = true;
auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
auto hProxyEvent = proxyEvent->toHandle();
proxyEvent->failHostSynchronize = true;
externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hProxyEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(externalSemaphore->toHandle())), 1u, ExternalSemaphoreController::SemaphoreOperation::Signal));
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
proxyEvent->hostSignal(false);
externalSemaphoreController->startThread();
auto mockNEOExternalSemaphore = static_cast<MockNEOExternalSemaphore *>(externalSemaphore->neoExternalSemaphore.get());
std::unique_lock<std::mutex> lock(externalSemaphoreController->semControllerMutex);
externalSemaphoreController->semControllerCv.wait(lock, [&] { return (externalSemaphoreController->proxyEvents.empty()); });
EXPECT_EQ(mockNEOExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Initial);
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 driverHandleImp = std::make_unique<MockDriverHandleImp>();

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

@ -47,7 +47,7 @@ class WddmSemaphoreFixture : public DeviceFixture {
using WddmExternalSemaphoreTest = Test<WddmSemaphoreFixture>;
using MockDriverHandleImp = Mock<L0::DriverHandleImp>;
HWTEST_F(WddmExternalSemaphoreTest, givenValidExternalSemaphoreWhenImportExternalSemaphoreExpIsCalledThenSuccessIsReturned) {
HWTEST_F(WddmExternalSemaphoreTest, DISABLED_givenValidExternalSemaphoreWhenImportExternalSemaphoreExpIsCalledThenSuccessIsReturned) {
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
ze_intel_external_semaphore_exp_desc_t desc = {};
@ -71,7 +71,135 @@ HWTEST_F(WddmExternalSemaphoreTest, givenValidExternalSemaphoreWhenImportExterna
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, givenImmediateCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
class MockFailGdi : public MockGdi {
public:
MockFailGdi() : MockGdi() {
signalSynchronizationObjectFromCpu = mockD3DKMTSignalSynchronizationObjectFromCpu;
}
static NTSTATUS __stdcall mockD3DKMTSignalSynchronizationObjectFromCpu(IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU *) {
return STATUS_UNSUCCESSFUL;
}
};
class MockExternalSemaphoreEvent : public MockEvent {
public:
MockExternalSemaphoreEvent() : MockEvent() {}
ze_result_t hostSynchronize(uint64_t timeout) override {
hostSynchronizeCalledTimes++;
if (failOnFirstHostSynchronize && hostSynchronizeCalledTimes == 1) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
bool failOnFirstHostSynchronize = false;
uint32_t hostSynchronizeCalledTimes = 0;
};
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExternalSemaphoreControllerIsRunningThenExpectedStateIsReturned, MatchAny) {
auto mockGdi = new MockFailGdi();
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
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;
HANDLE extSemaphoreHandle = 0;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandleImp->externalSemaphoreControllerCreated = true;
auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
auto hProxyEvent = proxyEvent->toHandle();
externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hProxyEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphore)), 1u, ExternalSemaphoreController::SemaphoreOperation::Signal));
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
proxyEvent->hostSignal(false);
externalSemaphoreController->startThread();
auto externalSemaphore = static_cast<ExternalSemaphoreImp *>(ExternalSemaphore::fromHandle(hSemaphore));
auto neoExternalSemaphore = externalSemaphore->neoExternalSemaphore.get();
std::unique_lock<std::mutex> lock(externalSemaphoreController->semControllerMutex);
externalSemaphoreController->semControllerCv.wait(lock, [&] { return (externalSemaphoreController->proxyEvents.empty()); });
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 driverHandleImp = std::make_unique<MockDriverHandleImp>();
driverHandleImp->setMemoryManager(mockMemoryManager.get());
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
l0Device.setDriverHandle(driverHandleImp.get());
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ExternalSemaphoreController *externalSemaphoreController = ExternalSemaphoreController::getInstance();
driverHandleImp->externalSemaphoreControllerCreated = true;
auto proxyEvent = std::make_unique<MockExternalSemaphoreEvent>();
auto hProxyEvent = proxyEvent->toHandle();
externalSemaphoreController->proxyEvents.push_back(std::make_tuple(Event::fromHandle(hProxyEvent), static_cast<ExternalSemaphore *>(ExternalSemaphore::fromHandle(hSemaphore)), 1u, ExternalSemaphoreController::SemaphoreOperation::Signal));
EXPECT_EQ(externalSemaphoreController->proxyEvents.size(), 1u);
proxyEvent->hostSignal(false);
externalSemaphoreController->startThread();
auto externalSemaphore = static_cast<ExternalSemaphoreImp *>(ExternalSemaphore::fromHandle(hSemaphore));
auto neoExternalSemaphore = externalSemaphore->neoExternalSemaphore.get();
std::unique_lock<std::mutex> lock(externalSemaphoreController->semControllerMutex);
externalSemaphoreController->semControllerCv.wait(lock, [&] { return (neoExternalSemaphore->getState() == NEO::ExternalSemaphore::SemaphoreState::Signaled); });
EXPECT_EQ(neoExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Signaled);
lock.unlock();
externalSemaphoreController->releaseResources();
driverHandleImp->externalSemaphoreControllerCreated = false;
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenImmediateCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
@ -121,7 +249,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, givenImmediateCommandListWhenAppendWaitExte
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, givenRegularCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenInvalidArgumentIsReturned, MatchAny) {
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenRegularCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenInvalidArgumentIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
@ -192,7 +320,7 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
bool failingSignalEvent = false;
};
HWTEST2_F(WddmExternalSemaphoreTest, givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
@ -242,7 +370,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, givenInternalProxyEventFailsToAppendWhenApp
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, givenWaitEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
@ -293,7 +421,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, givenWaitEventFailsToAppendWhenAppendWaitEx
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, givenSignalEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;

2
shared/source/os_interface/external_semaphore.h
View File

@ -48,7 +48,7 @@ class ExternalSemaphore {
virtual bool importSemaphore(void *extHandle, int fd, uint32_t flags, const char *name, Type type, bool isNative) = 0;
virtual bool enqueueWait(uint64_t *fenceValue) = 0;
virtual bool enqueueSignal() = 0;
virtual bool enqueueSignal(uint64_t *fenceValue) = 0;
OSInterface *osInterface = nullptr;

19
shared/source/os_interface/windows/external_semaphore_windows.cpp
View File

@ -79,8 +79,23 @@ bool ExternalSemaphoreWindows::enqueueWait(uint64_t *fenceValue) {
return true;
}
bool ExternalSemaphoreWindows::enqueueSignal() {
return false;
bool ExternalSemaphoreWindows::enqueueSignal(uint64_t *fenceValue) {
auto wddm = this->osInterface->getDriverModel()->as<Wddm>();
D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU signal = {};
signal.hDevice = wddm->getDeviceHandle();
signal.ObjectCount = 1;
signal.ObjectHandleArray = &this->syncHandle;
signal.FenceValueArray = fenceValue;
auto status = wddm->getGdi()->signalSynchronizationObjectFromCpu(&signal);
if (status != STATUS_SUCCESS) {
return false;
}
this->state = SemaphoreState::Signaled;
return true;
}
} // namespace NEO

2
shared/source/os_interface/windows/external_semaphore_windows.h
View File

@ -29,7 +29,7 @@ class ExternalSemaphoreWindows : public ExternalSemaphore {
bool importSemaphore(void *extHandle, int fd, uint32_t flags, const char *name, Type type, bool isNative) override;
bool enqueueWait(uint64_t *fenceValue) override;
bool enqueueSignal() override;
bool enqueueSignal(uint64_t *fenceValue) override;
protected:
D3DKMT_HANDLE syncHandle;