intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "feature: experimental Counter Based Event support"

Browse Source 
This reverts commit a8c79e0ba1.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2023-11-03 06:04:39 +01:00
committed by Compute-Runtime-Automation
parent 73bb139e17
commit da9adc6797
10 changed files with 48 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -172,7 +172,7 @@ void CommandListCoreFamily<gfxCoreFamily>::handleInOrderDependencyCounter(Event
this->commandContainer.addToResidencyContainer(&inOrderExecInfo->inOrderDependencyCounterAllocation);
if (signalEvent && signalEvent->isCounterBased()) {
if (signalEvent && signalEvent->isInOrderExecEvent()) {
signalEvent->updateInOrderExecState(inOrderExecInfo, inOrderExecInfo->inOrderDependencyCounter, this->inOrderAllocationOffset);
}
@@ -495,7 +495,7 @@ template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_handle_t hEvent) {
auto event = Event::fromHandle(hEvent);
if (event->isCounterBased()) {
if (event->isInOrderExecEvent()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
@@ -2430,7 +2430,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
continue;
}
if (event->isCounterBased()) {
if (event->isInOrderExecEvent()) {
if (!event->getInOrderExecDataAllocation()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT; // in-order event not signaled yet
}

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

@@ -507,7 +507,7 @@ bool CommandListCoreFamilyImmediate<gfxCoreFamily>::isSkippingInOrderBarrierAllo
auto signalEvent = Event::fromHandle(hSignalEvent);
return !(signalEvent && (signalEvent->isEventTimestampFlagSet() || !signalEvent->isCounterBased()));
return !(signalEvent && (signalEvent->isEventTimestampFlagSet() || !signalEvent->isInOrderExecEvent()));
}
template <GFXCORE_FAMILY gfxCoreFamily>

2
level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl
View File

@@ -76,7 +76,7 @@ void programEventL3Flush(Event *event,
template <GFXCORE_FAMILY gfxCoreFamily>
bool CommandListCoreFamily<gfxCoreFamily>::isInOrderNonWalkerSignalingRequired(const Event *event) const {
return (event && (event->isUsingContextEndOffset() || !event->isCounterBased() || compactL3FlushEvent(getDcFlushRequired(event->isSignalScope()))));
return (event && (event->isUsingContextEndOffset() || !event->isInOrderExecEvent() || compactL3FlushEvent(getDcFlushRequired(event->isSignalScope()))));
}
template <GFXCORE_FAMILY gfxCoreFamily>

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

@@ -194,20 +194,6 @@ EventPool *EventPool::create(DriverHandle *driver, Context *context, uint32_t nu
return eventPool.release();
}
void EventPool::setupDescriptorFlags(const ze_event_pool_desc_t *desc) {
eventPoolFlags = desc->flags;
if (eventPoolFlags & ZE_EVENT_POOL_FLAG_KERNEL_MAPPED_TIMESTAMP) {
eventPoolFlags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
}
auto pNext = reinterpret_cast<const ze_base_desc_t *>(desc->pNext);
if (pNext && pNext->stype == ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC) {
counterBased = true;
}
}
bool EventPool::isEventPoolTimestampFlagSet() const {
if (NEO::DebugManager.flags.OverrideTimestampEvents.get() != -1) {
auto timestampOverride = !!NEO::DebugManager.flags.OverrideTimestampEvents.get();

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

@@ -217,8 +217,8 @@ struct Event : _ze_event_handle_t {
this->metricStreamer = metricStreamer;
}
void updateInOrderExecState(std::shared_ptr<InOrderExecInfo> &newInOrderExecInfo, uint64_t signalValue, uint32_t allocationOffset);
bool isCounterBased() const { return counterBased; }
void enableCounterBasedMode() { this->counterBased = true; }
bool isInOrderExecEvent() const { return inOrderExecEvent; }
void enableInOrderMode() { this->inOrderExecEvent = true; }
NEO::GraphicsAllocation *getInOrderExecDataAllocation() const;
uint64_t getInOrderExecSignalValueWithSubmissionCounter() const;
uint64_t getInOrderExecBaseSignalValue() const { return inOrderExecSignalValue; }
@@ -287,7 +287,7 @@ struct Event : _ze_event_handle_t {
bool usingContextEndOffset = false;
bool signalAllEventPackets = false;
bool isFromIpcPool = false;
bool counterBased = false;
bool inOrderExecEvent = false;
uint64_t timestampRefreshIntervalInNanoSec = 0;
};
@@ -296,7 +296,10 @@ struct EventPool : _ze_event_pool_handle_t {
static ze_result_t openEventPoolIpcHandle(const ze_ipc_event_pool_handle_t &ipcEventPoolHandle, ze_event_pool_handle_t *eventPoolHandle,
DriverHandleImp *driver, ContextImp *context, uint32_t numDevices, ze_device_handle_t *deviceHandles);
EventPool(const ze_event_pool_desc_t *desc) : EventPool(desc->count) {
setupDescriptorFlags(desc);
eventPoolFlags = desc->flags;
if (eventPoolFlags & ZE_EVENT_POOL_FLAG_KERNEL_MAPPED_TIMESTAMP) {
eventPoolFlags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
}
}
virtual ~EventPool();
MOCKABLE_VIRTUAL ze_result_t destroy();
@@ -353,12 +356,9 @@ struct EventPool : _ze_event_pool_handle_t {
return isImplicitScalingCapable;
}
bool isCounterBased() const { return counterBased; }
protected:
EventPool() = default;
EventPool(size_t numEvents) : numEvents(numEvents) {}
void setupDescriptorFlags(const ze_event_pool_desc_t *desc);
std::vector<Device *> devices;
@@ -381,7 +381,6 @@ struct EventPool : _ze_event_pool_handle_t {
bool isImportedIpcPool = false;
bool isShareableEventMemory = false;
bool isImplicitScalingCapable = false;
bool counterBased = false;
};
} // namespace L0

2
level_zero/core/source/event/event_imp.h
View File

@@ -73,7 +73,7 @@ struct EventImp : public Event {
ze_result_t calculateProfilingData();
ze_result_t queryStatusEventPackets();
ze_result_t queryCounterBasedEventStatus();
ze_result_t queryInOrderEventStatus();
void handleSuccessfulHostSynchronization();
MOCKABLE_VIRTUAL ze_result_t hostEventSetValue(TagSizeT eventValue);
ze_result_t hostEventSetValueTimestamps(TagSizeT eventVal);

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

@@ -80,8 +80,8 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
event->timestampRefreshIntervalInNanoSec = refreshTime * milliSecondsToNanoSeconds;
}
if (eventPool->isCounterBased() || NEO::DebugManager.flags.ForceInOrderEvents.get() == 1) {
event->enableCounterBasedMode();
if (NEO::DebugManager.flags.ForceInOrderEvents.get() == 1) {
event->enableInOrderMode();
}
return event;
@@ -150,7 +150,7 @@ void EventImp<TagSizeT>::assignKernelEventCompletionData(void *address) {
}
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus() {
ze_result_t EventImp<TagSizeT>::queryInOrderEventStatus() {
if (!this->inOrderExecInfo.get()) {
return ZE_RESULT_NOT_READY;
}
@@ -281,8 +281,8 @@ ze_result_t EventImp<TagSizeT>::queryStatus() {
return ZE_RESULT_SUCCESS;
}
if (this->counterBased) {
return queryCounterBasedEventStatus();
if (this->inOrderExecEvent) {
return queryInOrderEventStatus();
} else {
return queryStatusEventPackets();
}
@@ -396,7 +396,7 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValue(TagSizeT eventVal) {
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::hostSignal() {
if (this->isCounterBased()) {
if (this->isInOrderExecEvent()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
@@ -447,7 +447,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
waitStartTime = std::chrono::high_resolution_clock::now();
lastHangCheckTime = waitStartTime;
do {
if (NEO::DebugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1 && this->counterBased) {
if (NEO::DebugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1 && this->inOrderExecEvent) {
ret = waitForUserFence(timeout);
} else {
ret = queryStatus();
@@ -494,7 +494,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::reset() {
if (this->isCounterBased()) {
if (this->isInOrderExecEvent()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}