Skip to content

Commit 42d00cd

Browse files
aarongreigaarongreig
committed
Merge branch 'aaron/clUSMCTSFixes' into aaron/clCTSFixMegaBranch
2 parents 4b1dd79 + fc34c26 commit 42d00cd

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,
@@ -331,14 +346,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
331346

332347
UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
333348
ur_queue_handle_t hQueue, [[maybe_unused]] const void *pMem,
334-
[[maybe_unused]] size_t size, ur_usm_migration_flags_t flags,
349+
[[maybe_unused]] size_t size,
350+
[[maybe_unused]] ur_usm_migration_flags_t flags,
335351
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
336352
ur_event_handle_t *phEvent) {
337353

338-
// flags is currently unused so fail if set
339-
if (flags != 0)
340-
return UR_RESULT_ERROR_INVALID_VALUE;
341-
342354
return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
343355
cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
344356
cl_adapter::cast<const cl_event *>(phEventWaitList),
@@ -504,9 +516,14 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
504516
}
505517

506518
if (FuncPtr) {
507-
RetVal =
508-
mapCLErrorToUR(FuncPtr(cl_adapter::cast<cl_context>(hContext), pMem,
509-
PropNameCL, propSize, pPropValue, pPropSizeRet));
519+
size_t CheckPropSize = 0;
520+
size_t *CheckPropSizeRet = pPropSizeRet ? pPropSizeRet : &CheckPropSize;
521+
RetVal = mapCLErrorToUR(FuncPtr(cl_adapter::cast<cl_context>(hContext),
522+
pMem, PropNameCL, propSize, pPropValue,
523+
CheckPropSizeRet));
524+
if (pPropValue && *CheckPropSizeRet != propSize) {
525+
return UR_RESULT_ERROR_INVALID_SIZE;
526+
}
510527
if (RetVal == UR_RESULT_SUCCESS && pPropValue &&
511528
propName == UR_USM_ALLOC_INFO_TYPE) {
512529
auto *AllocTypeCL =

0 commit comments

Comments
 (0)