Skip to content

Commit 9fcb2ac

Browse files
callumfarecallumfare
authored
[SYCL][UR] Bump UR version and add missing values to pi2ur (#10049)
Includes a large number of missing `pi_result` mappings, so previously reported errors should no longer map to just `PI_ERROR_UNKNOWN`. NFCI for the adapters.
1 parent 7e98cd4 commit 9fcb2ac

File tree

9 files changed

+187
-84
lines changed

9 files changed

+187
-84
lines changed

‎sycl/plugins/unified_runtime/CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ if (NOT DEFINED UNIFIED_RUNTIME_LIBRARY OR NOT DEFINED UNIFIED_RUNTIME_INCLUDE_D
44
include(FetchContent)
55

66
set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git")
7-
set(UNIFIED_RUNTIME_TAG 4136fbb19c37a8aa9d368559a738e2e7cc35033e)
7+
set(UNIFIED_RUNTIME_TAG 7e16bb37cbb12450637e595749c3617151cbe851)
88

99
message(STATUS "Will fetch Unified Runtime from ${UNIFIED_RUNTIME_REPO}")
1010
FetchContent_Declare(unified-runtime

‎sycl/plugins/unified_runtime/pi2ur.hpp

Lines changed: 130 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99

1010
#include "ur_api.h"
1111
#include <cstdarg>
12+
#include <sycl/detail/cuda_definitions.hpp>
1213
#include <sycl/detail/pi.h>
1314
#include <ur/ur.hpp>
1415

@@ -18,38 +19,128 @@ static pi_result ur2piResult(ur_result_t urResult) {
1819
return PI_SUCCESS;
1920

2021
switch (urResult) {
21-
case UR_RESULT_ERROR_UNKNOWN:
22-
return PI_ERROR_UNKNOWN;
23-
case UR_RESULT_ERROR_DEVICE_LOST:
24-
return PI_ERROR_DEVICE_NOT_FOUND;
2522
case UR_RESULT_ERROR_INVALID_OPERATION:
2623
return PI_ERROR_INVALID_OPERATION;
27-
case UR_RESULT_ERROR_INVALID_PLATFORM:
28-
return PI_ERROR_INVALID_PLATFORM;
29-
case UR_RESULT_ERROR_INVALID_ARGUMENT:
30-
return PI_ERROR_INVALID_ARG_VALUE;
24+
case UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES:
25+
return PI_ERROR_INVALID_QUEUE_PROPERTIES;
26+
case UR_RESULT_ERROR_INVALID_QUEUE:
27+
return PI_ERROR_INVALID_QUEUE;
3128
case UR_RESULT_ERROR_INVALID_VALUE:
3229
return PI_ERROR_INVALID_VALUE;
33-
case UR_RESULT_ERROR_INVALID_EVENT:
34-
return PI_ERROR_INVALID_EVENT;
30+
case UR_RESULT_ERROR_INVALID_CONTEXT:
31+
return PI_ERROR_INVALID_CONTEXT;
32+
case UR_RESULT_ERROR_INVALID_PLATFORM:
33+
return PI_ERROR_INVALID_PLATFORM;
3534
case UR_RESULT_ERROR_INVALID_BINARY:
3635
return PI_ERROR_INVALID_BINARY;
37-
case UR_RESULT_ERROR_INVALID_KERNEL_NAME:
38-
return PI_ERROR_INVALID_KERNEL_NAME;
39-
case UR_RESULT_ERROR_INVALID_FUNCTION_NAME:
40-
return PI_ERROR_BUILD_PROGRAM_FAILURE;
36+
case UR_RESULT_ERROR_INVALID_PROGRAM:
37+
return PI_ERROR_INVALID_PROGRAM;
38+
case UR_RESULT_ERROR_INVALID_SAMPLER:
39+
return PI_ERROR_INVALID_SAMPLER;
40+
case UR_RESULT_ERROR_INVALID_MEM_OBJECT:
41+
return PI_ERROR_INVALID_MEM_OBJECT;
42+
case UR_RESULT_ERROR_INVALID_EVENT:
43+
return PI_ERROR_INVALID_EVENT;
44+
case UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST:
45+
return PI_ERROR_INVALID_EVENT_WAIT_LIST;
46+
case UR_RESULT_ERROR_MISALIGNED_SUB_BUFFER_OFFSET:
47+
return PI_ERROR_MISALIGNED_SUB_BUFFER_OFFSET;
4148
case UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE:
4249
return PI_ERROR_INVALID_WORK_GROUP_SIZE;
43-
case UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY:
44-
return PI_ERROR_OUT_OF_RESOURCES;
50+
case UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE:
51+
return PI_ERROR_COMPILER_NOT_AVAILABLE;
52+
case UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE:
53+
return PI_ERROR_PROFILING_INFO_NOT_AVAILABLE;
54+
case UR_RESULT_ERROR_DEVICE_NOT_FOUND:
55+
return PI_ERROR_DEVICE_NOT_FOUND;
56+
case UR_RESULT_ERROR_INVALID_DEVICE:
57+
return PI_ERROR_INVALID_DEVICE;
58+
case UR_RESULT_ERROR_DEVICE_REQUIRES_RESET:
59+
case UR_RESULT_ERROR_DEVICE_LOST:
60+
return PI_ERROR_DEVICE_NOT_AVAILABLE;
61+
case UR_RESULT_ERROR_DEVICE_PARTITION_FAILED:
62+
return PI_ERROR_DEVICE_PARTITION_FAILED;
63+
case UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT:
64+
return PI_ERROR_INVALID_DEVICE_PARTITION_COUNT;
65+
case UR_RESULT_ERROR_INVALID_WORK_ITEM_SIZE:
66+
return PI_ERROR_INVALID_WORK_ITEM_SIZE;
67+
case UR_RESULT_ERROR_INVALID_WORK_DIMENSION:
68+
return PI_ERROR_INVALID_WORK_DIMENSION;
69+
case UR_RESULT_ERROR_INVALID_KERNEL_ARGS:
70+
return PI_ERROR_INVALID_KERNEL_ARGS;
71+
case UR_RESULT_ERROR_INVALID_KERNEL:
72+
return PI_ERROR_INVALID_KERNEL;
73+
case UR_RESULT_ERROR_INVALID_KERNEL_NAME:
74+
return PI_ERROR_INVALID_KERNEL_NAME;
75+
case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX:
76+
return PI_ERROR_INVALID_ARG_INDEX;
77+
case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE:
78+
return PI_ERROR_INVALID_ARG_SIZE;
79+
case UR_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE:
80+
return PI_ERROR_INVALID_VALUE;
81+
case UR_RESULT_ERROR_INVALID_IMAGE_SIZE:
82+
return PI_ERROR_INVALID_IMAGE_SIZE;
83+
case UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR:
84+
return PI_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR;
85+
case UR_RESULT_ERROR_IMAGE_FORMAT_NOT_SUPPORTED:
86+
return PI_ERROR_IMAGE_FORMAT_NOT_SUPPORTED;
87+
case UR_RESULT_ERROR_MEM_OBJECT_ALLOCATION_FAILURE:
88+
return PI_ERROR_MEM_OBJECT_ALLOCATION_FAILURE;
89+
case UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE:
90+
return PI_ERROR_INVALID_PROGRAM_EXECUTABLE;
91+
case UR_RESULT_ERROR_UNINITIALIZED:
92+
return PI_ERROR_UNINITIALIZED;
4593
case UR_RESULT_ERROR_OUT_OF_HOST_MEMORY:
4694
return PI_ERROR_OUT_OF_HOST_MEMORY;
95+
case UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY:
96+
case UR_RESULT_ERROR_OUT_OF_RESOURCES:
97+
return PI_ERROR_OUT_OF_RESOURCES;
4798
case UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE:
4899
return PI_ERROR_BUILD_PROGRAM_FAILURE;
49-
case UR_RESULT_ERROR_UNINITIALIZED:
50-
return PI_ERROR_UNINITIALIZED;
100+
case UR_RESULT_ERROR_PROGRAM_LINK_FAILURE:
101+
return PI_ERROR_LINK_PROGRAM_FAILURE;
102+
case UR_RESULT_ERROR_UNSUPPORTED_VERSION:
103+
case UR_RESULT_ERROR_UNSUPPORTED_FEATURE:
104+
case UR_RESULT_ERROR_INVALID_ARGUMENT:
105+
case UR_RESULT_ERROR_INVALID_NULL_HANDLE:
106+
case UR_RESULT_ERROR_HANDLE_OBJECT_IN_USE:
107+
case UR_RESULT_ERROR_INVALID_NULL_POINTER:
108+
return PI_ERROR_INVALID_VALUE;
109+
case UR_RESULT_ERROR_INVALID_SIZE:
110+
case UR_RESULT_ERROR_UNSUPPORTED_SIZE:
111+
return PI_ERROR_INVALID_BUFFER_SIZE;
112+
case UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT:
113+
return PI_ERROR_INVALID_VALUE;
114+
case UR_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT:
115+
case UR_RESULT_ERROR_INVALID_ENUMERATION:
116+
case UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION:
117+
return PI_ERROR_INVALID_VALUE;
118+
case UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT:
119+
return PI_ERROR_IMAGE_FORMAT_NOT_SUPPORTED;
120+
case UR_RESULT_ERROR_INVALID_NATIVE_BINARY:
121+
return PI_ERROR_INVALID_BINARY;
122+
case UR_RESULT_ERROR_INVALID_GLOBAL_NAME:
123+
return PI_ERROR_INVALID_VALUE;
124+
case UR_RESULT_ERROR_INVALID_FUNCTION_NAME:
125+
return PI_ERROR_FUNCTION_ADDRESS_IS_NOT_AVAILABLE;
126+
case UR_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION:
127+
return PI_ERROR_INVALID_WORK_DIMENSION;
128+
case UR_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION:
129+
return PI_ERROR_INVALID_VALUE;
130+
131+
case UR_RESULT_ERROR_PROGRAM_UNLINKED:
132+
return PI_ERROR_INVALID_PROGRAM_EXECUTABLE;
133+
case UR_RESULT_ERROR_OVERLAPPING_REGIONS:
134+
return PI_ERROR_MEM_COPY_OVERLAP;
135+
case UR_RESULT_ERROR_INVALID_HOST_PTR:
136+
return PI_ERROR_INVALID_HOST_PTR;
137+
case UR_RESULT_ERROR_INVALID_USM_SIZE:
138+
return PI_ERROR_INVALID_BUFFER_SIZE;
139+
case UR_RESULT_ERROR_OBJECT_ALLOCATION_FAILURE:
140+
return PI_ERROR_OUT_OF_RESOURCES;
51141
case UR_RESULT_ERROR_ADAPTER_SPECIFIC:
52142
return PI_ERROR_PLUGIN_SPECIFIC_ERROR;
143+
case UR_RESULT_ERROR_UNKNOWN:
53144
default:
54145
return PI_ERROR_UNKNOWN;
55146
};
@@ -253,6 +344,10 @@ inline pi_result ur2piDeviceInfoValue(ur_device_info_t ParamName,
253344
return PI_QUEUE_FLAG_ON_DEVICE;
254345
case UR_QUEUE_FLAG_ON_DEVICE_DEFAULT:
255346
return PI_QUEUE_FLAG_ON_DEVICE_DEFAULT;
347+
case UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM:
348+
return static_cast<uint64_t>(__SYCL_PI_CUDA_SYNC_WITH_DEFAULT);
349+
case UR_QUEUE_FLAG_USE_DEFAULT_STREAM:
350+
return static_cast<uint64_t>(__SYCL_PI_CUDA_USE_DEFAULT_STREAM);
256351
default:
257352
die("UR_DEVICE_INFO_QUEUE_PROPERTIES: unhandled value");
258353
}
@@ -1014,7 +1109,7 @@ inline pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName,
10141109
break;
10151110
}
10161111
case PI_EXT_CODEPLAY_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP: {
1017-
InfoType = UR_EXT_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP;
1112+
InfoType = UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP;
10181113
break;
10191114
}
10201115
default:
@@ -1380,6 +1475,10 @@ inline pi_result piextQueueCreate(pi_context Context, pi_device Device,
13801475
UrProperties.flags |= UR_QUEUE_FLAG_PRIORITY_LOW;
13811476
if (Properties[1] & PI_EXT_ONEAPI_QUEUE_FLAG_PRIORITY_HIGH)
13821477
UrProperties.flags |= UR_QUEUE_FLAG_PRIORITY_HIGH;
1478+
if (Properties[1] & __SYCL_PI_CUDA_SYNC_WITH_DEFAULT)
1479+
UrProperties.flags |= UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
1480+
if (Properties[1] & __SYCL_PI_CUDA_USE_DEFAULT_STREAM)
1481+
UrProperties.flags |= UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
13831482

13841483
ur_queue_index_properties_t IndexProperties{};
13851484
IndexProperties.stype = UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES;
@@ -1943,15 +2042,16 @@ inline pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex,
19432042

19442043
ur_kernel_handle_t UrKernel = reinterpret_cast<ur_kernel_handle_t>(Kernel);
19452044

1946-
HANDLE_ERRORS(urKernelSetArgValue(UrKernel, ArgIndex, ArgSize, ArgValue));
2045+
HANDLE_ERRORS(
2046+
urKernelSetArgValue(UrKernel, ArgIndex, ArgSize, nullptr, ArgValue));
19472047
return PI_SUCCESS;
19482048
}
19492049

19502050
inline pi_result piKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex,
19512051
size_t ArgSize, const void *ArgValue) {
19522052
std::ignore = ArgSize;
19532053
ur_kernel_handle_t UrKernel = reinterpret_cast<ur_kernel_handle_t>(Kernel);
1954-
HANDLE_ERRORS(urKernelSetArgPointer(UrKernel, ArgIndex, ArgValue));
2054+
HANDLE_ERRORS(urKernelSetArgPointer(UrKernel, ArgIndex, nullptr, ArgValue));
19552055

19562056
return PI_SUCCESS;
19572057
}
@@ -2013,17 +2113,15 @@ inline pi_result piKernelSetExecInfo(pi_kernel Kernel,
20132113
break;
20142114
}
20152115
case PI_EXT_KERNEL_EXEC_INFO_CACHE_CONFIG: {
2016-
PropName = UR_EXT_KERNEL_EXEC_INFO_CACHE_CONFIG;
2116+
PropName = UR_KERNEL_EXEC_INFO_CACHE_CONFIG;
20172117
auto Param = (*(static_cast<const pi_kernel_cache_config *>(ParamValue)));
20182118
if (Param == PI_EXT_KERNEL_EXEC_INFO_CACHE_LARGE_SLM) {
2019-
PropValue =
2020-
static_cast<uint64_t>(UR_EXT_KERNEL_EXEC_INFO_CACHE_LARGE_SLM);
2119+
PropValue = static_cast<uint64_t>(UR_KERNEL_CACHE_CONFIG_LARGE_SLM);
20212120
} else if (Param == PI_EXT_KERNEL_EXEC_INFO_CACHE_LARGE_DATA) {
2022-
PropValue =
2023-
static_cast<uint64_t>(UR_EXT_KERNEL_EXEC_INFO_CACHE_LARGE_DATA);
2121+
PropValue = static_cast<uint64_t>(UR_KERNEL_CACHE_CONFIG_LARGE_DATA);
20242122
break;
20252123
} else if (Param == PI_EXT_KERNEL_EXEC_INFO_CACHE_DEFAULT) {
2026-
PropValue = static_cast<uint64_t>(UR_EXT_KERNEL_EXEC_INFO_CACHE_DEFAULT);
2124+
PropValue = static_cast<uint64_t>(UR_KERNEL_CACHE_CONFIG_DEFAULT);
20272125
} else {
20282126
die("piKernelSetExecInfo: unsupported ParamValue\n");
20292127
}
@@ -2032,8 +2130,8 @@ inline pi_result piKernelSetExecInfo(pi_kernel Kernel,
20322130
default:
20332131
die("piKernelSetExecInfo: unsupported ParamName\n");
20342132
}
2035-
HANDLE_ERRORS(
2036-
urKernelSetExecInfo(UrKernel, PropName, ParamValueSize, &PropValue));
2133+
HANDLE_ERRORS(urKernelSetExecInfo(UrKernel, PropName, ParamValueSize, nullptr,
2134+
&PropValue));
20372135

20382136
return PI_SUCCESS;
20392137
}
@@ -2211,7 +2309,8 @@ inline pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex,
22112309
const void *ArgValue) {
22122310
ur_kernel_handle_t UrKernel = reinterpret_cast<ur_kernel_handle_t>(Kernel);
22132311

2214-
HANDLE_ERRORS(urKernelSetArgValue(UrKernel, ArgIndex, ArgSize, ArgValue));
2312+
HANDLE_ERRORS(
2313+
urKernelSetArgValue(UrKernel, ArgIndex, ArgSize, nullptr, ArgValue));
22152314

22162315
return PI_SUCCESS;
22172316
}
@@ -3919,7 +4018,7 @@ inline pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex,
39194018
ur_sampler_handle_t UrSampler =
39204019
reinterpret_cast<ur_sampler_handle_t>(*ArgValue);
39214020

3922-
HANDLE_ERRORS(urKernelSetArgSampler(UrKernel, ArgIndex, UrSampler));
4021+
HANDLE_ERRORS(urKernelSetArgSampler(UrKernel, ArgIndex, nullptr, UrSampler));
39234022

39244023
return PI_SUCCESS;
39254024
}

‎sycl/plugins/unified_runtime/ur/adapters/cuda/device.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -968,7 +968,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
968968

969969
return ReturnValue(ILVersion.data(), ILVersion.size());
970970
}
971-
case UR_EXT_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP: {
971+
case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP: {
972972
// Maximum number of 32-bit registers available to a thread block.
973973
// Note: This number is shared by all thread blocks simultaneously resident
974974
// on a multiprocessor.

‎sycl/plugins/unified_runtime/ur/adapters/cuda/kernel.cpp

Lines changed: 17 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -186,9 +186,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urKernelGetNativeHandle(
186186
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
187187
}
188188

189-
UR_APIEXPORT ur_result_t UR_APICALL
190-
urKernelSetArgValue(ur_kernel_handle_t hKernel, uint32_t argIndex,
191-
size_t argSize, const void *pArgValue) {
189+
UR_APIEXPORT ur_result_t UR_APICALL urKernelSetArgValue(
190+
ur_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize,
191+
const ur_kernel_arg_value_properties_t *pProperties,
192+
const void *pArgValue) {
193+
std::ignore = pProperties;
192194
UR_ASSERT(hKernel, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
193195
UR_ASSERT(argSize, UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE);
194196

@@ -289,8 +291,11 @@ urKernelGetSubGroupInfo(ur_kernel_handle_t hKernel, ur_device_handle_t hDevice,
289291
return UR_RESULT_ERROR_INVALID_ENUMERATION;
290292
}
291293

292-
UR_APIEXPORT ur_result_t UR_APICALL urKernelSetArgPointer(
293-
ur_kernel_handle_t hKernel, uint32_t argIndex, const void *pArgValue) {
294+
UR_APIEXPORT ur_result_t UR_APICALL
295+
urKernelSetArgPointer(ur_kernel_handle_t hKernel, uint32_t argIndex,
296+
const ur_kernel_arg_pointer_properties_t *pProperties,
297+
const void *pArgValue) {
298+
std::ignore = pProperties;
294299
hKernel->setKernelArg(argIndex, sizeof(pArgValue), pArgValue);
295300
return UR_RESULT_SUCCESS;
296301
}
@@ -339,10 +344,12 @@ urKernelSetArgMemObj(ur_kernel_handle_t hKernel, uint32_t argIndex,
339344
}
340345

341346
// A NOP for the CUDA backend
342-
UR_APIEXPORT ur_result_t UR_APICALL
343-
urKernelSetExecInfo(ur_kernel_handle_t hKernel, ur_kernel_exec_info_t propName,
344-
size_t propSize, const void *pPropValue) {
347+
UR_APIEXPORT ur_result_t UR_APICALL urKernelSetExecInfo(
348+
ur_kernel_handle_t hKernel, ur_kernel_exec_info_t propName, size_t propSize,
349+
const ur_kernel_exec_info_properties_t *pProperties,
350+
const void *pPropValue) {
345351
std::ignore = propSize;
352+
std::ignore = pProperties;
346353
UR_ASSERT(hKernel, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
347354
UR_ASSERT(pPropValue, UR_RESULT_ERROR_INVALID_NULL_POINTER);
348355
switch (propName) {
@@ -370,8 +377,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urKernelCreateWithNativeHandle(
370377

371378
UR_APIEXPORT ur_result_t UR_APICALL
372379
urKernelSetArgSampler(ur_kernel_handle_t hKernel, uint32_t argIndex,
380+
const ur_kernel_arg_sampler_properties_t *pProperties,
373381
ur_sampler_handle_t hArgValue) {
374382
UR_ASSERT(hKernel, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
383+
std::ignore = pProperties;
375384

376385
ur_result_t Result = UR_RESULT_SUCCESS;
377386
try {

‎sycl/plugins/unified_runtime/ur/adapters/cuda/queue.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -134,9 +134,9 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
134134
bool IsOutOfOrder = false;
135135
if (pProps && pProps->stype == UR_STRUCTURE_TYPE_QUEUE_PROPERTIES) {
136136
URFlags = pProps->flags;
137-
if (URFlags == __SYCL_UR_CUDA_USE_DEFAULT_STREAM) {
137+
if (URFlags == UR_QUEUE_FLAG_USE_DEFAULT_STREAM) {
138138
Flags = CU_STREAM_DEFAULT;
139-
} else if (URFlags == __SYCL_UR_CUDA_SYNC_WITH_DEFAULT) {
139+
} else if (URFlags == UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM) {
140140
Flags = 0;
141141
}
142142

@@ -261,9 +261,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
261261

262262
ur_queue_flags_t Flags = 0;
263263
if (CuFlags == CU_STREAM_DEFAULT)
264-
Flags = __SYCL_UR_CUDA_USE_DEFAULT_STREAM;
264+
Flags = UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
265265
else if (CuFlags == CU_STREAM_NON_BLOCKING)
266-
Flags = __SYCL_UR_CUDA_SYNC_WITH_DEFAULT;
266+
Flags = UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
267267
else
268268
sycl::detail::ur::die("Unknown cuda stream");
269269

‎sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_level_zero_event.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWait(
7070
ur_event_handle_t InternalEvent;
7171
bool IsInternal = OutEvent == nullptr;
7272
ur_event_handle_t *Event = OutEvent ? OutEvent : &InternalEvent;
73-
UR_CALL(createEventAndAssociateQueue(Queue, Event, UR_EXT_COMMAND_TYPE_USER,
73+
UR_CALL(createEventAndAssociateQueue(Queue, Event, UR_COMMAND_EVENTS_WAIT,
7474
CommandList, IsInternal));
7575

7676
ZeEvent = (*Event)->ZeEvent;
@@ -98,10 +98,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWait(
9898
std::scoped_lock<ur_shared_mutex> lock(Queue->Mutex);
9999

100100
if (OutEvent) {
101-
UR_CALL(createEventAndAssociateQueue(Queue, OutEvent,
102-
UR_EXT_COMMAND_TYPE_USER,
103-
Queue->CommandListMap.end(),
104-
/* IsInternal */ false));
101+
UR_CALL(createEventAndAssociateQueue(
102+
Queue, OutEvent, UR_COMMAND_EVENTS_WAIT, Queue->CommandListMap.end(),
103+
/* IsInternal */ false));
105104
}
106105

107106
Queue->synchronize();
@@ -161,7 +160,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
161160
}
162161

163162
UR_CALL(createEventAndAssociateQueue(
164-
Queue, &Event, UR_EXT_COMMAND_TYPE_USER, CmdList, IsInternal));
163+
Queue, &Event, UR_COMMAND_EVENTS_WAIT_WITH_BARRIER, CmdList,
164+
IsInternal));
165165

166166
Event->WaitList = EventWaitList;
167167

0 commit comments

Comments
 (0)