Skip to content

Commit a42adf2

Browse files
martygrantmartygrant
committed
[OpenCL] Add Command Buffer extension to OpenCL adapter.
1 parent 192e940 commit a42adf2

File tree

5 files changed

+304
-84
lines changed

5 files changed

+304
-84
lines changed

‎source/adapters/opencl/command_buffer.cpp

Lines changed: 202 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -11,58 +11,118 @@
1111
#include "command_buffer.hpp"
1212
#include "common.hpp"
1313

14-
/// Stub implementations of UR experimental feature command-buffers
15-
1614
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferCreateExp(
17-
[[maybe_unused]] ur_context_handle_t hContext,
18-
[[maybe_unused]] ur_device_handle_t hDevice,
15+
ur_context_handle_t hContext, ur_device_handle_t hDevice,
1916
[[maybe_unused]] const ur_exp_command_buffer_desc_t *pCommandBufferDesc,
20-
[[maybe_unused]] ur_exp_command_buffer_handle_t *phCommandBuffer) {
17+
ur_exp_command_buffer_handle_t *phCommandBuffer) {
2118

22-
cl_adapter::die("Experimental Command-buffer feature is not "
23-
"implemented for OpenCL adapter.");
24-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
19+
ur_queue_handle_t Queue = nullptr;
20+
UR_RETURN_ON_FAILURE(urQueueCreate(hContext, hDevice, nullptr, &Queue));
21+
22+
cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
23+
cl_ext::clCreateCommandBufferKHR_fn clCreateCommandBufferKHR = nullptr;
24+
cl_int Res =
25+
cl_ext::getExtFuncFromContext<decltype(clCreateCommandBufferKHR)>(
26+
CLContext, cl_ext::ExtFuncPtrCache->clCreateCommandBufferKHRCache,
27+
cl_ext::CreateCommandBufferName, &clCreateCommandBufferKHR);
28+
29+
if (!clCreateCommandBufferKHR || Res != CL_SUCCESS)
30+
return UR_RESULT_ERROR_INVALID_OPERATION;
31+
32+
auto CLCommandBuffer = clCreateCommandBufferKHR(
33+
1, cl_adapter::cast<cl_command_queue *>(&Queue), nullptr, &Res);
34+
CL_RETURN_ON_FAILURE_AND_SET_NULL(Res, phCommandBuffer);
35+
36+
try {
37+
auto URCommandBuffer = std::make_unique<ur_exp_command_buffer_handle_t_>(
38+
Queue, hContext, CLCommandBuffer);
39+
*phCommandBuffer = URCommandBuffer.release();
40+
} catch (...) {
41+
return UR_RESULT_ERROR_OUT_OF_RESOURCES;
42+
}
43+
44+
CL_RETURN_ON_FAILURE(Res);
45+
return UR_RESULT_SUCCESS;
2546
}
2647

27-
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferRetainExp(
28-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer) {
48+
UR_APIEXPORT ur_result_t UR_APICALL
49+
urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
50+
UR_RETURN_ON_FAILURE(urQueueRetain(hCommandBuffer->hInternalQueue));
2951

30-
cl_adapter::die("Experimental Command-buffer feature is not "
31-
"implemented for OpenCL adapter.");
32-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
52+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
53+
cl_ext::clRetainCommandBufferKHR_fn clRetainCommandBuffer = nullptr;
54+
cl_int Res = cl_ext::getExtFuncFromContext<decltype(clRetainCommandBuffer)>(
55+
CLContext, cl_ext::ExtFuncPtrCache->clRetainCommandBufferKHRCache,
56+
cl_ext::RetainCommandBufferName, &clRetainCommandBuffer);
57+
58+
if (!clRetainCommandBuffer || Res != CL_SUCCESS)
59+
return UR_RESULT_ERROR_INVALID_OPERATION;
60+
61+
CL_RETURN_ON_FAILURE(clRetainCommandBuffer(hCommandBuffer->CLCommandBuffer));
62+
return UR_RESULT_SUCCESS;
3363
}
3464

35-
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferReleaseExp(
36-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer) {
65+
UR_APIEXPORT ur_result_t UR_APICALL
66+
urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
67+
UR_RETURN_ON_FAILURE(urQueueRelease(hCommandBuffer->hInternalQueue));
3768

38-
cl_adapter::die("Experimental Command-buffer feature is not "
39-
"implemented for OpenCL adapter.");
40-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
69+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
70+
cl_ext::clReleaseCommandBufferKHR_fn clReleaseCommandBufferKHR = nullptr;
71+
cl_int Res =
72+
cl_ext::getExtFuncFromContext<decltype(clReleaseCommandBufferKHR)>(
73+
CLContext, cl_ext::ExtFuncPtrCache->clReleaseCommandBufferKHRCache,
74+
cl_ext::ReleaseCommandBufferName, &clReleaseCommandBufferKHR);
75+
76+
if (!clReleaseCommandBufferKHR || Res != CL_SUCCESS)
77+
return UR_RESULT_ERROR_INVALID_OPERATION;
78+
79+
CL_RETURN_ON_FAILURE(
80+
clReleaseCommandBufferKHR(hCommandBuffer->CLCommandBuffer));
81+
return UR_RESULT_SUCCESS;
4182
}
4283

43-
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferFinalizeExp(
44-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer) {
84+
UR_APIEXPORT ur_result_t UR_APICALL
85+
urCommandBufferFinalizeExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
86+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
87+
cl_ext::clFinalizeCommandBufferKHR_fn clFinalizeCommandBufferKHR = nullptr;
88+
cl_int Res =
89+
cl_ext::getExtFuncFromContext<decltype(clFinalizeCommandBufferKHR)>(
90+
CLContext, cl_ext::ExtFuncPtrCache->clFinalizeCommandBufferKHRCache,
91+
cl_ext::FinalizeCommandBufferName, &clFinalizeCommandBufferKHR);
4592

46-
cl_adapter::die("Experimental Command-buffer feature is not "
47-
"implemented for OpenCL adapter.");
48-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
93+
if (!clFinalizeCommandBufferKHR || Res != CL_SUCCESS)
94+
return UR_RESULT_ERROR_INVALID_OPERATION;
95+
96+
CL_RETURN_ON_FAILURE(
97+
clFinalizeCommandBufferKHR(hCommandBuffer->CLCommandBuffer));
98+
return UR_RESULT_SUCCESS;
4999
}
50100

51101
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp(
52-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer,
53-
[[maybe_unused]] ur_kernel_handle_t hKernel,
54-
[[maybe_unused]] uint32_t workDim,
55-
[[maybe_unused]] const size_t *pGlobalWorkOffset,
56-
[[maybe_unused]] const size_t *pGlobalWorkSize,
57-
[[maybe_unused]] const size_t *pLocalWorkSize,
58-
[[maybe_unused]] uint32_t numSyncPointsInWaitList,
59-
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
60-
*pSyncPointWaitList,
61-
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
102+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_kernel_handle_t hKernel,
103+
uint32_t workDim, const size_t *pGlobalWorkOffset,
104+
const size_t *pGlobalWorkSize, const size_t *pLocalWorkSize,
105+
uint32_t numSyncPointsInWaitList,
106+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
107+
ur_exp_command_buffer_sync_point_t *pSyncPoint) {
62108

63-
cl_adapter::die("Experimental Command-buffer feature is not "
64-
"implemented for OpenCL adapter.");
65-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
109+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
110+
cl_ext::clCommandNDRangeKernelKHR_fn clCommandNDRangeKernelKHR = nullptr;
111+
cl_int Res =
112+
cl_ext::getExtFuncFromContext<decltype(clCommandNDRangeKernelKHR)>(
113+
CLContext, cl_ext::ExtFuncPtrCache->clCommandNDRangeKernelKHRCache,
114+
cl_ext::CommandNRRangeKernelName, &clCommandNDRangeKernelKHR);
115+
116+
if (!clCommandNDRangeKernelKHR || Res != CL_SUCCESS)
117+
return UR_RESULT_ERROR_INVALID_OPERATION;
118+
119+
CL_RETURN_ON_FAILURE(clCommandNDRangeKernelKHR(
120+
hCommandBuffer->CLCommandBuffer, nullptr, nullptr,
121+
cl_adapter::cast<cl_kernel>(hKernel), workDim, pGlobalWorkOffset,
122+
pGlobalWorkSize, pLocalWorkSize, numSyncPointsInWaitList,
123+
pSyncPointWaitList, pSyncPoint, nullptr));
124+
125+
return UR_RESULT_SUCCESS;
66126
}
67127

68128
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMemcpyUSMExp(
@@ -73,44 +133,78 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMemcpyUSMExp(
73133
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
74134
*pSyncPointWaitList,
75135
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
76-
77-
cl_adapter::die("Experimental Command-buffer feature is not "
78-
"implemented for OpenCL adapter.");
79136
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
80137
}
81138

82-
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMembufferCopyExp(
139+
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp(
83140
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer,
84-
[[maybe_unused]] ur_mem_handle_t hSrcMem,
85-
[[maybe_unused]] ur_mem_handle_t hDstMem, [[maybe_unused]] size_t srcOffset,
86-
[[maybe_unused]] size_t dstOffset, [[maybe_unused]] size_t size,
141+
[[maybe_unused]] void *pMemory, [[maybe_unused]] const void *pPattern,
142+
[[maybe_unused]] size_t patternSize, [[maybe_unused]] size_t size,
87143
[[maybe_unused]] uint32_t numSyncPointsInWaitList,
88144
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
89145
*pSyncPointWaitList,
90146
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
91-
92-
cl_adapter::die("Experimental Command-buffer feature is not "
93-
"implemented for OpenCL adapter.");
94147
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
95148
}
96149

150+
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMembufferCopyExp(
151+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_mem_handle_t hSrcMem,
152+
ur_mem_handle_t hDstMem, size_t srcOffset, size_t dstOffset, size_t size,
153+
uint32_t numSyncPointsInWaitList,
154+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
155+
ur_exp_command_buffer_sync_point_t *pSyncPoint) {
156+
157+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
158+
cl_ext::clCommandCopyBufferKHR_fn clCommandCopyBufferKHR = nullptr;
159+
cl_int Res = cl_ext::getExtFuncFromContext<decltype(clCommandCopyBufferKHR)>(
160+
CLContext, cl_ext::ExtFuncPtrCache->clCommandCopyBufferKHRCache,
161+
cl_ext::CommandCopyBufferName, &clCommandCopyBufferKHR);
162+
163+
if (!clCommandCopyBufferKHR || Res != CL_SUCCESS)
164+
return UR_RESULT_ERROR_INVALID_OPERATION;
165+
166+
CL_RETURN_ON_FAILURE(clCommandCopyBufferKHR(
167+
hCommandBuffer->CLCommandBuffer,
168+
nullptr,
169+
cl_adapter::cast<cl_mem>(hSrcMem), cl_adapter::cast<cl_mem>(hDstMem),
170+
srcOffset, dstOffset, size, numSyncPointsInWaitList, pSyncPointWaitList,
171+
pSyncPoint, nullptr));
172+
173+
return UR_RESULT_SUCCESS;
174+
}
175+
97176
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMembufferCopyRectExp(
98-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer,
99-
[[maybe_unused]] ur_mem_handle_t hSrcMem,
100-
[[maybe_unused]] ur_mem_handle_t hDstMem,
101-
[[maybe_unused]] ur_rect_offset_t srcOrigin,
102-
[[maybe_unused]] ur_rect_offset_t dstOrigin,
103-
[[maybe_unused]] ur_rect_region_t region,
104-
[[maybe_unused]] size_t srcRowPitch, [[maybe_unused]] size_t srcSlicePitch,
105-
[[maybe_unused]] size_t dstRowPitch, [[maybe_unused]] size_t dstSlicePitch,
106-
[[maybe_unused]] uint32_t numSyncPointsInWaitList,
107-
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
108-
*pSyncPointWaitList,
109-
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
177+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_mem_handle_t hSrcMem,
178+
ur_mem_handle_t hDstMem, ur_rect_offset_t srcOrigin,
179+
ur_rect_offset_t dstOrigin, ur_rect_region_t region, size_t srcRowPitch,
180+
size_t srcSlicePitch, size_t dstRowPitch, size_t dstSlicePitch,
181+
uint32_t numSyncPointsInWaitList,
182+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
183+
ur_exp_command_buffer_sync_point_t *pSyncPoint) {
110184

111-
cl_adapter::die("Experimental Command-buffer feature is not "
112-
"implemented for OpenCL adapter.");
113-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
185+
size_t OpenCLOriginRect[3]{srcOrigin.x, srcOrigin.y, srcOrigin.z};
186+
size_t OpenCLDstRect[3]{dstOrigin.x, dstOrigin.y, dstOrigin.z};
187+
size_t OpenCLRegion[3]{region.width, region.height, region.depth};
188+
189+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
190+
cl_ext::clCommandCopyBufferRectKHR_fn clCommandCopyBufferRectKHR = nullptr;
191+
cl_int Res =
192+
cl_ext::getExtFuncFromContext<decltype(clCommandCopyBufferRectKHR)>(
193+
CLContext, cl_ext::ExtFuncPtrCache->clCommandCopyBufferRectKHRCache,
194+
cl_ext::CommandCopyBufferRectName, &clCommandCopyBufferRectKHR);
195+
196+
if (!clCommandCopyBufferRectKHR || Res != CL_SUCCESS)
197+
return UR_RESULT_ERROR_INVALID_OPERATION;
198+
199+
CL_RETURN_ON_FAILURE(clCommandCopyBufferRectKHR(
200+
hCommandBuffer->CLCommandBuffer,
201+
nullptr,
202+
cl_adapter::cast<cl_mem>(hSrcMem), cl_adapter::cast<cl_mem>(hDstMem),
203+
OpenCLOriginRect, OpenCLDstRect, OpenCLRegion, srcRowPitch, srcSlicePitch,
204+
dstRowPitch, dstSlicePitch, numSyncPointsInWaitList, pSyncPointWaitList,
205+
pSyncPoint, nullptr));
206+
207+
return UR_RESULT_SUCCESS;
114208
}
115209

116210
UR_APIEXPORT
@@ -122,9 +216,6 @@ ur_result_t UR_APICALL urCommandBufferAppendMembufferWriteExp(
122216
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
123217
*pSyncPointWaitList,
124218
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
125-
126-
cl_adapter::die("Experimental Command-buffer feature is not "
127-
"implemented for OpenCL adapter.");
128219
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
129220
}
130221

@@ -137,9 +228,6 @@ ur_result_t UR_APICALL urCommandBufferAppendMembufferReadExp(
137228
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
138229
*pSyncPointWaitList,
139230
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
140-
141-
cl_adapter::die("Experimental Command-buffer feature is not "
142-
"implemented for OpenCL adapter.");
143231
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
144232
}
145233

@@ -158,9 +246,6 @@ ur_result_t UR_APICALL urCommandBufferAppendMembufferWriteRectExp(
158246
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
159247
*pSyncPointWaitList,
160248
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
161-
162-
cl_adapter::die("Experimental Command-buffer feature is not "
163-
"implemented for OpenCL adapter.");
164249
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
165250
}
166251

@@ -179,20 +264,56 @@ ur_result_t UR_APICALL urCommandBufferAppendMembufferReadRectExp(
179264
[[maybe_unused]] const ur_exp_command_buffer_sync_point_t
180265
*pSyncPointWaitList,
181266
[[maybe_unused]] ur_exp_command_buffer_sync_point_t *pSyncPoint) {
182-
183-
cl_adapter::die("Experimental Command-buffer feature is not "
184-
"implemented for OpenCL adapter.");
185267
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
186268
}
187269

270+
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMembufferFillExp(
271+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_mem_handle_t hBuffer,
272+
const void *pPattern, size_t patternSize, size_t offset, size_t size,
273+
uint32_t numSyncPointsInWaitList,
274+
const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
275+
ur_exp_command_buffer_sync_point_t *pSyncPoint) {
276+
277+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
278+
cl_ext::clCommandFillBufferKHR_fn clCommandFillBufferKHR = nullptr;
279+
cl_int Res = cl_ext::getExtFuncFromContext<decltype(clCommandFillBufferKHR)>(
280+
CLContext, cl_ext::ExtFuncPtrCache->clCommandFillBufferKHRCache,
281+
cl_ext::CommandFillBufferName, &clCommandFillBufferKHR);
282+
283+
if (!clCommandFillBufferKHR || Res != CL_SUCCESS)
284+
return UR_RESULT_ERROR_INVALID_OPERATION;
285+
286+
CL_RETURN_ON_FAILURE(clCommandFillBufferKHR(
287+
hCommandBuffer->CLCommandBuffer,
288+
nullptr,
289+
cl_adapter::cast<cl_mem>(hBuffer), pPattern, patternSize, offset, size,
290+
numSyncPointsInWaitList, pSyncPointWaitList, pSyncPoint, nullptr));
291+
292+
return UR_RESULT_SUCCESS;
293+
}
294+
188295
UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferEnqueueExp(
189-
[[maybe_unused]] ur_exp_command_buffer_handle_t hCommandBuffer,
190-
[[maybe_unused]] ur_queue_handle_t hQueue,
191-
[[maybe_unused]] uint32_t numEventsInWaitList,
192-
[[maybe_unused]] const ur_event_handle_t *phEventWaitList,
193-
[[maybe_unused]] ur_event_handle_t *phEvent) {
296+
ur_exp_command_buffer_handle_t hCommandBuffer, ur_queue_handle_t hQueue,
297+
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
298+
ur_event_handle_t *phEvent) {
194299

195-
cl_adapter::die("Experimental Command-buffer feature is not "
196-
"implemented for OpenCL adapter.");
197-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
300+
cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
301+
cl_ext::clEnqueueCommandBufferKHR_fn clEnqueueCommandBufferKHR = nullptr;
302+
cl_int Res =
303+
cl_ext::getExtFuncFromContext<decltype(clEnqueueCommandBufferKHR)>(
304+
CLContext, cl_ext::ExtFuncPtrCache->clEnqueueCommandBufferKHRCache,
305+
cl_ext::EnqueueCommandBufferName, &clEnqueueCommandBufferKHR);
306+
307+
if (!clEnqueueCommandBufferKHR || Res != CL_SUCCESS)
308+
return UR_RESULT_ERROR_INVALID_OPERATION;
309+
310+
const uint32_t NumberOfQueues = 1;
311+
312+
CL_RETURN_ON_FAILURE(clEnqueueCommandBufferKHR(
313+
NumberOfQueues, cl_adapter::cast<cl_command_queue *>(&hQueue),
314+
hCommandBuffer->CLCommandBuffer, numEventsInWaitList,
315+
cl_adapter::cast<const cl_event *>(phEventWaitList),
316+
cl_adapter::cast<cl_event *>(phEvent)));
317+
318+
return UR_RESULT_SUCCESS;
198319
}

‎source/adapters/opencl/command_buffer.hpp

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,17 @@
88
//
99
//===----------------------------------------------------------------------===//
1010

11+
#include <CL/cl_ext.h>
1112
#include <ur/ur.hpp>
1213

13-
/// Stub implementation of command-buffers for OpenCL
14+
struct ur_exp_command_buffer_handle_t_ {
15+
ur_queue_handle_t hInternalQueue;
16+
ur_context_handle_t hContext;
17+
cl_command_buffer_khr CLCommandBuffer;
1418

15-
struct ur_exp_command_buffer_handle_t_ {};
19+
ur_exp_command_buffer_handle_t_(ur_queue_handle_t hQueue,
20+
ur_context_handle_t hContext,
21+
cl_command_buffer_khr CLCommandBuffer)
22+
: hInternalQueue(hQueue), hContext(hContext),
23+
CLCommandBuffer(CLCommandBuffer) {}
24+
};

‎source/adapters/opencl/common.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -77,6 +77,10 @@ ur_result_t mapCLErrorToUR(cl_int Result) {
7777
return UR_RESULT_ERROR_PROGRAM_LINK_FAILURE;
7878
case CL_INVALID_ARG_INDEX:
7979
return UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX;
80+
case CL_INVALID_COMMAND_BUFFER_KHR:
81+
return UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP;
82+
case CL_INVALID_SYNC_POINT_WAIT_LIST_KHR:
83+
return UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_WAIT_LIST_EXP;
8084
default:
8185
return UR_RESULT_ERROR_UNKNOWN;
8286
}

0 commit comments

Comments
 (0)