Merge branch 'main' into remove_opencl_assertions

.github/dependabot.yml

@@ -0,0 +1,9 @@
+# Run dependencies versions update
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/third_party" # Location of package manifests
+    schedule:
+      interval: "daily"
+    # Run only required security updates
+    open-pull-requests-limit: 0

include/ur_api.h

@@ -5023,8 +5023,8 @@ urKernelSetArgPointer(
     ur_kernel_handle_t hKernel,                            ///< [in] handle of the kernel object
     uint32_t argIndex,                                     ///< [in] argument index in range [0, num args - 1]
     const ur_kernel_arg_pointer_properties_t *pProperties, ///< [in][optional] pointer to USM pointer properties.
-    const void *pArgValue                                  ///< [in][optional] USM pointer to memory location holding the argument
-                                                           ///< value. If null then argument value is considered null.
+    const void *pArgValue                                  ///< [in][optional] Pointer obtained by USM allocation or virtual memory
+                                                           ///< mapping operation. If null then argument value is considered null.
 );
 
 ///////////////////////////////////////////////////////////////////////////////

scripts/core/PROG.rst

@@ -77,14 +77,14 @@ Initialization and Discovery
 Device handle lifetime
 ----------------------
 
-The device objects are reference-counted, and there are ${x}DeviceRetain and ${x}DeviceRelease.
-The ref-count of a device is automatically incremented when device is obtained by ${x}DeviceGet.
-After device is no longer needed to the application it must call to ${x}DeviceRelease.
-When ref-count of the underlying device handle becomes zero then that device object is deleted.
-Note, that besides the application itself, the Unified Runtime may increment and decrement ref-count on its own.
-So, after the call to ${x}DeviceRelease below, the device may stay alive until other
-objects attached to it, like command-queues, are deleted. But application may not use the device
-after it released its own reference.
+Device objects are reference-counted, using ${x}DeviceRetain and ${x}DeviceRelease.
+The ref-count of a device is automatically incremented when a device is obtained by ${x}DeviceGet.
+After a device is no longer needed by the application it must call ${x}DeviceRelease.
+When the ref-count of the underlying device handle becomes zero then that device object is deleted.
+Note that a Unified Runtime adapter may internally increment and decrement a device's ref-count.
+So after the call to ${x}DeviceRelease below, the device may stay active until other
+objects using it, such as a command-queue, are deleted. However, an application
+may not use the device after it releases its last reference.
 
 .. parsed-literal::
 
@@ -120,7 +120,7 @@ In case where the info size is only known at runtime then two calls are needed,
 Device partitioning into sub-devices
 ------------------------------------
 
-The ${x}DevicePartition could partition a device into sub-device. The exact representation and
+${x}DevicePartition partitions a device into a sub-device. The exact representation and
 characteristics of the sub-devices are device specific, but normally they each represent a
 fixed part of the parent device, which can explicitly be programmed individually.
 
@@ -161,9 +161,10 @@ An implementation will return "0" in the count if no further partitioning is sup
 Contexts
 ========
 
-Contexts are serving the purpose of resources sharing (between devices in the same context),
-and resources isolation (resources do not cross context boundaries). Resources such as memory allocations,
-events, and programs are explicitly created against a context. A trivial work with context looks like this:
+Contexts serve the purpose of resource sharing (between devices in the same context),
+and resource isolation (ensuring that resources do not cross context
+boundaries). Resources such as memory allocations, events, and programs are
+explicitly created against a context.
 
 .. parsed-literal::
 
@@ -235,18 +236,20 @@ explicit and implicit kernel arguments along with data needed for launch.
 Queue and Enqueue
 =================
 
-A queue object represents a logic input stream to a device. Kernels 
-and commands are submitted to queue for execution using Equeue commands:
+Queue objects are used to submit work to a given device. Kernels
+and commands are submitted to queue for execution using Enqueue commands:
 such as ${x}EnqueueKernelLaunch, ${x}EnqueueMemBufferWrite. Enqueued kernels
 and commands can be executed in order or out of order depending on the
 queue's property ${X}_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE when the
-queue is created.
+queue is created. If a queue is out of order, the queue may internally do some
+scheduling of work to achieve concurrency on the device, while honouring the
+event dependencies that are passed to each Enqueue command.
 
 .. parsed-literal::
 
     // Create an out of order queue for hDevice in hContext
     ${x}_queue_handle_t hQueue;
-    ${x}QueueCreate(hContext, hDevice, 
+    ${x}QueueCreate(hContext, hDevice,
                     ${X}_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE, &hQueue);
 
     // Launch a kernel with 3D workspace partitioning

scripts/core/kernel.yml

@@ -339,7 +339,7 @@ params:
       desc: "[in][optional] pointer to USM pointer properties."
     - type: "const void*"
       name: pArgValue
-      desc: "[in][optional] USM pointer to memory location holding the argument value. If null then argument value is considered null."
+      desc: "[in][optional] Pointer obtained by USM allocation or virtual memory mapping operation. If null then argument value is considered null."
 returns:
     - $X_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
     - $X_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE

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/kernel.cpp

@@ -287,7 +287,8 @@ urKernelSetArgPointer(ur_kernel_handle_t hKernel, uint32_t argIndex,
                       const ur_kernel_arg_pointer_properties_t *pProperties,
                       const void *pArgValue) {
   std::ignore = pProperties;
-  hKernel->setKernelArg(argIndex, sizeof(pArgValue), pArgValue);
+  // setKernelArg is expecting a pointer to our argument
+  hKernel->setKernelArg(argIndex, sizeof(pArgValue), &pArgValue);
   return UR_RESULT_SUCCESS;
 }
 

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;
   }
 }