Expand Event API.

openmp/libomptarget/include/omptarget.h

 
 /// This struct is a record of non-contiguous information
 struct __tgt_target_non_contig {
   uint64_t Offset;
   uint64_t Count;
   uint64_t Stride;
 };
 
+enum TargetEventStatusTy : int32_t {
+  TARGET_EVENT_COMPLETED = 0,
+  TARGET_EVENT_NOT_READY,
+  TARGET_EVENT_UNKNOWN
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 int omp_get_num_devices(void);
 int omp_get_initial_device(void);
 void *omp_target_alloc(size_t size, int device_num);
 void omp_target_free(void *device_ptr, int device_num);

openmp/libomptarget/plugins/cuda/dynamic_cuda/cuda.h

 typedef struct CUfunc_st *CUfunction;
 typedef struct CUstream_st *CUstream;
 typedef struct CUevent_st *CUevent;
 
 typedef enum cudaError_enum {
   CUDA_SUCCESS = 0,
   CUDA_ERROR_INVALID_VALUE = 1,
   CUDA_ERROR_INVALID_HANDLE = 400,
+  CUDA_ERROR_NOT_READY = 600,
 } CUresult;
 
 typedef enum CUstream_flags_enum {
   CU_STREAM_DEFAULT = 0x0,
   CU_STREAM_NON_BLOCKING = 0x1,
 } CUstream_flags;
 
 typedef enum CUlimit_enum {

 CUresult cuMemcpyPeerAsync(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext,
                            size_t, CUstream);
 
 CUresult cuCtxGetLimit(size_t *, CUlimit);
 CUresult cuCtxSetLimit(CUlimit, size_t);
 
 CUresult cuEventCreate(CUevent *, unsigned int);
 CUresult cuEventRecord(CUevent, CUstream);
+CUresult cuEventQuery(CUevent);
 CUresult cuStreamWaitEvent(CUstream, CUevent, unsigned int);
 CUresult cuEventSynchronize(CUevent);
 CUresult cuEventDestroy(CUevent);
 
 #endif

openmp/libomptarget/plugins/cuda/dynamic_cuda/cuda.cpp

 //===--- cuda/dynamic_cuda/cuda.pp ------------------------------- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement subset of cuda api by calling into cuda library via dlopen
 // Does the dlopen/dlsym calls as part of the call to cuInit
 //
 //===----------------------------------------------------------------------===//
 
 #include "cuda.h"
 #include "Debug.h"
 #include "dlwrap.h"
 
 #include <string>
 #include <unordered_map>
 
 #include <dlfcn.h>
 
 DLWRAP_INTERNAL(cuInit, 1);

 DLWRAP(cuCtxEnablePeerAccess, 2);
 DLWRAP(cuMemcpyPeerAsync, 6);
 
 DLWRAP(cuCtxGetLimit, 2);
 DLWRAP(cuCtxSetLimit, 2);
 
 DLWRAP(cuEventCreate, 2);
 DLWRAP(cuEventRecord, 2);
+DLWRAP(cuEventQuery, 1);
 DLWRAP(cuStreamWaitEvent, 3);
 DLWRAP(cuEventSynchronize, 1);
 DLWRAP(cuEventDestroy, 1);
 
 DLWRAP_FINALIZE();
 
 #ifndef DYNAMIC_CUDA_PATH
 #define DYNAMIC_CUDA_PATH "libcuda.so"

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 <unordered_map>
 #include <vector>
 
 #include "Debug.h"
DP("Error when recording event. stream = " DPxMOD ", event = " DPxMOD "\n",
        DPxPTR(Stream), DPxPTR(Event));
     CUDA_ERR_STRING(Err);
     return OFFLOAD_FAIL;
   }
 
   return OFFLOAD_SUCCESS;
 }
 
+int queryEvent(void *EventPtr, TargetEventStatusTy *EventStatus) {
+  CUevent Event = reinterpret_cast<CUevent>(EventPtr);
+  CUresult Err = cuEventQuery(Event);
+
+  if (Err == CUDA_ERROR_NOT_READY) {
+    DP("Captured work is incomplete. Event = " DPxMOD "\n", DPxPTR(Event));
+    *EventStatus = TARGET_EVENT_NOT_READY;
+    return OFFLOAD_SUCCESS;
+  }
+
+  if (Err != CUDA_SUCCESS) {
+    DP("Error when querying an event. Event = " DPxMOD "\n", DPxPTR(Event));
+    CUDA_ERR_STRING(Err);
+    *EventStatus = TARGET_EVENT_UNKNOWN;
+    return OFFLOAD_FAIL;
+  }
+
+  *EventStatus = TARGET_EVENT_COMPLETED;
+  return OFFLOAD_SUCCESS;
+}
+
 int syncEvent(void *EventPtr) {
   CUevent Event = reinterpret_cast<CUevent>(EventPtr);
 
   CUresult Err = cuEventSynchronize(Event);
   if (Err != CUDA_SUCCESS) {
     DP("Error when syncing event = " DPxMOD "\n", DPxPTR(Event));
     CUDA_ERR_STRING(Err);
     return OFFLOAD_FAIL;
int32_t __tgt_rtl_create_event(int32_t device_id, void **event) {
   assert(event && "event is nullptr");
   return createEvent(event);
 }
 
 int32_t __tgt_rtl_record_event(int32_t device_id, void *event_ptr,
                                __tgt_async_info *async_info_ptr) {
   assert(async_info_ptr && "async_info_ptr is nullptr");
   assert(async_info_ptr->Queue && "async_info_ptr->Queue is nullptr");
-  assert(event_ptr && "event_ptr is nullptr");
+  assert(event_ptr && "event is nullptr");
 
   return recordEvent(event_ptr, async_info_ptr);
 }
 
+int32_t __tgt_rtl_query_event(int32_t device_id, void *event_ptr,
+                              TargetEventStatusTy *event_status) {
+  assert(event_ptr && "event is nullptr");
+  return queryEvent(event_ptr, event_status);
+}
+
 int32_t __tgt_rtl_wait_event(int32_t device_id, void *event_ptr,
                              __tgt_async_info *async_info_ptr) {
   assert(DeviceRTL.isValidDeviceId(device_id) && "device_id is invalid");
   assert(async_info_ptr && "async_info_ptr is nullptr");
   assert(event_ptr && "event is nullptr");
 
   return DeviceRTL.waitEvent(device_id, async_info_ptr, event_ptr);
 }

openmp/libomptarget/plugins/exports

global:
     __tgt_rtl_synchronize;
     __tgt_rtl_register_lib;
     __tgt_rtl_unregister_lib;
     __tgt_rtl_supports_empty_images;
     __tgt_rtl_set_info_flag;
     __tgt_rtl_print_device_info;
     __tgt_rtl_create_event;
     __tgt_rtl_record_event;
+    __tgt_rtl_query_event;
     __tgt_rtl_wait_event;
     __tgt_rtl_sync_event;
     __tgt_rtl_destroy_event;
   local:
     *;
 };

openmp/libomptarget/src/device.h

 struct DeviceTy {
   int32_t DeviceID;
   RTLInfoTy *RTL;
   int32_t RTLDeviceID;
 
   bool IsInit;
   std::once_flag InitFlag;
   bool HasPendingGlobals;
+  bool HasEventSupport;
 
   HostDataToTargetListTy HostDataToTargetMap;
   PendingCtorsDtorsPerLibrary PendingCtorsDtors;
 
   ShadowPtrListTy ShadowPtrMap;
 
   std::mutex DataMapMtx, PendingGlobalsMtx, ShadowMtx;
 
struct DeviceTy {
   /// device RTL to obtain the information of the specific device.
   bool printDeviceInfo(int32_t RTLDevID);
 
   /// Event related interfaces.
   /// {
   /// Create an event.
   int32_t createEvent(void **Event);
 
+  /// query the status of an event.
+  int32_t queryEvent(void *Event, TargetEventStatusTy &EventStatus);
+
   /// Record the event based on status in AsyncInfo->Queue at the moment the
   /// function is called.
   int32_t recordEvent(void *Event, AsyncInfoTy &AsyncInfo);
 
   /// Wait for an event. This function can be blocking or non-blocking,
   /// depending on the implmentation. It is expected to set a dependence on the
   /// event such that corresponding operations shall only start once the event
   /// is fulfilled.

openmp/libomptarget/src/device.cpp

 #include <cassert>
 #include <climits>
 #include <cstdio>
 #include <string>
 
 DeviceTy::DeviceTy(const DeviceTy &D)
     : DeviceID(D.DeviceID), RTL(D.RTL), RTLDeviceID(D.RTLDeviceID),
       IsInit(D.IsInit), InitFlag(), HasPendingGlobals(D.HasPendingGlobals),
+      HasEventSupport(D.HasEventSupport),
       HostDataToTargetMap(D.HostDataToTargetMap),
       PendingCtorsDtors(D.PendingCtorsDtors), ShadowPtrMap(D.ShadowPtrMap),
       DataMapMtx(), PendingGlobalsMtx(), ShadowMtx(),
       LoopTripCnt(D.LoopTripCnt) {}
 
 DeviceTy &DeviceTy::operator=(const DeviceTy &D) {
   DeviceID = D.DeviceID;
   RTL = D.RTL;
   RTLDeviceID = D.RTLDeviceID;
   IsInit = D.IsInit;
   HasPendingGlobals = D.HasPendingGlobals;
+  HasEventSupport = D.HasEventSupport;
   HostDataToTargetMap = D.HostDataToTargetMap;
   PendingCtorsDtors = D.PendingCtorsDtors;
   ShadowPtrMap = D.ShadowPtrMap;
   LoopTripCnt = D.LoopTripCnt;
 
   return *this;
 }
 
 DeviceTy::DeviceTy(RTLInfoTy *RTL)
     : DeviceID(-1), RTL(RTL), RTLDeviceID(-1), IsInit(false), InitFlag(),
-      HasPendingGlobals(false), HostDataToTargetMap(), PendingCtorsDtors(),
-      ShadowPtrMap(), DataMapMtx(), PendingGlobalsMtx(), ShadowMtx() {}
+      HasPendingGlobals(false),
+      HasEventSupport(RTL->create_event ? true : false), HostDataToTargetMap(),
+      PendingCtorsDtors(), ShadowPtrMap(), DataMapMtx(), PendingGlobalsMtx(),
+      ShadowMtx() {}
 
 DeviceTy::~DeviceTy() {
   if (DeviceID == -1 || !(getInfoLevel() & OMP_INFOTYPE_DUMP_TABLE))
     return;
 
   ident_t loc = {0, 0, 0, 0, ";libomptarget;libomptarget;0;0;;"};
   dumpTargetPointerMappings(&loc, *this);
 }

 
 int32_t DeviceTy::recordEvent(void *Event, AsyncInfoTy &AsyncInfo) {
   if (RTL->record_event)
     return RTL->record_event(RTLDeviceID, Event, AsyncInfo);
 
   return OFFLOAD_SUCCESS;
 }
 
+int32_t DeviceTy::queryEvent(void *Event, TargetEventStatusTy &EventStatus) {
+  if (RTL->query_event)
+    return RTL->query_event(RTLDeviceID, Event, &EventStatus);
+
+  return OFFLOAD_SUCCESS;
+}
+
 int32_t DeviceTy::waitEvent(void *Event, AsyncInfoTy &AsyncInfo) {
   if (RTL->wait_event)
     return RTL->wait_event(RTLDeviceID, Event, AsyncInfo);
 
   return OFFLOAD_SUCCESS;
 }
 
 int32_t DeviceTy::syncEvent(void *Event) {

openmp/libomptarget/src/rtl.h

struct RTLInfoTy {
   typedef int64_t(init_requires_ty)(int64_t);
   typedef int64_t(synchronize_ty)(int32_t, __tgt_async_info *);
   typedef int32_t (*register_lib_ty)(__tgt_bin_desc *);
   typedef int32_t(supports_empty_images_ty)();
   typedef void(print_device_info_ty)(int32_t);
   typedef void(set_info_flag_ty)(uint32_t);
   typedef int32_t(create_event_ty)(int32_t, void **);
   typedef int32_t(record_event_ty)(int32_t, void *, __tgt_async_info *);
+  typedef int32_t(query_event_ty)(int32_t, void *, TargetEventStatusTy *);
   typedef int32_t(wait_event_ty)(int32_t, void *, __tgt_async_info *);
   typedef int32_t(sync_event_ty)(int32_t, void *);
   typedef int32_t(destroy_event_ty)(int32_t, void *);
 
   int32_t Idx = -1;             // RTL index, index is the number of devices
                                 // of other RTLs that were registered before,
                                 // i.e. the OpenMP index of the first device
                                 // to be registered with this RTL.
#endif
   synchronize_ty *synchronize = nullptr;
   register_lib_ty register_lib = nullptr;
   register_lib_ty unregister_lib = nullptr;
   supports_empty_images_ty *supports_empty_images = nullptr;
   set_info_flag_ty *set_info_flag = nullptr;
   print_device_info_ty *print_device_info = nullptr;
   create_event_ty *create_event = nullptr;
   record_event_ty *record_event = nullptr;
+  query_event_ty *query_event = nullptr;
   wait_event_ty *wait_event = nullptr;
   sync_event_ty *sync_event = nullptr;
   destroy_event_ty *destroy_event = nullptr;
 
   // Are there images associated with this RTL.
   bool isUsed = false;
 
   // Mutex for thread-safety when calling RTL interface functions.

openmp/libomptarget/src/rtl.cpp

#endif
     *((void **)&R.set_info_flag) =
         dlsym(dynlib_handle, "__tgt_rtl_set_info_flag");
     *((void **)&R.print_device_info) =
         dlsym(dynlib_handle, "__tgt_rtl_print_device_info");
     *((void **)&R.create_event) =
         dlsym(dynlib_handle, "__tgt_rtl_create_event");
     *((void **)&R.record_event) =
         dlsym(dynlib_handle, "__tgt_rtl_record_event");
+    *((void **)&R.query_event) = dlsym(dynlib_handle, "__tgt_rtl_query_event");
     *((void **)&R.wait_event) = dlsym(dynlib_handle, "__tgt_rtl_wait_event");
     *((void **)&R.sync_event) = dlsym(dynlib_handle, "__tgt_rtl_sync_event");
     *((void **)&R.destroy_event) =
         dlsym(dynlib_handle, "__tgt_rtl_destroy_event");
   }
 
 #if OMPT_SUPPORT
   DP("OMPT_SUPPORT is enabled in libomptarget\n");