Address feedback - missing breaks in switches, more appropriate error…

… codes or replacing original

error message to use an assert from cassert header and some other minor fixes.

source/adapters/cuda/common.hpp

@@ -13,7 +13,7 @@
 #include <ur/ur.hpp>
 
 /**
- * Call an UR API and, if the result is not UR_RESULT_SUCCESS, automatically
+ * Call a UR API and, if the result is not UR_RESULT_SUCCESS, automatically
  * return from the current function.
  */
 #define UR_RETURN_ON_FAILURE(urCall)                                           \

source/adapters/cuda/device.cpp

@@ -557,7 +557,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     UR_CHECK_ERROR(cuDeviceGetAttribute(
         &ECCEnabled, CU_DEVICE_ATTRIBUTE_ECC_ENABLED, hDevice->get()));
 
-    if ((ECCEnabled != 0) | (ECCEnabled != 1)) {
+    if ((ECCEnabled != 0) || (ECCEnabled != 1)) {
       return UR_RESULT_ERROR_INVALID_OPERATION;
     }
     auto Result = static_cast<bool>(ECCEnabled);
@@ -568,7 +568,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     UR_CHECK_ERROR(cuDeviceGetAttribute(
         &IsIntegrated, CU_DEVICE_ATTRIBUTE_INTEGRATED, hDevice->get()));
 
-    if ((IsIntegrated != 0) | (IsIntegrated != 1)) {
+    if ((IsIntegrated != 0) || (IsIntegrated != 1)) {
       return UR_RESULT_ERROR_INVALID_OPERATION;
     }
     auto result = static_cast<bool>(IsIntegrated);
@@ -851,9 +851,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_GLOBAL_MEM_FREE: {
     size_t FreeMemory = 0;
     size_t TotalMemory = 0;
-    if (cuMemGetInfo(&FreeMemory, &TotalMemory) != CUDA_SUCCESS) {
-      return UR_RESULT_ERROR_INVALID_OPERATION;
-    }
+    assert(cuMemGetInfo(&FreeMemory, &TotalMemory) != CUDA_SUCCESS &&
+           "failed cuMemGetInfo() API.");
     return ReturnValue(FreeMemory);
   }
   case UR_DEVICE_INFO_MEMORY_CLOCK_RATE: {

source/adapters/cuda/enqueue.cpp

@@ -844,24 +844,26 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferFill(
 }
 
 static ur_result_t imageElementByteSize(CUDA_ARRAY_DESCRIPTOR ArrayDesc,
-                                        int *Size) {
+                                        unsigned int *Size) {
   switch (ArrayDesc.Format) {
   case CU_AD_FORMAT_UNSIGNED_INT8:
   case CU_AD_FORMAT_SIGNED_INT8:
     *Size = 1;
+    break;
   case CU_AD_FORMAT_UNSIGNED_INT16:
   case CU_AD_FORMAT_SIGNED_INT16:
   case CU_AD_FORMAT_HALF:
     *Size = 2;
+    break;
   case CU_AD_FORMAT_UNSIGNED_INT32:
   case CU_AD_FORMAT_SIGNED_INT32:
   case CU_AD_FORMAT_FLOAT:
     *Size = 4;
+    break;
   default:
-    return UR_RESULT_ERROR_INVALID_IMAGE_SIZE;
+    return UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR;
     *Size = 0;
   }
-  return UR_RESULT_SUCCESS;
 }
 
 /// General ND memory copy operation for images (where N > 1).
@@ -957,7 +959,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageRead(
     CUDA_ARRAY_DESCRIPTOR ArrayDesc;
     UR_CHECK_ERROR(cuArrayGetDescriptor(&ArrayDesc, Array));
 
-    int ElementByteSize = 0;
+    unsigned int ElementByteSize = 0;
     UR_RETURN_ON_FAILURE(imageElementByteSize(ArrayDesc, &ElementByteSize));
 
     size_t ByteOffsetX = origin.x * ElementByteSize * ArrayDesc.NumChannels;
@@ -1030,7 +1032,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageWrite(
     CUDA_ARRAY_DESCRIPTOR ArrayDesc;
     UR_CHECK_ERROR(cuArrayGetDescriptor(&ArrayDesc, Array));
 
-    int ElementByteSize = 0;
+    unsigned int ElementByteSize = 0;
     UR_RETURN_ON_FAILURE(imageElementByteSize(ArrayDesc, &ElementByteSize));
 
     size_t ByteOffsetX = origin.x * ElementByteSize * ArrayDesc.NumChannels;
@@ -1110,7 +1112,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageCopy(
     UR_ASSERT(SrcArrayDesc.NumChannels == DstArrayDesc.NumChannels,
               UR_RESULT_ERROR_INVALID_MEM_OBJECT);
 
-    int ElementByteSize = 0;
+    unsigned int ElementByteSize = 0;
     UR_RETURN_ON_FAILURE(imageElementByteSize(SrcArrayDesc, &ElementByteSize));
 
     size_t DstByteOffsetX =

source/adapters/cuda/event.cpp

@@ -120,9 +120,7 @@ ur_result_t ur_event_handle_t_::record() {
 
   try {
     EventID = Queue->getNextEventID();
-    if (EventID == 0) {
-      return UR_RESULT_ERROR_INVALID_EVENT;
-    }
+    assert(EventID == 0 && "Unrecoverable program state reached in event identifier overflow.");
     UR_CHECK_ERROR(cuEventRecord(EvEnd, Stream));
   } catch (ur_result_t error) {
     Result = error;
@@ -245,19 +243,16 @@ urEventWait(uint32_t numEvents, const ur_event_handle_t *phEventWaitList) {
 UR_APIEXPORT ur_result_t UR_APICALL urEventRetain(ur_event_handle_t hEvent) {
   const auto RefCount = hEvent->incrementReferenceCount();
 
-  if (RefCount == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(RefCount == 0 &&
+         "Reference count overflow detected in urEventRetain.");
 
   return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEventRelease(ur_event_handle_t hEvent) {
   // double delete or someone is messing with the ref count.
   // either way, cannot safely proceed.
-  if (hEvent->getReferenceCount() == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(hEvent->getReferenceCount() == 0 && "Unrecoverable program state reached in urEventRetain.");
 
   // decrement ref count. If it is 0, delete the event.
   if (hEvent->decrementReferenceCount() == 0) {

source/adapters/cuda/memory.cpp

@@ -144,13 +144,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
     Result = UR_RESULT_ERROR_OUT_OF_RESOURCES;
   }
 
-  if (Result != UR_RESULT_SUCCESS) {
-    // A reported CUDA error is either an implementation or an asynchronous CUDA
-    // error for which it is unclear if the function that reported it succeeded
-    // or not. Either way, the state of the program is compromised and likely
-    // unrecoverable.
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  // A reported CUDA error is either an implementation or an asynchronous CUDA
+  // error for which it is unclear if the function that reported it succeeded
+  // or not. Either way, the state of the program is compromised and likely
+  // unrecoverable.
+  assert(Result != UR_RESULT_SUCCESS && "Unrecoverable program state reached in urMemRelease.");
 
   return UR_RESULT_SUCCESS;
 }
@@ -306,7 +304,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
     PixelTypeSizeBytes = 4;
     break;
   default:
-    return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    return UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR;
   }
 
   // When a dimension isn't used pImageDesc has the size set to 1

source/adapters/cuda/queue.cpp

@@ -265,7 +265,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   } else if (CuFlags == CU_STREAM_NON_BLOCKING) {
     Flags = UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
   } else {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
+    assert(!"Unknown cuda stream.");
   }
 
   std::vector<CUstream> ComputeCuStreams(1, CuStream);

source/adapters/cuda/sampler.cpp

@@ -84,9 +84,7 @@ UR_APIEXPORT ur_result_t UR_APICALL
 urSamplerRelease(ur_sampler_handle_t hSampler) {
   // double delete or someone is messing with the ref count.
   // either way, cannot safely proceed.
-  if (hSampler->getReferenceCount() == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert (hSampler->getReferenceCount() == 0 && "Reference count overflow detected in urSamplerRelease.");
 
   // decrement ref count. If it is 0, delete the sampler.
   if (hSampler->decrementReferenceCount() == 0) {

source/adapters/hip/common.cpp

@@ -179,19 +179,22 @@ ur_result_t urGetLastResult(ur_platform_handle_t, const char **ppMessage) {
   return ErrorMessageCode;
 }
 
-ur_result_t GetHipFormatPixelSize(hipArray_Format Format, int *Size) {
+ur_result_t imageElementByteSize(hipArray_Format Format, unsigned int *Size) {
   switch (Format) {
   case HIP_AD_FORMAT_UNSIGNED_INT8:
   case HIP_AD_FORMAT_SIGNED_INT8:
     *Size = 1;
+    break;
   case HIP_AD_FORMAT_UNSIGNED_INT16:
   case HIP_AD_FORMAT_SIGNED_INT16:
   case HIP_AD_FORMAT_HALF:
     *Size = 2;
+    break;
   case HIP_AD_FORMAT_UNSIGNED_INT32:
   case HIP_AD_FORMAT_SIGNED_INT32:
   case HIP_AD_FORMAT_FLOAT:
     *Size = 4;
+    break;
   default:
     return UR_RESULT_ERROR_IMAGE_FORMAT_NOT_SUPPORTED;
   }

source/adapters/hip/common.hpp

@@ -16,7 +16,7 @@
 #include <ur/ur.hpp>
 
 /**
- * Call an UR API and, if the result is not UR_RESULT_SUCCESS, automatically
+ * Call a UR API and, if the result is not UR_RESULT_SUCCESS, automatically
  * return from the current function.
  */
 #define UR_RETURN_ON_FAILURE(urCall)                                           \
@@ -170,8 +170,8 @@ template <typename T> class ReleaseGuard {
         // HIP error for which it is unclear if the function that reported it
         // succeeded or not. Either way, the state of the program is compromised
         // and likely unrecoverable.
-        detail::ur::hipPrint(
-            "Unrecoverable program state reached in piMemRelease");
+        assert(
+            !"Unrecoverable program state reached in piMemRelease");
       }
     }
   }
@@ -189,4 +189,4 @@ template <typename T> class ReleaseGuard {
   void dismiss() { Captive = nullptr; }
 };
 
-ur_result_t GetHipFormatPixelSize(hipArray_Format Format, int *Size);
+ur_result_t imageElementByteSize(hipArray_Format Format, int *Size);

source/adapters/hip/device.cpp

@@ -475,7 +475,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     UR_CHECK_ERROR(hipDeviceGetAttribute(
         &EccEnabled, hipDeviceAttributeEccEnabled, hDevice->get()));
 
-    if ((EccEnabled != 0) | (EccEnabled != 1)) {
+    if ((EccEnabled != 0) || (EccEnabled != 1)) {
       return UR_RESULT_ERROR_INVALID_OPERATION;
     }
     auto Result = static_cast<bool>(EccEnabled);

source/adapters/hip/enqueue.cpp

@@ -884,7 +884,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageRead(
     getArrayDesc(Array, Format, NumChannels);
 
     int ElementByteSize = 0;
-    UR_RETURN_ON_FAILURE(GetHipFormatPixelSize(Format, &ElementByteSize));
+    UR_RETURN_ON_FAILURE(imageElementByteSize(Format, &ElementByteSize));
 
     size_t ByteOffsetX = origin.x * ElementByteSize * NumChannels;
     size_t BytesToCopy = ElementByteSize * NumChannels * region.depth;
@@ -953,7 +953,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageWrite(
     getArrayDesc(Array, Format, NumChannels);
 
     int ElementByteSize = 0;
-    UR_RETURN_ON_FAILURE(GetHipFormatPixelSize(Format, &ElementByteSize));
+    UR_RETURN_ON_FAILURE(imageElementByteSize(Format, &ElementByteSize));
 
     size_t ByteOffsetX = origin.x * ElementByteSize * NumChannels;
     size_t BytesToCopy = ElementByteSize * NumChannels * region.depth;
@@ -1034,7 +1034,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageCopy(
               UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR);
 
     int ElementByteSize = 0;
-    UR_RETURN_ON_FAILURE(GetHipFormatPixelSize(SrcFormat, &ElementByteSize));
+    UR_RETURN_ON_FAILURE(imageElementByteSize(SrcFormat, &ElementByteSize));
 
     size_t DstByteOffsetX = dstOrigin.x * ElementByteSize * SrcNumChannels;
     size_t SrcByteOffsetX = srcOrigin.x * ElementByteSize * DstNumChannels;

source/adapters/hip/event.cpp

@@ -142,9 +142,7 @@ ur_result_t ur_event_handle_t_::record() {
 
   try {
     EventId = Queue->getNextEventId();
-    if (EventId == 0) {
-      return UR_RESULT_ERROR_INVALID_OPERATION;
-    }
+    assert (EventId == 0 && "Unrecoverable program state reached in event identifier overflow.");
     UR_CHECK_ERROR(hipEventRecord(EvEnd, Stream));
     Result = UR_RESULT_SUCCESS;
   } catch (ur_result_t Error) {
@@ -274,19 +272,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventSetCallback(ur_event_handle_t,
 UR_APIEXPORT ur_result_t UR_APICALL urEventRetain(ur_event_handle_t hEvent) {
   const auto RefCount = hEvent->incrementReferenceCount();
 
-  if (RefCount == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(RefCount == 0 && "Reference count overflow detected in urEventRetain.");
 
   return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEventRelease(ur_event_handle_t hEvent) {
   // double delete or someone is messing with the ref count.
   // either way, cannot safely proceed.
-  if (hEvent->getReferenceCount() == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(hEvent->getReferenceCount() == 0 && "Reference count overflow detected in urEventRelease.");
 
   // decrement ref count. If it is 0, delete the event.
   if (hEvent->decrementReferenceCount() == 0) {

source/adapters/hip/memory.cpp

@@ -92,7 +92,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
     // error for which it is unclear if the function that reported it succeeded
     // or not. Either way, the state of the program is compromised and likely
     // unrecoverable.
-    return UR_RESULT_ERROR_INVALID_OPERATION;
+    assert(!"Unrecoverable program state reached in urMemRelease");
   }
 
   return UR_RESULT_SUCCESS;
@@ -281,9 +281,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemGetInfo(ur_mem_handle_t hMemory,
 #else
           HIP_ARRAY3D_DESCRIPTOR ArrayDescriptor;
           UR_CHECK_ERROR(hipArray3DGetDescriptor(&ArrayDescriptor, Mem.Array));
-          auto PixelSize = 0;
+          int PixelSize = 0;
           UR_RETURN_ON_FAILURE(
-              GetHipFormatPixelSize(ArrayDescriptor.Format, &PixelSize));
+              imageElementByteSize(ArrayDescriptor.Format, &PixelSize));
           const auto PixelSizeBytes = PixelSize * ArrayDescriptor.NumChannels;
           const auto ImageSizeBytes =
               PixelSizeBytes *
@@ -565,7 +565,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory,
       return ReturnValue(ArrayInfo.Depth);
     case UR_IMAGE_INFO_ELEMENT_SIZE: {
       int Size = 0;
-      UR_RETURN_ON_FAILURE(GetHipFormatPixelSize(ArrayInfo.Format, &Size));
+      UR_RETURN_ON_FAILURE(imageElementByteSize(ArrayInfo.Format, &Size));
       return ReturnValue(Size);
     }
     case UR_IMAGE_INFO_ROW_PITCH:

source/adapters/hip/queue.cpp

@@ -280,7 +280,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   } else if (HIPFlags == hipStreamNonBlocking) {
     Flags = UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
   } else {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
+    assert(!"Unknown hip stream.");
   }
 
   std::vector<hipStream_t> ComputeHIPStreams(1, HIPStream);

source/adapters/hip/sampler.cpp

@@ -69,9 +69,7 @@ ur_result_t urSamplerRetain(ur_sampler_handle_t hSampler) {
 ur_result_t urSamplerRelease(ur_sampler_handle_t hSampler) {
   // double delete or someone is messing with the ref count.
   // either way, cannot safely proceed.
-  if (hSampler->getReferenceCount() == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(hSampler->getReferenceCount() == 0 && "Reference count overflow detected in urSamplerRelease.");
 
   // decrement ref count. If it is 0, delete the sampler.
   if (hSampler->decrementReferenceCount() == 0) {

source/adapters/level_zero/context.cpp

@@ -566,9 +566,7 @@ ur_context_handle_t_::decrementUnreleasedEventsInPool(ur_event_handle_t Event) {
       getZeEventPoolCache(Event->isHostVisible(), Event->isProfilingEnabled());
 
   // Put the empty pool to the cache of the pools.
-  if (NumEventsUnreleasedInEventPool[Event->ZeEventPool] == 0) {
-    return UR_RESULT_ERROR_INVALID_OPERATION;
-  }
+  assert(NumEventsUnreleasedInEventPool[Event->ZeEventPool] == 0 && "Invalid event release: event pool doesn't have unreleased events");
   if (--NumEventsUnreleasedInEventPool[Event->ZeEventPool] == 0) {
     if (ZePoolCache->front() != Event->ZeEventPool) {
       ZePoolCache->push_back(Event->ZeEventPool);

source/adapters/level_zero/event.cpp

@@ -512,9 +512,7 @@ ur_result_t ur_event_handle_t_::getOrCreateHostVisibleEvent(
                                                           this->Mutex);
 
   if (!HostVisibleEvent) {
-    if (UrQueue->ZeEventsScope != OnDemandHostVisibleProxy) {
-      return UR_RESULT_ERROR_INVALID_EVENT;
-    }
+    assert(UrQueue->ZeEventsScope != OnDemandHostVisibleProxy && "getOrCreateHostVisibleEvent: missing host-visible event");
 
     // Submit the command(s) signalling the proxy event to the queue.
     // We have to first submit a wait for the device-only event for which this
@@ -560,9 +558,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventWait(
       //
       ur_event_handle_t_ *Event =
           ur_cast<ur_event_handle_t_ *>(EventWaitList[I]);
-      if (!Event->hasExternalRefs()) {
-        return UR_RESULT_ERROR_INVALID_OPERATION;
-      }
+      assert(!Event->hasExternalRefs() && "urEventsWait must not be called for an internal event");
 
       ze_event_handle_t ZeHostVisibleEvent;
       if (auto Res = Event->getOrCreateHostVisibleEvent(ZeHostVisibleEvent))
@@ -587,15 +583,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventWait(
           ur_cast<ur_event_handle_t_ *>(EventWaitList[I]);
       {
         std::shared_lock<ur_shared_mutex> EventLock(Event->Mutex);
-        if (!Event->hasExternalRefs()) {
-          return UR_RESULT_ERROR_INVALID_OPERATION;
-        }
+        assert(!Event->hasExternalRefs() && "urEventWait must not be called for an internal event");
 
         if (!Event->Completed) {
           auto HostVisibleEvent = Event->HostVisibleEvent;
-          if (!HostVisibleEvent) {
-            return UR_RESULT_ERROR_INVALID_EVENT;
-          }
+          assert(!HostVisibleEvent && "The host-visible proxy event missing");
 
           ze_event_handle_t ZeEvent = HostVisibleEvent->ZeEvent;
           urPrint("ZeEvent = %#llx\n", ur_cast<std::uintptr_t>(ZeEvent));