Skip to content

Commit 739d8a7

Browse files
kbenziekbenzie
authored
Merge pull request oneapi-src#2694 from oneapi-src/revert-1600-event-bool-refactoring
Revert "[L0] Refactoring of boolean event parameters"
2 parents 2b81852 + 269d870 commit 739d8a7

File tree

5 files changed

+145
-110
lines changed

5 files changed

+145
-110
lines changed

‎source/adapters/level_zero/context.cpp

Lines changed: 28 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -435,7 +435,7 @@ ur_result_t ur_context_handle_t_::finalize() {
435435
}
436436
{
437437
std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
438-
for (auto &ZePoolCache : ZeEventPoolCaches) {
438+
for (auto &ZePoolCache : ZeEventPoolCache) {
439439
for (auto &ZePool : ZePoolCache) {
440440
auto ZeResult = ZE_CALL_NOCHECK(zeEventPoolDestroy, (ZePool));
441441
// Gracefully handle the case that L0 was already unloaded.
@@ -494,21 +494,21 @@ static const uint32_t MaxNumEventsPerPool = [] {
494494
}();
495495

496496
ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
497-
ze_event_pool_handle_t &Pool, size_t &Index, v2::event_flags_t Flags,
498-
ur_device_handle_t Device) {
497+
ze_event_pool_handle_t &Pool, size_t &Index, bool HostVisible,
498+
bool ProfilingEnabled, ur_device_handle_t Device,
499+
bool CounterBasedEventEnabled, bool UsingImmCmdList,
500+
bool InterruptBasedEventEnabled) {
499501
// Lock while updating event pool machinery.
500502
std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
501503

502504
ze_device_handle_t ZeDevice = nullptr;
503-
size_t DeviceId;
504505

505506
if (Device) {
506507
ZeDevice = Device->ZeDevice;
507-
DeviceId =
508-
Device->Id.has_value() ? static_cast<size_t>(Device->Id.value()) : 0;
509508
}
510-
std::list<ze_event_pool_handle_t> *ZePoolCache =
511-
getZeEventPoolCache(Flags, ZeDevice, DeviceId);
509+
std::list<ze_event_pool_handle_t> *ZePoolCache = getZeEventPoolCache(
510+
HostVisible, ProfilingEnabled, CounterBasedEventEnabled, UsingImmCmdList,
511+
InterruptBasedEventEnabled, ZeDevice);
512512

513513
if (!ZePoolCache->empty()) {
514514
if (NumEventsAvailableInEventPool[ZePoolCache->front()] == 0) {
@@ -546,26 +546,26 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
546546
ZeEventPoolDesc.count = MaxNumEventsPerPool;
547547
ZeEventPoolDesc.flags = 0;
548548
ZeEventPoolDesc.pNext = nullptr;
549-
if (Flags & v2::EVENT_FLAGS_HOST_VISIBLE)
549+
if (HostVisible)
550550
ZeEventPoolDesc.flags |= ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
551-
if (Flags & v2::EVENT_FLAGS_PROFILING_ENABLED)
551+
if (ProfilingEnabled)
552552
ZeEventPoolDesc.flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
553553
logger::debug("ze_event_pool_desc_t flags set to: {}",
554554
ZeEventPoolDesc.flags);
555-
if (Flags & v2::EVENT_FLAGS_COUNTER) {
556-
if (Flags & v2::EVENT_FLAGS_IMM_CMDLIST) {
555+
if (CounterBasedEventEnabled) {
556+
if (UsingImmCmdList) {
557557
counterBasedExt.flags = ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE;
558558
} else {
559559
counterBasedExt.flags =
560560
ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE;
561561
}
562562
logger::debug("ze_event_pool_desc_t counter based flags set to: {}",
563563
counterBasedExt.flags);
564-
if (Flags & EVENT_FLAG_INTERRUPT) {
564+
if (InterruptBasedEventEnabled) {
565565
counterBasedExt.pNext = &eventSyncMode;
566566
}
567567
ZeEventPoolDesc.pNext = &counterBasedExt;
568-
} else if (Flags & EVENT_FLAG_INTERRUPT) {
568+
} else if (InterruptBasedEventEnabled) {
569569
ZeEventPoolDesc.pNext = &eventSyncMode;
570570
}
571571

@@ -592,23 +592,18 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
592592
return UR_RESULT_SUCCESS;
593593
}
594594

595-
ur_event_handle_t
596-
ur_context_handle_t_::getEventFromContextCache(v2::event_flags_t Flags,
597-
ur_device_handle_t Device) {
595+
ur_event_handle_t ur_context_handle_t_::getEventFromContextCache(
596+
bool HostVisible, bool WithProfiling, ur_device_handle_t Device,
597+
bool CounterBasedEventEnabled, bool InterruptBasedEventEnabled) {
598598
std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
599-
600-
auto Cache = getEventCache(Flags & v2::EVENT_FLAGS_HOST_VISIBLE,
601-
Flags & v2::EVENT_FLAGS_PROFILING_ENABLED, Device,
602-
Flags & v2::EVENT_FLAGS_COUNTER,
603-
Flags & v2::EVENT_FLAGS_INTERRUPT);
604-
599+
auto Cache =
600+
getEventCache(HostVisible, WithProfiling, Device,
601+
CounterBasedEventEnabled, InterruptBasedEventEnabled);
605602
if (Cache->empty()) {
606603
logger::info("Cache empty (Host Visible: {}, Profiling: {}, Counter: {}, "
607604
"Interrupt: {}, Device: {})",
608-
(Flags & v2::EVENT_FLAGS_HOST_VISIBLE),
609-
(Flags & v2::EVENT_FLAGS_PROFILING_ENABLED),
610-
(Flags & v2::EVENT_FLAGS_COUNTER),
611-
(Flags & v2::EVENT_FLAGS_INTERRUPT), Device);
605+
HostVisible, WithProfiling, CounterBasedEventEnabled,
606+
InterruptBasedEventEnabled, Device);
612607
return nullptr;
613608
}
614609

@@ -637,7 +632,7 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) {
637632
}
638633

639634
auto Cache = getEventCache(
640-
Event->HostVisibleEvent, Event->isProfilingEnabled(), Device,
635+
Event->isHostVisible(), Event->isProfilingEnabled(), Device,
641636
Event->CounterBasedEventsEnabled, Event->InterruptBasedEventsEnabled);
642637
logger::info("Inserting {} event (Host Visible: {}, Profiling: {}, Counter: "
643638
"{}, Device: {}) into cache {}",
@@ -658,30 +653,17 @@ ur_context_handle_t_::decrementUnreleasedEventsInPool(ur_event_handle_t Event) {
658653
}
659654

660655
ze_device_handle_t ZeDevice = nullptr;
661-
size_t DeviceId;
662-
663656
bool UsingImmediateCommandlists =
664657
!Event->UrQueue || Event->UrQueue->UsingImmCmdLists;
665658

666659
if (!Event->IsMultiDevice && Event->UrQueue) {
667660
ZeDevice = Event->UrQueue->Device->ZeDevice;
668-
DeviceId = Event->UrQueue->Device->Id.has_value()
669-
? static_cast<size_t>(Event->UrQueue->Device->Id.value())
670-
: 0;
671661
}
672-
v2::event_flags_t Flags = 0;
673-
if (UsingImmediateCommandlists)
674-
Flags |= v2::EVENT_FLAGS_IMM_CMDLIST;
675-
if (Event->isHostVisible())
676-
Flags |= v2::EVENT_FLAGS_HOST_VISIBLE;
677-
if (Event->isProfilingEnabled())
678-
Flags |= v2::EVENT_FLAGS_PROFILING_ENABLED;
679-
if (Event->CounterBasedEventsEnabled)
680-
Flags |= v2::EVENT_FLAGS_COUNTER;
681-
if (Event->InterruptBasedEventsEnabled)
682-
Flags |= v2::EVENT_FLAGS_INTERRUPT;
683-
std::list<ze_event_pool_handle_t> *ZePoolCache =
684-
getZeEventPoolCache(Flags, ZeDevice, DeviceId);
662+
663+
std::list<ze_event_pool_handle_t> *ZePoolCache = getZeEventPoolCache(
664+
Event->isHostVisible(), Event->isProfilingEnabled(),
665+
Event->CounterBasedEventsEnabled, UsingImmediateCommandlists,
666+
Event->InterruptBasedEventsEnabled, ZeDevice);
685667

686668
// Put the empty pool to the cache of the pools.
687669
if (NumEventsUnreleasedInEventPool[Event->ZeEventPool] == 0)

‎source/adapters/level_zero/context.hpp

Lines changed: 108 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,6 @@
2222
#include <ze_api.h>
2323
#include <zes_api.h>
2424

25-
#include "./v2/event_provider.hpp"
2625
#include "common.hpp"
2726
#include "queue.hpp"
2827

@@ -169,8 +168,9 @@ struct ur_context_handle_t_ : _ur_object {
169168
// head.
170169
//
171170
// Cache of event pools to which host-visible events are added to.
172-
using ZeEventPoolCache = std::list<ze_event_pool_handle_t>;
173-
std::vector<ZeEventPoolCache> ZeEventPoolCaches;
171+
std::vector<std::list<ze_event_pool_handle_t>> ZeEventPoolCache{30};
172+
std::vector<std::unordered_map<ze_device_handle_t, size_t>>
173+
ZeEventPoolCacheDeviceMap{30};
174174

175175
// This map will be used to determine if a pool is full or not
176176
// by storing number of empty slots available in the pool.
@@ -213,54 +213,124 @@ struct ur_context_handle_t_ : _ur_object {
213213
// slot for a host-visible event. The ProfilingEnabled tells is we need a
214214
// slot for an event with profiling capabilities.
215215
ur_result_t getFreeSlotInExistingOrNewPool(ze_event_pool_handle_t &, size_t &,
216-
v2::event_flags_t Flags,
217-
ur_device_handle_t Device);
216+
bool HostVisible,
217+
bool ProfilingEnabled,
218+
ur_device_handle_t Device,
219+
bool CounterBasedEventEnabled,
220+
bool UsingImmCmdList,
221+
bool InterruptBasedEventEnabled);
218222

219223
// Get ur_event_handle_t from cache.
220-
ur_event_handle_t getEventFromContextCache(v2::event_flags_t Flags,
221-
ur_device_handle_t Device);
224+
ur_event_handle_t getEventFromContextCache(bool HostVisible,
225+
bool WithProfiling,
226+
ur_device_handle_t Device,
227+
bool CounterBasedEventEnabled,
228+
bool InterruptBasedEventEnabled);
222229

223230
// Add ur_event_handle_t to cache.
224231
void addEventToContextCache(ur_event_handle_t);
225232

233+
enum EventPoolCacheType {
234+
HostVisibleCacheType,
235+
HostInvisibleCacheType,
236+
HostVisibleCounterBasedRegularCacheType,
237+
HostInvisibleCounterBasedRegularCacheType,
238+
HostVisibleCounterBasedImmediateCacheType,
239+
HostInvisibleCounterBasedImmediateCacheType,
240+
241+
HostVisibleInterruptBasedRegularCacheType,
242+
HostInvisibleInterruptBasedRegularCacheType,
243+
HostVisibleInterruptBasedImmediateCacheType,
244+
HostInvisibleInterruptBasedImmediateCacheType,
245+
246+
HostVisibleInterruptAndCounterBasedRegularCacheType,
247+
HostInvisibleInterruptAndCounterBasedRegularCacheType,
248+
HostVisibleInterruptAndCounterBasedImmediateCacheType,
249+
HostInvisibleInterruptAndCounterBasedImmediateCacheType
250+
};
251+
226252
std::list<ze_event_pool_handle_t> *
227-
getZeEventPoolCache(v2::event_flags_t Flags, ze_device_handle_t ZeDevice,
228-
size_t DeviceId) {
229-
size_t index = 0;
230-
index |= uint64_t(Flags);
253+
getZeEventPoolCache(bool HostVisible, bool WithProfiling,
254+
bool CounterBasedEventEnabled, bool UsingImmediateCmdList,
255+
bool InterruptBasedEventEnabled,
256+
ze_device_handle_t ZeDevice) {
257+
EventPoolCacheType CacheType;
258+
259+
calculateCacheIndex(HostVisible, CounterBasedEventEnabled,
260+
UsingImmediateCmdList, InterruptBasedEventEnabled,
261+
CacheType);
231262
if (ZeDevice) {
232-
index |= v2::EVENT_FLAGS_DEVICE | (DeviceId << v2::MAX_EVENT_FLAG_BITS);
233-
}
234-
235-
if (index >= ZeEventPoolCaches.size()) {
236-
ZeEventPoolCaches.resize(index + 1);
263+
auto ZeEventPoolCacheMap =
264+
WithProfiling ? &ZeEventPoolCacheDeviceMap[CacheType * 2]
265+
: &ZeEventPoolCacheDeviceMap[CacheType * 2 + 1];
266+
if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
267+
ZeEventPoolCache.emplace_back();
268+
ZeEventPoolCacheMap->insert(
269+
std::make_pair(ZeDevice, ZeEventPoolCache.size() - 1));
270+
}
271+
return &ZeEventPoolCache[(*ZeEventPoolCacheMap)[ZeDevice]];
272+
} else {
273+
return WithProfiling ? &ZeEventPoolCache[CacheType * 2]
274+
: &ZeEventPoolCache[CacheType * 2 + 1];
237275
}
238-
return &ZeEventPoolCaches[index];
239276
}
240277

241-
/*
242-
std::list<ze_event_pool_handle_t> *
243-
getZeEventPoolCache(v2::event_flags_t Flags, ze_device_handle_t ZeDevice) {
244-
size_t index = 0;
245-
index |= Flags;
246-
bool WithProfiling = Flags & v2::EVENT_FLAGS_PROFILING_ENABLED;
247-
248-
if (ZeDevice) {
249-
auto ZeEventPoolCacheMap =
250-
WithProfiling ? &ZeEventPoolCachesDeviceMap[index * 2]
251-
: &ZeEventPoolCachesDeviceMap[index * 2 + 1];
252-
if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
253-
ZeEventPoolCaches.emplace_back();
254-
ZeEventPoolCacheMap->insert(
255-
std::make_pair(ZeDevice, ZeEventPoolCaches.size() - 1));
278+
ur_result_t calculateCacheIndex(bool HostVisible,
279+
bool CounterBasedEventEnabled,
280+
bool UsingImmediateCmdList,
281+
bool InterruptBasedEventEnabled,
282+
EventPoolCacheType &CacheType) {
283+
if (InterruptBasedEventEnabled) {
284+
if (CounterBasedEventEnabled) {
285+
if (HostVisible) {
286+
if (UsingImmediateCmdList) {
287+
CacheType = HostVisibleInterruptAndCounterBasedImmediateCacheType;
288+
} else {
289+
CacheType = HostVisibleInterruptAndCounterBasedRegularCacheType;
290+
}
291+
} else {
292+
if (UsingImmediateCmdList) {
293+
CacheType = HostInvisibleInterruptAndCounterBasedImmediateCacheType;
294+
} else {
295+
CacheType = HostInvisibleInterruptAndCounterBasedRegularCacheType;
296+
}
256297
}
257-
return &ZeEventPoolCaches[(*ZeEventPoolCacheMap)[ZeDevice]];
258298
} else {
259-
return WithProfiling ? &ZeEventPoolCaches[index * 2]
260-
: &ZeEventPoolCaches[index * 2 + 1];
299+
if (HostVisible) {
300+
if (UsingImmediateCmdList) {
301+
CacheType = HostVisibleInterruptBasedImmediateCacheType;
302+
} else {
303+
CacheType = HostVisibleInterruptBasedRegularCacheType;
304+
}
305+
} else {
306+
if (UsingImmediateCmdList) {
307+
CacheType = HostInvisibleInterruptBasedImmediateCacheType;
308+
} else {
309+
CacheType = HostInvisibleInterruptBasedRegularCacheType;
310+
}
311+
}
312+
}
313+
} else {
314+
if (CounterBasedEventEnabled && HostVisible && !UsingImmediateCmdList) {
315+
CacheType = HostVisibleCounterBasedRegularCacheType;
316+
} else if (CounterBasedEventEnabled && !HostVisible &&
317+
!UsingImmediateCmdList) {
318+
CacheType = HostInvisibleCounterBasedRegularCacheType;
319+
} else if (CounterBasedEventEnabled && HostVisible &&
320+
UsingImmediateCmdList) {
321+
CacheType = HostVisibleCounterBasedImmediateCacheType;
322+
} else if (CounterBasedEventEnabled && !HostVisible &&
323+
UsingImmediateCmdList) {
324+
CacheType = HostInvisibleCounterBasedImmediateCacheType;
325+
} else if (!CounterBasedEventEnabled && HostVisible) {
326+
CacheType = HostVisibleCacheType;
327+
} else {
328+
CacheType = HostInvisibleCacheType;
261329
}
262330
}
263-
*/
331+
332+
return UR_RESULT_SUCCESS;
333+
}
264334

265335
// Decrement number of events living in the pool upon event destroy
266336
// and return the pool to the cache if there are no unreleased events.
@@ -309,6 +379,7 @@ struct ur_context_handle_t_ : _ur_object {
309379
MAX_EVENT_FLAG_BITS =
310380
5, // this is used as an offset for embedding device id
311381
};
382+
312383
// Mutex to control operations on event caches.
313384
ur_mutex EventCacheMutex;
314385

@@ -341,6 +412,7 @@ struct ur_context_handle_t_ : _ur_object {
341412
if (index >= EventCaches.size()) {
342413
EventCaches.resize(index + 1);
343414
}
415+
344416
return &EventCaches[index];
345417
}
346418
};

‎source/adapters/level_zero/event.cpp

Lines changed: 7 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1341,27 +1341,16 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
13411341
bool ProfilingEnabled =
13421342
ForceDisableProfiling ? false : (!Queue || Queue->isProfilingEnabled());
13431343
bool UsingImmediateCommandlists = !Queue || Queue->UsingImmCmdLists;
1344-
v2::event_flags_t Flags = 0;
1345-
if (ProfilingEnabled)
1346-
Flags |= v2::EVENT_FLAGS_PROFILING_ENABLED;
1347-
if (UsingImmediateCommandlists)
1348-
Flags |= v2::EVENT_FLAGS_IMM_CMDLIST;
1349-
if (HostVisible)
1350-
Flags |= v2::EVENT_FLAGS_HOST_VISIBLE;
1351-
if (IsMultiDevice)
1352-
Flags |= v2::EVENT_FLAGS_MULTIDEVICE;
1353-
if (CounterBasedEventEnabled)
1354-
Flags |= v2::EVENT_FLAGS_COUNTER;
1355-
if (InterruptBasedEventEnabled)
1356-
Flags |= v2::EVENT_FLAGS_INTERRUPT;
13571344

13581345
ur_device_handle_t Device = nullptr;
13591346

13601347
if (!IsMultiDevice && Queue) {
13611348
Device = Queue->Device;
13621349
}
13631350

1364-
if (auto CachedEvent = Context->getEventFromContextCache(Flags, Device)) {
1351+
if (auto CachedEvent = Context->getEventFromContextCache(
1352+
HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled,
1353+
InterruptBasedEventEnabled)) {
13651354
*RetEvent = CachedEvent;
13661355
return UR_RESULT_SUCCESS;
13671356
}
@@ -1371,8 +1360,10 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
13711360

13721361
size_t Index = 0;
13731362

1374-
if (auto Res = Context->getFreeSlotInExistingOrNewPool(ZeEventPool, Index,
1375-
Flags, Device))
1363+
if (auto Res = Context->getFreeSlotInExistingOrNewPool(
1364+
ZeEventPool, Index, HostVisible, ProfilingEnabled, Device,
1365+
CounterBasedEventEnabled, UsingImmediateCommandlists,
1366+
InterruptBasedEventEnabled))
13761367
return Res;
13771368

13781369
ZeStruct<ze_event_desc_t> ZeEventDesc;
@@ -1409,7 +1400,6 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
14091400
if (HostVisible)
14101401
(*RetEvent)->HostVisibleEvent =
14111402
reinterpret_cast<ur_event_handle_t>(*RetEvent);
1412-
(*RetEvent)->Flags = Flags;
14131403

14141404
return UR_RESULT_SUCCESS;
14151405
}

0 commit comments

Comments
 (0)