[UR][CL] Use regular malloc where clHostMemAllocINTEL_fn is not supported for USM allocs. (#18119)

Fixes oneapi-src/unified-runtime#1837

The UR OpenCL adapter expects patterns of 2 for USM allocs, and
fallsback to using clHostMemAllocINTEL_fn for non patterns of 2. Some
devices/platforms don't support this extension so we can just use a
regular malloc instead.

Author: martygrant

unified-runtime/source/adapters/opencl/usm.cpp

@@ -293,10 +293,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMFill(
   // as the largest CL type (double16/long16 - 128 bytes), anything larger or
   // not a power of 2, we need to do on the host side and copy it into the
   // target allocation.
-  clHostMemAllocINTEL_fn HostMemAlloc = nullptr;
-  UR_RETURN_ON_FAILURE(cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
-      CLContext, ur::cl::getAdapter()->fnCache.clHostMemAllocINTELCache,
-      cl_ext::HostMemAllocName, &HostMemAlloc));
 
   clEnqueueMemcpyINTEL_fn USMMemcpy = nullptr;
   UR_RETURN_ON_FAILURE(cl_ext::getExtFuncFromContext<clEnqueueMemcpyINTEL_fn>(
@@ -308,10 +304,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMFill(
       CLContext, ur::cl::getAdapter()->fnCache.clMemBlockingFreeINTELCache,
       cl_ext::MemBlockingFreeName, &USMFree));
 
-  cl_int ClErr = CL_SUCCESS;
-  auto HostBuffer =
-      static_cast<uint8_t *>(HostMemAlloc(CLContext, nullptr, size, 0, &ClErr));
-  CL_RETURN_ON_FAILURE(ClErr);
+  uint8_t *HostBuffer = new uint8_t[size];
 
   auto *End = HostBuffer + size;
   for (auto *Iter = HostBuffer; Iter < End; Iter += patternSize) {
@@ -343,9 +336,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMFill(
   }
 
   // This self destructs taking the event and allocation with it.
-  auto Info = new AllocDeleterCallbackInfo(USMFree, CLContext, HostBuffer);
+  AllocDeleterCallbackInfo *Info =
+      new AllocDeleterCallbackInfo(CLContext, HostBuffer);
 
-  ClErr =
+  cl_int ClErr =
       clSetEventCallback(CopyEvent, CL_COMPLETE,
                          AllocDeleterCallback<AllocDeleterCallbackInfo>, Info);
   if (ClErr != CL_SUCCESS) {
@@ -422,7 +416,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
         CLContext, ur::cl::getAdapter()->fnCache.clHostMemAllocINTELCache,
         cl_ext::HostMemAllocName, &HostMemAlloc));
 
-    auto HostAlloc = HostMemAlloc(CLContext, nullptr, size, 0, &CLErr);
+    auto HostAlloc = static_cast<uint8_t *>(
+        HostMemAlloc(CLContext, nullptr, size, 0, &CLErr));
     CL_RETURN_ON_FAILURE(CLErr);
 
     // Now that we've successfully allocated we should try to clean it up if we
@@ -489,12 +484,13 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
       }
 
       // This self destructs taking the event and allocation with it.
-      auto DeleterInfo = new AllocDeleterCallbackInfoWithQueue(
+      auto DeleterInfo = new AllocDeleterCallbackInfoUSMWithQueue(
           USMFree, CLContext, HostAlloc, MissingQueue);
 
       CLErr = clSetEventCallback(
           HostCopyEvent, CL_COMPLETE,
-          AllocDeleterCallback<AllocDeleterCallbackInfoWithQueue>, DeleterInfo);
+          AllocDeleterCallback<AllocDeleterCallbackInfoUSMWithQueue>,
+          DeleterInfo);
 
       if (CLErr != CL_SUCCESS) {
         // We can attempt to recover gracefully by attempting to wait for the

unified-runtime/source/adapters/opencl/usm.hpp

@@ -17,44 +17,56 @@
 //
 // Example usage:
 //
-// auto Info = new AllocDeleterCallbackInfo(USMFreeFuncPtr, Context,
+// auto Info = new AllocDeleterCallbackInfoUSM(USMFreeFuncPtr, Context,
 // Allocation); clSetEventCallback(USMOpEvent, CL_COMPLETE,
 // AllocDeleterCallback, Info);
-struct AllocDeleterCallbackInfo {
-  AllocDeleterCallbackInfo(clMemBlockingFreeINTEL_fn USMFree,
-                           cl_context CLContext, void *Allocation)
-      : USMFree(USMFree), CLContext(CLContext), Allocation(Allocation) {
+
+struct AllocDeleterCallbackInfoBase {
+  AllocDeleterCallbackInfoBase(cl_context Context, uint8_t *Allocation)
+      : CLContext(Context), Allocation(Allocation) {
     clRetainContext(CLContext);
   }
-  ~AllocDeleterCallbackInfo() {
-    USMFree(CLContext, Allocation);
-    clReleaseContext(CLContext);
-  }
-  AllocDeleterCallbackInfo(const AllocDeleterCallbackInfo &) = delete;
-  AllocDeleterCallbackInfo &
-  operator=(const AllocDeleterCallbackInfo &) = delete;
 
-  clMemBlockingFreeINTEL_fn USMFree;
+  virtual ~AllocDeleterCallbackInfoBase() { clReleaseContext(CLContext); }
+
+  AllocDeleterCallbackInfoBase(const AllocDeleterCallbackInfoBase &) = delete;
+  AllocDeleterCallbackInfoBase &
+  operator=(const AllocDeleterCallbackInfoBase &) = delete;
+
+protected:
   cl_context CLContext;
-  void *Allocation;
+  uint8_t *Allocation;
 };
 
-struct AllocDeleterCallbackInfoWithQueue : AllocDeleterCallbackInfo {
-  AllocDeleterCallbackInfoWithQueue(clMemBlockingFreeINTEL_fn USMFree,
-                                    cl_context CLContext, void *Allocation,
-                                    cl_command_queue CLQueue)
-      : AllocDeleterCallbackInfo(USMFree, CLContext, Allocation),
-        CLQueue(CLQueue) {
-    clRetainContext(CLContext);
+struct AllocDeleterCallbackInfo : AllocDeleterCallbackInfoBase {
+  AllocDeleterCallbackInfo(cl_context CLContext, uint8_t *Allocation)
+      : AllocDeleterCallbackInfoBase(CLContext, Allocation) {}
+
+  ~AllocDeleterCallbackInfo() override { delete[] Allocation; }
+};
+
+struct AllocDeleterCallbackInfoUSM : AllocDeleterCallbackInfoBase {
+  AllocDeleterCallbackInfoUSM(clMemBlockingFreeINTEL_fn USMFree,
+                              cl_context CLContext, uint8_t *Allocation)
+      : AllocDeleterCallbackInfoBase(CLContext, Allocation), USMFree(USMFree) {}
+  ~AllocDeleterCallbackInfoUSM() override { USMFree(CLContext, Allocation); }
+
+  clMemBlockingFreeINTEL_fn USMFree;
+};
+
+struct AllocDeleterCallbackInfoUSMWithQueue : AllocDeleterCallbackInfoUSM {
+  AllocDeleterCallbackInfoUSMWithQueue(clMemBlockingFreeINTEL_fn USMFree,
+                                       cl_context CLContext,
+                                       uint8_t *Allocation,
+                                       cl_command_queue CLQueue)
+      : AllocDeleterCallbackInfoUSM(USMFree, CLContext, Allocation),
+        CLQueue(CLQueue) {}
+  ~AllocDeleterCallbackInfoUSMWithQueue() override {
+    clReleaseCommandQueue(CLQueue);
   }
-  ~AllocDeleterCallbackInfoWithQueue() { clReleaseCommandQueue(CLQueue); }
-  AllocDeleterCallbackInfoWithQueue(const AllocDeleterCallbackInfoWithQueue &) =
-      delete;
-  AllocDeleterCallbackInfoWithQueue &
-  operator=(const AllocDeleterCallbackInfoWithQueue &) = delete;
 
   cl_command_queue CLQueue;
 };
 
 template <class T>
-void AllocDeleterCallback(cl_event event, cl_int, void *pUserData);
+void AllocDeleterCallback(cl_event event, cl_int, uint8_t *pUserData);