Merge pull request #1774 from hdelan/readytomerge-branch

[UR][HIP][CUDA] Master Branch

Author: kbenzie

source/adapters/cuda/adapter.cpp

@@ -36,8 +36,12 @@ class ur_legacy_sink : public logger::Sink {
 
   ~ur_legacy_sink() = default;
 };
+
+// FIXME: Remove the default log level when querying logging info is supported
+// through UR entry points. See #1330.
 ur_adapter_handle_t_::ur_adapter_handle_t_()
-    : logger(logger::get_logger("cuda")) {
+    : logger(logger::get_logger("cuda",
+                                /*default_log_level*/ logger::Level::ERR)) {
 
   if (std::getenv("UR_LOG_CUDA") != nullptr)
     return;

source/adapters/cuda/context.cpp

@@ -142,16 +142,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextGetNativeHandle(
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urContextCreateWithNativeHandle(
-    ur_native_handle_t hNativeContext, uint32_t numDevices,
-    const ur_device_handle_t *phDevices,
-    const ur_context_native_properties_t *pProperties,
-    ur_context_handle_t *phContext) {
-  std::ignore = hNativeContext;
-  std::ignore = numDevices;
-  std::ignore = phDevices;
-  std::ignore = pProperties;
-  std::ignore = phContext;
-
+    [[maybe_unused]] ur_native_handle_t hNativeContext,
+    [[maybe_unused]] uint32_t numDevices,
+    [[maybe_unused]] const ur_device_handle_t *phDevices,
+    [[maybe_unused]] const ur_context_native_properties_t *pProperties,
+    [[maybe_unused]] ur_context_handle_t *phContext) {
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 

source/adapters/cuda/event.cpp

@@ -36,9 +36,9 @@ ur_event_handle_t_::ur_event_handle_t_(ur_context_handle_t Context,
                                        CUevent EventNative)
     : CommandType{UR_COMMAND_EVENTS_WAIT}, RefCount{1}, HasOwnership{false},
       HasBeenWaitedOn{false}, IsRecorded{false}, IsStarted{false},
-      StreamToken{std::numeric_limits<uint32_t>::max()}, EventID{0},
-      EvEnd{EventNative}, EvStart{nullptr}, EvQueued{nullptr}, Queue{nullptr},
-      Stream{nullptr}, Context{Context} {
+      IsInterop{true}, StreamToken{std::numeric_limits<uint32_t>::max()},
+      EventID{0}, EvEnd{EventNative}, EvStart{nullptr}, EvQueued{nullptr},
+      Queue{nullptr}, Stream{nullptr}, Context{Context} {
   urContextRetain(Context);
 }
 

source/adapters/cuda/event.hpp

@@ -45,6 +45,8 @@ struct ur_event_handle_t_ {
 
   bool isCompleted() const noexcept;
 
+  bool isInterop() const noexcept { return IsInterop; };
+
   uint32_t getExecutionStatus() const noexcept {
 
     if (!isRecorded()) {
@@ -141,6 +143,8 @@ struct ur_event_handle_t_ {
   bool IsStarted;  // Signifies wether the operation associated with the
                    // UR event has started or not
 
+  const bool IsInterop{false}; // Made with urEventCreateWithNativeHandle
+
   uint32_t StreamToken;
   uint32_t EventID; // Queue identifier of the event.
 
@@ -195,7 +199,8 @@ ur_result_t forLatestEvents(const ur_event_handle_t *EventWaitList,
   CUstream LastSeenStream = 0;
   for (size_t i = 0; i < Events.size(); i++) {
     auto Event = Events[i];
-    if (!Event || (i != 0 && Event->getStream() == LastSeenStream)) {
+    if (!Event || (i != 0 && !Event->isInterop() &&
+                   Event->getStream() == LastSeenStream)) {
       continue;
     }
 

source/adapters/cuda/memory.cpp

@@ -56,9 +56,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
 
     auto URMemObj = std::unique_ptr<ur_mem_handle_t_>(
         new ur_mem_handle_t_{hContext, flags, AllocMode, HostPtr, size});
-    if (URMemObj == nullptr) {
-      return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
 
     // First allocation will be made at urMemBufferCreate if context only
     // has one device
@@ -74,6 +71,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
     MemObj = URMemObj.release();
   } catch (ur_result_t Err) {
     return Err;
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
   } catch (...) {
     return UR_RESULT_ERROR_OUT_OF_RESOURCES;
   }
@@ -102,15 +101,9 @@ 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
+    // Call destructor
     std::unique_ptr<ur_mem_handle_t_> MemObjPtr(hMem);
 
-    if (hMem->isSubBuffer()) {
-      return UR_RESULT_SUCCESS;
-    }
-
-    UR_CHECK_ERROR(hMem->clear());
-
   } catch (ur_result_t Err) {
     Result = Err;
   } catch (...) {
@@ -230,13 +223,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
@@ -248,16 +240,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
       }
     }
 
-    if (URMemObj == nullptr) {
-      return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
     *phMem = URMemObj.release();
   } catch (ur_result_t Err) {
-    (*phMem)->clear();
     return Err;
+  } catch (std::bad_alloc &) {
+    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/cuda/physical_mem.cpp

@@ -32,8 +32,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urPhysicalMemCreate(
   default:
     UR_CHECK_ERROR(Result);
   }
-  *phPhysicalMem = new ur_physical_mem_handle_t_(ResHandle, hContext, hDevice);
-
+  try {
+    *phPhysicalMem =
+        new ur_physical_mem_handle_t_(ResHandle, hContext, hDevice);
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+  } catch (...) {
+    return UR_RESULT_ERROR_UNKNOWN;
+  }
   return UR_RESULT_SUCCESS;
 }
 
@@ -53,10 +59,10 @@ urPhysicalMemRelease(ur_physical_mem_handle_t hPhysicalMem) {
 
     ScopedContext Active(hPhysicalMem->getDevice());
     UR_CHECK_ERROR(cuMemRelease(hPhysicalMem->get()));
-    return UR_RESULT_SUCCESS;
   } catch (ur_result_t err) {
     return err;
   } catch (...) {
     return UR_RESULT_ERROR_OUT_OF_RESOURCES;
   }
+  return UR_RESULT_SUCCESS;
 }

source/adapters/cuda/program.cpp

@@ -187,23 +187,30 @@ ur_result_t createProgram(ur_context_handle_t hContext,
             UR_RESULT_ERROR_INVALID_CONTEXT);
   UR_ASSERT(size, UR_RESULT_ERROR_INVALID_SIZE);
 
-  std::unique_ptr<ur_program_handle_t_> RetProgram{
-      new ur_program_handle_t_{hContext, hDevice}};
-
-  if (pProperties) {
-    if (pProperties->count > 0 && pProperties->pMetadatas == nullptr) {
-      return UR_RESULT_ERROR_INVALID_NULL_POINTER;
-    } else if (pProperties->count == 0 && pProperties->pMetadatas != nullptr) {
-      return UR_RESULT_ERROR_INVALID_SIZE;
+  try {
+    std::unique_ptr<ur_program_handle_t_> RetProgram{
+        new ur_program_handle_t_{hContext, hDevice}};
+
+    if (pProperties) {
+      if (pProperties->count > 0 && pProperties->pMetadatas == nullptr) {
+        return UR_RESULT_ERROR_INVALID_NULL_POINTER;
+      } else if (pProperties->count == 0 &&
+                 pProperties->pMetadatas != nullptr) {
+        return UR_RESULT_ERROR_INVALID_SIZE;
+      }
+      UR_CHECK_ERROR(
+          RetProgram->setMetadata(pProperties->pMetadatas, pProperties->count));
     }
-    UR_CHECK_ERROR(
-        RetProgram->setMetadata(pProperties->pMetadatas, pProperties->count));
-  }
 
-  auto pBinary_string = reinterpret_cast<const char *>(pBinary);
+    auto pBinary_string = reinterpret_cast<const char *>(pBinary);
 
-  UR_CHECK_ERROR(RetProgram->setBinary(pBinary_string, size));
-  *phProgram = RetProgram.release();
+    UR_CHECK_ERROR(RetProgram->setBinary(pBinary_string, size));
+    *phProgram = RetProgram.release();
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+  } catch (...) {
+    return UR_RESULT_ERROR_UNKNOWN;
+  }
 
   return UR_RESULT_SUCCESS;
 }
@@ -317,6 +324,8 @@ urProgramLink(ur_context_handle_t hContext, uint32_t count,
 
   } catch (ur_result_t Err) {
     Result = Err;
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
   }
   return Result;
 }
@@ -345,16 +354,24 @@ urProgramGetBuildInfo(ur_program_handle_t hProgram, ur_device_handle_t hDevice,
   UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);
 
   switch (propName) {
-  case UR_PROGRAM_BUILD_INFO_STATUS: {
+  case UR_PROGRAM_BUILD_INFO_STATUS:
     return ReturnValue(hProgram->BuildStatus);
-  }
   case UR_PROGRAM_BUILD_INFO_OPTIONS:
     return ReturnValue(hProgram->BuildOptions.c_str());
-  case UR_PROGRAM_BUILD_INFO_LOG:
-    return ReturnValue(hProgram->InfoLog, hProgram->MaxLogSize);
-  case UR_PROGRAM_BUILD_INFO_BINARY_TYPE: {
-    return ReturnValue(hProgram->BinaryType);
+  case UR_PROGRAM_BUILD_INFO_LOG: {
+    // We only know the maximum log length, which CUDA guarantees will include
+    // the null terminator.
+    // To determine the actual length of the log, search for the first
+    // null terminator, not searching past the known maximum. If that does find
+    // one, it will return the length excluding the null terminator, so remember
+    // to include that.
+    auto LogLen =
+        std::min(hProgram->MaxLogSize,
+                 strnlen(hProgram->InfoLog, hProgram->MaxLogSize) + 1);
+    return ReturnValue(hProgram->InfoLog, LogLen);
   }
+  case UR_PROGRAM_BUILD_INFO_BINARY_TYPE:
+    return ReturnValue(hProgram->BinaryType);
   default:
     break;
   }

source/adapters/cuda/queue.cpp

@@ -167,12 +167,11 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
 
     return UR_RESULT_SUCCESS;
   } catch (ur_result_t Err) {
-
     return Err;
-
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
   } catch (...) {
-
-    return UR_RESULT_ERROR_OUT_OF_RESOURCES;
+    return UR_RESULT_ERROR_UNKNOWN;
   }
 }
 

source/adapters/cuda/sampler.cpp

@@ -14,46 +14,55 @@
 UR_APIEXPORT ur_result_t UR_APICALL
 urSamplerCreate(ur_context_handle_t hContext, const ur_sampler_desc_t *pDesc,
                 ur_sampler_handle_t *phSampler) {
-  std::unique_ptr<ur_sampler_handle_t_> Sampler{
-      new ur_sampler_handle_t_(hContext)};
+  try {
+    std::unique_ptr<ur_sampler_handle_t_> Sampler{
+        new ur_sampler_handle_t_(hContext)};
 
-  if (pDesc->stype == UR_STRUCTURE_TYPE_SAMPLER_DESC) {
-    Sampler->Props |= static_cast<uint32_t>(pDesc->normalizedCoords);
-    Sampler->Props |= pDesc->filterMode << 1;
-    Sampler->Props |= pDesc->addressingMode << 2;
-  } else {
-    // Set default values
-    Sampler->Props |= true; // Normalized Coords
-    Sampler->Props |= UR_SAMPLER_ADDRESSING_MODE_CLAMP << 2;
-  }
+    if (pDesc->stype == UR_STRUCTURE_TYPE_SAMPLER_DESC) {
+      Sampler->Props |= static_cast<uint32_t>(pDesc->normalizedCoords);
+      Sampler->Props |= pDesc->filterMode << 1;
+      Sampler->Props |= pDesc->addressingMode << 2;
+    } else {
+      // Set default values
+      Sampler->Props |= true; // Normalized Coords
+      Sampler->Props |= UR_SAMPLER_ADDRESSING_MODE_CLAMP << 2;
+    }
 
-  void *pNext = const_cast<void *>(pDesc->pNext);
-  while (pNext != nullptr) {
-    const ur_base_desc_t *BaseDesc =
-        reinterpret_cast<const ur_base_desc_t *>(pNext);
-    if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES) {
-      const ur_exp_sampler_mip_properties_t *SamplerMipProperties =
-          reinterpret_cast<const ur_exp_sampler_mip_properties_t *>(pNext);
-      Sampler->MaxMipmapLevelClamp = SamplerMipProperties->maxMipmapLevelClamp;
-      Sampler->MinMipmapLevelClamp = SamplerMipProperties->minMipmapLevelClamp;
-      Sampler->MaxAnisotropy = SamplerMipProperties->maxAnisotropy;
-      Sampler->Props |= SamplerMipProperties->mipFilterMode << 11;
-    } else if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES) {
-      const ur_exp_sampler_addr_modes_t *SamplerAddrModes =
-          reinterpret_cast<const ur_exp_sampler_addr_modes_t *>(pNext);
-      Sampler->Props |= SamplerAddrModes->addrModes[0] << 2;
-      Sampler->Props |= SamplerAddrModes->addrModes[1] << 5;
-      Sampler->Props |= SamplerAddrModes->addrModes[2] << 8;
-    } else if (BaseDesc->stype ==
-               UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES) {
-      const ur_exp_sampler_cubemap_properties_t *SamplerCubemapProperties =
-          reinterpret_cast<const ur_exp_sampler_cubemap_properties_t *>(pNext);
-      Sampler->Props |= SamplerCubemapProperties->cubemapFilterMode << 12;
+    void *pNext = const_cast<void *>(pDesc->pNext);
+    while (pNext != nullptr) {
+      const ur_base_desc_t *BaseDesc =
+          reinterpret_cast<const ur_base_desc_t *>(pNext);
+      if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES) {
+        const ur_exp_sampler_mip_properties_t *SamplerMipProperties =
+            reinterpret_cast<const ur_exp_sampler_mip_properties_t *>(pNext);
+        Sampler->MaxMipmapLevelClamp =
+            SamplerMipProperties->maxMipmapLevelClamp;
+        Sampler->MinMipmapLevelClamp =
+            SamplerMipProperties->minMipmapLevelClamp;
+        Sampler->MaxAnisotropy = SamplerMipProperties->maxAnisotropy;
+        Sampler->Props |= SamplerMipProperties->mipFilterMode << 11;
+      } else if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES) {
+        const ur_exp_sampler_addr_modes_t *SamplerAddrModes =
+            reinterpret_cast<const ur_exp_sampler_addr_modes_t *>(pNext);
+        Sampler->Props |= SamplerAddrModes->addrModes[0] << 2;
+        Sampler->Props |= SamplerAddrModes->addrModes[1] << 5;
+        Sampler->Props |= SamplerAddrModes->addrModes[2] << 8;
+      } else if (BaseDesc->stype ==
+                 UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES) {
+        const ur_exp_sampler_cubemap_properties_t *SamplerCubemapProperties =
+            reinterpret_cast<const ur_exp_sampler_cubemap_properties_t *>(
+                pNext);
+        Sampler->Props |= SamplerCubemapProperties->cubemapFilterMode << 12;
+      }
+      pNext = const_cast<void *>(BaseDesc->pNext);
     }
-    pNext = const_cast<void *>(BaseDesc->pNext);
-  }
 
-  *phSampler = Sampler.release();
+    *phSampler = Sampler.release();
+  } catch (std::bad_alloc &) {
+    return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+  } catch (...) {
+    return UR_RESULT_ERROR_UNKNOWN;
+  }
   return UR_RESULT_SUCCESS;
 }