Skip to content

Commit 0b979bf

Browse files
Xewar313Xewar313
authored
[UR] Add remaining calls shared with queue in level-zero v2 adapter (intel#17061)
Adds implements calls shared between command buffer and queue in unified-runtime level-zero v2 adapter and moves the shared code to `command_list_manager.cpp`
1 parent e925b2b commit 0b979bf

File tree

5 files changed

+281
-155
lines changed

5 files changed

+281
-155
lines changed

‎unified-runtime/source/adapters/level_zero/v2/api.cpp

-47
Original file line numberDiff line numberDiff line change
@@ -170,53 +170,6 @@ ur_result_t urBindlessImagesReleaseExternalSemaphoreExp(
170170
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
171171
}
172172

173-
ur_result_t urCommandBufferAppendUSMFillExp(
174-
ur_exp_command_buffer_handle_t hCommandBuffer, void *pMemory,
175-
const void *pPattern, size_t patternSize, size_t size,
176-
uint32_t numSyncPointsInWaitList,
177-
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
178-
uint32_t NumEventsInWaitList, const ur_event_handle_t *phEventWaitList,
179-
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
180-
ur_exp_command_buffer_command_handle_t *phCommand) {
181-
logger::error("{} function not implemented!", __FUNCTION__);
182-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
183-
}
184-
185-
ur_result_t urCommandBufferAppendMemBufferFillExp(
186-
ur_exp_command_buffer_handle_t hCommandBuffer, ur_mem_handle_t hBuffer,
187-
const void *pPattern, size_t patternSize, size_t offset, size_t size,
188-
uint32_t numSyncPointsInWaitList,
189-
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
190-
uint32_t NumEventsInWaitList, const ur_event_handle_t *phEventWaitList,
191-
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
192-
ur_exp_command_buffer_command_handle_t *phCommand) {
193-
logger::error("{} function not implemented!", __FUNCTION__);
194-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
195-
}
196-
197-
ur_result_t urCommandBufferAppendUSMPrefetchExp(
198-
ur_exp_command_buffer_handle_t hCommandBuffer, const void *pMemory,
199-
size_t size, ur_usm_migration_flags_t flags,
200-
uint32_t numSyncPointsInWaitList,
201-
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
202-
uint32_t NumEventsInWaitList, const ur_event_handle_t *phEventWaitList,
203-
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
204-
ur_exp_command_buffer_command_handle_t *phCommand) {
205-
logger::error("{} function not implemented!", __FUNCTION__);
206-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
207-
}
208-
209-
ur_result_t urCommandBufferAppendUSMAdviseExp(
210-
ur_exp_command_buffer_handle_t hCommandBuffer, const void *pMemory,
211-
size_t size, ur_usm_advice_flags_t advice, uint32_t numSyncPointsInWaitList,
212-
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
213-
uint32_t NumEventsInWaitList, const ur_event_handle_t *phEventWaitList,
214-
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
215-
ur_exp_command_buffer_command_handle_t *phCommand) {
216-
logger::error("{} function not implemented!", __FUNCTION__);
217-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
218-
}
219-
220173
ur_result_t urCommandBufferUpdateKernelLaunchExp(
221174
ur_exp_command_buffer_command_handle_t hCommand,
222175
const ur_exp_command_buffer_update_kernel_launch_desc_t

‎unified-runtime/source/adapters/level_zero/v2/command_buffer.cpp

+109
Original file line numberDiff line numberDiff line change
@@ -346,6 +346,115 @@ ur_result_t urCommandBufferAppendMemBufferReadRectExp(
346346
return exceptionToResult(std::current_exception());
347347
}
348348

349+
ur_result_t urCommandBufferAppendUSMFillExp(
350+
ur_exp_command_buffer_handle_t hCommandBuffer, void *pMemory,
351+
const void *pPattern, size_t patternSize, size_t size,
352+
uint32_t numSyncPointsInWaitList,
353+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
354+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
355+
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
356+
ur_exp_command_buffer_command_handle_t *phCommand) try {
357+
358+
// the same issue as in urCommandBufferAppendKernelLaunchExp
359+
std::ignore = numEventsInWaitList;
360+
std::ignore = phEventWaitList;
361+
std::ignore = phEvent;
362+
// sync mechanic can be ignored, because all lists are in-order
363+
std::ignore = numSyncPointsInWaitList;
364+
std::ignore = pSyncPointWaitList;
365+
std::ignore = pSyncPoint;
366+
367+
std::ignore = phCommand;
368+
369+
UR_CALL(hCommandBuffer->commandListManager.appendUSMFill(
370+
pMemory, patternSize, pPattern, size, 0, nullptr, nullptr));
371+
return UR_RESULT_SUCCESS;
372+
} catch (...) {
373+
return exceptionToResult(std::current_exception());
374+
}
375+
376+
ur_result_t urCommandBufferAppendMemBufferFillExp(
377+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_mem_handle_t hBuffer,
378+
const void *pPattern, size_t patternSize, size_t offset, size_t size,
379+
uint32_t numSyncPointsInWaitList,
380+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
381+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
382+
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
383+
ur_exp_command_buffer_command_handle_t *phCommand) try {
384+
385+
// the same issue as in urCommandBufferAppendKernelLaunchExp
386+
std::ignore = numEventsInWaitList;
387+
std::ignore = phEventWaitList;
388+
std::ignore = phEvent;
389+
// sync mechanic can be ignored, because all lists are in-order
390+
std::ignore = numSyncPointsInWaitList;
391+
std::ignore = pSyncPointWaitList;
392+
std::ignore = pSyncPoint;
393+
394+
std::ignore = phCommand;
395+
396+
UR_CALL(hCommandBuffer->commandListManager.appendMemBufferFill(
397+
hBuffer, pPattern, patternSize, offset, size, 0, nullptr, nullptr));
398+
return UR_RESULT_SUCCESS;
399+
} catch (...) {
400+
return exceptionToResult(std::current_exception());
401+
}
402+
403+
ur_result_t urCommandBufferAppendUSMPrefetchExp(
404+
ur_exp_command_buffer_handle_t hCommandBuffer, const void *pMemory,
405+
size_t size, ur_usm_migration_flags_t flags,
406+
uint32_t numSyncPointsInWaitList,
407+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
408+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
409+
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
410+
ur_exp_command_buffer_command_handle_t *phCommand) try {
411+
412+
// the same issue as in urCommandBufferAppendKernelLaunchExp
413+
std::ignore = numEventsInWaitList;
414+
std::ignore = phEventWaitList;
415+
std::ignore = phEvent;
416+
// sync mechanic can be ignored, because all lists are in-order
417+
std::ignore = numSyncPointsInWaitList;
418+
std::ignore = pSyncPointWaitList;
419+
std::ignore = pSyncPoint;
420+
421+
std::ignore = phCommand;
422+
423+
UR_CALL(hCommandBuffer->commandListManager.appendUSMPrefetch(
424+
pMemory, size, flags, 0, nullptr, nullptr));
425+
426+
return UR_RESULT_SUCCESS;
427+
} catch (...) {
428+
return exceptionToResult(std::current_exception());
429+
}
430+
431+
ur_result_t urCommandBufferAppendUSMAdviseExp(
432+
ur_exp_command_buffer_handle_t hCommandBuffer, const void *pMemory,
433+
size_t size, ur_usm_advice_flags_t advice, uint32_t numSyncPointsInWaitList,
434+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
435+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
436+
ur_exp_command_buffer_sync_point_t *pSyncPoint, ur_event_handle_t *phEvent,
437+
ur_exp_command_buffer_command_handle_t *phCommand) try {
438+
439+
// the same issue as in urCommandBufferAppendKernelLaunchExp
440+
std::ignore = numEventsInWaitList;
441+
std::ignore = phEventWaitList;
442+
std::ignore = phEvent;
443+
// sync mechanic can be ignored, because all lists are in-order
444+
std::ignore = numSyncPointsInWaitList;
445+
std::ignore = pSyncPointWaitList;
446+
std::ignore = pSyncPoint;
447+
448+
std::ignore = phCommand;
449+
450+
UR_CALL(hCommandBuffer->commandListManager.appendUSMAdvise(pMemory, size,
451+
advice, nullptr));
452+
453+
return UR_RESULT_SUCCESS;
454+
} catch (...) {
455+
return exceptionToResult(std::current_exception());
456+
}
457+
349458
ur_result_t
350459
urCommandBufferGetInfoExp(ur_exp_command_buffer_handle_t hCommandBuffer,
351460
ur_exp_command_buffer_info_t propName,

‎unified-runtime/source/adapters/level_zero/v2/command_list_manager.cpp

+134
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,50 @@ ur_command_list_manager::~ur_command_list_manager() {
3131
ur::level_zero::urDeviceRelease(device);
3232
}
3333

34+
ur_result_t ur_command_list_manager::appendGenericFillUnlocked(
35+
ur_mem_buffer_t *dst, size_t offset, size_t patternSize,
36+
const void *pPattern, size_t size, uint32_t numEventsInWaitList,
37+
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent,
38+
ur_command_t commandType) {
39+
40+
auto zeSignalEvent = getSignalEvent(phEvent, commandType);
41+
42+
auto waitListView = getWaitListView(phEventWaitList, numEventsInWaitList);
43+
44+
auto pDst = ur_cast<char *>(dst->getDevicePtr(
45+
device, ur_mem_buffer_t::device_access_mode_t::read_only, offset, size,
46+
[&](void *src, void *dst, size_t size) {
47+
ZE2UR_CALL_THROWS(zeCommandListAppendMemoryCopy,
48+
(zeCommandList.get(), dst, src, size, nullptr,
49+
waitListView.num, waitListView.handles));
50+
waitListView.clear();
51+
}));
52+
53+
// PatternSize must be a power of two for zeCommandListAppendMemoryFill.
54+
// When it's not, the fill is emulated with zeCommandListAppendMemoryCopy.
55+
if (isPowerOf2(patternSize)) {
56+
ZE2UR_CALL(zeCommandListAppendMemoryFill,
57+
(zeCommandList.get(), pDst, pPattern, patternSize, size,
58+
zeSignalEvent, waitListView.num, waitListView.handles));
59+
} else {
60+
// Copy pattern into every entry in memory array pointed by Ptr.
61+
uint32_t numOfCopySteps = size / patternSize;
62+
const void *src = pPattern;
63+
64+
for (uint32_t step = 0; step < numOfCopySteps; ++step) {
65+
void *dst = reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(pDst) +
66+
step * patternSize);
67+
ZE2UR_CALL(zeCommandListAppendMemoryCopy,
68+
(zeCommandList.get(), dst, src, patternSize,
69+
step == numOfCopySteps - 1 ? zeSignalEvent : nullptr,
70+
waitListView.num, waitListView.handles));
71+
waitListView.clear();
72+
}
73+
}
74+
75+
return UR_RESULT_SUCCESS;
76+
}
77+
3478
ur_result_t ur_command_list_manager::appendGenericCopyUnlocked(
3579
ur_mem_buffer_t *src, ur_mem_buffer_t *dst, bool blocking, size_t srcOffset,
3680
size_t dstOffset, size_t size, uint32_t numEventsInWaitList,
@@ -209,6 +253,96 @@ ur_result_t ur_command_list_manager::appendUSMMemcpy(
209253
return UR_RESULT_SUCCESS;
210254
}
211255

256+
ur_result_t ur_command_list_manager::appendMemBufferFill(
257+
ur_mem_handle_t hMem, const void *pPattern, size_t patternSize,
258+
size_t offset, size_t size, uint32_t numEventsInWaitList,
259+
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
260+
TRACK_SCOPE_LATENCY("ur_command_list_manager::appendMemBufferFill");
261+
262+
auto hBuffer = hMem->getBuffer();
263+
UR_ASSERT(offset + size <= hBuffer->getSize(), UR_RESULT_ERROR_INVALID_SIZE);
264+
265+
std::scoped_lock<ur_shared_mutex, ur_shared_mutex> lock(this->Mutex,
266+
hBuffer->getMutex());
267+
268+
return appendGenericFillUnlocked(hBuffer, offset, patternSize, pPattern, size,
269+
numEventsInWaitList, phEventWaitList,
270+
phEvent, UR_COMMAND_MEM_BUFFER_FILL);
271+
}
272+
273+
ur_result_t ur_command_list_manager::appendUSMFill(
274+
void *pMem, size_t patternSize, const void *pPattern, size_t size,
275+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
276+
ur_event_handle_t *phEvent) {
277+
TRACK_SCOPE_LATENCY("ur_command_list_manager::appendUSMFill");
278+
279+
std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
280+
281+
ur_usm_handle_t dstHandle(context, size, pMem);
282+
return appendGenericFillUnlocked(&dstHandle, 0, patternSize, pPattern, size,
283+
numEventsInWaitList, phEventWaitList,
284+
phEvent, UR_COMMAND_USM_FILL);
285+
}
286+
287+
ur_result_t ur_command_list_manager::appendUSMPrefetch(
288+
const void *pMem, size_t size, ur_usm_migration_flags_t flags,
289+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
290+
ur_event_handle_t *phEvent) {
291+
TRACK_SCOPE_LATENCY("ur_command_list_manager::appendUSMPrefetch");
292+
293+
std::ignore = flags;
294+
295+
std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
296+
297+
auto zeSignalEvent = getSignalEvent(phEvent, UR_COMMAND_USM_PREFETCH);
298+
299+
auto [pWaitEvents, numWaitEvents] =
300+
getWaitListView(phEventWaitList, numEventsInWaitList);
301+
302+
if (pWaitEvents) {
303+
ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
304+
(zeCommandList.get(), numWaitEvents, pWaitEvents));
305+
}
306+
// TODO: figure out how to translate "flags"
307+
ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
308+
(zeCommandList.get(), pMem, size));
309+
if (zeSignalEvent) {
310+
ZE2UR_CALL(zeCommandListAppendSignalEvent,
311+
(zeCommandList.get(), zeSignalEvent));
312+
}
313+
314+
return UR_RESULT_SUCCESS;
315+
}
316+
317+
ur_result_t
318+
ur_command_list_manager::appendUSMAdvise(const void *pMem, size_t size,
319+
ur_usm_advice_flags_t advice,
320+
ur_event_handle_t *phEvent) {
321+
TRACK_SCOPE_LATENCY("ur_command_list_manager::appendUSMAdvise");
322+
323+
std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
324+
325+
auto zeAdvice = ur_cast<ze_memory_advice_t>(advice);
326+
327+
auto zeSignalEvent = getSignalEvent(phEvent, UR_COMMAND_USM_ADVISE);
328+
329+
auto [pWaitEvents, numWaitEvents] = getWaitListView(nullptr, 0);
330+
331+
if (pWaitEvents) {
332+
ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
333+
(zeCommandList.get(), numWaitEvents, pWaitEvents));
334+
}
335+
336+
ZE2UR_CALL(zeCommandListAppendMemAdvise,
337+
(zeCommandList.get(), device->ZeDevice, pMem, size, zeAdvice));
338+
339+
if (zeSignalEvent) {
340+
ZE2UR_CALL(zeCommandListAppendSignalEvent,
341+
(zeCommandList.get(), zeSignalEvent));
342+
}
343+
return UR_RESULT_SUCCESS;
344+
}
345+
212346
ur_result_t ur_command_list_manager::appendMemBufferRead(
213347
ur_mem_handle_t hMem, bool blockingRead, size_t offset, size_t size,
214348
void *pDst, uint32_t numEventsInWaitList,

‎unified-runtime/source/adapters/level_zero/v2/command_list_manager.hpp

+27
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,27 @@ struct ur_command_list_manager : public _ur_object {
9999
const ur_event_handle_t *phEventWaitList,
100100
ur_event_handle_t *phEvent);
101101

102+
ur_result_t appendMemBufferFill(ur_mem_handle_t hBuffer, const void *pPattern,
103+
size_t patternSize, size_t offset,
104+
size_t size, uint32_t numEventsInWaitList,
105+
const ur_event_handle_t *phEventWaitList,
106+
ur_event_handle_t *phEvent);
107+
108+
ur_result_t appendUSMFill(void *pMem, size_t patternSize,
109+
const void *pPattern, size_t size,
110+
uint32_t numEventsInWaitList,
111+
const ur_event_handle_t *phEventWaitList,
112+
ur_event_handle_t *phEvent);
113+
114+
ur_result_t appendUSMPrefetch(const void *pMem, size_t size,
115+
ur_usm_migration_flags_t flags,
116+
uint32_t numEventsInWaitList,
117+
const ur_event_handle_t *phEventWaitList,
118+
ur_event_handle_t *phEvent);
119+
120+
ur_result_t appendUSMAdvise(const void *pMem, size_t size,
121+
ur_usm_advice_flags_t advice,
122+
ur_event_handle_t *phEvent);
102123
ze_command_list_handle_t getZeCommandList();
103124

104125
wait_list_view getWaitListView(const ur_event_handle_t *phWaitEvents,
@@ -107,6 +128,12 @@ struct ur_command_list_manager : public _ur_object {
107128
ur_command_t commandType);
108129

109130
private:
131+
ur_result_t appendGenericFillUnlocked(
132+
ur_mem_buffer_t *hBuffer, size_t offset, size_t patternSize,
133+
const void *pPattern, size_t size, uint32_t numEventsInWaitList,
134+
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent,
135+
ur_command_t commandType);
136+
110137
ur_result_t appendGenericCopyUnlocked(
111138
ur_mem_buffer_t *src, ur_mem_buffer_t *dst, bool blocking,
112139
size_t srcOffset, size_t dstOffset, size_t size,

0 commit comments

Comments
 (0)