push some error checking down

Author: adurang

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

@@ -307,7 +307,7 @@ class MemAllocatorTy {
   bool IsHostMem = false;
   // Internal deallocation function to be called when already
   // hondling the Mtx lock
-  int32_t dealloc_locked(void *Ptr);
+  Error dealloc_locked(void *Ptr);
 
 public:
   MemAllocatorTy() = default;
@@ -337,12 +337,12 @@ class MemAllocatorTy {
   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
-  void *alloc(size_t Size, size_t Align, int32_t Kind, intptr_t Offset,
-              bool UserAlloc, bool DevMalloc, uint32_t MemAdvice,
-              AllocOptionTy AllocOpt);
+  Expected<void *> alloc(size_t Size, size_t Align, int32_t Kind,
+                         intptr_t Offset, bool UserAlloc, bool DevMalloc,
+                         uint32_t MemAdvice, AllocOptionTy AllocOpt);
 
   /// Deallocate memory
-  int32_t dealloc(void *Ptr) {
+  Error dealloc(void *Ptr) {
     std::lock_guard<std::mutex> Lock(Mtx);
     return dealloc_locked(Ptr);
   }

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

@@ -816,7 +816,7 @@ Expected<void *> L0DeviceTy::dataAlloc(size_t Size, size_t Align, int32_t Kind,
 
 Error L0DeviceTy::dataDelete(void *Ptr) {
   auto &Allocator = getMemAllocator(Ptr);
-  return Plugin::check(Allocator.dealloc(Ptr), "Error deleting ptr");
+  return Allocator.dealloc(Ptr);
 }
 
 int32_t L0DeviceTy::makeMemoryResident(void *Mem, size_t Size) {

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

@@ -405,8 +405,11 @@ void MemAllocatorTy::updateMaxAllocSize(L0DeviceTy &L0Device) {
 void MemAllocatorTy::deinit() {
   std::lock_guard<std::mutex> Lock(Mtx);
   // Release RTL-owned memory
-  for (auto *M : MemOwned)
-    dealloc_locked(M);
+  for (auto *M : MemOwned) {
+    auto Err = dealloc_locked(M);
+    if (Err)
+      consumeError(std::move(Err));
+  }
   // Release resources used in the pool
   Pools.clear();
   ReductionPool.reset(nullptr);
@@ -436,9 +439,10 @@ void MemAllocatorTy::deinit() {
 }
 
 /// Allocate memory with the specified information
-void *MemAllocatorTy::alloc(size_t Size, size_t Align, int32_t Kind,
-                            intptr_t Offset, bool UserAlloc, bool DevMalloc,
-                            uint32_t MemAdvice, AllocOptionTy AllocOpt) {
+Expected<void *> MemAllocatorTy::alloc(size_t Size, size_t Align, int32_t Kind,
+                                       intptr_t Offset, bool UserAlloc,
+                                       bool DevMalloc, uint32_t MemAdvice,
+                                       AllocOptionTy AllocOpt) {
   assert((Kind == TARGET_ALLOC_DEVICE || Kind == TARGET_ALLOC_HOST ||
           Kind == TARGET_ALLOC_SHARED) &&
          "Unknown memory kind while allocating target memory");
@@ -503,12 +507,13 @@ void *MemAllocatorTy::alloc(size_t Size, size_t Align, int32_t Kind,
 }
 
 /// Deallocate memory
-int32_t MemAllocatorTy::dealloc_locked(void *Ptr) {
+Error MemAllocatorTy::dealloc_locked(void *Ptr) {
   MemAllocInfoTy Info;
   if (!AllocInfo.remove(Ptr, &Info)) {
-    DP("Error: Cannot find memory allocation information for " DPxMOD "\n",
-       DPxPTR(Ptr));
-    return OFFLOAD_FAIL;
+    return Plugin::error(ErrorCode::BACKEND_FAILURE,
+                         "Cannot find memory allocation information for " DPxMOD
+                         "\n",
+                         DPxPTR(Ptr));
   }
   if (Info.InPool) {
     size_t DeallocSize = 0;
@@ -521,24 +526,27 @@ int32_t MemAllocatorTy::dealloc_locked(void *Ptr) {
       if (DeallocSize == 0)
         DeallocSize = CounterPool->dealloc(Info.Base);
       if (DeallocSize == 0) {
-        DP("Error: Cannot return memory " DPxMOD " to pool\n", DPxPTR(Ptr));
-        return OFFLOAD_FAIL;
+        return Plugin::error(ErrorCode::BACKEND_FAILURE,
+                             "Cannot return memory " DPxMOD " to pool\n",
+                             DPxPTR(Ptr));
       }
     }
     log(0, DeallocSize, Info.Kind, true /* Pool */);
-    return OFFLOAD_SUCCESS;
+    return Plugin::success();
   }
   if (!Info.Base) {
     DP("Error: Cannot find base address of " DPxMOD "\n", DPxPTR(Ptr));
-    return OFFLOAD_FAIL;
+    return Plugin::error(ErrorCode::INVALID_ARGUMENT,
+                         "Cannot find base address of " DPxMOD "\n",
+                         DPxPTR(Ptr));
   }
-  CALL_ZE_RET_FAIL(zeMemFree, L0Context->getZeContext(), Info.Base);
+  CALL_ZE_RET_ERROR(zeMemFree, L0Context->getZeContext(), Info.Base);
   log(0, Info.Size, Info.Kind);
 
   DP("Deleted device memory " DPxMOD " (Base: " DPxMOD ", Size: %zu)\n",
      DPxPTR(Ptr), DPxPTR(Info.Base), Info.Size);
 
-  return OFFLOAD_SUCCESS;
+  return Plugin::success();
 }
 
 int32_t MemAllocatorTy::enqueueMemCopy(void *Dst, const void *Src,