Skip to content

Commit fc34c26

Browse files
aarongreigaarongreig
committed
[OpenCL] Make USM functions return UR_RESULT_ERROR_INVALID_USM_SIZE
Also ignore flags in no-op urEnqueueUSMPrefetch hint.
1 parent 55d432c commit fc34c26

File tree

1 file changed

+55
-38
lines changed

1 file changed

+55
-38
lines changed

‎source/adapters/opencl/usm.cpp

Lines changed: 55 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,6 @@ urUSMHostAlloc(ur_context_handle_t hContext, const ur_usm_desc_t *pUSMDesc,
1515
ur_usm_pool_handle_t, size_t size, void **ppMem) {
1616

1717
void *Ptr = nullptr;
18-
ur_result_t RetVal = UR_RESULT_ERROR_INVALID_OPERATION;
1918
uint32_t Alignment = pUSMDesc ? pUSMDesc->align : 0;
2019

2120
cl_mem_alloc_flags_intel Flags = 0;
@@ -40,23 +39,28 @@ urUSMHostAlloc(ur_context_handle_t hContext, const ur_usm_desc_t *pUSMDesc,
4039
// First we need to look up the function pointer
4140
clHostMemAllocINTEL_fn FuncPtr = nullptr;
4241
cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
43-
RetVal = cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
44-
CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
45-
cl_ext::HostMemAllocName, &FuncPtr);
42+
if (auto UrResult = cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
43+
CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
44+
cl_ext::HostMemAllocName, &FuncPtr)) {
45+
return UrResult;
46+
}
4647

4748
if (FuncPtr) {
48-
Ptr = FuncPtr(CLContext, Properties, size, Alignment,
49-
cl_adapter::cast<cl_int *>(&RetVal));
49+
cl_int ClResult = CL_SUCCESS;
50+
Ptr = FuncPtr(CLContext, Properties, size, Alignment, &ClResult);
51+
if (ClResult == CL_INVALID_BUFFER_SIZE) {
52+
return UR_RESULT_ERROR_INVALID_USM_SIZE;
53+
}
54+
CL_RETURN_ON_FAILURE(ClResult);
5055
}
5156

5257
*ppMem = Ptr;
5358

54-
// ensure we aligned the allocation correctly
55-
if (RetVal == UR_RESULT_SUCCESS && Alignment != 0)
56-
assert(reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0 &&
57-
"allocation not aligned correctly");
59+
assert((Alignment == 0 ||
60+
reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0) &&
61+
"Allocation not aligned correctly!");
5862

59-
return RetVal;
63+
return UR_RESULT_SUCCESS;
6064
}
6165

6266
UR_APIEXPORT ur_result_t UR_APICALL
@@ -65,7 +69,6 @@ urUSMDeviceAlloc(ur_context_handle_t hContext, ur_device_handle_t hDevice,
6569
size_t size, void **ppMem) {
6670

6771
void *Ptr = nullptr;
68-
ur_result_t RetVal = UR_RESULT_ERROR_INVALID_OPERATION;
6972
uint32_t Alignment = pUSMDesc ? pUSMDesc->align : 0;
7073

7174
cl_mem_alloc_flags_intel Flags = 0;
@@ -92,24 +95,30 @@ urUSMDeviceAlloc(ur_context_handle_t hContext, ur_device_handle_t hDevice,
9295
// First we need to look up the function pointer
9396
clDeviceMemAllocINTEL_fn FuncPtr = nullptr;
9497
cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
95-
RetVal = cl_ext::getExtFuncFromContext<clDeviceMemAllocINTEL_fn>(
96-
CLContext, cl_ext::ExtFuncPtrCache->clDeviceMemAllocINTELCache,
97-
cl_ext::DeviceMemAllocName, &FuncPtr);
98+
if (auto UrResult = cl_ext::getExtFuncFromContext<clDeviceMemAllocINTEL_fn>(
99+
CLContext, cl_ext::ExtFuncPtrCache->clDeviceMemAllocINTELCache,
100+
cl_ext::DeviceMemAllocName, &FuncPtr)) {
101+
return UrResult;
102+
}
98103

99104
if (FuncPtr) {
105+
cl_int ClResult = CL_SUCCESS;
100106
Ptr = FuncPtr(CLContext, cl_adapter::cast<cl_device_id>(hDevice),
101107
cl_adapter::cast<cl_mem_properties_intel *>(Properties), size,
102-
Alignment, cl_adapter::cast<cl_int *>(&RetVal));
108+
Alignment, &ClResult);
109+
if (ClResult == CL_INVALID_BUFFER_SIZE) {
110+
return UR_RESULT_ERROR_INVALID_USM_SIZE;
111+
}
112+
CL_RETURN_ON_FAILURE(ClResult);
103113
}
104114

105115
*ppMem = Ptr;
106116

107-
// ensure we aligned the allocation correctly
108-
if (RetVal == UR_RESULT_SUCCESS && Alignment != 0)
109-
assert(reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0 &&
110-
"allocation not aligned correctly");
117+
assert((Alignment == 0 ||
118+
reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0) &&
119+
"Allocation not aligned correctly!");
111120

112-
return RetVal;
121+
return UR_RESULT_SUCCESS;
113122
}
114123

115124
UR_APIEXPORT ur_result_t UR_APICALL
@@ -118,7 +127,6 @@ urUSMSharedAlloc(ur_context_handle_t hContext, ur_device_handle_t hDevice,
118127
size_t size, void **ppMem) {
119128

120129
void *Ptr = nullptr;
121-
ur_result_t RetVal = UR_RESULT_ERROR_INVALID_OPERATION;
122130
uint32_t Alignment = pUSMDesc ? pUSMDesc->align : 0;
123131

124132
cl_mem_alloc_flags_intel Flags = 0;
@@ -155,22 +163,29 @@ urUSMSharedAlloc(ur_context_handle_t hContext, ur_device_handle_t hDevice,
155163
// First we need to look up the function pointer
156164
clSharedMemAllocINTEL_fn FuncPtr = nullptr;
157165
cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
158-
RetVal = cl_ext::getExtFuncFromContext<clSharedMemAllocINTEL_fn>(
159-
CLContext, cl_ext::ExtFuncPtrCache->clSharedMemAllocINTELCache,
160-
cl_ext::SharedMemAllocName, &FuncPtr);
166+
if (auto UrResult = cl_ext::getExtFuncFromContext<clSharedMemAllocINTEL_fn>(
167+
CLContext, cl_ext::ExtFuncPtrCache->clSharedMemAllocINTELCache,
168+
cl_ext::SharedMemAllocName, &FuncPtr)) {
169+
return UrResult;
170+
}
161171

162172
if (FuncPtr) {
173+
cl_int ClResult = CL_SUCCESS;
163174
Ptr = FuncPtr(CLContext, cl_adapter::cast<cl_device_id>(hDevice),
164175
cl_adapter::cast<cl_mem_properties_intel *>(Properties), size,
165-
Alignment, cl_adapter::cast<cl_int *>(&RetVal));
176+
Alignment, cl_adapter::cast<cl_int *>(&ClResult));
177+
if (ClResult == CL_INVALID_BUFFER_SIZE) {
178+
return UR_RESULT_ERROR_INVALID_USM_SIZE;
179+
}
180+
CL_RETURN_ON_FAILURE(ClResult);
166181
}
167182

168183
*ppMem = Ptr;
169184

170-
assert(Alignment == 0 ||
171-
(RetVal == UR_RESULT_SUCCESS &&
172-
reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0));
173-
return RetVal;
185+
assert((Alignment == 0 ||
186+
reinterpret_cast<std::uintptr_t>(*ppMem) % Alignment == 0) &&
187+
"Allocation not aligned correctly!");
188+
return UR_RESULT_SUCCESS;
174189
}
175190

176191
UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext,
@@ -255,14 +270,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
255270

256271
UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
257272
ur_queue_handle_t hQueue, [[maybe_unused]] const void *pMem,
258-
[[maybe_unused]] size_t size, ur_usm_migration_flags_t flags,
273+
[[maybe_unused]] size_t size,
274+
[[maybe_unused]] ur_usm_migration_flags_t flags,
259275
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
260276
ur_event_handle_t *phEvent) {
261277

262-
// flags is currently unused so fail if set
263-
if (flags != 0)
264-
return UR_RESULT_ERROR_INVALID_VALUE;
265-
266278
return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
267279
cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
268280
cl_adapter::cast<const cl_event *>(phEventWaitList),
@@ -387,9 +399,14 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
387399
}
388400

389401
if (FuncPtr) {
390-
RetVal =
391-
mapCLErrorToUR(FuncPtr(cl_adapter::cast<cl_context>(hContext), pMem,
392-
PropNameCL, propSize, pPropValue, pPropSizeRet));
402+
size_t CheckPropSize = 0;
403+
size_t *CheckPropSizeRet = pPropSizeRet ? pPropSizeRet : &CheckPropSize;
404+
RetVal = mapCLErrorToUR(FuncPtr(cl_adapter::cast<cl_context>(hContext),
405+
pMem, PropNameCL, propSize, pPropValue,
406+
CheckPropSizeRet));
407+
if (pPropValue && *CheckPropSizeRet != propSize) {
408+
return UR_RESULT_ERROR_INVALID_SIZE;
409+
}
393410
if (RetVal == UR_RESULT_SUCCESS && pPropValue &&
394411
propName == UR_USM_ALLOC_INFO_TYPE) {
395412
auto *AllocTypeCL =

0 commit comments

Comments
 (0)