Skip to content

Commit 2aa10dd

Browse files
pbalcerpbalcer
committed
Revert "[L0] Fix the multi device event cache to allocate lists as pointers"
This reverts commit 123c00f.
1 parent e0393a4 commit 2aa10dd

File tree

4 files changed

+27
-80
lines changed

4 files changed

+27
-80
lines changed

‎source/adapters/level_zero/context.cpp

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -395,29 +395,27 @@ ur_result_t ur_context_handle_t_::finalize() {
395395

396396
if (!DisableEventsCaching) {
397397
std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
398-
for (auto EventCache : EventCaches) {
399-
for (auto Event : *EventCache) {
398+
for (auto &EventCache : EventCaches) {
399+
for (auto &Event : EventCache) {
400400
auto ZeResult = ZE_CALL_NOCHECK(zeEventDestroy, (Event->ZeEvent));
401401
// Gracefully handle the case that L0 was already unloaded.
402402
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
403403
return ze2urResult(ZeResult);
404404
delete Event;
405405
}
406-
EventCache->clear();
407-
delete EventCache;
406+
EventCache.clear();
408407
}
409408
}
410409
{
411410
std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
412-
for (auto ZePoolCache : ZeEventPoolCache) {
413-
for (auto ZePool : *ZePoolCache) {
411+
for (auto &ZePoolCache : ZeEventPoolCache) {
412+
for (auto &ZePool : ZePoolCache) {
414413
auto ZeResult = ZE_CALL_NOCHECK(zeEventPoolDestroy, (ZePool));
415414
// Gracefully handle the case that L0 was already unloaded.
416415
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
417416
return ze2urResult(ZeResult);
418417
}
419-
ZePoolCache->clear();
420-
delete ZePoolCache;
418+
ZePoolCache.clear();
421419
}
422420
}
423421

‎source/adapters/level_zero/context.hpp

Lines changed: 14 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -141,7 +141,7 @@ struct ur_context_handle_t_ : _ur_object {
141141
// head.
142142
//
143143
// Cache of event pools to which host-visible events are added to.
144-
std::vector<std::list<ze_event_pool_handle_t> *> ZeEventPoolCache;
144+
std::vector<std::list<ze_event_pool_handle_t>> ZeEventPoolCache{4};
145145
std::vector<std::unordered_map<ze_device_handle_t,
146146
std::list<ze_event_pool_handle_t> *>>
147147
ZeEventPoolCacheDeviceMap{4};
@@ -165,7 +165,7 @@ struct ur_context_handle_t_ : _ur_object {
165165
ur_mutex EventCacheMutex;
166166

167167
// Caches for events.
168-
std::vector<std::list<ur_event_handle_t> *> EventCaches;
168+
std::vector<std::list<ur_event_handle_t>> EventCaches{4};
169169
std::vector<
170170
std::unordered_map<ur_device_handle_t, std::list<ur_event_handle_t> *>>
171171
EventCachesDeviceMap{4};
@@ -207,44 +207,31 @@ struct ur_context_handle_t_ : _ur_object {
207207

208208
auto getZeEventPoolCache(bool HostVisible, bool WithProfiling,
209209
ze_device_handle_t ZeDevice) {
210-
// Adding 4 initial global caches for provided scope and profiling modes:
211-
// Host Scope, Device Scope, with Profiling, without Profiling.
212-
if (ZeEventPoolCache.empty()) {
213-
for (int i = 0; i < 4; i++) {
214-
std::list<ze_event_pool_handle_t> *deviceZeEventPoolCache =
215-
new std::list<ze_event_pool_handle_t>;
216-
ZeEventPoolCache.push_back(deviceZeEventPoolCache);
217-
}
218-
}
219210
if (HostVisible) {
220211
if (ZeDevice) {
221212
auto ZeEventPoolCacheMap = WithProfiling
222213
? &ZeEventPoolCacheDeviceMap[0]
223214
: &ZeEventPoolCacheDeviceMap[1];
224215
if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
225-
std::list<ze_event_pool_handle_t> *deviceZeEventPoolCache =
226-
new std::list<ze_event_pool_handle_t>;
227-
ZeEventPoolCache.push_back(deviceZeEventPoolCache);
228-
(*ZeEventPoolCacheMap)[ZeDevice] = deviceZeEventPoolCache;
216+
ZeEventPoolCache.emplace_back();
217+
(*ZeEventPoolCacheMap)[ZeDevice] = &ZeEventPoolCache.back();
229218
}
230219
return (*ZeEventPoolCacheMap)[ZeDevice];
231220
} else {
232-
return WithProfiling ? ZeEventPoolCache[0] : ZeEventPoolCache[1];
221+
return WithProfiling ? &ZeEventPoolCache[0] : &ZeEventPoolCache[1];
233222
}
234223
} else {
235224
if (ZeDevice) {
236225
auto ZeEventPoolCacheMap = WithProfiling
237226
? &ZeEventPoolCacheDeviceMap[2]
238227
: &ZeEventPoolCacheDeviceMap[3];
239228
if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
240-
std::list<ze_event_pool_handle_t> *deviceZeEventPoolCache =
241-
new std::list<ze_event_pool_handle_t>;
242-
ZeEventPoolCache.push_back(deviceZeEventPoolCache);
243-
(*ZeEventPoolCacheMap)[ZeDevice] = deviceZeEventPoolCache;
229+
ZeEventPoolCache.emplace_back();
230+
(*ZeEventPoolCacheMap)[ZeDevice] = &ZeEventPoolCache.back();
244231
}
245232
return (*ZeEventPoolCacheMap)[ZeDevice];
246233
} else {
247-
return WithProfiling ? ZeEventPoolCache[2] : ZeEventPoolCache[3];
234+
return WithProfiling ? &ZeEventPoolCache[2] : &ZeEventPoolCache[3];
248235
}
249236
}
250237
}
@@ -287,42 +274,29 @@ struct ur_context_handle_t_ : _ur_object {
287274
// Get the cache of events for a provided scope and profiling mode.
288275
auto getEventCache(bool HostVisible, bool WithProfiling,
289276
ur_device_handle_t Device) {
290-
// Adding 4 initial global caches for provided scope and profiling modes:
291-
// Host Scope, Device Scope, with Profiling, without Profiling.
292-
if (EventCaches.empty()) {
293-
for (int i = 0; i < 4; i++) {
294-
std::list<ur_event_handle_t> *deviceEventCache =
295-
new std::list<ur_event_handle_t>;
296-
EventCaches.push_back(deviceEventCache);
297-
}
298-
}
299277
if (HostVisible) {
300278
if (Device) {
301279
auto EventCachesMap =
302280
WithProfiling ? &EventCachesDeviceMap[0] : &EventCachesDeviceMap[1];
303281
if (EventCachesMap->find(Device) == EventCachesMap->end()) {
304-
std::list<ur_event_handle_t> *deviceEventCache =
305-
new std::list<ur_event_handle_t>;
306-
EventCaches.push_back(deviceEventCache);
307-
(*EventCachesMap)[Device] = deviceEventCache;
282+
EventCaches.emplace_back();
283+
(*EventCachesMap)[Device] = &EventCaches.back();
308284
}
309285
return (*EventCachesMap)[Device];
310286
} else {
311-
return WithProfiling ? EventCaches[0] : EventCaches[1];
287+
return WithProfiling ? &EventCaches[0] : &EventCaches[1];
312288
}
313289
} else {
314290
if (Device) {
315291
auto EventCachesMap =
316292
WithProfiling ? &EventCachesDeviceMap[2] : &EventCachesDeviceMap[3];
317293
if (EventCachesMap->find(Device) == EventCachesMap->end()) {
318-
std::list<ur_event_handle_t> *deviceEventCache =
319-
new std::list<ur_event_handle_t>;
320-
EventCaches.push_back(deviceEventCache);
321-
(*EventCachesMap)[Device] = deviceEventCache;
294+
EventCaches.emplace_back();
295+
(*EventCachesMap)[Device] = &EventCaches.back();
322296
}
323297
return (*EventCachesMap)[Device];
324298
} else {
325-
return WithProfiling ? EventCaches[2] : EventCaches[3];
299+
return WithProfiling ? &EventCaches[2] : &EventCaches[3];
326300
}
327301
}
328302
}

‎source/adapters/level_zero/queue.cpp

Lines changed: 6 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1267,28 +1267,17 @@ ur_queue_handle_t_::resetDiscardedEvent(ur_command_list_ptr_t CommandList) {
12671267
}
12681268

12691269
ur_result_t ur_queue_handle_t_::addEventToQueueCache(ur_event_handle_t Event) {
1270-
// Adding 2 initial global caches for provided scope:
1271-
// Host Scope, Device Scope.
1272-
if (EventCaches.empty()) {
1273-
for (int i = 0; i < 2; i++) {
1274-
std::list<ur_event_handle_t> *deviceEventCache =
1275-
new std::list<ur_event_handle_t>;
1276-
EventCaches.push_back(deviceEventCache);
1277-
}
1278-
}
12791270
if (!Event->IsMultiDevice && Event->UrQueue) {
12801271
auto Device = Event->UrQueue->Device;
12811272
auto EventCachesMap = Event->isHostVisible() ? &EventCachesDeviceMap[0]
12821273
: &EventCachesDeviceMap[1];
12831274
if (EventCachesMap->find(Device) == EventCachesMap->end()) {
1284-
std::list<ur_event_handle_t> *deviceEventCache =
1285-
new std::list<ur_event_handle_t>;
1286-
EventCaches.push_back(deviceEventCache);
1287-
(*EventCachesMap)[Device] = deviceEventCache;
1275+
EventCaches.emplace_back();
1276+
(*EventCachesMap)[Device] = &EventCaches.back();
12881277
}
12891278
(*EventCachesMap)[Device]->emplace_back(Event);
12901279
} else {
1291-
auto Cache = Event->isHostVisible() ? EventCaches[0] : EventCaches[1];
1280+
auto Cache = Event->isHostVisible() ? &EventCaches[0] : &EventCaches[1];
12921281
Cache->emplace_back(Event);
12931282
}
12941283
return UR_RESULT_SUCCESS;
@@ -1312,13 +1301,9 @@ ur_result_t urQueueReleaseInternal(ur_queue_handle_t Queue) {
13121301
if (!UrQueue->RefCount.decrementAndTest())
13131302
return UR_RESULT_SUCCESS;
13141303

1315-
for (auto Cache : UrQueue->EventCaches) {
1316-
for (auto Event : *Cache) {
1304+
for (auto &Cache : UrQueue->EventCaches)
1305+
for (auto &Event : Cache)
13171306
UR_CALL(urEventReleaseInternal(Event));
1318-
}
1319-
Cache->clear();
1320-
delete Cache;
1321-
}
13221307

13231308
if (UrQueue->OwnZeCommandQueue) {
13241309
for (auto &QueueMap :
@@ -1475,16 +1460,6 @@ ur_event_handle_t ur_queue_handle_t_::getEventFromQueueCache(bool IsMultiDevice,
14751460
bool HostVisible) {
14761461
std::list<ur_event_handle_t> *Cache;
14771462

1478-
// Adding 2 initial global caches for provided scope:
1479-
// Host Scope, Device Scope.
1480-
if (EventCaches.empty()) {
1481-
for (int i = 0; i < 2; i++) {
1482-
std::list<ur_event_handle_t> *deviceEventCache =
1483-
new std::list<ur_event_handle_t>;
1484-
EventCaches.push_back(deviceEventCache);
1485-
}
1486-
}
1487-
14881463
if (!IsMultiDevice) {
14891464
auto Device = this->Device;
14901465
Cache = HostVisible ? EventCachesDeviceMap[0][Device]
@@ -1493,7 +1468,7 @@ ur_event_handle_t ur_queue_handle_t_::getEventFromQueueCache(bool IsMultiDevice,
14931468
return nullptr;
14941469
}
14951470
} else {
1496-
Cache = HostVisible ? EventCaches[0] : EventCaches[1];
1471+
Cache = HostVisible ? &EventCaches[0] : &EventCaches[1];
14971472
}
14981473

14991474
// If we don't have any events, return nullptr.

‎source/adapters/level_zero/queue.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -342,7 +342,7 @@ struct ur_queue_handle_t_ : _ur_object {
342342
// requested type of event. Each list contains events which can be reused
343343
// inside all command lists in the queue as described in the 2-event model.
344344
// Leftover events in the cache are relased at the queue destruction.
345-
std::vector<std::list<ur_event_handle_t> *> EventCaches;
345+
std::vector<std::list<ur_event_handle_t>> EventCaches{2};
346346
std::vector<
347347
std::unordered_map<ur_device_handle_t, std::list<ur_event_handle_t> *>>
348348
EventCachesDeviceMap{2};

0 commit comments

Comments
 (0)