[OpenMP] Make isDone lightweight without calling synchronize

[ye-luo]

Summary

~TaskAsyncInfoWrapperTy() calls isDone. With synchronize inside isDone, we need to handle the error return from synchronize in the destructor.
The consumers of TaskAsyncInfoWrapperTy, targetDataMapper and targetKernel, both call AsyncInfo.synchronize() before exiting.
For this reason in ~TaskAsyncInfoWrapperTy(), calling synchronize() via isDone() is redundant.
This patch removes synchronize() call inside isDone() and makes it a lightweight check.
__tgt_target_nowait_query needs to call synchronize() before checking isDone().

[jhuber6]

The better solution, makes the error patch more explicit and removes a redundant sync. Thanks.

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:
   int synchronize();
 
   /// Return a void* reference with a lifetime that is at least as long as this
   /// 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.
+  /// \note only a lightweight check. If needed, use synchronize() to query the
+  /// status of AsyncInfo before checking.
   ///
   /// \returns true if there is no pending asynchronous operations, false
-  /// otherwise. We return a null value in the case of an error from the plugin.
-  std::optional<bool> isDone();
+  /// otherwise.
+  bool isDone() const;
 
   /// 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)
+  if (const int Rc = AsyncInfo->synchronize())
     FATAL_MESSAGE0(1, "Error while querying the async queue for completion.\n");
   // If there are device operations still pending, return immediately without
   // deallocating the handle and increase the current thread query count.
-  if (!*DoneOrErr) {
+  if (!AsyncInfo->isDone()) {
     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();
 }
 
-std::optional<bool> AsyncInfoTy::isDone() {
-  if (synchronize() == OFFLOAD_FAIL)
-    return std::nullopt;
-
-  // The async info operations are completed when the internal queue is empty.
-  return isQueueEmpty();
-}
+bool AsyncInfoTy::isDone() const { return isQueueEmpty(); }
 
 int32_t AsyncInfoTy::runPostProcessing() {
   size_t Size = PostProcessingFunctions.size();
   for (size_t I = 0; I < Size; ++I) {
     const int Result = PostProcessingFunctions[I]();
     if (Result != OFFLOAD_SUCCESS)
       return Result;
   }

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 querying the async queue for completion.\n");
     // If the are device operations still pending, return immediately without
     // deallocating the handle.
-    if (!*DoneOrErr)
+    if (!AsyncInfo->isDone())
       return;
 
     // Delete the handle and unset it from the OpenMP task data.
     delete AsyncInfo;
     *TaskAsyncInfoPtr = nullptr;
   }
 
   operator AsyncInfoTy &() { return *AsyncInfo; }