Match cuda

Author: omarahmed1111

source/adapters/opencl/adapter.cpp

@@ -22,7 +22,10 @@ urAdapterGet(uint32_t NumEntries, ur_adapter_handle_t *phAdapters,
              uint32_t *pNumAdapters) {
   if (NumEntries > 0 && phAdapters) {
     std::lock_guard<std::mutex> Lock{adapter.Mutex};
-    adapter.RefCount++;
+    // adapter.RefCount++;
+    if (adapter.RefCount++ == 0) {
+      cl_ext::ExtFuncPtrCache = std::make_unique<cl_ext::ExtFuncPtrCacheT>();
+    }
     *phAdapters = &adapter;
   }
 
@@ -40,7 +43,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterRetain(ur_adapter_handle_t) {
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {
   std::lock_guard<std::mutex> Lock{adapter.Mutex};
-  --adapter.RefCount;
+  // --adapter.RefCount;
+  if (--adapter.RefCount == 0) {
+    cl_ext::ExtFuncPtrCache.reset();
+  }
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/opencl/command_buffer.cpp

@@ -10,6 +10,7 @@
 
 #include "command_buffer.hpp"
 #include "common.hpp"
+#include "context.hpp"
 
 UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferCreateExp(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
@@ -19,7 +20,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferCreateExp(
   ur_queue_handle_t Queue = nullptr;
   UR_RETURN_ON_FAILURE(urQueueCreate(hContext, hDevice, nullptr, &Queue));
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
+  cl_context CLContext = hContext->get();
   cl_ext::clCreateCommandBufferKHR_fn clCreateCommandBufferKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clCreateCommandBufferKHR)>(
@@ -49,7 +50,7 @@ UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
   UR_RETURN_ON_FAILURE(urQueueRetain(hCommandBuffer->hInternalQueue));
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clRetainCommandBufferKHR_fn clRetainCommandBuffer = nullptr;
   cl_int Res = cl_ext::getExtFuncFromContext<decltype(clRetainCommandBuffer)>(
       CLContext, cl_ext::ExtFuncPtrCache->clRetainCommandBufferKHRCache,
@@ -66,7 +67,7 @@ UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
   UR_RETURN_ON_FAILURE(urQueueRelease(hCommandBuffer->hInternalQueue));
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clReleaseCommandBufferKHR_fn clReleaseCommandBufferKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clReleaseCommandBufferKHR)>(
@@ -83,7 +84,7 @@ urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
 
 UR_APIEXPORT ur_result_t UR_APICALL
 urCommandBufferFinalizeExp(ur_exp_command_buffer_handle_t hCommandBuffer) {
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clFinalizeCommandBufferKHR_fn clFinalizeCommandBufferKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clFinalizeCommandBufferKHR)>(
@@ -106,7 +107,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp(
     const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
     ur_exp_command_buffer_sync_point_t *pSyncPoint) {
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clCommandNDRangeKernelKHR_fn clCommandNDRangeKernelKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clCommandNDRangeKernelKHR)>(
@@ -154,7 +155,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp(
     const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
     ur_exp_command_buffer_sync_point_t *pSyncPoint) {
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clCommandCopyBufferKHR_fn clCommandCopyBufferKHR = nullptr;
   cl_int Res = cl_ext::getExtFuncFromContext<decltype(clCommandCopyBufferKHR)>(
       CLContext, cl_ext::ExtFuncPtrCache->clCommandCopyBufferKHRCache,
@@ -190,7 +191,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp(
   size_t OpenCLDstRect[3]{dstOrigin.x, dstOrigin.y, dstOrigin.z};
   size_t OpenCLRegion[3]{region.width, region.height, region.depth};
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clCommandCopyBufferRectKHR_fn clCommandCopyBufferRectKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clCommandCopyBufferRectKHR)>(
@@ -280,7 +281,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferAppendMembufferFillExp(
     const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
     ur_exp_command_buffer_sync_point_t *pSyncPoint) {
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clCommandFillBufferKHR_fn clCommandFillBufferKHR = nullptr;
   cl_int Res = cl_ext::getExtFuncFromContext<decltype(clCommandFillBufferKHR)>(
       CLContext, cl_ext::ExtFuncPtrCache->clCommandFillBufferKHRCache,
@@ -302,7 +303,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferEnqueueExp(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
 
-  cl_context CLContext = cl_adapter::cast<cl_context>(hCommandBuffer->hContext);
+  cl_context CLContext = hCommandBuffer->hContext->get();
   cl_ext::clEnqueueCommandBufferKHR_fn clEnqueueCommandBufferKHR = nullptr;
   cl_int Res =
       cl_ext::getExtFuncFromContext<decltype(clEnqueueCommandBufferKHR)>(

source/adapters/opencl/context.cpp

@@ -18,20 +18,16 @@ ur_result_t cl_adapter::getDevicesFromContext(
     ur_context_handle_t hContext,
     std::unique_ptr<std::vector<cl_device_id>> &DevicesInCtx) {
 
-  cl_uint DeviceCount;
-  CL_RETURN_ON_FAILURE(clGetContextInfo(cl_adapter::cast<cl_context>(hContext),
-                                        CL_CONTEXT_NUM_DEVICES, sizeof(cl_uint),
-                                        &DeviceCount, nullptr));
+  cl_uint DeviceCount = hContext->DeviceCount;
 
   if (DeviceCount < 1) {
     return UR_RESULT_ERROR_INVALID_CONTEXT;
   }
 
   DevicesInCtx = std::make_unique<std::vector<cl_device_id>>(DeviceCount);
-
-  CL_RETURN_ON_FAILURE(clGetContextInfo(
-      cl_adapter::cast<cl_context>(hContext), CL_CONTEXT_DEVICES,
-      DeviceCount * sizeof(cl_device_id), (*DevicesInCtx).data(), nullptr));
+  for (size_t i = 0; i < DeviceCount; i++) {
+    (*DevicesInCtx)[i] = hContext->Devices[i]->get();
+  }
 
   return UR_RESULT_SUCCESS;
 }
@@ -41,11 +37,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextCreate(
     const ur_context_properties_t *, ur_context_handle_t *phContext) {
 
   cl_int Ret;
-  *phContext = cl_adapter::cast<ur_context_handle_t>(
-      clCreateContext(nullptr, cl_adapter::cast<cl_uint>(DeviceCount),
-                      cl_adapter::cast<const cl_device_id *>(phDevices),
-                      nullptr, nullptr, cl_adapter::cast<cl_int *>(&Ret)));
+  std::vector<cl_device_id> CLDevices(DeviceCount);
+  for (size_t i = 0; i < DeviceCount; i++) {
+    CLDevices[i] = phDevices[i]->get();
+  }
+
+  cl_context Ctx = clCreateContext(nullptr, cl_adapter::cast<cl_uint>(DeviceCount),
+                      CLDevices.data(),
+                      nullptr, nullptr, cl_adapter::cast<cl_int *>(&Ret));
 
+  *phContext = new ur_context_handle_t_(Ctx, DeviceCount, phDevices);
   return mapCLErrorToUR(Ret);
 }
 
@@ -95,7 +96,7 @@ urContextGetInfo(ur_context_handle_t hContext, ur_context_info_t propName,
   case UR_CONTEXT_INFO_REFERENCE_COUNT: {
     size_t CheckPropSize = 0;
     auto ClResult =
-        clGetContextInfo(cl_adapter::cast<cl_context>(hContext), CLPropName,
+        clGetContextInfo(hContext->get(), CLPropName,
                          propSize, pPropValue, &CheckPropSize);
     if (pPropValue && CheckPropSize != propSize) {
       return UR_RESULT_ERROR_INVALID_SIZE;
@@ -114,29 +115,31 @@ urContextGetInfo(ur_context_handle_t hContext, ur_context_info_t propName,
 UR_APIEXPORT ur_result_t UR_APICALL
 urContextRelease(ur_context_handle_t hContext) {
 
-  cl_int Ret = clReleaseContext(cl_adapter::cast<cl_context>(hContext));
+  cl_int Ret = clReleaseContext(hContext->get());
   return mapCLErrorToUR(Ret);
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL
 urContextRetain(ur_context_handle_t hContext) {
 
-  cl_int Ret = clRetainContext(cl_adapter::cast<cl_context>(hContext));
+  cl_int Ret = clRetainContext(hContext->get());
   return mapCLErrorToUR(Ret);
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urContextGetNativeHandle(
     ur_context_handle_t hContext, ur_native_handle_t *phNativeContext) {
 
-  *phNativeContext = reinterpret_cast<ur_native_handle_t>(hContext);
+  *phNativeContext = reinterpret_cast<ur_native_handle_t>(hContext->get());
   return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urContextCreateWithNativeHandle(
-    ur_native_handle_t hNativeContext, uint32_t, const ur_device_handle_t *,
+    ur_native_handle_t hNativeContext, uint32_t numDevices, const ur_device_handle_t *phDevices,
     const ur_context_native_properties_t *, ur_context_handle_t *phContext) {
 
-  *phContext = reinterpret_cast<ur_context_handle_t>(hNativeContext);
+  cl_context NativeHandle =
+      reinterpret_cast<cl_context>(hNativeContext);
+  *phContext = new ur_context_handle_t_(NativeHandle, numDevices, phDevices);
   return UR_RESULT_SUCCESS;
 }
 
@@ -187,7 +190,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextSetExtendedDeleter(
     C->execute();
   };
   CL_RETURN_ON_FAILURE(clSetContextDestructorCallback(
-      cl_adapter::cast<cl_context>(hContext), ClCallback, Callback));
+      hContext->get(), ClCallback, Callback));
 
   return UR_RESULT_SUCCESS;
 }

source/adapters/opencl/context.hpp

@@ -10,28 +10,29 @@
 #pragma once
 
 #include "common.hpp"
+#include "device.hpp"
+
+#include <vector>
 
 namespace cl_adapter {
 ur_result_t
 getDevicesFromContext(ur_context_handle_t hContext,
                       std::unique_ptr<std::vector<cl_device_id>> &DevicesInCtx);
 }
 
-// struct ur_context_handle_t_ {
-//     using native_type = cl_context;
-//     native_type Context;
-//     std::atomic_uint32_t RefCount;
-//     ur_platform_handle_t Platform;
-
-//     ur_context_handle_t_(native_type Ctx):Context(Ctx) {}
-
-//     ~ur_context_handle_t_() {}
-
-//     native_type get() { return Context; }
+struct ur_context_handle_t_ {
+    using native_type = cl_context;
+    native_type Context;
+    std::vector<ur_device_handle_t> Devices;
+    uint32_t DeviceCount;
 
-//     uint32_t incrementReferenceCount() noexcept { return ++RefCount; }
+    ur_context_handle_t_(native_type Ctx, uint32_t DevCount, const ur_device_handle_t *phDevices) : Context(Ctx), DeviceCount(DevCount) {
+        for (uint32_t i = 0; i < DeviceCount; i++) {
+            Devices.emplace_back(phDevices[i]);
+        }
+    }
 
-//     uint32_t decrementReferenceCount() noexcept { return --RefCount; }
+    ~ur_context_handle_t_() {}
 
-//     uint32_t getReferenceCount() const noexcept { return RefCount; }
-// };
+    native_type get() { return Context; }
+};

source/adapters/opencl/device.cpp

@@ -75,31 +75,31 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,
     Type = CL_DEVICE_TYPE_ACCELERATOR;
     break;
   case UR_DEVICE_TYPE_DEFAULT:
-    Type = CL_DEVICE_TYPE_DEFAULT;
+    Type = UR_DEVICE_TYPE_DEFAULT;
     break;
   default:
     return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
-  std::vector<cl_device_id> CLDevices(NumEntries);
-  cl_int Result = clGetDeviceIDs(
-      hPlatform->get(), Type, cl_adapter::cast<cl_uint>(NumEntries),
-      CLDevices.data(), cl_adapter::cast<cl_uint *>(pNumDevices));
-
-  // Absorb the CL_DEVICE_NOT_FOUND and just return 0 in num_devices
-  if (Result == CL_DEVICE_NOT_FOUND) {
-    Result = CL_SUCCESS;
+  CL_RETURN_ON_FAILURE(hPlatform->GetDevices(Type));
+  size_t NumDevices = hPlatform->Devices.size();
+  try {
     if (pNumDevices) {
-      *pNumDevices = 0;
+      *pNumDevices = NumDevices;
     }
-  }
-  if (NumEntries && phDevices) {
-    for (uint32_t i = 0; i < NumEntries; i++) {
-      phDevices[i] = new ur_device_handle_t_(CLDevices[i], hPlatform);
+
+    if (phDevices) {
+      for (size_t i = 0; i < std::min(size_t(NumEntries), NumDevices); ++i) {
+        phDevices[i] = hPlatform->Devices[i];
+      }
     }
-  }
 
-  return mapCLErrorToUR(Result);
+    return UR_RESULT_SUCCESS;
+  } catch (ur_result_t Err) {
+    return Err;
+  } catch (...) {
+    return UR_RESULT_ERROR_OUT_OF_RESOURCES;
+  }
 }
 
 static ur_device_fp_capability_flags_t
@@ -861,7 +861,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_MAX_PARAMETER_SIZE:
   case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION:
   case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE:
-  case UR_DEVICE_INFO_PLATFORM:
   case UR_DEVICE_INFO_PARENT_DEVICE:
   case UR_DEVICE_INFO_IL_VERSION:
   case UR_DEVICE_INFO_NAME:
@@ -890,6 +889,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
 
     return UR_RESULT_SUCCESS;
   }
+  case UR_DEVICE_INFO_PLATFORM: {
+    if (hDevice->Platform && hDevice->Platform->get()) {
+      return ReturnValue(hDevice->Platform);
+    }
+    return UR_RESULT_ERROR_INVALID_DEVICE;
+  }
   case UR_DEVICE_INFO_EXTENSIONS: {
     cl_device_id Dev = hDevice->get();
     size_t ExtSize = 0;

source/adapters/opencl/memory.cpp

@@ -9,6 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "common.hpp"
+#include "context.hpp"
 
 cl_image_format mapURImageFormatToCL(const ur_image_format_t *PImageFormat) {
   cl_image_format CLImageFormat;
@@ -230,7 +231,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
     // TODO: need to check if all properties are supported by OpenCL RT and
     // ignore unsupported
     clCreateBufferWithPropertiesINTEL_fn FuncPtr = nullptr;
-    cl_context CLContext = cl_adapter::cast<cl_context>(hContext);
+    cl_context CLContext = hContext->get();
     // First we need to look up the function pointer
     RetErr =
         cl_ext::getExtFuncFromContext<clCreateBufferWithPropertiesINTEL_fn>(
@@ -270,7 +271,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
 
   void *HostPtr = pProperties ? pProperties->pHost : nullptr;
   *phBuffer = reinterpret_cast<ur_mem_handle_t>(clCreateBuffer(
-      cl_adapter::cast<cl_context>(hContext), static_cast<cl_mem_flags>(flags),
+      hContext->get(), static_cast<cl_mem_flags>(flags),
       size, HostPtr, cl_adapter::cast<cl_int *>(&RetErr)));
   CL_RETURN_ON_FAILURE(RetErr);
 
@@ -289,7 +290,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
   cl_map_flags MapFlags = convertURMemFlagsToCL(flags);
 
   *phMem = reinterpret_cast<ur_mem_handle_t>(clCreateImage(
-      cl_adapter::cast<cl_context>(hContext), MapFlags, &ImageFormat,
+      hContext->get(), MapFlags, &ImageFormat,
       &ImageDesc, pHost, cl_adapter::cast<cl_int *>(&RetErr)));
   CL_RETURN_ON_FAILURE(RetErr);