[OpenMP] Make `__tgt_async_info` a RAII object

[jdoerfert]

Summary

The AsyncInfo should be passed everywhere and it should automatically
ensure synchronization. To this end we make it a RAII object that will
synchronize at the end of its lifetime as necessary.

[tianshilei1992]

If we want to use event later for target task, this design needs to be revised because the life time of the async info object will be out of its scope.

[jdoerfert]

I will abandon this. We probably are fine with synchronizing explicitly given that we want to look at the return status anyway.

In D96431#2554464, @tianshilei1992 wrote:

If we want to use event later for target task, this design needs to be revised because the life time of the async info object will be out of its scope.

openmp/libomptarget/include/omptarget.h

 
 /// This struct contains the offload entries identified by the target runtime
 struct __tgt_target_table {
   __tgt_offload_entry *EntriesBegin; // Begin of the table with all the entries
   __tgt_offload_entry
       *EntriesEnd; // End of the table with all the entries (non inclusive)
 };
 
+struct DeviceTy;
+
 /// This struct contains information exchanged between different asynchronous
 /// operations for device-dependent optimization and potential synchronization
 struct __tgt_async_info {
-  // A pointer to a queue-like structure where offloading operations are issued.
-  // We assume to use this structure to do synchronization. In CUDA backend, it
-  // is CUstream.
+  __tgt_async_info(DeviceTy &Device) :Device(Device) {}
+
+  /// The destructor ensures synchronization.
+  ~__tgt_async_info() { synchronize(); }
+
+  /// Synchronize the queue, if necessary, and resets it to indicate no pending actions.
+  ///
+  /// \returns OFFLOAD_FAIL or OFFLOAD_SUCCESS appropriately.
+  int synchronize();
+
+  /// The device this object was created for.
+  DeviceTy &Device;
+
+  /// A pointer to a queue-like structure where offloading operations are issued.
+  /// We assume to use this structure to do synchronization. In CUDA backend, it
+  /// is CUstream. If it is a nullptr there are no pending actions that are not
+  /// synchronized yet.
   void *Queue = nullptr;
 };
 
 /// This struct is a record of non-contiguous information
 struct __tgt_target_non_contig {
   uint64_t Offset;
   uint64_t Count;
   uint64_t Stride;

openmp/libomptarget/src/omptarget.cpp

 #include "omptarget.h"
 #include "device.h"
 #include "private.h"
 #include "rtl.h"
 
 #include <cassert>
 #include <vector>
 
+int __tgt_async_info::synchronize() {
+  int Result = OFFLOAD_SUCCESS;
+  if (Queue) {
+    // If we have a queue we need to synchronize it now. As it is synchronized
+    // afterwards we can get rid of the queue indicating no pending actions.
+    Result = Device.synchronize(this);
+    Queue = nullptr;
+  }
+  return Result;
+}
+
 /* All begin addresses for partially mapped structs must be 8-aligned in order
  * to ensure proper alignment of members. E.g.
  *
  * struct S {
  *   int a;   // 4-aligned
  *   int b;   // 4-aligned
  *   int *p;  // 8-aligned
  * } s1;
struct DeallocTgtPtrInfo {
   /// Whether it has \p close modifier
   bool HasCloseModifier;
 
   DeallocTgtPtrInfo(void *HstPtr, int64_t Size, bool ForceDelete,
                     bool HasCloseModifier)
       : HstPtrBegin(HstPtr), DataSize(Size), ForceDelete(ForceDelete),
         HasCloseModifier(HasCloseModifier) {}
 };
-
-/// Synchronize device
-static int syncDevice(DeviceTy &Device, __tgt_async_info *AsyncInfo) {
-  assert(AsyncInfo && AsyncInfo->Queue && "Invalid AsyncInfo");
-  if (Device.synchronize(AsyncInfo) != OFFLOAD_SUCCESS) {
-    REPORT("Failed to synchronize device.\n");
-    return OFFLOAD_FAIL;
-  }
-
-  return OFFLOAD_SUCCESS;
-}
 } // namespace
 
 /// Internal function to undo the mapping and retrieve the data from the device.
 int targetDataEnd(ident_t *loc, DeviceTy &Device, int32_t ArgNum,
                   void **ArgBases, void **Args, int64_t *ArgSizes,
                   int64_t *ArgTypes, map_var_info_t *ArgNames,
                   void **ArgMappers, __tgt_async_info *AsyncInfo) {
   int Ret;
int targetDataEnd(ident_t *loc, DeviceTy &Device, int32_t ArgNum,
   }
 
   // We need to synchronize before deallocating data.
   // If AsyncInfo is nullptr, the previous data transfer (if has) will be
   // synchronous, so we don't need to synchronize again. If AsyncInfo->Queue is
   // nullptr, there is no data transfer happened because once there is,
   // AsyncInfo->Queue will not be nullptr, so again, we don't need to
   // synchronize.
-  if (AsyncInfo && AsyncInfo->Queue) {
-    Ret = syncDevice(Device, AsyncInfo);
+  if (AsyncInfo) {
+    Ret = AsyncInfo->synchronize();
     if (Ret != OFFLOAD_SUCCESS)
       return OFFLOAD_FAIL;
   }
 
   // Deallocate target pointer
   for (DeallocTgtPtrInfo &Info : DeallocTgtPtrs) {
     Ret = Device.deallocTgtPtr(Info.HstPtrBegin, Info.DataSize,
                                Info.ForceDelete, Info.HasCloseModifier);
__tgt_target_table *TargetTable = nullptr;
     assert(TM->Table->TargetsTable.size() > (size_t)DeviceId &&
            "Not expecting a device ID outside the table's bounds!");
     TargetTable = TM->Table->TargetsTable[DeviceId];
   }
   assert(TargetTable && "Global data has not been mapped\n");
 
   // TODO: This will go away as soon as we consequently pass in async info
   // objects (as references).
-  __tgt_async_info InternalAsyncInfo;
+  __tgt_async_info InternalAsyncInfo(Device);
   if (!AsyncInfo)
     AsyncInfo = &InternalAsyncInfo;
 
   std::vector<void *> TgtArgs;
   std::vector<ptrdiff_t> TgtOffsets;
 
   PrivateArgumentManagerTy PrivateArgumentManager(Device, AsyncInfo);
 
if (ArgNum) {
     // variables
     Ret = processDataAfter(loc, DeviceId, HostPtr, ArgNum, ArgBases, Args,
                            ArgSizes, ArgTypes, ArgNames, ArgMappers,
                            PrivateArgumentManager, AsyncInfo);
     if (Ret != OFFLOAD_SUCCESS) {
       REPORT("Failed to process data after launching the kernel.\n");
       return OFFLOAD_FAIL;
     }
-  } else if (AsyncInfo->Queue) {
-    // If ArgNum is zero, but AsyncInfo.Queue is valid, then the kernel doesn't
-    // hava any argument, and the device supports async operations, so we need a
-    // sync at this point.
-    return syncDevice(Device, AsyncInfo);
   }
 
   return OFFLOAD_SUCCESS;
 }