[OpenMP][NFC] Use `AsyncInfo` as the variable name for a `__tgt_async_info`

[tianshilei1992]

LG with one nit.

openmp/libomptarget/plugins/cuda/src/rtl.cpp

1203

These functions are C interfaces. Do we want to use C style here?

[jdoerfert]

openmp/libomptarget/plugins/cuda/src/rtl.cpp

1203

Because sed apparently doesn't distinguish. I try to manually go through and adjust before committing.

[jdoerfert]

Keep "C spelling" for C-interfaces and only modify the internal C++ code.

[grokos]

NFC patch, naming in line with the rest of the library, good to go.

[rogfer01]

openmp/libomptarget/plugins/remote/server/Server.cpp

167

I don't think this is caused by this patch, but I'm unable to build this using clang trunk (I'm building openmp as a runtime).

/work/llvm-src/openmp/libomptarget/plugins/remote/server/Server.cpp:169:9: error: non-const lvalue reference to type 'AsyncInfoTy' cannot bind to a temporary of type '__tgt_async_info *'
        (__tgt_async_info *)AsyncInfo));
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/work/llvm-src/openmp/libomptarget/src/device.h:223:36: note: passing argument to parameter 'AsyncInfo' here
  int32_t synchronize(AsyncInfoTy &AsyncInfo);
                                   ^

Has anyone else run into this? What version of clang (or gcc?) do you commonly use to build this code? Thanks!

[jdoerfert]

openmp/libomptarget/plugins/remote/server/Server.cpp

167

@atmnpatel was looking into this. I forgot to rename that part.

openmp/libomptarget/include/omptargetplugin.h

 void *__tgt_rtl_data_alloc(int32_t ID, int64_t Size, void *HostPtr);
 
 // Pass the data content to the target device using the target address. In case
 // of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_submit(int32_t ID, void *TargetPtr, void *HostPtr,
                               int64_t Size);
 
 int32_t __tgt_rtl_data_submit_async(int32_t ID, void *TargetPtr, void *HostPtr,
-                                    int64_t Size,
-                                    __tgt_async_info *AsyncInfoPtr);
+                                    int64_t Size, __tgt_async_info *AsyncInfo);
 
 // Retrieve the data content from the target device using its address. In case
 // of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_retrieve(int32_t ID, void *HostPtr, void *TargetPtr,
                                 int64_t Size);
 
 // Asynchronous version of __tgt_rtl_data_retrieve
 int32_t __tgt_rtl_data_retrieve_async(int32_t ID, void *HostPtr,
                                       void *TargetPtr, int64_t Size,
-                                      __tgt_async_info *AsyncInfoPtr);
+                                      __tgt_async_info *AsyncInfo);
 
 // Copy the data content from one target device to another target device using
 // its address. This operation does not need to copy data back to host and then
 // from host to another device. In case of success, return zero. Otherwise,
 // return an error code.
 int32_t __tgt_rtl_data_exchange(int32_t SrcID, void *SrcPtr, int32_t DstID,
                                 void *DstPtr, int64_t Size);
 
 // Asynchronous version of __tgt_rtl_data_exchange
 int32_t __tgt_rtl_data_exchange_async(int32_t SrcID, void *SrcPtr,
                                       int32_t DesID, void *DstPtr, int64_t Size,
-                                      __tgt_async_info *AsyncInfoPtr);
+                                      __tgt_async_info *AsyncInfo);
 
 // De-allocate the data referenced by target ptr on the device. In case of
 // success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_delete(int32_t ID, void *TargetPtr);
 
 // Transfer control to the offloaded entry Entry on the target device.
 // Args and Offsets are arrays of NumArgs size of target addresses and
 // offsets. An offset should be added to the target address before passing it
-// to the outlined function on device side. If AsyncInfoPtr is nullptr, it is
-// synchronous; otherwise it is asynchronous. However, AsyncInfoPtr may be
+// to the outlined function on device side. If AsyncInfo is nullptr, it is
+// synchronous; otherwise it is asynchronous. However, AsyncInfo may be
 // ignored on some platforms, like x86_64. In that case, it is synchronous. In
 // case of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_run_target_region(int32_t ID, void *Entry, void **Args,
                                     ptrdiff_t *Offsets, int32_t NumArgs);
 
 // Asynchronous version of __tgt_rtl_run_target_region
 int32_t __tgt_rtl_run_target_region_async(int32_t ID, void *Entry, void **Args,
                                           ptrdiff_t *Offsets, int32_t NumArgs,
-                                          __tgt_async_info *AsyncInfoPtr);
+                                          __tgt_async_info *AsyncInfo);
 
 // Similar to __tgt_rtl_run_target_region, but additionally specify the
 // number of teams to be created and a number of threads in each team. If
-// AsyncInfoPtr is nullptr, it is synchronous; otherwise it is asynchronous.
-// However, AsyncInfoPtr may be ignored on some platforms, like x86_64. In that
+// AsyncInfo is nullptr, it is synchronous; otherwise it is asynchronous.
+// However, AsyncInfo may be ignored on some platforms, like x86_64. In that
 // case, it is synchronous.
 int32_t __tgt_rtl_run_target_team_region(int32_t ID, void *Entry, void **Args,
                                          ptrdiff_t *Offsets, int32_t NumArgs,
                                          int32_t NumTeams, int32_t ThreadLimit,
                                          uint64_t loop_tripcount);
 
 // Asynchronous version of __tgt_rtl_run_target_team_region
 int32_t __tgt_rtl_run_target_team_region_async(
     int32_t ID, void *Entry, void **Args, ptrdiff_t *Offsets, int32_t NumArgs,
     int32_t NumTeams, int32_t ThreadLimit, uint64_t loop_tripcount,
-    __tgt_async_info *AsyncInfoPtr);
+    __tgt_async_info *AsyncInfo);
 
 // Device synchronization. In case of success, return zero. Otherwise, return an
 // error code.
-int32_t __tgt_rtl_synchronize(int32_t ID, __tgt_async_info *AsyncInfoPtr);
+int32_t __tgt_rtl_synchronize(int32_t ID, __tgt_async_info *AsyncInfo);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // _OMPTARGETPLUGIN_H_

openmp/libomptarget/plugins/amdgpu/src/rtl.cpp

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <dlfcn.h>
 #include <elf.h>
 #include <ffi.h>
 #include <fstream>
 #include <iostream>
 #include <libelf.h>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <shared_mutex>
 #include <thread>
 #include <unordered_map>
 #include <vector>
 
struct omptarget_device_environmentTy {
   int32_t device_num;  // gets a value 0 to num_devices-1
 };
 
 static RTLDeviceInfoTy DeviceInfo;
 
 namespace {
 
 int32_t dataRetrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr, int64_t Size,
-                     __tgt_async_info *AsyncInfoPtr) {
-  assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+                     __tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo && "AsyncInfo is nullptr");
   assert(DeviceId < DeviceInfo.NumberOfDevices && "Device ID too large");
   // Return success if we are not copying back to host from target.
   if (!HstPtr)
     return OFFLOAD_SUCCESS;
   atmi_status_t err;
   DP("Retrieve data %ld bytes, (tgt:%016llx) -> (hst:%016llx).\n", Size,
      (long long unsigned)(Elf64_Addr)TgtPtr,
      (long long unsigned)(Elf64_Addr)HstPtr);
int32_t dataRetrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr, int64_t Size,
   }
   DP("DONE Retrieve data %ld bytes, (tgt:%016llx) -> (hst:%016llx).\n", Size,
      (long long unsigned)(Elf64_Addr)TgtPtr,
      (long long unsigned)(Elf64_Addr)HstPtr);
   return OFFLOAD_SUCCESS;
 }
 
 int32_t dataSubmit(int32_t DeviceId, void *TgtPtr, void *HstPtr, int64_t Size,
-                   __tgt_async_info *AsyncInfoPtr) {
-  assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+                   __tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo && "AsyncInfo is nullptr");
   atmi_status_t err;
   assert(DeviceId < DeviceInfo.NumberOfDevices && "Device ID too large");
   // Return success if we are not doing host to target.
   if (!HstPtr)
     return OFFLOAD_SUCCESS;
 
   DP("Submit data %ld bytes, (hst:%016llx) -> (tgt:%016llx).\n", Size,
      (long long unsigned)(Elf64_Addr)HstPtr,

 // of N data_submit_async calls are expected to execute serially. HSA offers
 // various options to run the data copies concurrently. This may require changes
 // to libomptarget.
 
 // __tgt_async_info* contains a void * Queue. Queue = 0 is used to indicate that
 // there are no outstanding kernels that need to be synchronized. Any async call
 // may be passed a Queue==0, at which point the cuda implementation will set it
 // to non-null (see getStream). The cuda streams are per-device. Upstream may
-// change this interface to explicitly initialize the async_info_pointer, but
+// change this interface to explicitly initialize the AsyncInfo_pointer, but
 // until then hsa lazily initializes it as well.
 
-void initAsyncInfoPtr(__tgt_async_info *async_info_ptr) {
+void initAsyncInfo(__tgt_async_info *AsyncInfo) {
   // set non-null while using async calls, return to null to indicate completion
-  assert(async_info_ptr);
-  if (!async_info_ptr->Queue) {
-    async_info_ptr->Queue = reinterpret_cast<void *>(UINT64_MAX);
+  assert(AsyncInfo);
+  if (!AsyncInfo->Queue) {
+    AsyncInfo->Queue = reinterpret_cast<void *>(UINT64_MAX);
   }
 }
-void finiAsyncInfoPtr(__tgt_async_info *async_info_ptr) {
-  assert(async_info_ptr);
-  assert(async_info_ptr->Queue);
-  async_info_ptr->Queue = 0;
+void finiAsyncInfo(__tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo);
+  assert(AsyncInfo->Queue);
+  AsyncInfo->Queue = 0;
 }
 
 bool elf_machine_id_is_amdgcn(__tgt_device_image *image) {
   const uint16_t amdgcnMachineID = 224; // EM_AMDGPU may not be in system elf.h
   int32_t r = elf_check_machine(image, amdgcnMachineID);
   if (!r) {
     DP("Supported machine ID not found\n");
   }
DP("Tgt alloc data %ld bytes, (tgt:%016llx).\n", size,
      (long long unsigned)(Elf64_Addr)ptr);
   ptr = (err == ATMI_STATUS_SUCCESS) ? ptr : NULL;
   return ptr;
 }
 
 int32_t __tgt_rtl_data_submit(int device_id, void *tgt_ptr, void *hst_ptr,
                               int64_t size) {
   assert(device_id < DeviceInfo.NumberOfDevices && "Device ID too large");
-  __tgt_async_info async_info;
-  int32_t rc = dataSubmit(device_id, tgt_ptr, hst_ptr, size, &async_info);
+  __tgt_async_info AsyncInfo;
+  int32_t rc = dataSubmit(device_id, tgt_ptr, hst_ptr, size, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_submit_async(int device_id, void *tgt_ptr, void *hst_ptr,
-                                    int64_t size,
-                                    __tgt_async_info *async_info_ptr) {
+                                    int64_t size, __tgt_async_info *AsyncInfo) {
   assert(device_id < DeviceInfo.NumberOfDevices && "Device ID too large");
-  if (async_info_ptr) {
-    initAsyncInfoPtr(async_info_ptr);
-    return dataSubmit(device_id, tgt_ptr, hst_ptr, size, async_info_ptr);
+  if (AsyncInfo) {
+    initAsyncInfo(AsyncInfo);
+    return dataSubmit(device_id, tgt_ptr, hst_ptr, size, AsyncInfo);
   } else {
     return __tgt_rtl_data_submit(device_id, tgt_ptr, hst_ptr, size);
   }
 }
 
 int32_t __tgt_rtl_data_retrieve(int device_id, void *hst_ptr, void *tgt_ptr,
                                 int64_t size) {
   assert(device_id < DeviceInfo.NumberOfDevices && "Device ID too large");
-  __tgt_async_info async_info;
-  int32_t rc = dataRetrieve(device_id, hst_ptr, tgt_ptr, size, &async_info);
+  __tgt_async_info AsyncInfo;
+  int32_t rc = dataRetrieve(device_id, hst_ptr, tgt_ptr, size, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_retrieve_async(int device_id, void *hst_ptr,
                                       void *tgt_ptr, int64_t size,
-                                      __tgt_async_info *async_info_ptr) {
-  assert(async_info_ptr && "async_info is nullptr");
+                                      __tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo && "AsyncInfo is nullptr");
   assert(device_id < DeviceInfo.NumberOfDevices && "Device ID too large");
-  initAsyncInfoPtr(async_info_ptr);
-  return dataRetrieve(device_id, hst_ptr, tgt_ptr, size, async_info_ptr);
+  initAsyncInfo(AsyncInfo);
+  return dataRetrieve(device_id, hst_ptr, tgt_ptr, size, AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_delete(int device_id, void *tgt_ptr) {
   assert(device_id < DeviceInfo.NumberOfDevices && "Device ID too large");
   atmi_status_t err;
   DP("Tgt free data (tgt:%016llx).\n", (long long unsigned)(Elf64_Addr)tgt_ptr);
   err = atmi_free(tgt_ptr);
   if (err != ATMI_STATUS_SUCCESS) {
return __tgt_rtl_run_target_team_region(device_id, tgt_entry_ptr, tgt_args,
                                           tgt_offsets, arg_num, team_num,
                                           thread_limit, 0);
 }
 
 int32_t __tgt_rtl_run_target_region_async(int32_t device_id,
                                           void *tgt_entry_ptr, void **tgt_args,
                                           ptrdiff_t *tgt_offsets,
                                           int32_t arg_num,
-                                          __tgt_async_info *async_info_ptr) {
-  assert(async_info_ptr && "async_info is nullptr");
-  initAsyncInfoPtr(async_info_ptr);
+                                          __tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo && "AsyncInfo is nullptr");
+  initAsyncInfo(AsyncInfo);
 
   // use one team and one thread
   // fix thread num
   int32_t team_num = 1;
   int32_t thread_limit = 0; // use default
   return __tgt_rtl_run_target_team_region(device_id, tgt_entry_ptr, tgt_args,
                                           tgt_offsets, arg_num, team_num,
                                           thread_limit, 0);
 }
 
-int32_t __tgt_rtl_synchronize(int32_t device_id,
-                              __tgt_async_info *async_info_ptr) {
-  assert(async_info_ptr && "async_info is nullptr");
+int32_t __tgt_rtl_synchronize(int32_t device_id, __tgt_async_info *AsyncInfo) {
+  assert(AsyncInfo && "AsyncInfo is nullptr");
 
-  // Cuda asserts that async_info_ptr->Queue is non-null, but this invariant
+  // Cuda asserts that AsyncInfo->Queue is non-null, but this invariant
   // is not ensured by devices.cpp for amdgcn
-  // assert(async_info_ptr->Queue && "async_info_ptr->Queue is nullptr");
-  if (async_info_ptr->Queue) {
-    finiAsyncInfoPtr(async_info_ptr);
+  // assert(AsyncInfo->Queue && "AsyncInfo->Queue is nullptr");
+  if (AsyncInfo->Queue) {
+    finiAsyncInfo(AsyncInfo);
   }
   return OFFLOAD_SUCCESS;
 }

openmp/libomptarget/plugins/cuda/src/rtl.cpp

 //===----RTLs/cuda/src/rtl.cpp - Target RTLs Implementation ------- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RTL for CUDA machine
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstddef>
 #include <cuda.h>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
class DeviceRTLTy {
   // Clear entries table for a device
   void clearOffloadEntriesTable(const int DeviceId) {
     DeviceData[DeviceId].FuncGblEntries.emplace_back();
     FuncOrGblEntryTy &E = DeviceData[DeviceId].FuncGblEntries.back();
     E.Entries.clear();
     E.Table.EntriesBegin = E.Table.EntriesEnd = nullptr;
   }
 
-  CUstream getStream(const int DeviceId, __tgt_async_info *AsyncInfoPtr) const {
-    assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+  CUstream getStream(const int DeviceId, __tgt_async_info *AsyncInfo) const {
+    assert(AsyncInfo && "AsyncInfo is nullptr");
 
-    if (!AsyncInfoPtr->Queue)
-      AsyncInfoPtr->Queue = StreamManager->getStream(DeviceId);
+    if (!AsyncInfo->Queue)
+      AsyncInfo->Queue = StreamManager->getStream(DeviceId);
 
-    return reinterpret_cast<CUstream>(AsyncInfoPtr->Queue);
+    return reinterpret_cast<CUstream>(AsyncInfo->Queue);
   }
 
 public:
   // This class should not be copied
   DeviceRTLTy(const DeviceRTLTy &) = delete;
   DeviceRTLTy(DeviceRTLTy &&) = delete;
 
   DeviceRTLTy()
#endif
   void *dataAlloc(const int DeviceId, const int64_t Size) {
     if (UseMemoryManager)
       return MemoryManagers[DeviceId]->allocate(Size, nullptr);
 
     return DeviceAllocators[DeviceId].allocate(Size, nullptr);
   }
 
   int dataSubmit(const int DeviceId, const void *TgtPtr, const void *HstPtr,
-                 const int64_t Size, __tgt_async_info *AsyncInfoPtr) const {
-    assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+                 const int64_t Size, __tgt_async_info *AsyncInfo) const {
+    assert(AsyncInfo && "AsyncInfo is nullptr");
 
     CUresult Err = cuCtxSetCurrent(DeviceData[DeviceId].Context);
     if (!checkResult(Err, "Error returned from cuCtxSetCurrent\n"))
       return OFFLOAD_FAIL;
 
-    CUstream Stream = getStream(DeviceId, AsyncInfoPtr);
+    CUstream Stream = getStream(DeviceId, AsyncInfo);
 
     Err = cuMemcpyHtoDAsync((CUdeviceptr)TgtPtr, HstPtr, Size, Stream);
     if (Err != CUDA_SUCCESS) {
       REPORT("Error when copying data from host to device. Pointers: host "
              "= " DPxMOD ", device = " DPxMOD ", size = %" PRId64 "\n",
              DPxPTR(HstPtr), DPxPTR(TgtPtr), Size);
       CUDA_ERR_STRING(Err);
       return OFFLOAD_FAIL;
     }
 
     return OFFLOAD_SUCCESS;
   }
 
   int dataRetrieve(const int DeviceId, void *HstPtr, const void *TgtPtr,
-                   const int64_t Size, __tgt_async_info *AsyncInfoPtr) const {
-    assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+                   const int64_t Size, __tgt_async_info *AsyncInfo) const {
+    assert(AsyncInfo && "AsyncInfo is nullptr");
 
     CUresult Err = cuCtxSetCurrent(DeviceData[DeviceId].Context);
     if (!checkResult(Err, "Error returned from cuCtxSetCurrent\n"))
       return OFFLOAD_FAIL;
 
-    CUstream Stream = getStream(DeviceId, AsyncInfoPtr);
+    CUstream Stream = getStream(DeviceId, AsyncInfo);
 
     Err = cuMemcpyDtoHAsync(HstPtr, (CUdeviceptr)TgtPtr, Size, Stream);
     if (Err != CUDA_SUCCESS) {
       REPORT("Error when copying data from device to host. Pointers: host "
              "= " DPxMOD ", device = " DPxMOD ", size = %" PRId64 "\n",
              DPxPTR(HstPtr), DPxPTR(TgtPtr), Size);
       CUDA_ERR_STRING(Err);
       return OFFLOAD_FAIL;
     }
 
     return OFFLOAD_SUCCESS;
   }
 
   int dataExchange(int SrcDevId, const void *SrcPtr, int DstDevId, void *DstPtr,
-                   int64_t Size, __tgt_async_info *AsyncInfoPtr) const {
-    assert(AsyncInfoPtr && "AsyncInfoPtr is nullptr");
+                   int64_t Size, __tgt_async_info *AsyncInfo) const {
+    assert(AsyncInfo && "AsyncInfo is nullptr");
 
     CUresult Err = cuCtxSetCurrent(DeviceData[SrcDevId].Context);
     if (!checkResult(Err, "Error returned from cuCtxSetCurrent\n"))
       return OFFLOAD_FAIL;
 
-    CUstream Stream = getStream(SrcDevId, AsyncInfoPtr);
+    CUstream Stream = getStream(SrcDevId, AsyncInfo);
 
     // If they are two devices, we try peer to peer copy first
     if (SrcDevId != DstDevId) {
       int CanAccessPeer = 0;
       Err = cuDeviceCanAccessPeer(&CanAccessPeer, SrcDevId, DstDevId);
       if (Err != CUDA_SUCCESS) {
         REPORT("Error returned from cuDeviceCanAccessPeer. src = %" PRId32
                ", dst = %" PRId32 "\n",
if (!checkResult(Err, "Error returned from cuLaunchKernel\n"))
       return OFFLOAD_FAIL;
 
     DP("Launch of entry point at " DPxMOD " successful!\n",
        DPxPTR(TgtEntryPtr));
 
     return OFFLOAD_SUCCESS;
   }
 
-  int synchronize(const int DeviceId, __tgt_async_info *AsyncInfoPtr) const {
-    CUstream Stream = reinterpret_cast<CUstream>(AsyncInfoPtr->Queue);
+  int synchronize(const int DeviceId, __tgt_async_info *AsyncInfo) const {
+    CUstream Stream = reinterpret_cast<CUstream>(AsyncInfo->Queue);
     CUresult Err = cuStreamSynchronize(Stream);
     if (Err != CUDA_SUCCESS) {
       REPORT("Error when synchronizing stream. stream = " DPxMOD
              ", async info ptr = " DPxMOD "\n",
-             DPxPTR(Stream), DPxPTR(AsyncInfoPtr));
+             DPxPTR(Stream), DPxPTR(AsyncInfo));
       CUDA_ERR_STRING(Err);
       return OFFLOAD_FAIL;
     }
 
     // Once the stream is synchronized, return it to stream pool and reset
-    // async_info. This is to make sure the synchronization only works for its
+    // AsyncInfo. This is to make sure the synchronization only works for its
     // own tasks.
-    StreamManager->returnStream(
-        DeviceId, reinterpret_cast<CUstream>(AsyncInfoPtr->Queue));
-    AsyncInfoPtr->Queue = nullptr;
+    StreamManager->returnStream(DeviceId,
+                                reinterpret_cast<CUstream>(AsyncInfo->Queue));
+    AsyncInfo->Queue = nullptr;
 
     return OFFLOAD_SUCCESS;
   }
 };
 
 DeviceRTLTy DeviceRTL;
 } // namespace
 
void *__tgt_rtl_data_alloc(int32_t device_id, int64_t size, void *) {
 
   return DeviceRTL.dataAlloc(device_id, size);
 }
 
 int32_t __tgt_rtl_data_submit(int32_t device_id, void *tgt_ptr, void *hst_ptr,
                               int64_t size) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
-  __tgt_async_info async_info;
+  __tgt_async_info AsyncInfo;
   const int32_t rc = __tgt_rtl_data_submit_async(device_id, tgt_ptr, hst_ptr,
-                                                 size, &async_info);
+                                                 size, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_submit_async(int32_t device_id, void *tgt_ptr,
                                     void *hst_ptr, int64_t size,
-                                    __tgt_async_info *async_info_ptr) {
+                                    __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
-  assert(async_info_ptr && "async_info_ptr is nullptr");
+  assert(AsyncInfo && "AsyncInfo is nullptr");
 
-  return DeviceRTL.dataSubmit(device_id, tgt_ptr, hst_ptr, size,
-                              async_info_ptr);
+  return DeviceRTL.dataSubmit(device_id, tgt_ptr, hst_ptr, size, AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_retrieve(int32_t device_id, void *hst_ptr, void *tgt_ptr,
                                 int64_t size) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
-  __tgt_async_info async_info;
+  __tgt_async_info AsyncInfo;
   const int32_t rc = __tgt_rtl_data_retrieve_async(device_id, hst_ptr, tgt_ptr,
-                                                   size, &async_info);
+                                                   size, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_retrieve_async(int32_t device_id, void *hst_ptr,
                                       void *tgt_ptr, int64_t size,
-                                      __tgt_async_info *async_info_ptr) {
+                                      __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
-  assert(async_info_ptr && "async_info_ptr is nullptr");
+  assert(AsyncInfo && "AsyncInfo is nullptr");
 
-  return DeviceRTL.dataRetrieve(device_id, hst_ptr, tgt_ptr, size,
-                                async_info_ptr);
+  return DeviceRTL.dataRetrieve(device_id, hst_ptr, tgt_ptr, size, AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_exchange_async(int32_t src_dev_id, void *src_ptr,
                                       int dst_dev_id, void *dst_ptr,
                                       int64_t size,
-                                      __tgt_async_info *async_info_ptr) {
+                                      __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(src_dev_id) && "src_dev_id is invalid");
   assert(DeviceRTL.isValidDeviceId(dst_dev_id) && "dst_dev_id is invalid");
-  assert(async_info_ptr && "async_info_ptr is nullptr");
+  assert(AsyncInfo && "AsyncInfo is nullptr");
 
   return DeviceRTL.dataExchange(src_dev_id, src_ptr, dst_dev_id, dst_ptr, size,
-                                async_info_ptr);
+                                AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_exchange(int32_t src_dev_id, void *src_ptr,
                                 int32_t dst_dev_id, void *dst_ptr,
                                 int64_t size) {
   assert(DeviceRTL.isValidDeviceId(src_dev_id) && "src_dev_id is invalid");
   assert(DeviceRTL.isValidDeviceId(dst_dev_id) && "dst_dev_id is invalid");
 
-  __tgt_async_info async_info;
+  __tgt_async_info AsyncInfo;
   const int32_t rc = __tgt_rtl_data_exchange_async(
-      src_dev_id, src_ptr, dst_dev_id, dst_ptr, size, &async_info);
+      src_dev_id, src_ptr, dst_dev_id, dst_ptr, size, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(src_dev_id, &async_info);
+  return __tgt_rtl_synchronize(src_dev_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_delete(int32_t device_id, void *tgt_ptr) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
   return DeviceRTL.dataDelete(device_id, tgt_ptr);
 }
 
 int32_t __tgt_rtl_run_target_team_region(int32_t device_id, void *tgt_entry_ptr,
                                          void **tgt_args,
                                          ptrdiff_t *tgt_offsets,
                                          int32_t arg_num, int32_t team_num,
                                          int32_t thread_limit,
                                          uint64_t loop_tripcount) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
-  __tgt_async_info async_info;
+  __tgt_async_info AsyncInfo;
   const int32_t rc = __tgt_rtl_run_target_team_region_async(
       device_id, tgt_entry_ptr, tgt_args, tgt_offsets, arg_num, team_num,
-      thread_limit, loop_tripcount, &async_info);
+      thread_limit, loop_tripcount, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_run_target_team_region_async(
     int32_t device_id, void *tgt_entry_ptr, void **tgt_args,
     ptrdiff_t *tgt_offsets, int32_t arg_num, int32_t team_num,
     int32_t thread_limit, uint64_t loop_tripcount,
-    __tgt_async_info *async_info_ptr) {
+    __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
-  return DeviceRTL.runTargetTeamRegion(
-      device_id, tgt_entry_ptr, tgt_args, tgt_offsets, arg_num, team_num,
-      thread_limit, loop_tripcount, async_info_ptr);
+  return DeviceRTL.runTargetTeamRegion(device_id, tgt_entry_ptr, tgt_args,
+                                       tgt_offsets, arg_num, team_num,
+                                       thread_limit, loop_tripcount, AsyncInfo);
 }
 
 int32_t __tgt_rtl_run_target_region(int32_t device_id, void *tgt_entry_ptr,
                                     void **tgt_args, ptrdiff_t *tgt_offsets,
                                     int32_t arg_num) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
-  __tgt_async_info async_info;
+  __tgt_async_info AsyncInfo;
   const int32_t rc = __tgt_rtl_run_target_region_async(
-      device_id, tgt_entry_ptr, tgt_args, tgt_offsets, arg_num, &async_info);
+      device_id, tgt_entry_ptr, tgt_args, tgt_offsets, arg_num, &AsyncInfo);
   if (rc != OFFLOAD_SUCCESS)
     return OFFLOAD_FAIL;
 
-  return __tgt_rtl_synchronize(device_id, &async_info);
+  return __tgt_rtl_synchronize(device_id, &AsyncInfo);
 }
 
 int32_t __tgt_rtl_run_target_region_async(int32_t device_id,
                                           void *tgt_entry_ptr, void **tgt_args,
                                           ptrdiff_t *tgt_offsets,
                                           int32_t arg_num,
-                                          __tgt_async_info *async_info_ptr) {
+                                          __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
 
   return __tgt_rtl_run_target_team_region_async(
       device_id, tgt_entry_ptr, tgt_args, tgt_offsets, arg_num,
-      /* team num*/ 1, /* thread_limit */ 1, /* loop_tripcount */ 0,
-      async_info_ptr);
+      /* team num*/ 1, /* thread_limit */ 1, /* loop_tripcount */ 0, AsyncInfo);
 }
 
-int32_t __tgt_rtl_synchronize(int32_t device_id,
-                              __tgt_async_info *async_info_ptr) {
+int32_t __tgt_rtl_synchronize(int32_t device_id, __tgt_async_info *AsyncInfo) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
-  assert(async_info_ptr && "async_info_ptr is nullptr");
-  assert(async_info_ptr->Queue && "async_info_ptr->Queue is nullptr");
+  assert(AsyncInfo && "AsyncInfo is nullptr");
+  assert(AsyncInfo->Queue && "AsyncInfo->Queue is nullptr");
 
-  return DeviceRTL.synchronize(device_id, async_info_ptr);
+  return DeviceRTL.synchronize(device_id, AsyncInfo);
 }
 
 #ifdef __cplusplus
 }
 #endif

openmp/libomptarget/plugins/remote/server/Server.cpp

 }
 
 Status RemoteOffloadImpl::Synchronize(ServerContext *Context,
                                       const SynchronizeDevice *Info,
                                       I32 *Reply) {
   SERVER_DBG("Synchronizing device %d (probably won't work)",
              Info->device_id());
 
-  void *AsyncInfoPtr = (void *)Info->queue_ptr();
+  void *AsyncInfo = (void *)Info->queue_ptr();
   Reply->set_number(0);
   if (PM->Devices[Info->device_id()].RTL->synchronize)
     Reply->set_number(PM->Devices[Info->device_id()].synchronize(
-        (__tgt_async_info *)AsyncInfoPtr));
+        (__tgt_async_info *)AsyncInfo));
 
   SERVER_DBG("Synchronized device %d", Info->device_id());
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::IsDataExchangeable(ServerContext *Context,
                                              const DevicePair *Request,
                                              I32 *Reply) {

openmp/libomptarget/plugins/remote/src/Client.h

 //===------------------ Client.h - Client Implementation ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // gRPC Client for the remote plugin.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OPENMP_LIBOMPTARGET_PLUGINS_REMOTE_SRC_CLIENT_H
 #define LLVM_OPENMP_LIBOMPTARGET_PLUGINS_REMOTE_SRC_CLIENT_H
 
 #include "Utils.h"
 #include "omptarget.h"
 #include <google/protobuf/arena.h>
 #include <grpcpp/grpcpp.h>
 #include <grpcpp/security/credentials.h>
 #include <grpcpp/support/channel_arguments.h>
 #include <memory>
 #include <mutex>
 #include <numeric>
public:
 
   int32_t isValidBinary(__tgt_device_image *Image);
   int32_t getNumberOfDevices();
 
   int32_t initDevice(int32_t DeviceId);
   int32_t initRequires(int64_t RequiresFlags);
 
   __tgt_target_table *loadBinary(int32_t DeviceId, __tgt_device_image *Image);
-  int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfoPtr);
+  int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo);
   int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
 
   void *dataAlloc(int32_t DeviceId, int64_t Size, void *HstPtr);
   int32_t dataDelete(int32_t DeviceId, void *TgtPtr);
 
   int32_t dataSubmitAsync(int32_t DeviceId, void *TgtPtr, void *HstPtr,
-                          int64_t Size, __tgt_async_info *AsyncInfoPtr);
+                          int64_t Size, __tgt_async_info *AsyncInfo);
   int32_t dataRetrieveAsync(int32_t DeviceId, void *HstPtr, void *TgtPtr,
-                            int64_t Size, __tgt_async_info *AsyncInfoPtr);
+                            int64_t Size, __tgt_async_info *AsyncInfo);
 
   int32_t dataExchangeAsync(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
                             void *DstPtr, int64_t Size,
-                            __tgt_async_info *AsyncInfoPtr);
+                            __tgt_async_info *AsyncInfo);
 
   int32_t runTargetRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
                                void **TgtArgs, ptrdiff_t *TgtOffsets,
-                               int32_t ArgNum, __tgt_async_info *AsyncInfoPtr);
+                               int32_t ArgNum, __tgt_async_info *AsyncInfo);
 
   int32_t runTargetTeamRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
                                    void **TgtArgs, ptrdiff_t *TgtOffsets,
                                    int32_t ArgNum, int32_t TeamNum,
                                    int32_t ThreadLimit, uint64_t LoopTripCount,
-                                   __tgt_async_info *AsyncInfoPtr);
+                                   __tgt_async_info *AsyncInfo);
 };
 
 class RemoteClientManager {
 private:
   std::vector<std::string> Addresses;
   std::vector<RemoteOffloadClient> Clients;
   std::vector<int> Devices;
 
public:
 
   int32_t isValidBinary(__tgt_device_image *Image);
   int32_t getNumberOfDevices();
 
   int32_t initDevice(int32_t DeviceId);
   int32_t initRequires(int64_t RequiresFlags);
 
   __tgt_target_table *loadBinary(int32_t DeviceId, __tgt_device_image *Image);
-  int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfoPtr);
+  int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo);
   int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
 
   void *dataAlloc(int32_t DeviceId, int64_t Size, void *HstPtr);
   int32_t dataDelete(int32_t DeviceId, void *TgtPtr);
 
   int32_t dataSubmitAsync(int32_t DeviceId, void *TgtPtr, void *HstPtr,
-                          int64_t Size, __tgt_async_info *AsyncInfoPtr);
+                          int64_t Size, __tgt_async_info *AsyncInfo);
   int32_t dataRetrieveAsync(int32_t DeviceId, void *HstPtr, void *TgtPtr,
-                            int64_t Size, __tgt_async_info *AsyncInfoPtr);
+                            int64_t Size, __tgt_async_info *AsyncInfo);
 
   int32_t dataExchangeAsync(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
                             void *DstPtr, int64_t Size,
-                            __tgt_async_info *AsyncInfoPtr);
+                            __tgt_async_info *AsyncInfo);
 
   int32_t runTargetRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
                                void **TgtArgs, ptrdiff_t *TgtOffsets,
-                               int32_t ArgNum, __tgt_async_info *AsyncInfoPtr);
+                               int32_t ArgNum, __tgt_async_info *AsyncInfo);
 
   int32_t runTargetTeamRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
                                    void **TgtArgs, ptrdiff_t *TgtOffsets,
                                    int32_t ArgNum, int32_t TeamNum,
                                    int32_t ThreadLimit, uint64_t LoopTripCount,
-                                   __tgt_async_info *AsyncInfoPtr);
+                                   __tgt_async_info *AsyncInfo);
 };
 
 #endif

openmp/libomptarget/plugins/remote/src/Client.cpp

return remoteCall(
 
         return DevicesToTables[DeviceId].get();
       },
       /* Error Value */ (__tgt_target_table *)nullptr,
       /* Timeout */ false);
 }
 
 int64_t RemoteOffloadClient::synchronize(int32_t DeviceId,
-                                         __tgt_async_info *AsyncInfoPtr) {
+                                         __tgt_async_info *AsyncInfo) {
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
         auto *Info =
             protobuf::Arena::CreateMessage<SynchronizeDevice>(Arena.get());
 
         Info->set_device_id(DeviceId);
-        Info->set_queue_ptr((uint64_t)AsyncInfoPtr);
+        Info->set_queue_ptr((uint64_t)AsyncInfo);
 
         CLIENT_DBG("Synchronizing device %d", DeviceId);
         RPCStatus = Stub->Synchronize(&Context, *Info, Reply);
         return Reply;
       },
       /* Postprocess */
       [&](auto &Reply) {
         if (Reply->number()) {
return remoteCall(
         }
         return (void *)Reply->number();
       },
       /* Error Value */ (void *)nullptr);
 }
 
 int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
                                              void *HstPtr, int64_t Size,
-                                             __tgt_async_info *AsyncInfoPtr) {
+                                             __tgt_async_info *AsyncInfo) {
 
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
         std::unique_ptr<ClientWriter<SubmitDataAsync>> Writer(
             Stub->DataSubmitAsync(&Context, Reply));
 
         if (Size > BlockSize) {
           int64_t Start = 0, End = BlockSize;
           for (auto I = 0; I < ceil((float)Size / BlockSize); I++) {
             auto *Request =
                 protobuf::Arena::CreateMessage<SubmitDataAsync>(Arena.get());
 
             Request->set_device_id(DeviceId);
             Request->set_data((char *)HstPtr + Start, End - Start);
             Request->set_hst_ptr((uint64_t)HstPtr);
             Request->set_tgt_ptr((uint64_t)TgtPtr);
             Request->set_start(Start);
             Request->set_size(Size);
-            Request->set_queue_ptr((uint64_t)AsyncInfoPtr);
+            Request->set_queue_ptr((uint64_t)AsyncInfo);
 
             CLIENT_DBG("Submitting %ld-%ld/%ld bytes async on device %d at %p",
                        Start, End, Size, DeviceId, TgtPtr)
 
             if (!Writer->Write(*Request)) {
               CLIENT_DBG("Broken stream when submitting data");
               Reply->set_number(0);
               return Reply;
return remoteCall(
         return Reply->number();
       },
       /* Error Value */ -1,
       /* Timeout */ false);
 }
 
 int32_t RemoteOffloadClient::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
                                                void *TgtPtr, int64_t Size,
-                                               __tgt_async_info *AsyncInfoPtr) {
+                                               __tgt_async_info *AsyncInfo) {
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Request =
             protobuf::Arena::CreateMessage<RetrieveDataAsync>(Arena.get());
 
         Request->set_device_id(DeviceId);
         Request->set_size(Size);
         Request->set_hst_ptr((int64_t)HstPtr);
         Request->set_tgt_ptr((int64_t)TgtPtr);
-        Request->set_queue_ptr((uint64_t)AsyncInfoPtr);
+        Request->set_queue_ptr((uint64_t)AsyncInfo);
 
         auto *Reply = protobuf::Arena::CreateMessage<Data>(Arena.get());
         std::unique_ptr<ClientReader<Data>> Reader(
             Stub->DataRetrieveAsync(&Context, *Request));
         Reader->WaitForInitialMetadata();
         while (Reader->Read(Reply)) {
           if (Reply->ret()) {
             CLIENT_DBG("Could not async retrieve %ld bytes on device %d at %p "
return remoteCall(
       },
       /* Error Value */ -1,
       /* Timeout */ false);
 }
 
 int32_t RemoteOffloadClient::dataExchangeAsync(int32_t SrcDevId, void *SrcPtr,
                                                int32_t DstDevId, void *DstPtr,
                                                int64_t Size,
-                                               __tgt_async_info *AsyncInfoPtr) {
+                                               __tgt_async_info *AsyncInfo) {
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
         auto *Request =
             protobuf::Arena::CreateMessage<ExchangeDataAsync>(Arena.get());
 
         Request->set_src_dev_id(SrcDevId);
         Request->set_src_ptr((uint64_t)SrcPtr);
         Request->set_dst_dev_id(DstDevId);
         Request->set_dst_ptr((uint64_t)DstPtr);
         Request->set_size(Size);
-        Request->set_queue_ptr((uint64_t)AsyncInfoPtr);
+        Request->set_queue_ptr((uint64_t)AsyncInfo);
 
         CLIENT_DBG(
             "Exchanging %ld bytes on device %d at %p for %p on device %d", Size,
             SrcDevId, SrcPtr, DstPtr, DstDevId);
         RPCStatus = Stub->DataExchangeAsync(&Context, *Request, Reply);
         return Reply;
       },
       /* Postprocess */
return remoteCall(
         }
         return Reply->number();
       },
       /* Error Value */ -1);
 }
 
 int32_t RemoteOffloadClient::runTargetRegionAsync(
     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
-    int32_t ArgNum, __tgt_async_info *AsyncInfoPtr) {
+    int32_t ArgNum, __tgt_async_info *AsyncInfo) {
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
         auto *Request =
             protobuf::Arena::CreateMessage<TargetRegionAsync>(Arena.get());
 
         Request->set_device_id(DeviceId);
-        Request->set_queue_ptr((uint64_t)AsyncInfoPtr);
+        Request->set_queue_ptr((uint64_t)AsyncInfo);
 
         Request->set_tgt_entry_ptr(
             (uint64_t)RemoteEntries[DeviceId][TgtEntryPtr]);
 
         char **ArgPtr = (char **)TgtArgs;
         for (auto I = 0; I < ArgNum; I++, ArgPtr++)
           Request->add_tgt_args((uint64_t)*ArgPtr);
 
return remoteCall(
       },
       /* Error Value */ -1,
       /* Timeout */ false);
 }
 
 int32_t RemoteOffloadClient::runTargetTeamRegionAsync(
     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
-    uint64_t LoopTripcount, __tgt_async_info *AsyncInfoPtr) {
+    uint64_t LoopTripcount, __tgt_async_info *AsyncInfo) {
   return remoteCall(
       /* Preprocess */
       [&](auto &RPCStatus, auto &Context) {
         auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
         auto *Request =
             protobuf::Arena::CreateMessage<TargetTeamRegionAsync>(Arena.get());
 
         Request->set_device_id(DeviceId);
-        Request->set_queue_ptr((uint64_t)AsyncInfoPtr);
+        Request->set_queue_ptr((uint64_t)AsyncInfo);
 
         Request->set_tgt_entry_ptr(
             (uint64_t)RemoteEntries[DeviceId][TgtEntryPtr]);
 
         char **ArgPtr = (char **)TgtArgs;
         for (auto I = 0; I < ArgNum; I++, ArgPtr++) {
           Request->add_tgt_args((uint64_t)*ArgPtr);
         }

 __tgt_target_table *RemoteClientManager::loadBinary(int32_t DeviceId,
                                                     __tgt_device_image *Image) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].loadBinary(DeviceIdx, Image);
 }
 
 int64_t RemoteClientManager::synchronize(int32_t DeviceId,
-                                         __tgt_async_info *AsyncInfoPtr) {
+                                         __tgt_async_info *AsyncInfo) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
-  return Clients[ClientIdx].synchronize(DeviceIdx, AsyncInfoPtr);
+  return Clients[ClientIdx].synchronize(DeviceIdx, AsyncInfo);
 }
 
 int32_t RemoteClientManager::isDataExchangeable(int32_t SrcDevId,
                                                 int32_t DstDevId) {
   int32_t SrcClientIdx, SrcDeviceIdx, DstClientIdx, DstDeviceIdx;
   std::tie(SrcClientIdx, SrcDeviceIdx) = mapDeviceId(SrcDevId);
   std::tie(DstClientIdx, DstDeviceIdx) = mapDeviceId(DstDevId);
   return Clients[SrcClientIdx].isDataExchangeable(SrcDeviceIdx, DstDeviceIdx);

 int32_t RemoteClientManager::dataDelete(int32_t DeviceId, void *TgtPtr) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].dataDelete(DeviceIdx, TgtPtr);
 }
 
 int32_t RemoteClientManager::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
                                              void *HstPtr, int64_t Size,
-                                             __tgt_async_info *AsyncInfoPtr) {
+                                             __tgt_async_info *AsyncInfo) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].dataSubmitAsync(DeviceIdx, TgtPtr, HstPtr, Size,
-                                            AsyncInfoPtr);
+                                            AsyncInfo);
 }
 
 int32_t RemoteClientManager::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
                                                void *TgtPtr, int64_t Size,
-                                               __tgt_async_info *AsyncInfoPtr) {
+                                               __tgt_async_info *AsyncInfo) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].dataRetrieveAsync(DeviceIdx, HstPtr, TgtPtr, Size,
-                                              AsyncInfoPtr);
+                                              AsyncInfo);
 }
 
 int32_t RemoteClientManager::dataExchangeAsync(int32_t SrcDevId, void *SrcPtr,
                                                int32_t DstDevId, void *DstPtr,
                                                int64_t Size,
-                                               __tgt_async_info *AsyncInfoPtr) {
+                                               __tgt_async_info *AsyncInfo) {
   int32_t SrcClientIdx, SrcDeviceIdx, DstClientIdx, DstDeviceIdx;
   std::tie(SrcClientIdx, SrcDeviceIdx) = mapDeviceId(SrcDevId);
   std::tie(DstClientIdx, DstDeviceIdx) = mapDeviceId(DstDevId);
   return Clients[SrcClientIdx].dataExchangeAsync(
-      SrcDeviceIdx, SrcPtr, DstDeviceIdx, DstPtr, Size, AsyncInfoPtr);
+      SrcDeviceIdx, SrcPtr, DstDeviceIdx, DstPtr, Size, AsyncInfo);
 }
 
 int32_t RemoteClientManager::runTargetRegionAsync(
     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
-    int32_t ArgNum, __tgt_async_info *AsyncInfoPtr) {
+    int32_t ArgNum, __tgt_async_info *AsyncInfo) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].runTargetRegionAsync(
-      DeviceIdx, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, AsyncInfoPtr);
+      DeviceIdx, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, AsyncInfo);
 }
 
 int32_t RemoteClientManager::runTargetTeamRegionAsync(
     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
-    uint64_t LoopTripCount, __tgt_async_info *AsyncInfoPtr) {
+    uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
   int32_t ClientIdx, DeviceIdx;
   std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
   return Clients[ClientIdx].runTargetTeamRegionAsync(
       DeviceIdx, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
-      LoopTripCount, AsyncInfoPtr);
+      LoopTripCount, AsyncInfo);
 }

openmp/libomptarget/plugins/remote/src/rtl.cpp

int64_t __tgt_rtl_init_requires(int64_t RequiresFlags) {
   return Manager->initRequires(RequiresFlags);
 }
 
 __tgt_target_table *__tgt_rtl_load_binary(int32_t DeviceId,
                                           __tgt_device_image *Image) {
   return Manager->loadBinary(DeviceId, (__tgt_device_image *)Image);
 }
 
-int32_t __tgt_rtl_synchronize(int32_t DeviceId,
-                              __tgt_async_info *AsyncInfoPtr) {
-  return Manager->synchronize(DeviceId, AsyncInfoPtr);
+int32_t __tgt_rtl_synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo) {
+  return Manager->synchronize(DeviceId, AsyncInfo);
 }
 
 int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId) {
   return Manager->isDataExchangeable(SrcDevId, DstDevId);
 }
 
 void *__tgt_rtl_data_alloc(int32_t DeviceId, int64_t Size, void *HstPtr) {
   return Manager->dataAlloc(DeviceId, Size, HstPtr);
 }
 
 int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
                               int64_t Size) {
   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, nullptr);
 }
 
 int32_t __tgt_rtl_data_submit_async(int32_t DeviceId, void *TgtPtr,
                                     void *HstPtr, int64_t Size,
-                                    __tgt_async_info *AsyncInfoPtr) {
-  return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfoPtr);
+                                    __tgt_async_info *AsyncInfo) {
+  return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_retrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
                                 int64_t Size) {
   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, nullptr);
 }
 
 int32_t __tgt_rtl_data_retrieve_async(int32_t DeviceId, void *HstPtr,
                                       void *TgtPtr, int64_t Size,
-                                      __tgt_async_info *AsyncInfoPtr) {
-  return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size,
-                                    AsyncInfoPtr);
+                                      __tgt_async_info *AsyncInfo) {
+  return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, AsyncInfo);
 }
 
 int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
   return Manager->dataDelete(DeviceId, TgtPtr);
 }
 
 int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
                                 int32_t DstDevId, void *DstPtr, int64_t Size) {
   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
                                     nullptr);
 }
 
 int32_t __tgt_rtl_data_exchange_async(int32_t SrcDevId, void *SrcPtr,
                                       int32_t DstDevId, void *DstPtr,
                                       int64_t Size,
-                                      __tgt_async_info *AsyncInfoPtr) {
+                                      __tgt_async_info *AsyncInfo) {
   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
-                                    AsyncInfoPtr);
+                                    AsyncInfo);
 }
 
 int32_t __tgt_rtl_run_target_region(int32_t DeviceId, void *TgtEntryPtr,
                                     void **TgtArgs, ptrdiff_t *TgtOffsets,
                                     int32_t ArgNum) {
   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
                                        TgtOffsets, ArgNum, nullptr);
 }
 
 int32_t __tgt_rtl_run_target_region_async(int32_t DeviceId, void *TgtEntryPtr,
                                           void **TgtArgs, ptrdiff_t *TgtOffsets,
                                           int32_t ArgNum,
-                                          __tgt_async_info *AsyncInfoPtr) {
+                                          __tgt_async_info *AsyncInfo) {
   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
-                                       TgtOffsets, ArgNum, AsyncInfoPtr);
+                                       TgtOffsets, ArgNum, AsyncInfo);
 }
 
 int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
                                          void **TgtArgs, ptrdiff_t *TgtOffsets,
                                          int32_t ArgNum, int32_t TeamNum,
                                          int32_t ThreadLimit,
                                          uint64_t LoopTripCount) {
   return Manager->runTargetTeamRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
                                            TgtOffsets, ArgNum, TeamNum,
                                            ThreadLimit, LoopTripCount, nullptr);
 }
 
 int32_t __tgt_rtl_run_target_team_region_async(
     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
-    uint64_t LoopTripCount, __tgt_async_info *AsyncInfoPtr) {
+    uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
   return Manager->runTargetTeamRegionAsync(
       DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
-      LoopTripCount, AsyncInfoPtr);
+      LoopTripCount, AsyncInfo);
 }
 
 // Exposed library API function
 #ifdef __cplusplus
 }
 #endif

openmp/libomptarget/src/device.h

struct DeviceTy {
   /// default value of \p HstPtr is nullptr. Note: this function doesn't do
   /// pointer association. Actually, all the __tgt_rtl_data_alloc
   /// implementations ignore \p HstPtr.
   void *allocData(int64_t Size, void *HstPtr = nullptr);
   /// Deallocates memory which \p TgtPtrBegin points at and returns
   /// OFFLOAD_SUCCESS/OFFLOAD_FAIL when succeeds/fails.
   int32_t deleteData(void *TgtPtrBegin);
 
-  // Data transfer. When AsyncInfoPtr is nullptr, the transfer will be
+  // Data transfer. When AsyncInfo is nullptr, the transfer will be
   // synchronous.
   // Copy data from host to device
   int32_t submitData(void *TgtPtrBegin, void *HstPtrBegin, int64_t Size,
-                     __tgt_async_info *AsyncInfoPtr);
+                     __tgt_async_info *AsyncInfo);
   // Copy data from device back to host
   int32_t retrieveData(void *HstPtrBegin, void *TgtPtrBegin, int64_t Size,
-                       __tgt_async_info *AsyncInfoPtr);
+                       __tgt_async_info *AsyncInfo);
   // Copy data from current device to destination device directly
   int32_t dataExchange(void *SrcPtr, DeviceTy &DstDev, void *DstPtr,
                        int64_t Size, __tgt_async_info *AsyncInfo);
 
   int32_t runRegion(void *TgtEntryPtr, void **TgtVarsPtr, ptrdiff_t *TgtOffsets,
-                    int32_t TgtVarsSize, __tgt_async_info *AsyncInfoPtr);
+                    int32_t TgtVarsSize, __tgt_async_info *AsyncInfo);
   int32_t runTeamRegion(void *TgtEntryPtr, void **TgtVarsPtr,
                         ptrdiff_t *TgtOffsets, int32_t TgtVarsSize,
                         int32_t NumTeams, int32_t ThreadLimit,
-                        uint64_t LoopTripCount, __tgt_async_info *AsyncInfoPtr);
+                        uint64_t LoopTripCount, __tgt_async_info *AsyncInfo);
 
-  /// Synchronize device/queue/event based on \p AsyncInfoPtr and return
+  /// Synchronize device/queue/event based on \p AsyncInfo and return
   /// OFFLOAD_SUCCESS/OFFLOAD_FAIL when succeeds/fails.
-  int32_t synchronize(__tgt_async_info *AsyncInfoPtr);
+  int32_t synchronize(__tgt_async_info *AsyncInfo);
 
 private:
   // Call to RTL
   void init(); // To be called only via DeviceTy::initOnce()
 };
 
 /// Map between Device ID (i.e. openmp device id) and its DeviceTy.
 typedef std::vector<DeviceTy> DevicesTy;

openmp/libomptarget/src/device.cpp

 }
 
 int32_t DeviceTy::deleteData(void *TgtPtrBegin) {
   return RTL->data_delete(RTLDeviceID, TgtPtrBegin);
 }
 
 // Submit data to device
 int32_t DeviceTy::submitData(void *TgtPtrBegin, void *HstPtrBegin, int64_t Size,
-                             __tgt_async_info *AsyncInfoPtr) {
-  if (!AsyncInfoPtr || !RTL->data_submit_async || !RTL->synchronize)
+                             __tgt_async_info *AsyncInfo) {
+  if (!AsyncInfo || !RTL->data_submit_async || !RTL->synchronize)
     return RTL->data_submit(RTLDeviceID, TgtPtrBegin, HstPtrBegin, Size);
   else
     return RTL->data_submit_async(RTLDeviceID, TgtPtrBegin, HstPtrBegin, Size,
-                                  AsyncInfoPtr);
+                                  AsyncInfo);
 }
 
 // Retrieve data from device
 int32_t DeviceTy::retrieveData(void *HstPtrBegin, void *TgtPtrBegin,
-                               int64_t Size, __tgt_async_info *AsyncInfoPtr) {
-  if (!AsyncInfoPtr || !RTL->data_retrieve_async || !RTL->synchronize)
+                               int64_t Size, __tgt_async_info *AsyncInfo) {
+  if (!AsyncInfo || !RTL->data_retrieve_async || !RTL->synchronize)
     return RTL->data_retrieve(RTLDeviceID, HstPtrBegin, TgtPtrBegin, Size);
   else
     return RTL->data_retrieve_async(RTLDeviceID, HstPtrBegin, TgtPtrBegin, Size,
-                                    AsyncInfoPtr);
+                                    AsyncInfo);
 }
 
 // Copy data from current device to destination device directly
 int32_t DeviceTy::dataExchange(void *SrcPtr, DeviceTy &DstDev, void *DstPtr,
                                int64_t Size, __tgt_async_info *AsyncInfo) {
   if (!AsyncInfo || !RTL->data_exchange_async || !RTL->synchronize) {
     assert(RTL->data_exchange && "RTL->data_exchange is nullptr");
     return RTL->data_exchange(RTLDeviceID, SrcPtr, DstDev.RTLDeviceID, DstPtr,
                               Size);
   } else
     return RTL->data_exchange_async(RTLDeviceID, SrcPtr, DstDev.RTLDeviceID,
                                     DstPtr, Size, AsyncInfo);
 }
 
 // Run region on device
 int32_t DeviceTy::runRegion(void *TgtEntryPtr, void **TgtVarsPtr,
                             ptrdiff_t *TgtOffsets, int32_t TgtVarsSize,
-                            __tgt_async_info *AsyncInfoPtr) {
-  if (!AsyncInfoPtr || !RTL->run_region || !RTL->synchronize)
+                            __tgt_async_info *AsyncInfo) {
+  if (!AsyncInfo || !RTL->run_region || !RTL->synchronize)
     return RTL->run_region(RTLDeviceID, TgtEntryPtr, TgtVarsPtr, TgtOffsets,
                            TgtVarsSize);
   else
     return RTL->run_region_async(RTLDeviceID, TgtEntryPtr, TgtVarsPtr,
-                                 TgtOffsets, TgtVarsSize, AsyncInfoPtr);
+                                 TgtOffsets, TgtVarsSize, AsyncInfo);
 }
 
 // Run team region on device.
 int32_t DeviceTy::runTeamRegion(void *TgtEntryPtr, void **TgtVarsPtr,
                                 ptrdiff_t *TgtOffsets, int32_t TgtVarsSize,
                                 int32_t NumTeams, int32_t ThreadLimit,
                                 uint64_t LoopTripCount,
-                                __tgt_async_info *AsyncInfoPtr) {
-  if (!AsyncInfoPtr || !RTL->run_team_region_async || !RTL->synchronize)
+                                __tgt_async_info *AsyncInfo) {
+  if (!AsyncInfo || !RTL->run_team_region_async || !RTL->synchronize)
     return RTL->run_team_region(RTLDeviceID, TgtEntryPtr, TgtVarsPtr,
                                 TgtOffsets, TgtVarsSize, NumTeams, ThreadLimit,
                                 LoopTripCount);
   else
     return RTL->run_team_region_async(RTLDeviceID, TgtEntryPtr, TgtVarsPtr,
                                       TgtOffsets, TgtVarsSize, NumTeams,
-                                      ThreadLimit, LoopTripCount, AsyncInfoPtr);
+                                      ThreadLimit, LoopTripCount, AsyncInfo);
 }
 
 // Whether data can be copied to DstDevice directly
 bool DeviceTy::isDataExchangable(const DeviceTy &DstDevice) {
   if (RTL != DstDevice.RTL || !RTL->is_data_exchangable)
     return false;
 
   if (RTL->is_data_exchangable(RTLDeviceID, DstDevice.RTLDeviceID))
     return (RTL->data_exchange != nullptr) ||
            (RTL->data_exchange_async != nullptr);
 
   return false;
 }
 
-int32_t DeviceTy::synchronize(__tgt_async_info *AsyncInfoPtr) {
+int32_t DeviceTy::synchronize(__tgt_async_info *AsyncInfo) {
   if (RTL->synchronize)
-    return RTL->synchronize(RTLDeviceID, AsyncInfoPtr);
+    return RTL->synchronize(RTLDeviceID, AsyncInfo);
   return OFFLOAD_SUCCESS;
 }
 
 /// Check whether a device has an associated RTL and initialize it if it's not
 /// already initialized.
 bool device_is_ready(int device_num) {
   DP("Checking whether device %d is ready.\n", device_num);
   // Devices.size() can only change while registering a new