Make urMemImageCreate failsafe

Use unique ptrs, and have the destructor call clear(), instead of
calling it manually. Also add a case for a std::bad_alloc.

Author: Hugh Delaney

source/adapters/cuda/memory.cpp

@@ -102,14 +102,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
       return UR_RESULT_SUCCESS;
     }
 
-    // make sure hMem is released in case checkErrorUR throws
-    std::unique_ptr<ur_mem_handle_t_> MemObjPtr(hMem);
-
     if (hMem->isSubBuffer()) {
       return UR_RESULT_SUCCESS;
     }
 
-    UR_CHECK_ERROR(hMem->clear());
+    // Call destructor
+    std::unique_ptr<ur_mem_handle_t_> MemObjPtr(hMem);
 
   } catch (ur_result_t Err) {
     Result = Err;
@@ -230,13 +228,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
   UR_ASSERT(pImageFormat->channelOrder == UR_IMAGE_CHANNEL_ORDER_RGBA,
             UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
 
-  auto URMemObj = std::unique_ptr<ur_mem_handle_t_>(
-      new ur_mem_handle_t_{hContext, flags, *pImageFormat, *pImageDesc, pHost});
-
-  UR_ASSERT(std::get<SurfaceMem>(URMemObj->Mem).PixelTypeSizeBytes,
-            UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
-
   try {
+    auto URMemObj = std::unique_ptr<ur_mem_handle_t_>(new ur_mem_handle_t_{
+        hContext, flags, *pImageFormat, *pImageDesc, pHost});
+    UR_ASSERT(std::get<SurfaceMem>(URMemObj->Mem).PixelTypeSizeBytes,
+              UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
+
     if (PerformInitialCopy) {
       for (const auto &Device : hContext->getDevices()) {
         // Synchronous behaviour is best in this case
@@ -254,10 +251,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
 
     *phMem = URMemObj.release();
   } catch (ur_result_t Err) {
-    (*phMem)->clear();
     return Err;
+  } catch (std::bad_alloc &Err) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
   } catch (...) {
-    (*phMem)->clear();
     return UR_RESULT_ERROR_UNKNOWN;
   }
   return UR_RESULT_SUCCESS;

source/adapters/cuda/memory.hpp

@@ -394,6 +394,7 @@ struct ur_mem_handle_t_ {
   }
 
   ~ur_mem_handle_t_() {
+    clear();
     if (isBuffer() && isSubBuffer()) {
       urMemRelease(std::get<BufferMem>(Mem).Parent);
       return;

source/adapters/hip/memory.cpp

@@ -68,14 +68,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
       return UR_RESULT_SUCCESS;
     }
 
-    // make sure memObj is released in case UR_CHECK_ERROR throws
-    std::unique_ptr<ur_mem_handle_t_> uniqueMemObj(hMem);
-
     if (hMem->isSubBuffer()) {
       return UR_RESULT_SUCCESS;
     }
 
-    UR_CHECK_ERROR(hMem->clear());
+    // Call destructor
+    std::unique_ptr<ur_mem_handle_t_> uniqueMemObj(hMem);
 
   } catch (ur_result_t Err) {
     Result = Err;
@@ -380,25 +378,33 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
   UR_ASSERT(pImageFormat->channelOrder == UR_IMAGE_CHANNEL_ORDER_RGBA,
             UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
 
-  UR_CHECK_ERROR(checkSupportedImageChannelType(pImageFormat->channelType));
+  try {
+    UR_CHECK_ERROR(checkSupportedImageChannelType(pImageFormat->channelType));
 
-  auto URMemObj = std::unique_ptr<ur_mem_handle_t_>(
-      new ur_mem_handle_t_{hContext, flags, *pImageFormat, *pImageDesc, pHost});
+    auto URMemObj = std::unique_ptr<ur_mem_handle_t_>(new ur_mem_handle_t_{
+        hContext, flags, *pImageFormat, *pImageDesc, pHost});
 
-  if (URMemObj == nullptr) {
-    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-  }
+    if (URMemObj == nullptr) {
+      return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
 
-  if (PerformInitialCopy) {
-    for (const auto &Dev : hContext->getDevices()) {
-      ScopedContext Active(Dev);
-      hipStream_t Stream{0}; // Use default stream
-      UR_CHECK_ERROR(
-          enqueueMigrateMemoryToDeviceIfNeeded(URMemObj.get(), Dev, Stream));
-      UR_CHECK_ERROR(hipStreamSynchronize(Stream));
+    if (PerformInitialCopy) {
+      for (const auto &Dev : hContext->getDevices()) {
+        ScopedContext Active(Dev);
+        hipStream_t Stream{0}; // Use default stream
+        UR_CHECK_ERROR(
+            enqueueMigrateMemoryToDeviceIfNeeded(URMemObj.get(), Dev, Stream));
+        UR_CHECK_ERROR(hipStreamSynchronize(Stream));
+      }
     }
+    *phMem = URMemObj.release();
+  } catch (ur_result_t Err) {
+    return Err;
+  } catch (std::bad_alloc &Err) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+  } catch (...) {
+    return UR_RESULT_ERROR_UNKNOWN;
   }
-  *phMem = URMemObj.release();
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/hip/memory.hpp

@@ -390,6 +390,7 @@ struct ur_mem_handle_t_ {
   }
 
   ~ur_mem_handle_t_() noexcept(false) {
+    clear();
     if (isBuffer() && isSubBuffer()) {
       urMemRelease(std::get<BufferMem>(Mem).Parent);
       return;