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: unify event creation functions

Browse Source 
Related-To: NEO-11925

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski
2024-11-06 11:23:46 +00:00
committed by Compute-Runtime-Automation
parent df7e5191ed
commit efc31fbe06
5 changed files with 121 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
level_zero/api/driver_experimental/public/zex_event.cpp
View File

@ -46,42 +46,42 @@ ZE_APIEXPORT ze_result_t ZE_APICALL
zexCounterBasedEventCreate(ze_context_handle_t hContext, ze_device_handle_t hDevice, uint64_t *deviceAddress, uint64_t *hostAddress, uint64_t completionValue, const ze_event_desc_t *desc, ze_event_handle_t *phEvent) {
constexpr uint32_t counterBasedFlags = (ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE | ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE);
constexpr EventDescriptor eventDescriptor = {
nullptr, // eventPoolAllocation
0, // totalEventSize
EventPacketsCount::maxKernelSplit, // maxKernelCount
0, // maxPacketsCount
counterBasedFlags, // counterBasedFlags
false, // timestampPool
false, // kerneMappedTsPoolFlag
false, // importedIpcPool
false, // ipcPool
};
auto device = Device::fromHandle(toInternalType(hDevice));
if (!hDevice || !desc || !phEvent) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
NEO::SvmAllocationData *externalHostAllocData = nullptr;
if (hostAddress) {
bool allocFound = device->getDriverHandle()->findAllocationDataForRange(hostAddress, sizeof(uint64_t), externalHostAllocData);
if (!allocFound) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
EventDescriptor eventDescriptor = {
nullptr, // eventPoolAllocation
desc->pNext, // extensions
0, // totalEventSize
EventPacketsCount::maxKernelSplit, // maxKernelCount
0, // maxPacketsCount
counterBasedFlags, // counterBasedFlags
0, // index
0, // signalScope
0, // waitScope
false, // timestampPool
false, // kerneMappedTsPoolFlag
false, // importedIpcPool
false, // ipcPool
};
zex_counter_based_event_external_sync_alloc_properties_t externalSyncAllocProperties = {ZEX_STRUCTURE_COUTER_BASED_EVENT_EXTERNAL_SYNC_ALLOC_PROPERTIES}; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange), NEO-12901
externalSyncAllocProperties.completionValue = completionValue;
externalSyncAllocProperties.deviceAddress = deviceAddress;
externalSyncAllocProperties.hostAddress = hostAddress;
if (externalSyncAllocProperties.deviceAddress && externalSyncAllocProperties.hostAddress) {
externalSyncAllocProperties.pNext = desc->pNext;
eventDescriptor.extensions = &externalSyncAllocProperties;
}
*phEvent = Event::create<uint64_t>(eventDescriptor, desc, device);
ze_result_t result = ZE_RESULT_SUCCESS;
*phEvent = Event::create<uint64_t>(eventDescriptor, device, result);
if (hostAddress && deviceAddress) {
NEO::GraphicsAllocation *allocation = nullptr;
allocation = externalHostAllocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
auto inOrderExecInfo = NEO::InOrderExecInfo::createFromExternalAllocation(*device->getNEODevice(), nullptr, castToUint64(deviceAddress), allocation, hostAddress, completionValue, 1, 1);
Event::fromHandle(*phEvent)->updateInOrderExecState(inOrderExecInfo, completionValue, 0);
}
return ZE_RESULT_SUCCESS;
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL zexIntelAllocateNetworkInterrupt(ze_context_handle_t hContext, uint32_t &networkInterruptId) {

70
level_zero/core/source/event/event.cpp
View File

@ -38,8 +38,8 @@
namespace L0 {
template Event *Event::create<uint64_t>(EventPool *, const ze_event_desc_t *, Device *);
template Event *Event::create<uint32_t>(EventPool *, const ze_event_desc_t *, Device *);
template Event *Event::create<uint64_t>(const EventDescriptor &, const ze_event_desc_t *, Device *);
template Event *Event::create<uint32_t>(const EventDescriptor &, const ze_event_desc_t *, Device *);
template Event *Event::create<uint64_t>(const EventDescriptor &, Device *, ze_result_t &);
template Event *Event::create<uint32_t>(const EventDescriptor &, Device *, ze_result_t &);
bool Event::standaloneInOrderTimestampAllocationEnabled() {
return (NEO::debugManager.flags.StandaloneInOrderTimestampAllocationEnabled.get() != 0);
@ -302,26 +302,28 @@ ze_result_t Event::openCounterBasedIpcHandle(const IpcCounterBasedEventData &ipc
const EventDescriptor eventDescriptor = {
nullptr, // eventPoolAllocation
nullptr, // extensions
0, // totalEventSize
EventPacketsCount::maxKernelSplit, // maxKernelCount
0, // maxPacketsCount
ipcData.counterBasedFlags, // counterBasedFlags
0, // index
ipcData.signalScopeFlags, // signalScope
ipcData.waitScopeFlags, // waitScope
false, // timestampPool
false, // kerneMappedTsPoolFlag
true, // importedIpcPool
false, // ipcPool
};
ze_event_desc_t desc = {ZE_STRUCTURE_TYPE_EVENT_DESC};
desc.signal = ipcData.signalScopeFlags;
desc.wait = ipcData.waitScopeFlags;
ze_result_t result = ZE_RESULT_SUCCESS;
auto event = Event::create<uint64_t>(eventDescriptor, &desc, device);
auto event = Event::create<uint64_t>(eventDescriptor, device, result);
event->updateInOrderExecState(inOrderExecInfo, ipcData.counterValue, ipcData.counterOffset);
*eventHandle = event;
return ZE_RESULT_SUCCESS;
return result;
}
ze_result_t Event::getCounterBasedIpcHandle(IpcCounterBasedEventData &ipcData) {
@ -659,4 +661,58 @@ void Event::resetInOrderTimestampNode(NEO::TagNodeBase *newNode) {
inOrderTimestampNode = newNode;
}
ze_result_t Event::enableExtensions(const EventDescriptor &eventDescriptor) {
bool interruptMode = false;
bool kmdWaitMode = false;
bool externalInterruptWait = false;
auto extendedDesc = reinterpret_cast<const ze_base_desc_t *>(eventDescriptor.extensions);
while (extendedDesc) {
if (extendedDesc->stype == ZEX_INTEL_STRUCTURE_TYPE_EVENT_SYNC_MODE_EXP_DESC) {
auto eventSyncModeDesc = reinterpret_cast<const zex_intel_event_sync_mode_exp_desc_t *>(extendedDesc);
interruptMode = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT);
kmdWaitMode = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT);
externalInterruptWait = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_EXTERNAL_INTERRUPT_WAIT);
if (externalInterruptWait) {
setExternalInterruptId(eventSyncModeDesc->externalInterruptId);
UNRECOVERABLE_IF(eventSyncModeDesc->externalInterruptId > 0 && eventDescriptor.eventPoolAllocation);
}
} else if (extendedDesc->stype == ZEX_STRUCTURE_COUTER_BASED_EVENT_EXTERNAL_SYNC_ALLOC_PROPERTIES) {
auto externalSyncAllocProperties = reinterpret_cast<const zex_counter_based_event_external_sync_alloc_properties_t *>(extendedDesc);
if (!externalSyncAllocProperties->deviceAddress || !externalSyncAllocProperties->hostAddress) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
NEO::SvmAllocationData *externalHostAllocData = nullptr;
if (!device->getDriverHandle()->findAllocationDataForRange(externalSyncAllocProperties->hostAddress, sizeof(uint64_t), externalHostAllocData)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
auto allocation = externalHostAllocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
auto inOrderExecInfo = NEO::InOrderExecInfo::createFromExternalAllocation(*device->getNEODevice(), nullptr, castToUint64(externalSyncAllocProperties->deviceAddress),
allocation, externalSyncAllocProperties->hostAddress, externalSyncAllocProperties->completionValue, 1, 1);
updateInOrderExecState(inOrderExecInfo, externalSyncAllocProperties->completionValue, 0);
}
extendedDesc = reinterpret_cast<const ze_base_desc_t *>(extendedDesc->pNext);
}
interruptMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1);
kmdWaitMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1);
if (interruptMode) {
enableInterruptMode();
}
if (externalInterruptWait || (interruptMode && kmdWaitMode)) {
enableKmdWaitMode();
}
return ZE_RESULT_SUCCESS;
}
} // namespace L0

8
level_zero/core/source/event/event.h
View File

@ -85,10 +85,14 @@ inline constexpr uint32_t eventPackets = maxKernelSplit * NEO ::TimestampPacketC
struct EventDescriptor {
NEO::MultiGraphicsAllocation *eventPoolAllocation = nullptr;
const void *extensions = nullptr;
uint32_t totalEventSize = 0;
uint32_t maxKernelCount = 0;
uint32_t maxPacketsCount = 0;
uint32_t counterBasedFlags = 0;
uint32_t index = 0;
uint32_t signalScope = 0;
uint32_t waitScope = 0;
bool timestampPool = false;
bool kerneMappedTsPoolFlag = false;
bool importedIpcPool = false;
@ -132,7 +136,7 @@ struct Event : _ze_event_handle_t {
static Event *create(EventPool *eventPool, const ze_event_desc_t *desc, Device *device);
template <typename TagSizeT>
static Event *create(const EventDescriptor &eventDescriptor, const ze_event_desc_t *desc, Device *device);
static Event *create(const EventDescriptor &eventDescriptor, Device *device, ze_result_t &result);
static Event *fromHandle(ze_event_handle_t handle) { return static_cast<Event *>(handle); }
@ -326,6 +330,8 @@ struct Event : _ze_event_handle_t {
protected:
Event(int index, Device *device) : device(device), index(index) {}
ze_result_t enableExtensions(const EventDescriptor &eventDescriptor);
void unsetCmdQueue();
void releaseTempInOrderTimestampNodes();

49
level_zero/core/source/event/event_impl.inl
View File

@ -18,6 +18,7 @@
#include "shared/source/os_interface/os_time.h"
#include "shared/source/utilities/wait_util.h"
#include "level_zero/api/driver_experimental/public/zex_common.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/event/event_imp.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
@ -26,12 +27,12 @@
namespace L0 {
template <typename TagSizeT>
Event *Event::create(const EventDescriptor &eventDescriptor, const ze_event_desc_t *desc, Device *device) {
Event *Event::create(const EventDescriptor &eventDescriptor, Device *device, ze_result_t &result) {
auto neoDevice = device->getNEODevice();
auto csr = neoDevice->getDefaultEngine().commandStreamReceiver;
auto &hwInfo = neoDevice->getHardwareInfo();
auto event = std::make_unique<EventImp<TagSizeT>>(desc->index, device, csr->isTbxMode());
auto event = std::make_unique<EventImp<TagSizeT>>(eventDescriptor.index, device, csr->isTbxMode());
UNRECOVERABLE_IF(!event.get());
event->eventPoolAllocation = eventDescriptor.eventPoolAllocation;
@ -50,10 +51,10 @@ Event *Event::create(const EventDescriptor &eventDescriptor, const ze_event_desc
}
event->totalEventSize = eventDescriptor.totalEventSize;
event->eventPoolOffset = desc->index * event->totalEventSize;
event->eventPoolOffset = eventDescriptor.index * event->totalEventSize;
event->hostAddressFromPool = ptrOffset(baseHostAddress, event->eventPoolOffset);
event->signalScope = desc->signal;
event->waitScope = desc->wait;
event->signalScope = eventDescriptor.signalScope;
event->waitScope = eventDescriptor.waitScope;
event->csrs.push_back(csr);
event->maxKernelCount = eventDescriptor.maxKernelCount;
event->maxPacketCount = eventDescriptor.maxPacketsCount;
@ -94,34 +95,10 @@ Event *Event::create(const EventDescriptor &eventDescriptor, const ze_event_desc
event->resetDeviceCompletionData(true);
}
auto extendedDesc = reinterpret_cast<const ze_base_desc_t *>(desc->pNext);
result = event->enableExtensions(eventDescriptor);
bool interruptMode = false;
bool kmdWaitMode = false;
bool externalInterruptWait = false;
if (extendedDesc && (extendedDesc->stype == ZEX_INTEL_STRUCTURE_TYPE_EVENT_SYNC_MODE_EXP_DESC)) {
auto eventSyncModeDesc = reinterpret_cast<const zex_intel_event_sync_mode_exp_desc_t *>(extendedDesc);
interruptMode = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT);
kmdWaitMode = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT);
externalInterruptWait = (eventSyncModeDesc->syncModeFlags & ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_EXTERNAL_INTERRUPT_WAIT);
if (externalInterruptWait) {
event->setExternalInterruptId(eventSyncModeDesc->externalInterruptId);
UNRECOVERABLE_IF(eventSyncModeDesc->externalInterruptId > 0 && eventDescriptor.eventPoolAllocation);
}
}
interruptMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1);
kmdWaitMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1);
if (interruptMode) {
event->enableInterruptMode();
}
if (externalInterruptWait || (interruptMode && kmdWaitMode)) {
event->enableKmdWaitMode();
if (result != ZE_RESULT_SUCCESS) {
return nullptr;
}
return event.release();
@ -131,10 +108,14 @@ template <typename TagSizeT>
Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *device) {
EventDescriptor eventDescriptor = {
&eventPool->getAllocation(), // eventPoolAllocation
desc->pNext, // extensions
eventPool->getEventSize(), // totalEventSize
eventPool->getMaxKernelCount(), // maxKernelCount
eventPool->getEventMaxPackets(), // maxPacketsCount
eventPool->getCounterBasedFlags(), // counterBasedFlags
desc->index, // index
desc->signal, // signalScope
desc->wait, // waitScope
eventPool->isEventPoolTimestampFlagSet(), // timestampPool
eventPool->isEventPoolKerneMappedTsFlagSet(), // kerneMappedTsPoolFlag
eventPool->getImportedIpcPool(), // importedIpcPool
@ -145,7 +126,9 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
eventDescriptor.eventPoolAllocation = nullptr;
}
Event *event = Event::create<TagSizeT>(eventDescriptor, desc, device);
ze_result_t result = ZE_RESULT_SUCCESS;
Event *event = Event::create<TagSizeT>(eventDescriptor, device, result);
UNRECOVERABLE_IF(event == nullptr);
event->setEventPool(eventPool);
return event;

12
level_zero/core/test/unit_tests/fixtures/in_order_cmd_list_fixture.h
View File

@ -86,12 +86,16 @@ struct InOrderCmdListFixture : public ::Test<ModuleFixture> {
DestroyableZeUniquePtr<FixtureMockEvent> createStandaloneCbEvent(const ze_base_desc_t *pNext) {
constexpr uint32_t counterBasedFlags = (ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE | ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE);
constexpr EventDescriptor eventDescriptor = {
const EventDescriptor eventDescriptor = {
nullptr, // eventPoolAllocation
pNext, // extension
0, // totalEventSize
EventPacketsCount::maxKernelSplit, // maxKernelCount
0, // maxPacketsCount
counterBasedFlags, // counterBasedFlags
0, // index
0, // signalScope
0, // waitScope
false, // timestampPool
false, // kerneMappedTsPoolFlag
false, // importedIpcPool
@ -105,9 +109,9 @@ struct InOrderCmdListFixture : public ::Test<ModuleFixture> {
auto inOrderExecInfo = NEO::InOrderExecInfo::createFromExternalAllocation(*device->getNEODevice(), nullptr, castToUint64(deviceAddress), nullptr, hostAddress, 1, 1, 1);
ze_event_desc_t eventDesc = {};
eventDesc.pNext = pNext;
auto event = static_cast<FixtureMockEvent *>(Event::create<uint64_t>(eventDescriptor, &eventDesc, device));
ze_result_t result = ZE_RESULT_SUCCESS;
auto event = static_cast<FixtureMockEvent *>(Event::create<uint64_t>(eventDescriptor, device, result));
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
event->updateInOrderExecState(inOrderExecInfo, 1, 0);
return DestroyableZeUniquePtr<FixtureMockEvent>(event);