Add more error checking

Author: adurang

offload/include/PerThreadTable.h

@@ -14,6 +14,7 @@
 #define OFFLOAD_PERTHREADTABLE_H
 
 #include <list>
+#include <llvm/Support/Error.h>
 #include <memory>
 #include <mutex>
 #include <type_traits>
@@ -204,6 +205,24 @@ template <typename ContainerType, typename ObjectType> struct PerThreadTable {
     }
     ThreadDataList.clear();
   }
+
+  template <class F> llvm::Error deinit(F f) {
+    std::lock_guard<std::mutex> Lock(Mtx);
+    for (auto ThData : ThreadDataList) {
+      if (!ThData->ThEntry || ThData->NElements == 0)
+        continue;
+      for (auto &Obj : *ThData->ThEntry) {
+        if constexpr (is_associative<ContainerType>::value) {
+          if (auto Err = f(Obj.second))
+            return Err;
+        } else {
+          if (auto Err = f(Obj))
+            return Err;
+        }
+      }
+    }
+    return llvm::Error::success();
+  }
 };
 
 template <typename T, typename = std::void_t<>> struct ContainerValueType {

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

@@ -27,14 +27,15 @@ class L0ContextTLSTy {
   auto &getStagingBuffer() { return StagingBuffer; }
   const auto &getStagingBuffer() const { return StagingBuffer; }
 
-  void clear() { StagingBuffer.clear(); }
+  Error deinit() { return StagingBuffer.clear(); }
 };
 
 struct L0ContextTLSTableTy
     : public PerThreadContainer<
           std::unordered_map<ze_context_handle_t, L0ContextTLSTy>> {
-  void clear() {
-    PerThreadTable::clear([](L0ContextTLSTy &Entry) { Entry.clear(); });
+  Error deinit() {
+    return PerThreadTable::deinit(
+        [](L0ContextTLSTy &Entry) -> auto { return Entry.deinit(); });
   }
 };
 

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

@@ -423,55 +423,55 @@ class L0DeviceTy final : public GenericDeviceTy {
 
   // Command queues related functions
   /// Create a command list with given ordinal and flags
-  ze_command_list_handle_t createCmdList(ze_context_handle_t Context,
+  Expected<ze_command_list_handle_t> createCmdList(ze_context_handle_t Context,
                                          ze_device_handle_t Device,
                                          uint32_t Ordinal,
                                          ze_command_list_flags_t Flags,
                                          const std::string_view DeviceIdStr);
 
   /// Create a command list with default flags
-  ze_command_list_handle_t createCmdList(ze_context_handle_t Context,
+  Expected<ze_command_list_handle_t> createCmdList(ze_context_handle_t Context,
                                          ze_device_handle_t Device,
                                          uint32_t Ordinal,
                                          const std::string_view DeviceIdStr);
 
-  ze_command_list_handle_t getCmdList();
+  Expected<ze_command_list_handle_t> getCmdList();
 
   /// Create a command queue with given ordinal and flags
-  ze_command_queue_handle_t createCmdQueue(ze_context_handle_t Context,
+  Expected<ze_command_queue_handle_t> createCmdQueue(ze_context_handle_t Context,
                                            ze_device_handle_t Device,
                                            uint32_t Ordinal, uint32_t Index,
                                            ze_command_queue_flags_t Flags,
                                            const std::string_view DeviceIdStr);
 
   /// Create a command queue with default flags
-  ze_command_queue_handle_t createCmdQueue(ze_context_handle_t Context,
+  Expected<ze_command_queue_handle_t> createCmdQueue(ze_context_handle_t Context,
                                            ze_device_handle_t Device,
                                            uint32_t Ordinal, uint32_t Index,
                                            const std::string_view DeviceIdStr,
                                            bool InOrder = false);
 
   /// Create a new command queue for the given OpenMP device ID
-  ze_command_queue_handle_t createCommandQueue(bool InOrder = false);
+  Expected<ze_command_queue_handle_t> createCommandQueue(bool InOrder = false);
 
   /// Create an immediate command list
-  ze_command_list_handle_t createImmCmdList(uint32_t Ordinal, uint32_t Index,
+  Expected<ze_command_list_handle_t> createImmCmdList(uint32_t Ordinal, uint32_t Index,
                                             bool InOrder = false);
 
   /// Create an immediate command list for computing
-  ze_command_list_handle_t createImmCmdList(bool InOrder = false) {
+  Expected<ze_command_list_handle_t> createImmCmdList(bool InOrder = false) {
     return createImmCmdList(getComputeEngine(), getComputeIndex(), InOrder);
   }
 
   /// Create an immediate command list for copying
-  ze_command_list_handle_t createImmCopyCmdList();
-  ze_command_queue_handle_t getCmdQueue();
-  ze_command_list_handle_t getCopyCmdList();
-  ze_command_queue_handle_t getCopyCmdQueue();
-  ze_command_list_handle_t getLinkCopyCmdList();
-  ze_command_queue_handle_t getLinkCopyCmdQueue();
-  ze_command_list_handle_t getImmCmdList();
-  ze_command_list_handle_t getImmCopyCmdList();
+  Expected<ze_command_list_handle_t> createImmCopyCmdList();
+  Expected<ze_command_queue_handle_t> getCmdQueue();
+  Expected<ze_command_list_handle_t> getCopyCmdList();
+  Expected<ze_command_queue_handle_t> getCopyCmdQueue();
+  Expected<ze_command_list_handle_t> getLinkCopyCmdList();
+  Expected<ze_command_queue_handle_t> getLinkCopyCmdQueue();
+  Expected<ze_command_list_handle_t> getImmCmdList();
+  Expected<ze_command_list_handle_t> getImmCopyCmdList();
 
   /// Enqueue copy command
   Error enqueueMemCopy(void *Dst, const void *Src, size_t Size,

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

@@ -502,13 +502,13 @@ class StagingBufferTy {
   /// Next buffer location in the buffers
   size_t Offset = 0;
 
-  void *addBuffers() {
+  Expected<void *> addBuffers() {
     ze_host_mem_alloc_desc_t AllocDesc{ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC,
                                        nullptr, 0};
     void *Ret = nullptr;
     size_t AllocSize = Size * Count;
-    CALL_ZE_RET_NULL(zeMemAllocHost, Context, &AllocDesc, AllocSize,
-                     L0DefaultAlignment, &Ret);
+    CALL_ZE_RET_ERROR(zeMemAllocHost, Context, &AllocDesc, AllocSize,
+                      L0DefaultAlignment, &Ret);
     Buffers.push_back(Ret);
     return Ret;
   }
@@ -522,12 +522,13 @@ class StagingBufferTy {
 
   ~StagingBufferTy() {}
 
-  void clear() {
+  Error clear() {
     ze_result_t Rc;
     (void)Rc; // GCC build compiler thinks Rc is unused for some reason.
     for (auto Ptr : Buffers)
-      CALL_ZE(Rc, zeMemFree, Context, Ptr);
+      CALL_ZE_RET_ERROR(zeMemFree, Context, Ptr);
     Context = nullptr;
+    return Plugin::success();
   }
 
   bool initialized() const { return Context != nullptr; }
@@ -541,23 +542,26 @@ class StagingBufferTy {
   void reset() { Offset = 0; }
 
   /// Always return the first buffer
-  void *get() {
+  Expected<void *> get() {
     if (Size == 0 || Count == 0)
       return nullptr;
     return Buffers.empty() ? addBuffers() : Buffers.front();
   }
 
   /// Return the next available buffer
-  void *getNext() {
+  Expected<void *> getNext() {
     void *Ret = nullptr;
     if (Size == 0 || Count == 0)
       return Ret;
 
     size_t AllocSize = Size * Count;
     bool NeedToGrow = Buffers.empty() || Offset >= Buffers.size() * AllocSize;
-    if (NeedToGrow)
-      Ret = addBuffers();
-    else
+    if (NeedToGrow) {
+      auto PtrOrErr = addBuffers();
+      if (!PtrOrErr)
+        return PtrOrErr.takeError();
+      Ret = *PtrOrErr;
+    } else
       Ret = reinterpret_cast<void *>(
           reinterpret_cast<uintptr_t>(Buffers.back()) + (Offset % AllocSize));
 
@@ -569,7 +573,7 @@ class StagingBufferTy {
   }
 
   /// Return either a fixed buffer or next buffer
-  void *get(bool Next) { return Next ? getNext() : get(); }
+  Expected<void *> get(bool Next) { return Next ? getNext() : get(); }
 };
 
 } // namespace llvm::omp::target::plugin