Skip to content

Commit b05ffb5

Browse files
kbenziekbenzie
authored
Merge pull request #1600 from winstonzhang-intel/event-bool-refactoring
[L0] Refactoring of boolean event parameters
2 parents f66751d + f1c14d4 commit b05ffb5

File tree

5 files changed

+110
-145
lines changed

5 files changed

+110
-145
lines changed

‎source/adapters/level_zero/context.cpp‎

Lines changed: 46 additions & 28 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 : ZeEventPoolCache) {
438+
for (auto &ZePoolCache : ZeEventPoolCaches) {
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, bool HostVisible,
498-
bool ProfilingEnabled, ur_device_handle_t Device,
499-
bool CounterBasedEventEnabled, bool UsingImmCmdList,
500-
bool InterruptBasedEventEnabled) {
497+
ze_event_pool_handle_t &Pool, size_t &Index, v2::event_flags_t Flags,
498+
ur_device_handle_t Device) {
501499
// Lock while updating event pool machinery.
502500
std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
503501

504502
ze_device_handle_t ZeDevice = nullptr;
503+
size_t DeviceId;
505504

506505
if (Device) {
507506
ZeDevice = Device->ZeDevice;
507+
DeviceId =
508+
Device->Id.has_value() ? static_cast<size_t>(Device->Id.value()) : 0;
508509
}
509-
std::list<ze_event_pool_handle_t> *ZePoolCache = getZeEventPoolCache(
510-
HostVisible, ProfilingEnabled, CounterBasedEventEnabled, UsingImmCmdList,
511-
InterruptBasedEventEnabled, ZeDevice);
510+
std::list<ze_event_pool_handle_t> *ZePoolCache =
511+
getZeEventPoolCache(Flags, ZeDevice, DeviceId);
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 (HostVisible)
549+
if (Flags & v2::EVENT_FLAGS_HOST_VISIBLE)
550550
ZeEventPoolDesc.flags |= ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
551-
if (ProfilingEnabled)
551+
if (Flags & v2::EVENT_FLAGS_PROFILING_ENABLED)
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 (CounterBasedEventEnabled) {
556-
if (UsingImmCmdList) {
555+
if (Flags & v2::EVENT_FLAGS_COUNTER) {
556+
if (Flags & v2::EVENT_FLAGS_IMM_CMDLIST) {
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 (InterruptBasedEventEnabled) {
564+
if (Flags & EVENT_FLAG_INTERRUPT) {
565565
counterBasedExt.pNext = &eventSyncMode;
566566
}
567567
ZeEventPoolDesc.pNext = &counterBasedExt;
568-
} else if (InterruptBasedEventEnabled) {
568+
} else if (Flags & EVENT_FLAG_INTERRUPT) {
569569
ZeEventPoolDesc.pNext = &eventSyncMode;
570570
}
571571

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

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) {
595+
ur_event_handle_t
596+
ur_context_handle_t_::getEventFromContextCache(v2::event_flags_t Flags,
597+
ur_device_handle_t Device) {
598598
std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
599-
auto Cache =
600-
getEventCache(HostVisible, WithProfiling, Device,
601-
CounterBasedEventEnabled, InterruptBasedEventEnabled);
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+
602605
if (Cache->empty()) {
603606
logger::info("Cache empty (Host Visible: {}, Profiling: {}, Counter: {}, "
604607
"Interrupt: {}, Device: {})",
605-
HostVisible, WithProfiling, CounterBasedEventEnabled,
606-
InterruptBasedEventEnabled, 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);
607612
return nullptr;
608613
}
609614

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

634639
auto Cache = getEventCache(
635-
Event->isHostVisible(), Event->isProfilingEnabled(), Device,
640+
Event->HostVisibleEvent, Event->isProfilingEnabled(), Device,
636641
Event->CounterBasedEventsEnabled, Event->InterruptBasedEventsEnabled);
637642
logger::info("Inserting {} event (Host Visible: {}, Profiling: {}, Counter: "
638643
"{}, Device: {}) into cache {}",
@@ -653,17 +658,30 @@ ur_context_handle_t_::decrementUnreleasedEventsInPool(ur_event_handle_t Event) {
653658
}
654659

655660
ze_device_handle_t ZeDevice = nullptr;
661+
size_t DeviceId;
662+
656663
bool UsingImmediateCommandlists =
657664
!Event->UrQueue || Event->UrQueue->UsingImmCmdLists;
658665

659666
if (!Event->IsMultiDevice && Event->UrQueue) {
660667
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;
661671
}
662-
663-
std::list<ze_event_pool_handle_t> *ZePoolCache = getZeEventPoolCache(
664-
Event->isHostVisible(), Event->isProfilingEnabled(),
665-
Event->CounterBasedEventsEnabled, UsingImmediateCommandlists,
666-
Event->InterruptBasedEventsEnabled, ZeDevice);
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);
667685

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

‎source/adapters/level_zero/context.hpp‎

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

25+
#include "./v2/event_provider.hpp"
2526
#include "common.hpp"
2627
#include "queue.hpp"
2728

@@ -168,9 +169,8 @@ struct ur_context_handle_t_ : _ur_object {
168169
// head.
169170
//
170171
// Cache of event pools to which host-visible events are added to.
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};
172+
using ZeEventPoolCache = std::list<ze_event_pool_handle_t>;
173+
std::vector<ZeEventPoolCache> ZeEventPoolCaches;
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,124 +213,54 @@ 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-
bool HostVisible,
217-
bool ProfilingEnabled,
218-
ur_device_handle_t Device,
219-
bool CounterBasedEventEnabled,
220-
bool UsingImmCmdList,
221-
bool InterruptBasedEventEnabled);
216+
v2::event_flags_t Flags,
217+
ur_device_handle_t Device);
222218

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

230223
// Add ur_event_handle_t to cache.
231224
void addEventToContextCache(ur_event_handle_t);
232225

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-
252226
std::list<ze_event_pool_handle_t> *
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);
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);
262231
if (ZeDevice) {
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];
232+
index |= v2::EVENT_FLAGS_DEVICE | (DeviceId << v2::MAX_EVENT_FLAG_BITS);
275233
}
234+
235+
if (index >= ZeEventPoolCaches.size()) {
236+
ZeEventPoolCaches.resize(index + 1);
237+
}
238+
return &ZeEventPoolCaches[index];
276239
}
277240

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-
}
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));
297256
}
257+
return &ZeEventPoolCaches[(*ZeEventPoolCacheMap)[ZeDevice]];
298258
} else {
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;
259+
return WithProfiling ? &ZeEventPoolCaches[index * 2]
260+
: &ZeEventPoolCaches[index * 2 + 1];
329261
}
330262
}
331-
332-
return UR_RESULT_SUCCESS;
333-
}
263+
*/
334264

335265
// Decrement number of events living in the pool upon event destroy
336266
// and return the pool to the cache if there are no unreleased events.
@@ -379,7 +309,6 @@ struct ur_context_handle_t_ : _ur_object {
379309
MAX_EVENT_FLAG_BITS =
380310
5, // this is used as an offset for embedding device id
381311
};
382-
383312
// Mutex to control operations on event caches.
384313
ur_mutex EventCacheMutex;
385314

@@ -412,7 +341,6 @@ struct ur_context_handle_t_ : _ur_object {
412341
if (index >= EventCaches.size()) {
413342
EventCaches.resize(index + 1);
414343
}
415-
416344
return &EventCaches[index];
417345
}
418346
};

‎source/adapters/level_zero/event.cpp‎

Lines changed: 17 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1341,16 +1341,27 @@ 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;
13441357

13451358
ur_device_handle_t Device = nullptr;
13461359

13471360
if (!IsMultiDevice && Queue) {
13481361
Device = Queue->Device;
13491362
}
13501363

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

13611372
size_t Index = 0;
13621373

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

13691378
ZeStruct<ze_event_desc_t> ZeEventDesc;
@@ -1400,6 +1409,7 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
14001409
if (HostVisible)
14011410
(*RetEvent)->HostVisibleEvent =
14021411
reinterpret_cast<ur_event_handle_t>(*RetEvent);
1412+
(*RetEvent)->Flags = Flags;
14031413

14041414
return UR_RESULT_SUCCESS;
14051415
}

0 commit comments

Comments
 (0)