Refactor makeWithNative

source/adapters/opencl/context.cpp

@@ -143,10 +143,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextCreateWithNativeHandle(
     ur_context_handle_t *phContext) {
 
   cl_context NativeHandle = reinterpret_cast<cl_context>(hNativeContext);
-  auto URContext = std::make_unique<ur_context_handle_t_>(
-      NativeHandle, numDevices, phDevices);
-  UR_RETURN_ON_FAILURE(URContext->initWithNative());
-  *phContext = URContext.release();
+  UR_RETURN_ON_FAILURE(ur_context_handle_t_::makeWithNative(
+      NativeHandle, numDevices, phDevices, *phContext));
+
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/opencl/context.hpp

@@ -33,23 +33,31 @@ struct ur_context_handle_t_ {
       Devices.emplace_back(phDevices[i]);
     }
   }
-  ur_result_t initWithNative() {
+
+  static ur_result_t makeWithNative(native_type Ctx, uint32_t DevCount,
+                                    const ur_device_handle_t *phDevices,
+                                    ur_context_handle_t &Context) {
+    auto URContext =
+        std::make_unique<ur_context_handle_t_>(Ctx, DevCount, phDevices);
+    native_type &NativeContext = URContext->Context;
+    uint32_t &DeviceCount = URContext->DeviceCount;
     if (!DeviceCount) {
-      CL_RETURN_ON_FAILURE(clGetContextInfo(Context, CL_CONTEXT_NUM_DEVICES,
-                                            sizeof(DeviceCount), &DeviceCount,
-                                            nullptr));
+      CL_RETURN_ON_FAILURE(
+          clGetContextInfo(NativeContext, CL_CONTEXT_NUM_DEVICES,
+                           sizeof(DeviceCount), &DeviceCount, nullptr));
       std::vector<cl_device_id> CLDevices(DeviceCount);
-      CL_RETURN_ON_FAILURE(clGetContextInfo(Context, CL_CONTEXT_DEVICES,
+      CL_RETURN_ON_FAILURE(clGetContextInfo(NativeContext, CL_CONTEXT_DEVICES,
                                             sizeof(CLDevices), CLDevices.data(),
                                             nullptr));
-      Devices.resize(DeviceCount);
+      URContext->Devices.resize(DeviceCount);
       for (uint32_t i = 0; i < DeviceCount; i++) {
         ur_native_handle_t NativeDevice =
             reinterpret_cast<ur_native_handle_t>(CLDevices[i]);
         UR_RETURN_ON_FAILURE(urDeviceCreateWithNativeHandle(
-            NativeDevice, nullptr, nullptr, &Devices[i]));
+            NativeDevice, nullptr, nullptr, &(URContext->Devices[i])));
       }
     }
+    Context = URContext.release();
     return UR_RESULT_SUCCESS;
   }
 

source/adapters/opencl/kernel.cpp

@@ -385,10 +385,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urKernelCreateWithNativeHandle(
     const ur_kernel_native_properties_t *pProperties,
     ur_kernel_handle_t *phKernel) {
   cl_kernel NativeHandle = reinterpret_cast<cl_kernel>(hNativeKernel);
-  auto URKernel =
-      std::make_unique<ur_kernel_handle_t_>(NativeHandle, hProgram, hContext);
-  UR_RETURN_ON_FAILURE(URKernel->initWithNative());
-  *phKernel = URKernel.release();
+
+  UR_RETURN_ON_FAILURE(ur_kernel_handle_t_::makeWithNative(
+      NativeHandle, hProgram, hContext, *phKernel));
 
   if (!pProperties || !pProperties->isNativeHandleOwned) {
     return urKernelRetain(*phKernel);

source/adapters/opencl/kernel.hpp

@@ -26,27 +26,35 @@ struct ur_kernel_handle_t_ {
 
   ~ur_kernel_handle_t_() {}
 
-  ur_result_t initWithNative() {
+  static ur_result_t makeWithNative(native_type NativeKernel,
+                                    ur_program_handle_t Program,
+                                    ur_context_handle_t Context,
+                                    ur_kernel_handle_t &Kernel) {
+    auto URKernel =
+        std::make_unique<ur_kernel_handle_t_>(NativeKernel, Program, Context);
     if (!Program) {
       cl_program CLProgram;
-      CL_RETURN_ON_FAILURE(clGetKernelInfo(
-          Kernel, CL_KERNEL_PROGRAM, sizeof(CLProgram), &CLProgram, nullptr));
+      CL_RETURN_ON_FAILURE(clGetKernelInfo(NativeKernel, CL_KERNEL_PROGRAM,
+                                           sizeof(CLProgram), &CLProgram,
+                                           nullptr));
       ur_native_handle_t NativeProgram =
           reinterpret_cast<ur_native_handle_t>(CLProgram);
       UR_RETURN_ON_FAILURE(urProgramCreateWithNativeHandle(
-          NativeProgram, nullptr, nullptr, &Program));
+          NativeProgram, nullptr, nullptr, &(URKernel->Program)));
     }
     cl_context CLContext;
-    CL_RETURN_ON_FAILURE(clGetKernelInfo(
-        Kernel, CL_KERNEL_CONTEXT, sizeof(CLContext), &CLContext, nullptr));
+    CL_RETURN_ON_FAILURE(clGetKernelInfo(NativeKernel, CL_KERNEL_CONTEXT,
+                                         sizeof(CLContext), &CLContext,
+                                         nullptr));
     if (!Context) {
       ur_native_handle_t NativeContext =
           reinterpret_cast<ur_native_handle_t>(CLContext);
       UR_RETURN_ON_FAILURE(urContextCreateWithNativeHandle(
-          NativeContext, 0, nullptr, nullptr, &Context));
+          NativeContext, 0, nullptr, nullptr, &(URKernel->Context)));
     } else if (Context->get() != CLContext) {
       return UR_RESULT_ERROR_INVALID_CONTEXT;
     }
+    Kernel = URKernel.release();
     return UR_RESULT_SUCCESS;
   }
 

source/adapters/opencl/memory.cpp

@@ -227,7 +227,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
     ur_context_handle_t hContext, ur_mem_flags_t flags, size_t size,
     const ur_buffer_properties_t *pProperties, ur_mem_handle_t *phBuffer) {
   cl_int RetErr = CL_INVALID_OPERATION;
-  UR_RETURN_ON_FAILURE(urContextRetain(hContext));
+  // UR_RETURN_ON_FAILURE(urContextRetain(hContext));
   if (pProperties) {
     // TODO: need to check if all properties are supported by OpenCL RT and
     // ignore unsupported
@@ -348,9 +348,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle(
     ur_native_handle_t hNativeMem, ur_context_handle_t hContext,
     const ur_mem_native_properties_t *pProperties, ur_mem_handle_t *phMem) {
   cl_mem NativeHandle = reinterpret_cast<cl_mem>(hNativeMem);
-  auto URMem = std::make_unique<ur_mem_handle_t_>(NativeHandle, hContext);
-  UR_RETURN_ON_FAILURE(URMem->initWithNative());
-  *phMem = URMem.release();
+  UR_RETURN_ON_FAILURE(
+      ur_mem_handle_t_::makeWithNative(NativeHandle, hContext, *phMem));
   if (!pProperties || !pProperties->isNativeHandleOwned) {
     return urMemRetain(*phMem);
   }
@@ -363,9 +362,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreateWithNativeHandle(
     [[maybe_unused]] const ur_image_desc_t *pImageDesc,
     const ur_mem_native_properties_t *pProperties, ur_mem_handle_t *phMem) {
   cl_mem NativeHandle = reinterpret_cast<cl_mem>(hNativeMem);
-  auto URMem = std::make_unique<ur_mem_handle_t_>(NativeHandle, hContext);
-  UR_RETURN_ON_FAILURE(URMem->initWithNative());
-  *phMem = URMem.release();
+  UR_RETURN_ON_FAILURE(
+      ur_mem_handle_t_::makeWithNative(NativeHandle, hContext, *phMem));
   if (!pProperties || !pProperties->isNativeHandleOwned) {
     return urMemRetain(*phMem);
   }

source/adapters/opencl/memory.hpp

@@ -23,16 +23,20 @@ struct ur_mem_handle_t_ {
 
   ~ur_mem_handle_t_() {}
 
-  ur_result_t initWithNative() {
-    if (!Context) {
+  static ur_result_t makeWithNative(native_type NativeMem,
+                                    ur_context_handle_t Ctx,
+                                    ur_mem_handle_t &Mem) {
+    auto URMem = std::make_unique<ur_mem_handle_t_>(NativeMem, Ctx);
+    if (!Ctx) {
       cl_context CLContext;
       CL_RETURN_ON_FAILURE(clGetMemObjectInfo(
-          Memory, CL_MEM_CONTEXT, sizeof(CLContext), &CLContext, nullptr));
+          NativeMem, CL_MEM_CONTEXT, sizeof(CLContext), &CLContext, nullptr));
       ur_native_handle_t NativeContext =
           reinterpret_cast<ur_native_handle_t>(CLContext);
       UR_RETURN_ON_FAILURE(urContextCreateWithNativeHandle(
-          NativeContext, 0, nullptr, nullptr, &Context));
+          NativeContext, 0, nullptr, nullptr, &(URMem->Context)));
     }
+    Mem = URMem.release();
     return UR_RESULT_SUCCESS;
   }
 

source/adapters/opencl/program.cpp

@@ -349,10 +349,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramCreateWithNativeHandle(
     ur_program_handle_t *phProgram) {
   cl_program NativeHandle = reinterpret_cast<cl_program>(hNativeProgram);
 
-  auto URProgram =
-      std::make_unique<ur_program_handle_t_>(NativeHandle, hContext);
-  UR_RETURN_ON_FAILURE(URProgram->initWithNative());
-  *phProgram = URProgram.release();
+  UR_RETURN_ON_FAILURE(
+      ur_program_handle_t_::makeWithNative(NativeHandle, hContext, *phProgram));
   if (!pProperties || !pProperties->isNativeHandleOwned) {
     return urProgramRetain(*phProgram);
   }

source/adapters/opencl/program.hpp

@@ -23,16 +23,22 @@ struct ur_program_handle_t_ {
 
   ~ur_program_handle_t_() {}
 
-  ur_result_t initWithNative() {
+  static ur_result_t makeWithNative(native_type NativeProg,
+                                    ur_context_handle_t Context,
+                                    ur_program_handle_t &Program) {
+    auto URProgram =
+        std::make_unique<ur_program_handle_t_>(NativeProg, Context);
     if (!Context) {
       cl_context CLContext;
-      CL_RETURN_ON_FAILURE(clGetProgramInfo(
-          Program, CL_PROGRAM_CONTEXT, sizeof(CLContext), &CLContext, nullptr));
+      CL_RETURN_ON_FAILURE(clGetProgramInfo(NativeProg, CL_PROGRAM_CONTEXT,
+                                            sizeof(CLContext), &CLContext,
+                                            nullptr));
       ur_native_handle_t NativeContext =
           reinterpret_cast<ur_native_handle_t>(CLContext);
       UR_RETURN_ON_FAILURE(urContextCreateWithNativeHandle(
-          NativeContext, 0, nullptr, nullptr, &Context));
+          NativeContext, 0, nullptr, nullptr, &(URProgram->Context)));
     }
+    Program = URProgram.release();
     return UR_RESULT_SUCCESS;
   }
 

source/adapters/opencl/queue.cpp

@@ -169,10 +169,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
 
   cl_command_queue NativeHandle =
       reinterpret_cast<cl_command_queue>(hNativeQueue);
-  auto URQueue =
-      std::make_unique<ur_queue_handle_t_>(NativeHandle, hContext, hDevice);
-  UR_RETURN_ON_FAILURE(URQueue->initWithNative());
-  *phQueue = URQueue.release();
+
+  UR_RETURN_ON_FAILURE(ur_queue_handle_t_::makeWithNative(
+      NativeHandle, hContext, hDevice, *phQueue));
 
   CL_RETURN_ON_FAILURE(clRetainCommandQueue(NativeHandle));
 

source/adapters/opencl/queue.hpp

@@ -23,25 +23,32 @@ struct ur_queue_handle_t_ {
                      ur_device_handle_t Dev)
       : Queue(Queue), Context(Ctx), Device(Dev) {}
 
-  ur_result_t initWithNative() {
+  static ur_result_t makeWithNative(native_type NativeQueue,
+                                    ur_context_handle_t Context,
+                                    ur_device_handle_t Device,
+                                    ur_queue_handle_t &Queue) {
+    auto URQueue =
+        std::make_unique<ur_queue_handle_t_>(NativeQueue, Context, Device);
     if (!Context) {
       cl_context CLContext;
-      CL_RETURN_ON_FAILURE(clGetCommandQueueInfo(
-          Queue, CL_QUEUE_CONTEXT, sizeof(CLContext), &CLContext, nullptr));
+      CL_RETURN_ON_FAILURE(clGetCommandQueueInfo(NativeQueue, CL_QUEUE_CONTEXT,
+                                                 sizeof(CLContext), &CLContext,
+                                                 nullptr));
       ur_native_handle_t NativeContext =
           reinterpret_cast<ur_native_handle_t>(CLContext);
       UR_RETURN_ON_FAILURE(urContextCreateWithNativeHandle(
-          NativeContext, 0, nullptr, nullptr, &Context));
+          NativeContext, 0, nullptr, nullptr, &(URQueue->Context)));
     }
     if (!Device) {
       cl_device_id CLDevice;
       CL_RETURN_ON_FAILURE(clGetCommandQueueInfo(
-          Queue, CL_QUEUE_DEVICE, sizeof(CLDevice), &CLDevice, nullptr));
+          NativeQueue, CL_QUEUE_DEVICE, sizeof(CLDevice), &CLDevice, nullptr));
       ur_native_handle_t NativeDevice =
           reinterpret_cast<ur_native_handle_t>(CLDevice);
-      UR_RETURN_ON_FAILURE(urDeviceCreateWithNativeHandle(NativeDevice, nullptr,
-                                                          nullptr, &Device));
+      UR_RETURN_ON_FAILURE(urDeviceCreateWithNativeHandle(
+          NativeDevice, nullptr, nullptr, &(URQueue->Device)));
     }
+    Queue = URQueue.release();
     return UR_RESULT_SUCCESS;
   }