[Libomptarget] Check errors when synchronizing the async queue

[jhuber6]

Summary

Currently when we synchronize the asynchronous queue for the plugins, we
ignore the return value. This is problematic because we will continue on
like nothing happened if the kernel fails.

Fixes https://github.com/llvm/llvm-project/issues/60814

[jdoerfert]

LG, one nit.

openmp/libomptarget/include/omptarget.h

250–251

docs plz

[jhuber6]

Add line for the error.

[ye-luo]

openmp/libomptarget/src/interface.cpp

415

Prefer DoneStatusOrError. Unclear how DoneOrErr encapsulate NotDones state.

416

if (!DoneOrErr.has_value()) can be more readable.

openmp/libomptarget/src/omptarget.cpp

55

synchronize returns OFFLOAD_SUCCESS which has value 0.
quite hard to get through this logic by just reading the above line.
Why not

if (synchronize() == OFFLOAD_SUCCESS)
  return isQueueEmpty();
return std::nullopt;

[ye-luo]

openmp/libomptarget/src/interface.cpp

415

Changed my mind. Shorter name is fine.

openmp/libomptarget/src/omptarget.cpp

55

Got unhappy GNU.

/home/yeluo/opt/llvm-clang/llvm-project/openmp/libomptarget/src/omptarget.cpp: In member function 'std::optional<bool> AsyncInfoTy::isDone()':
/home/yeluo/opt/llvm-clang/llvm-project/openmp/libomptarget/src/omptarget.cpp:55:11: warning: unused variable 'Result' [-Wunused-variable]
   55 |   if (int Result = synchronize())

openmp/libomptarget/src/private.h

255

This message confused me "Error while query the async queue completion.\n"

openmp/libomptarget/include/omptarget.h

 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_H_
 #define _OMPTARGET_H_
 
 #include <cstdint>
 #include <deque>
 #include <functional>
+#include <optional>
 #include <stddef.h>
 #include <stdint.h>
 #include <type_traits>
 
 #include <SourceInfo.h>
 
 #include "llvm/ADT/SmallVector.h"
 
public:
   /// AsyncInfoTy object. The location can be used as intermediate buffer.
   void *&getVoidPtrLocation();
 
   /// Check if all asynchronous operations are completed.
   ///
   /// \note if the operations are completed, the registered post-processing
   /// functions will be executed once and unregistered afterwards.
   ///
   /// \returns true if there is no pending asynchronous operations, false
-  /// otherwise.
-  bool isDone();
+  /// otherwise. We return a null value in the case of an error from the plugin.
+  std::optional<bool> isDone();
 
   /// Add a new post-processing function to be executed after synchronization.
   ///
   /// \param[in] Function is a templated function (e.g., function pointers,
   /// lambdas, std::function) that can be convertible to a PostProcFuncTy (i.e.,
   /// it must have int() as its function signature).
   template <typename FuncTy> void addPostProcessingFunction(FuncTy &&Function) {
     static_assert(std::is_convertible_v<FuncTy, PostProcFuncTy>,

openmp/libomptarget/src/interface.cpp

EXTERN void __tgt_target_nowait_query(void **AsyncHandle) {
 
   auto *AsyncInfo = (AsyncInfoTy *)*AsyncHandle;
 
   // If the thread is actively waiting on too many target nowait regions, we
   // should use the blocking sync type.
   if (QueryCounter.isAboveThreshold())
     AsyncInfo->SyncType = AsyncInfoTy::SyncTy::BLOCKING;
 
+  auto DoneOrErr = AsyncInfo->isDone();
+  if (!DoneOrErr)
+    FATAL_MESSAGE0(1, "Error while synchronizing the async queue\n");
   // If there are device operations still pending, return immediately without
   // deallocating the handle and increase the current thread query count.
-  if (!AsyncInfo->isDone()) {
+  if (!*DoneOrErr) {
     QueryCounter.increment();
     return;
   }
 
   // When a thread successfully completes a target nowait region, we
   // exponentially backoff its query counter by the query factor.
   QueryCounter.decrement();
 
   // Delete the handle and unset it from the OpenMP task data.
   delete AsyncInfo;
   *AsyncHandle = nullptr;
 }

openmp/libomptarget/src/omptarget.cpp

int AsyncInfoTy::synchronize() {
   return Result;
 }
 
 void *&AsyncInfoTy::getVoidPtrLocation() {
   BufferLocations.push_back(nullptr);
   return BufferLocations.back();
 }
 
-bool AsyncInfoTy::isDone() {
-  synchronize();
+std::optional<bool> AsyncInfoTy::isDone() {
+  if (int Result = synchronize())
+    return std::nullopt;
+
   // The async info operations are completed when the internal queue is empty.
   return isQueueEmpty();
 }
 
 int32_t AsyncInfoTy::runPostProcessing() {
   size_t Size = PostProcessingFunctions.size();
   for (size_t I = 0; I < Size; ++I) {
     const int Result = PostProcessingFunctions[I]();

openmp/libomptarget/src/private.h

TaskAsyncInfoWrapperTy(DeviceTy &Device)
     *TaskAsyncInfoPtr = (void *)AsyncInfo;
   }
 
   ~TaskAsyncInfoWrapperTy() {
     // Local async info destruction is automatically handled by ~AsyncInfoTy.
     if (AsyncInfo == &LocalAsyncInfo)
       return;
 
+    auto DoneOrErr = AsyncInfo->isDone();
+    if (!DoneOrErr)
+      FATAL_MESSAGE0(1, "Error while synchronizing the async queue\n");
     // If the are device operations still pending, return immediately without
     // deallocating the handle.
-    if (!AsyncInfo->isDone())
+    if (!*DoneOrErr)
       return;
 
     // Delete the handle and unset it from the OpenMP task data.
     delete AsyncInfo;
     *TaskAsyncInfoPtr = nullptr;
   }
 
   operator AsyncInfoTy &() { return *AsyncInfo; }