Remove legacy error checking Pt 2

adurang · adurang · commit 1221006caa5b · 2025-10-21T18:13:18.000+02:00
diff --git a/offload/plugins-nextgen/level_zero/include/L0Device.h b/offload/plugins-nextgen/level_zero/include/L0Device.h
@@ -549,7 +549,7 @@ class L0DeviceTy final : public GenericDeviceTy {
     return getDeviceMemAllocator();
   }
 
-  int32_t makeMemoryResident(void *Mem, size_t Size);
+  Error makeMemoryResident(void *Mem, size_t Size);
 
   // Generic device interface implementation
   Expected<DeviceImageTy *>
diff --git a/offload/plugins-nextgen/level_zero/include/L0Kernel.h b/offload/plugins-nextgen/level_zero/include/L0Kernel.h
@@ -110,9 +110,9 @@ class L0KernelTy : public GenericKernelTy {
   KernelPropertiesTy Properties;
   auto &getProperties() { return Properties; }
 
-  int32_t runTargetTeamRegion(L0DeviceTy &Device, KernelArgsTy &KernelArgs,
-                              KernelLaunchParamsTy LaunchParams,
-                              __tgt_async_info *AsyncInfo) const;
+  Error runTargetTeamRegion(L0DeviceTy &Device, KernelArgsTy &KernelArgs,
+                            KernelLaunchParamsTy LaunchParams,
+                            __tgt_async_info *AsyncInfo) const;
 
   void decideKernelGroupArguments(L0DeviceTy &Device, uint32_t NumTeams,
                                   uint32_t ThreadLimit,
@@ -122,10 +122,12 @@ class L0KernelTy : public GenericKernelTy {
                                   bool HalfNumThreads,
                                   bool IsTeamsNDRange) const;
 
-  int32_t decideLoopKernelGroupArguments(
-      L0DeviceTy &Device, uint32_t ThreadLimit, TgtNDRangeDescTy *LoopLevels,
-      uint32_t *GroupSizes, ze_group_count_t &GroupCounts, bool HalfNumThreads,
-      bool &AllowCooperative) const;
+  Error decideLoopKernelGroupArguments(L0DeviceTy &Device, uint32_t ThreadLimit,
+                                       TgtNDRangeDescTy *LoopLevels,
+                                       uint32_t *GroupSizes,
+                                       ze_group_count_t &GroupCounts,
+                                       bool HalfNumThreads,
+                                       bool &AllowCooperative) const;
 
   Error buildKernel(L0ProgramTy &Program);
 
@@ -160,10 +162,10 @@ class L0KernelTy : public GenericKernelTy {
 
   ze_kernel_handle_t getZeKernel() const { return zeKernel; }
 
-  int32_t getGroupsShape(L0DeviceTy &Device, int32_t NumTeams,
-                         int32_t ThreadLimit, uint32_t *GroupSizes,
-                         ze_group_count_t &GroupCounts, void *LoopDesc,
-                         bool &AllowCooperative) const;
+  Error getGroupsShape(L0DeviceTy &Device, int32_t NumTeams,
+                       int32_t ThreadLimit, uint32_t *GroupSizes,
+                       ze_group_count_t &GroupCounts, void *LoopDesc,
+                       bool &AllowCooperative) const;
 };
 
 } // namespace llvm::omp::target::plugin
diff --git a/offload/plugins-nextgen/level_zero/include/L0Memory.h b/offload/plugins-nextgen/level_zero/include/L0Memory.h
@@ -329,7 +329,8 @@ class MemAllocatorTy {
   /// Allocate memory from L0 GPU RT. We use over-allocation workaround
   /// to support target pointer with offset, and positive "ActiveSize" is
   /// specified in such cases for correct debug logging.
-  void *allocL0(size_t Size, size_t Align, int32_t Kind, size_t ActiveSize = 0);
+  Expected<void *> allocL0(size_t Size, size_t Align, int32_t Kind,
+                           size_t ActiveSize = 0);
 
   /// Allocate memory with the specified information from a memory pool
   Expected<void *> alloc(size_t Size, size_t Align, int32_t Kind,
diff --git a/offload/plugins-nextgen/level_zero/include/L0Program.h b/offload/plugins-nextgen/level_zero/include/L0Program.h
@@ -109,7 +109,7 @@ class L0ProgramTy : public DeviceImageTy {
   /// \p Name and \p Size in the device environment for the current device.
   /// The lookup is first done via the device offload table. If it fails,
   /// then the lookup falls back to non-OpenMP specific lookup on the device.
-  void *getOffloadVarDeviceAddr(const char *Name) const;
+  Expected<void *> getOffloadVarDeviceAddr(const char *Name) const;
 
   /// Returns the handle of a module that contains a given Kernel name
   ze_module_handle_t findModuleFromKernelName(const char *KernelName) const {
diff --git a/offload/plugins-nextgen/level_zero/src/L0Device.cpp b/offload/plugins-nextgen/level_zero/src/L0Device.cpp
@@ -255,13 +255,13 @@ L0DeviceTy::loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
   auto &Program = addProgram(ImageId, std::move(TgtImage));
 
   if (auto Err = Program.buildModules(CompilationOptions))
-    return Err;
+    return std::move(Err);
 
   if (auto Err = Program.linkModules())
-    return Err;
+    return std::move(Err);
 
   if (auto Err = Program.loadModuleKernels())
-    return Err;
+    return std::move(Err);
 
   return &Program;
 }
@@ -787,17 +787,10 @@ Error L0DeviceTy::dataDelete(void *Ptr) {
   return Allocator.dealloc(Ptr);
 }
 
-int32_t L0DeviceTy::makeMemoryResident(void *Mem, size_t Size) {
-  ze_result_t RC;
-  CALL_ZE(RC, zeContextMakeMemoryResident, getZeContext(), getZeDevice(), Mem,
-          Size);
-  if (RC != ZE_RESULT_SUCCESS) {
-    DP("Could not make memory " DPxMOD " resident on Level Zero device " DPxMOD
-       ".\n",
-       DPxPTR(Mem), DPxPTR(getZeDevice()));
-    return OFFLOAD_FAIL;
-  }
-  return OFFLOAD_SUCCESS;
+Error L0DeviceTy::makeMemoryResident(void *Mem, size_t Size) {
+  CALL_ZE_RET_ERROR(zeContextMakeMemoryResident, getZeContext(), getZeDevice(),
+                    Mem, Size);
+  return Plugin::success();
 }
 
 // Command queues related functions
diff --git a/offload/plugins-nextgen/level_zero/src/L0Kernel.cpp b/offload/plugins-nextgen/level_zero/src/L0Kernel.cpp
@@ -24,12 +24,8 @@ Error L0KernelTy::launchImpl(GenericDeviceTy &GenericDevice,
                              AsyncInfoWrapperTy &AsyncInfoWrapper) const {
 
   auto &l0Device = L0DeviceTy::makeL0Device(GenericDevice);
-  int32_t RC = runTargetTeamRegion(l0Device, KernelArgs,
-                                   std::move(LaunchParams), AsyncInfoWrapper);
-  if (RC == OFFLOAD_SUCCESS)
-    return Plugin::success();
-  return Plugin::error(error::ErrorCode::UNKNOWN,
-                       "Error in launch Kernel %s: %d", getName(), RC);
+  return runTargetTeamRegion(l0Device, KernelArgs, std::move(LaunchParams),
+                             AsyncInfoWrapper);
 }
 
 Error L0KernelTy::buildKernel(L0ProgramTy &Program) {
@@ -222,7 +218,7 @@ static uint64_t computeThreadsNeeded(const llvm::ArrayRef<size_t> TripCounts,
   return GroupCount[0] * ThreadsPerWG;
 }
 
-int32_t L0KernelTy::decideLoopKernelGroupArguments(
+Error L0KernelTy::decideLoopKernelGroupArguments(
     L0DeviceTy &Device, uint32_t ThreadLimit, TgtNDRangeDescTy *LoopLevels,
     uint32_t *GroupSizes, ze_group_count_t &GroupCounts, bool HalfNumThreads,
     bool &AllowCooperative) const {
@@ -282,15 +278,15 @@ int32_t L0KernelTy::decideLoopKernelGroupArguments(
         INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
              "Invalid number of teams %zu due to large loop trip count\n",
              DistributeTripCount);
-        return OFFLOAD_FAIL;
+        return Plugin::success();
       }
       GRPCounts[DistributeDim] = DistributeTripCount;
     }
     AllowCooperative = false;
     GroupCounts.groupCountX = GRPCounts[0];
     GroupCounts.groupCountY = GRPCounts[1];
     GroupCounts.groupCountZ = GRPCounts[2];
-    return OFFLOAD_SUCCESS;
+    return Plugin::success();
   }
 
   if (!MaxGroupSizeForced) {
@@ -355,9 +351,10 @@ int32_t L0KernelTy::decideLoopKernelGroupArguments(
       GRPSizes[I] = Trip;
     size_t Count = (Trip + GRPSizes[I] - 1) / GRPSizes[I];
     if (Count > UINT32_MAX) {
-      INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
-           "Invalid number of teams %zu due to large loop trip count\n", Count);
-      return OFFLOAD_FAIL;
+      return Plugin::error(ErrorCode::INVALID_ARGUMENT,
+                           "Invalid number of teams %zu due to large loop "
+                           "trip count\n",
+                           Count);
     }
     GRPCounts[I] = (uint32_t)Count;
   }
@@ -367,14 +364,13 @@ int32_t L0KernelTy::decideLoopKernelGroupArguments(
   GroupCounts.groupCountZ = GRPCounts[2];
   std::copy(GRPSizes, GRPSizes + 3, GroupSizes);
 
-  return OFFLOAD_SUCCESS;
+  return Plugin::success();
 }
 
-int32_t L0KernelTy::getGroupsShape(L0DeviceTy &Device, int32_t NumTeams,
-                                   int32_t ThreadLimit, uint32_t *GroupSizes,
-                                   ze_group_count_t &GroupCounts,
-                                   void *LoopDesc,
-                                   bool &AllowCooperative) const {
+Error L0KernelTy::getGroupsShape(L0DeviceTy &Device, int32_t NumTeams,
+                                 int32_t ThreadLimit, uint32_t *GroupSizes,
+                                 ze_group_count_t &GroupCounts, void *LoopDesc,
+                                 bool &AllowCooperative) const {
 
   const auto DeviceId = Device.getDeviceId();
   const auto &KernelPR = getProperties();
@@ -443,13 +439,13 @@ int32_t L0KernelTy::getGroupsShape(L0DeviceTy &Device, int32_t NumTeams,
     AllowCooperative = false;
   }
 
-  return OFFLOAD_SUCCESS;
+  return Plugin::success();
 }
 
-int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
-                                        KernelArgsTy &KernelArgs,
-                                        KernelLaunchParamsTy LaunchParams,
-                                        __tgt_async_info *AsyncInfo) const {
+Error L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
+                                      KernelArgsTy &KernelArgs,
+                                      KernelLaunchParamsTy LaunchParams,
+                                      __tgt_async_info *AsyncInfo) const {
   // Libomptarget can pass negative NumTeams and ThreadLimit now after
   // introducing __tgt_target_kernel. This happens only when we have valid
   // LoopDesc and the region is not a teams region.
@@ -500,13 +496,9 @@ int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
       GroupSizes, GroupCounts, AllowCooperative);
 
   if (!GroupParamsReused) {
-    auto RC = getGroupsShape(Device, NumTeams, ThreadLimit, GroupSizes,
-                             GroupCounts, LoopDesc, AllowCooperative);
-
-    if (RC != OFFLOAD_SUCCESS) {
-      return RC;
-    }
-
+    if (auto Err = getGroupsShape(Device, NumTeams, ThreadLimit, GroupSizes,
+                                  GroupCounts, LoopDesc, AllowCooperative))
+      return Err;
     KernelPR.cacheGroupParams(static_cast<TgtNDRangeDescTy *>(LoopDesc),
                               NumTeams, ThreadLimit, GroupSizes, GroupCounts,
                               AllowCooperative);
@@ -522,8 +514,8 @@ int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
   for (int32_t I = 0; I < NumArgs; I++) {
     {
       void *Arg = (static_cast<void **>(LaunchParams.Data))[I];
-      CALL_ZE_RET_FAIL(zeKernelSetArgumentValue, zeKernel, I, sizeof(Arg),
-                       Arg == nullptr ? nullptr : &Arg);
+      CALL_ZE_RET_ERROR(zeKernelSetArgumentValue, zeKernel, I, sizeof(Arg),
+                        Arg == nullptr ? nullptr : &Arg);
       INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
            "Kernel Pointer argument %" PRId32 " (value: " DPxMOD
            ") was set successfully for device %s.\n",
@@ -540,14 +532,14 @@ int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
   if (PrevFlags != Flags) {
     // Combine with common access flags
     const auto FinalFlags = Device.getIndirectFlags() | Flags;
-    CALL_ZE_RET_FAIL(zeKernelSetIndirectAccess, getZeKernel(), FinalFlags);
+    CALL_ZE_RET_ERROR(zeKernelSetIndirectAccess, getZeKernel(), FinalFlags);
     DP("Setting indirect access flags " DPxMOD "\n", DPxPTR(FinalFlags));
     PrevFlags = Flags;
   }
 
   if (!GroupParamsReused) {
-    CALL_ZE_RET_FAIL(zeKernelSetGroupSize, zeKernel, GroupSizes[0],
-                     GroupSizes[1], GroupSizes[2]);
+    CALL_ZE_RET_ERROR(zeKernelSetGroupSize, zeKernel, GroupSizes[0],
+                      GroupSizes[1], GroupSizes[2]);
   }
 
   ze_command_list_handle_t CmdList = nullptr;
@@ -580,36 +572,36 @@ int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
     INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
          "Kernel depends on %zu data copying events.\n", NumWaitEvents);
     if (AllowCooperative)
-      CALL_ZE_RET_FAIL(zeCommandListAppendLaunchCooperativeKernel, CmdList,
-                       zeKernel, &GroupCounts, Event, NumWaitEvents,
-                       WaitEvents);
+      CALL_ZE_RET_ERROR(zeCommandListAppendLaunchCooperativeKernel, CmdList,
+                        zeKernel, &GroupCounts, Event, NumWaitEvents,
+                        WaitEvents);
     else
-      CALL_ZE_RET_FAIL(zeCommandListAppendLaunchKernel, CmdList, zeKernel,
-                       &GroupCounts, Event, NumWaitEvents, WaitEvents);
+      CALL_ZE_RET_ERROR(zeCommandListAppendLaunchKernel, CmdList, zeKernel,
+                        &GroupCounts, Event, NumWaitEvents, WaitEvents);
     KernelLock.unlock();
     if (IsAsync) {
       AsyncQueue->WaitEvents.push_back(Event);
       AsyncQueue->KernelEvent = Event;
     } else {
-      CALL_ZE_RET_FAIL(zeEventHostSynchronize, Event, UINT64_MAX);
+      CALL_ZE_RET_ERROR(zeEventHostSynchronize, Event, UINT64_MAX);
       Device.releaseEvent(Event);
     }
   } else {
     ze_event_handle_t Event = nullptr;
     if (AllowCooperative)
-      CALL_ZE_RET_FAIL(zeCommandListAppendLaunchCooperativeKernel, CmdList,
-                       zeKernel, &GroupCounts, Event, 0, nullptr);
+      CALL_ZE_RET_ERROR(zeCommandListAppendLaunchCooperativeKernel, CmdList,
+                        zeKernel, &GroupCounts, Event, 0, nullptr);
     else
-      CALL_ZE_RET_FAIL(zeCommandListAppendLaunchKernel, CmdList, zeKernel,
-                       &GroupCounts, Event, 0, nullptr);
+      CALL_ZE_RET_ERROR(zeCommandListAppendLaunchKernel, CmdList, zeKernel,
+                        &GroupCounts, Event, 0, nullptr);
     KernelLock.unlock();
-    CALL_ZE_RET_FAIL(zeCommandListClose, CmdList);
-    CALL_ZE_RET_FAIL_MTX(zeCommandQueueExecuteCommandLists, Device.getMutex(),
-                         CmdQueue, 1, &CmdList, nullptr);
+    CALL_ZE_RET_ERROR(zeCommandListClose, CmdList);
+    CALL_ZE_RET_ERROR_MTX(zeCommandQueueExecuteCommandLists, Device.getMutex(),
+                          CmdQueue, 1, &CmdList, nullptr);
     INFO(OMP_INFOTYPE_PLUGIN_KERNEL, DeviceId,
          "Submitted kernel " DPxMOD " to device %s\n", DPxPTR(zeKernel), IdStr);
-    CALL_ZE_RET_FAIL(zeCommandQueueSynchronize, CmdQueue, UINT64_MAX);
-    CALL_ZE_RET_FAIL(zeCommandListReset, CmdList);
+    CALL_ZE_RET_ERROR(zeCommandQueueSynchronize, CmdQueue, UINT64_MAX);
+    CALL_ZE_RET_ERROR(zeCommandListReset, CmdList);
     if (Event) {
       Device.releaseEvent(Event);
     }
@@ -619,7 +611,7 @@ int32_t L0KernelTy::runTargetTeamRegion(L0DeviceTy &l0Device,
        "Executed kernel entry " DPxMOD " on device %s\n", DPxPTR(zeKernel),
        IdStr);
 
-  return OFFLOAD_SUCCESS;
+  return Plugin::success();
 }
 
 } // namespace llvm::omp::target::plugin
diff --git a/offload/plugins-nextgen/level_zero/src/L0Memory.cpp b/offload/plugins-nextgen/level_zero/src/L0Memory.cpp
@@ -83,7 +83,10 @@ MemAllocatorTy::MemPoolTy::MemPoolTy(int32_t Kind, MemAllocatorTy *_Allocator,
 
   // Check page size used for this allocation kind to decide minimum
   // allocation size when allocating from L0.
-  void *Mem = Allocator->allocL0(8, 0, AllocKind);
+  auto MemOrErr = Allocator->allocL0(8, 0, AllocKind);
+  if (!MemOrErr)
+    FATAL_MESSAGE0(0, "Failed to allocate memory pool\n");
+  void *Mem = *MemOrErr;
   ze_memory_allocation_properties_t AP{
       ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES, nullptr,
       ZE_MEMORY_TYPE_UNKNOWN, 0, 0};
@@ -277,7 +280,14 @@ void *MemAllocatorTy::MemPoolTy::alloc(size_t Size, size_t &AllocSize) {
     // Bucket is empty or all blocks in the bucket are full
     const auto ChunkSize = BucketParams[BucketId].first;
     const auto BlockSize = BucketParams[BucketId].second;
-    void *Base = Allocator->allocL0(BlockSize, 0, AllocKind);
+    auto BaseOrErr = Allocator->allocL0(BlockSize, 0, AllocKind);
+    if (!BaseOrErr) {
+      consumeError(BaseOrErr.takeError());
+      DP("Failed to allocate new block for %s pool\n",
+         AllocKindToStr(AllocKind));
+      return nullptr;
+    }
+    void *Base = *BaseOrErr;
 
     if (ZeroInit) {
       auto Err = Allocator->enqueueMemSet(Base, 0, BlockSize);
@@ -515,7 +525,10 @@ Expected<void *> MemAllocatorTy::alloc(size_t Size, size_t Align, int32_t Kind,
     }
   }
 
-  AllocBase = allocL0(AllocSize, Align, Kind, Size);
+  auto AllocBaseOrErr = allocL0(AllocSize, Align, Kind, Size);
+  if (!AllocBaseOrErr)
+    return AllocBaseOrErr.takeError();
+  AllocBase = *AllocBaseOrErr;
   if (AllocBase) {
     Mem = (void *)((uintptr_t)AllocBase + Offset);
     AllocInfo.add(Mem, AllocBase, Size, Kind, false, UserAlloc);
@@ -581,8 +594,8 @@ Error MemAllocatorTy::enqueueMemCopy(void *Dst, const void *Src, size_t Size) {
   return Device->enqueueMemCopy(Dst, Src, Size);
 }
 
-void *MemAllocatorTy::allocL0(size_t Size, size_t Align, int32_t Kind,
-                              size_t ActiveSize) {
+Expected<void *> MemAllocatorTy::allocL0(size_t Size, size_t Align,
+                                         int32_t Kind, size_t ActiveSize) {
   void *Mem = nullptr;
   ze_device_mem_alloc_desc_t DeviceDesc{ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
                                         nullptr, 0, 0};
@@ -604,17 +617,17 @@ void *MemAllocatorTy::allocL0(size_t Size, size_t Align, int32_t Kind,
   switch (Kind) {
   case TARGET_ALLOC_DEVICE:
     makeResident = true;
-    CALL_ZE_RET_NULL(zeMemAllocDevice, zeContext, &DeviceDesc, Size, Align,
-                     zeDevice, &Mem);
+    CALL_ZE_RET_ERROR(zeMemAllocDevice, zeContext, &DeviceDesc, Size, Align,
+                      zeDevice, &Mem);
     DP("Allocated a device memory " DPxMOD "\n", DPxPTR(Mem));
     break;
   case TARGET_ALLOC_HOST:
-    CALL_ZE_RET_NULL(zeMemAllocHost, zeContext, &HostDesc, Size, Align, &Mem);
+    CALL_ZE_RET_ERROR(zeMemAllocHost, zeContext, &HostDesc, Size, Align, &Mem);
     DP("Allocated a host memory " DPxMOD "\n", DPxPTR(Mem));
     break;
   case TARGET_ALLOC_SHARED:
-    CALL_ZE_RET_NULL(zeMemAllocShared, zeContext, &DeviceDesc, &HostDesc, Size,
-                     Align, zeDevice, &Mem);
+    CALL_ZE_RET_ERROR(zeMemAllocShared, zeContext, &DeviceDesc, &HostDesc, Size,
+                      Align, zeDevice, &Mem);
     DP("Allocated a shared memory " DPxMOD "\n", DPxPTR(Mem));
     break;
   default:
@@ -626,8 +639,10 @@ void *MemAllocatorTy::allocL0(size_t Size, size_t Align, int32_t Kind,
   if (makeResident) {
     assert(Device &&
            "Device is not set for memory allocation. Is this a Device Pool?");
-    if (Device->makeMemoryResident(Mem, Size) != OFFLOAD_SUCCESS)
+    if (auto Err = Device->makeMemoryResident(Mem, Size)) {
       Mem = nullptr;
+      return std::move(Err);
+    }
   }
   return Mem;
 }
diff --git a/offload/plugins-nextgen/level_zero/src/L0Program.cpp b/offload/plugins-nextgen/level_zero/src/L0Program.cpp

Original file line number	Diff line number	Diff line change
`@@ -549,7 +549,7 @@ class L0DeviceTy final : public GenericDeviceTy {`
`549`	`549`	`return getDeviceMemAllocator();`
`550`	`550`	`}`
`551`	`551`
`552`		`- int32_t makeMemoryResident(void *Mem, size_t Size);`
	`552`	`+ Error makeMemoryResident(void *Mem, size_t Size);`
`553`	`553`
`554`	`554`	`// Generic device interface implementation`
`555`	`555`	`Expected<DeviceImageTy *>`