Remove legacy error checking Pt 3

Author: adurang

offload/plugins-nextgen/level_zero/include/L0Context.h

@@ -71,7 +71,8 @@ class L0ContextTy {
 
   /// Create context, initialize event pool and extension functions
   L0ContextTy(LevelZeroPluginTy &Plugin, ze_driver_handle_t zeDriver,
-              int32_t DriverId);
+              int32_t DriverId)
+      : Plugin(Plugin), zeDriver(zeDriver) {}
 
   L0ContextTy(const L0ContextTy &) = delete;
   L0ContextTy(L0ContextTy &&) = delete;
@@ -81,15 +82,8 @@ class L0ContextTy {
   /// Release resources
   ~L0ContextTy() {}
 
-  Error deinit() {
-    EventPool.deinit();
-    auto Err = HostMemAllocator.deinit();
-    if (Err)
-      return Err;
-    if (zeContext)
-      CALL_ZE_RET_ERROR(zeContextDestroy, zeContext);
-    return Error::success();
-  }
+  Error init();
+  Error deinit();
 
   auto &getPlugin() const { return Plugin; }
 

offload/plugins-nextgen/level_zero/include/L0Defs.h

@@ -42,16 +42,6 @@ using namespace error;
 /// Generic L0 handle type
 using ZeHandleTy = void *;
 
-template <typename... ArgsTy>
-static Error Plugin::check(int32_t Code, const char *ErrFmt, ArgsTy... Args) {
-
-  if (Code == OFFLOAD_SUCCESS)
-    return Plugin::success();
-  const char *Desc = "Unknown error";
-  return createStringError<ArgsTy..., const char *>(inconvertibleErrorCode(),
-                                                    ErrFmt, Args..., Desc);
-}
-
 } // namespace llvm::omp::target::plugin
 
 #endif // OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_LEVEL_ZERO_L0DEFS_H

offload/plugins-nextgen/level_zero/include/L0Device.h

@@ -267,8 +267,6 @@ class L0DeviceTy final : public GenericDeviceTy {
   /// Get copy command queue group ordinal. Returns Ordinal-NumQueues pair
   std::pair<uint32_t, uint32_t> findCopyOrdinal(bool LinkCopy = false);
 
-  Error internalInit();
-
 public:
   L0DeviceTy(GenericPluginTy &Plugin, int32_t DeviceId, int32_t NumDevices,
              ze_device_handle_t zeDevice, L0ContextTy &DriverInfo,
@@ -284,11 +282,6 @@ class L0DeviceTy final : public GenericDeviceTy {
     MemoryProperties.pNext = nullptr;
     CacheProperties.stype = ZE_STRUCTURE_TYPE_DEVICE_CACHE_PROPERTIES;
     CacheProperties.pNext = nullptr;
-
-    auto Err = internalInit();
-    if (Err)
-      FATAL_MESSAGE(DeviceId, "Couldn't initialize device: %s\n",
-                    toString(std::move(Err)).c_str());
   }
 
   static L0DeviceTy &makeL0Device(GenericDeviceTy &Device) {
@@ -507,11 +500,13 @@ class L0DeviceTy final : public GenericDeviceTy {
   }
 
   /// Return an event from the driver associated to this device
-  ze_event_handle_t getEvent() { return l0Context.getEventPool().getEvent(); }
+  Expected<ze_event_handle_t> getEvent() {
+    return l0Context.getEventPool().getEvent();
+  }
 
   /// Release event to the pool associated to this device
-  void releaseEvent(ze_event_handle_t Event) {
-    l0Context.getEventPool().releaseEvent(Event, *this);
+  Error releaseEvent(ze_event_handle_t Event) {
+    return l0Context.getEventPool().releaseEvent(Event, *this);
   }
 
   StagingBufferTy &getStagingBuffer() { return l0Context.getStagingBuffer(); }

offload/plugins-nextgen/level_zero/include/L0Memory.h

@@ -464,25 +464,27 @@ class EventPoolTy {
 
 public:
   /// Initialize context, flags, and mutex
-  void init(ze_context_handle_t ContextIn, uint32_t FlagsIn) {
+  Error init(ze_context_handle_t ContextIn, uint32_t FlagsIn) {
     Context = ContextIn;
     Flags = FlagsIn;
     Mtx.reset(new std::mutex);
+    return Plugin::success();
   }
 
   /// Destroys L0 resources
-  void deinit() {
+  Error deinit() {
     for (auto E : Events)
-      CALL_ZE_RET_VOID(zeEventDestroy, E);
+      CALL_ZE_RET_ERROR(zeEventDestroy, E);
     for (auto P : Pools)
-      CALL_ZE_RET_VOID(zeEventPoolDestroy, P);
+      CALL_ZE_RET_ERROR(zeEventPoolDestroy, P);
+    return Plugin::success();
   }
 
   /// Get a free event from the pool
-  ze_event_handle_t getEvent();
+  Expected<ze_event_handle_t> getEvent();
 
   /// Return an event to the pool
-  void releaseEvent(ze_event_handle_t Event, L0DeviceTy &Device);
+  Error releaseEvent(ze_event_handle_t Event, L0DeviceTy &Device);
 };
 
 /// Staging buffer

offload/plugins-nextgen/level_zero/include/L0Plugin.h

@@ -81,7 +81,7 @@ class LevelZeroPluginTy final : public GenericPluginTy {
 
   /// Find L0 devices and initialize device properties.
   /// Returns number of devices reported to omptarget.
-  int32_t findDevices();
+  Expected<int32_t> findDevices();
 
   L0DeviceTy &getDeviceFromId(int32_t DeviceId) const {
     assert("Invalid device ID" && DeviceId >= 0 &&

offload/plugins-nextgen/level_zero/src/L0Context.cpp

@@ -15,17 +15,26 @@
 
 namespace llvm::omp::target::plugin {
 
-L0ContextTy::L0ContextTy(LevelZeroPluginTy &Plugin, ze_driver_handle_t zeDriver,
-                         int32_t /*DriverId*/)
-    : Plugin(Plugin), zeDriver(zeDriver) {
-  CALL_ZE_RET_VOID(zeDriverGetApiVersion, zeDriver, &APIVersion);
+Error L0ContextTy::init() {
+  CALL_ZE_RET_ERROR(zeDriverGetApiVersion, zeDriver, &APIVersion);
   DP("Driver API version is %" PRIx32 "\n", APIVersion);
 
   ze_context_desc_t Desc{ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-  CALL_ZE_RET_VOID(zeContextCreate, zeDriver, &Desc, &zeContext);
-
-  EventPool.init(zeContext, 0);
+  CALL_ZE_RET_ERROR(zeContextCreate, zeDriver, &Desc, &zeContext);
+  if (auto Err = EventPool.init(zeContext, 0))
+    return Err;
   HostMemAllocator.initHostPool(*this, Plugin.getOptions());
+  return Plugin::success();
+}
+
+Error L0ContextTy::deinit() {
+  if (auto Err = EventPool.deinit())
+    return Err;
+  if (auto Err = HostMemAllocator.deinit())
+    return Err;
+  if (zeContext)
+    CALL_ZE_RET_ERROR(zeContextDestroy, zeContext);
+  return Plugin::success();
 }
 
 StagingBufferTy &L0ContextTy::getStagingBuffer() {

offload/plugins-nextgen/level_zero/src/L0Device.cpp

@@ -174,7 +174,7 @@ void L0DeviceTy::reportDeviceInfo() const {
   DP("-- Max clock frequency (MHz)    : %" PRIu32 "\n", getClockRate());
 }
 
-Error L0DeviceTy::internalInit() {
+Error L0DeviceTy::initImpl(GenericPluginTy &Plugin) {
   const auto &Options = getPlugin().getOptions();
 
   uint32_t Count = 1;
@@ -219,10 +219,6 @@ Error L0DeviceTy::internalInit() {
   return Plugin::success();
 }
 
-Error L0DeviceTy::initImpl(GenericPluginTy &Plugin) {
-  return Plugin::success();
-}
-
 Error L0DeviceTy::deinitImpl() {
   for (auto &PGM : Programs)
     if (auto Err = PGM.deinit())
@@ -293,7 +289,8 @@ Error L0DeviceTy::synchronizeImpl(__tgt_async_info &AsyncInfo,
         CALL_ZE_RET_ERROR(zeEventHostSynchronize, KE, UINT64_MAX);
       }
       for (auto &Event : WaitEvents) {
-        releaseEvent(Event);
+        if (auto Err = releaseEvent(Event))
+          return Err;
       }
     } else { // Async
       // Wait for all events. We should wait and reset events in reverse order
@@ -308,7 +305,8 @@ Error L0DeviceTy::synchronizeImpl(__tgt_async_info &AsyncInfo,
           if (*Itr == AsyncQueue->KernelEvent)
             WaitDone = true;
         }
-        releaseEvent(*Itr);
+        if (auto Err = releaseEvent(*Itr))
+          return Err;
       }
     }
   }
@@ -507,13 +505,13 @@ Error L0DeviceTy::dataExchangeImpl(const void *SrcPtr, GenericDeviceTy &DstDev,
   const bool UseCopyEngine = getZeDevice() != L0DstDev.getZeDevice();
 
   if (asyncEnabled() && AsyncInfoWrapper.hasQueue()) {
-    if (enqueueMemCopyAsync(DstPtr, SrcPtr, Size,
-                            (__tgt_async_info *)AsyncInfoWrapper))
-      return Plugin::error(ErrorCode::UNKNOWN, "dataExchangeImpl failed");
+    if (auto Err = enqueueMemCopyAsync(DstPtr, SrcPtr, Size,
+                                       (__tgt_async_info *)AsyncInfoWrapper))
+      return Err;
   } else {
-    if (enqueueMemCopy(DstPtr, SrcPtr, Size,
-                       /* AsyncInfo */ nullptr, UseCopyEngine))
-      return Plugin::error(ErrorCode::UNKNOWN, "dataExchangeImpl failed");
+    if (auto Err = enqueueMemCopy(DstPtr, SrcPtr, Size,
+                                  /* AsyncInfo */ nullptr, UseCopyEngine))
+      return Err;
   }
   return Plugin::success();
 }
@@ -708,7 +706,10 @@ Error L0DeviceTy::enqueueMemCopyAsync(void *Dst, const void *Src, size_t Size,
                                       bool CopyTo) {
   const bool Ordered =
       (getPlugin().getOptions().CommandMode == CommandModeTy::AsyncOrdered);
-  ze_event_handle_t SignalEvent = getEvent();
+  auto EventOrErr = getEvent();
+  if (!EventOrErr)
+    return EventOrErr.takeError();
+  ze_event_handle_t SignalEvent = *EventOrErr;
   size_t NumWaitEvents = 0;
   ze_event_handle_t *WaitEvents = nullptr;
   AsyncQueueTy *AsyncQueue = reinterpret_cast<AsyncQueueTy *>(AsyncInfo->Queue);
@@ -734,7 +735,10 @@ Error L0DeviceTy::enqueueMemFill(void *Ptr, const void *Pattern,
                                  size_t PatternSize, size_t Size) {
   if (useImmForCopy()) {
     const auto CmdList = getImmCopyCmdList();
-    auto Event = getEvent();
+    auto EventOrErr = getEvent();
+    if (!EventOrErr)
+      return EventOrErr.takeError();
+    ze_event_handle_t Event = *EventOrErr;
     CALL_ZE_RET_ERROR(zeCommandListAppendMemoryFill, CmdList, Ptr, Pattern,
                       PatternSize, Size, Event, 0, nullptr);
     CALL_ZE_RET_ERROR(zeEventHostSynchronize, Event, UINT64_MAX);

offload/plugins-nextgen/level_zero/src/L0Kernel.cpp

@@ -557,7 +557,10 @@ Error L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
   if (UseImmCmdList) {
     INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
          "Using immediate command list for kernel submission.\n");
-    auto Event = Device.getEvent();
+    auto EventOrError = Device.getEvent();
+    if (!EventOrError)
+      return EventOrError.takeError();
+    ze_event_handle_t Event = *EventOrError;
     size_t NumWaitEvents = 0;
     ze_event_handle_t *WaitEvents = nullptr;
     if (IsAsync && !AsyncQueue->WaitEvents.empty()) {
@@ -584,7 +587,8 @@ Error L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
       AsyncQueue->KernelEvent = Event;
     } else {
       CALL_ZE_RET_ERROR(zeEventHostSynchronize, Event, UINT64_MAX);
-      Device.releaseEvent(Event);
+      if (auto Err = Device.releaseEvent(Event))
+        return Err;
     }
   } else {
     ze_event_handle_t Event = nullptr;
@@ -603,7 +607,8 @@ Error L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
     CALL_ZE_RET_ERROR(zeCommandQueueSynchronize, CmdQueue, UINT64_MAX);
     CALL_ZE_RET_ERROR(zeCommandListReset, CmdList);
     if (Event) {
-      Device.releaseEvent(Event);
+      if (auto Err = Device.releaseEvent(Event))
+        return Err;
     }
   }
 

offload/plugins-nextgen/level_zero/src/L0Memory.cpp

@@ -647,7 +647,7 @@ Expected<void *> MemAllocatorTy::allocL0(size_t Size, size_t Align,
   return Mem;
 }
 
-ze_event_handle_t EventPoolTy::getEvent() {
+Expected<ze_event_handle_t> EventPoolTy::getEvent() {
   std::lock_guard<std::mutex> Lock(*Mtx);
 
   if (Events.empty()) {
@@ -656,7 +656,7 @@ ze_event_handle_t EventPoolTy::getEvent() {
     Desc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | Flags;
     Desc.count = PoolSize;
     ze_event_pool_handle_t Pool;
-    CALL_ZE_RET_NULL(zeEventPoolCreate, Context, &Desc, 0, nullptr, &Pool);
+    CALL_ZE_RET_ERROR(zeEventPoolCreate, Context, &Desc, 0, nullptr, &Pool);
     Pools.push_back(Pool);
 
     // Create events
@@ -666,7 +666,7 @@ ze_event_handle_t EventPoolTy::getEvent() {
     for (uint32_t I = 0; I < PoolSize; I++) {
       EventDesc.index = I;
       ze_event_handle_t Event;
-      CALL_ZE_RET_NULL(zeEventCreate, Pool, &EventDesc, &Event);
+      CALL_ZE_RET_ERROR(zeEventCreate, Pool, &EventDesc, &Event);
       Events.push_back(Event);
     }
   }
@@ -678,10 +678,11 @@ ze_event_handle_t EventPoolTy::getEvent() {
 }
 
 /// Return an event to the pool
-void EventPoolTy::releaseEvent(ze_event_handle_t Event, L0DeviceTy &Device) {
+Error EventPoolTy::releaseEvent(ze_event_handle_t Event, L0DeviceTy &Device) {
   std::lock_guard<std::mutex> Lock(*Mtx);
-  CALL_ZE_RET_VOID(zeEventHostReset, Event);
+  CALL_ZE_RET_ERROR(zeEventHostReset, Event);
   Events.push_back(Event);
+  return Plugin::success();
 }
 
 } // namespace llvm::omp::target::plugin

offload/plugins-nextgen/level_zero/src/L0Plugin.cpp

@@ -27,10 +27,10 @@ using namespace error;
 // Common data across all possible plugin instantiations
 L0OptionsTy LevelZeroPluginTy::Options;
 
-int32_t LevelZeroPluginTy::findDevices() {
-  CALL_ZE_RET_ZERO(zeInit, ZE_INIT_FLAG_GPU_ONLY);
+Expected<int32_t> LevelZeroPluginTy::findDevices() {
+  CALL_ZE_RET_ERROR(zeInit, ZE_INIT_FLAG_GPU_ONLY);
   uint32_t NumDrivers = 0;
-  CALL_ZE_RET_ZERO(zeDriverGet, &NumDrivers, nullptr);
+  CALL_ZE_RET_ERROR(zeDriverGet, &NumDrivers, nullptr);
   if (NumDrivers == 0) {
     DP("Cannot find any drivers.\n");
     return 0;
@@ -39,7 +39,7 @@ int32_t LevelZeroPluginTy::findDevices() {
   // We expect multiple drivers on Windows to support different device types,
   // so we need to maintain multiple drivers and contexts in general.
   llvm::SmallVector<ze_driver_handle_t> FoundDrivers(NumDrivers);
-  CALL_ZE_RET_ZERO(zeDriverGet, &NumDrivers, FoundDrivers.data());
+  CALL_ZE_RET_ERROR(zeDriverGet, &NumDrivers, FoundDrivers.data());
 
   struct RootInfoTy {
     uint32_t OrderId;
@@ -62,8 +62,10 @@ int32_t LevelZeroPluginTy::findDevices() {
     // We have a driver that supports at least one device
     ContextList.emplace_back(*this, Driver, DriverId);
     auto &DrvInfo = ContextList.back();
+    if (auto Err = DrvInfo.init())
+      return std::move(Err);
     llvm::SmallVector<ze_device_handle_t> FoundDevices(DeviceCount);
-    CALL_ZE_RET_ZERO(zeDeviceGet, Driver, &DeviceCount, FoundDevices.data());
+    CALL_ZE_RET_ERROR(zeDeviceGet, Driver, &DeviceCount, FoundDevices.data());
 
     for (auto &zeDevice : FoundDevices)
       RootDevices.push_back(