[OpenACC] Prototype OpenMP extension: omp_get_accessible_buffer

`omp_get_accessible_buffer` is an original OpenMP extension that will
be made use of by future patches to improve various OpenACC routines'
handling of shared memory.  For now, all testing of
`omp_get_accessible_buffer` will be via testing of OpenACC routines.
That is, `omp_get_accessible_buffer` routines are not well tested
outside of Clacc's OpenACC runtime, so they are not yet recommended
for general use in OpenMP code.

Author: jdenny-ornl

openmp/libomptarget/include/omptarget.h

@@ -161,6 +161,8 @@ int omp_target_associate_ptr(void *host_ptr, void *device_ptr, size_t size,
     size_t device_offset, int device_num);
 int omp_target_disassociate_ptr(void *host_ptr, int device_num);
 void *omp_get_mapped_ptr(const void *ptr, int device_num);
+size_t omp_get_accessible_buffer(const void *ptr, size_t size, int device_num,
+                                 void **buffer_host, void **buffer_device);
 void *omp_target_map_to(void *, size_t, int);
 void omp_target_map_from(void *, size_t, int);
 void omp_target_map_from_delete(void *, size_t, int);

openmp/libomptarget/src/api.cpp

@@ -367,6 +367,53 @@ EXTERN void *omp_get_mapped_ptr(const void *ptr, int device_num) {
   return TgtPtr;
 }
 
+EXTERN size_t omp_get_accessible_buffer(
+  const void *ptr, size_t size, int device_num, void **buffer_host,
+  void **buffer_device) {
+  DP("Call to omp_get_accessible_buffer for address " DPxMOD ", size %zu, and "
+     "device %d\n",
+     DPxPTR(ptr), size, device_num);
+
+  if (device_num == omp_get_initial_device()) {
+    DP("Call to omp_get_accessible_buffer for initial device, returning "
+       "SIZE_MAX\n");
+    if (buffer_host)
+      *buffer_host = nullptr;
+    if (buffer_device)
+      *buffer_device = nullptr;
+    return SIZE_MAX;
+  }
+
+  RTLsMtx->lock();
+  size_t Devices_size = Devices.size();
+  RTLsMtx->unlock();
+  if (Devices_size <= (size_t)device_num) {
+    DP("Call to omp_get_accessible_buffer with invalid device ID, returning "
+       "0\n");
+    if (buffer_host)
+      *buffer_host = nullptr;
+    if (buffer_device)
+      *buffer_device = nullptr;
+    return 0;
+  }
+
+  if (!ptr) {
+    DP("Call to omp_get_accessible_buffer with NULL ptr, returning SIZE_MAX\n");
+    if (buffer_host)
+      *buffer_host = nullptr;
+    if (buffer_device)
+      *buffer_device = nullptr;
+    return SIZE_MAX;
+  }
+
+  DeviceTy &Device = Devices[device_num];
+  size_t BufferSize = Device.getAccessibleBuffer(const_cast<void *>(ptr),
+                                                 /*Size=*/size, buffer_host,
+                                                 buffer_device);
+  DP("Call to omp_get_accessible_buffer returns %zu\n", BufferSize);
+  return BufferSize;;
+}
+
 EXTERN int omp_target_memcpy(void *dst, void *src, size_t length,
     size_t dst_offset, size_t src_offset, int dst_device, int src_device) {
   DP("Call to omp_target_memcpy, dst device %d, src device %d, "

openmp/libomptarget/src/device.cpp

@@ -164,6 +164,41 @@ LookupResult DeviceTy::lookupMapping(void *HstPtrBegin, int64_t Size) {
   return lr;
 }
 
+size_t DeviceTy::getAccessibleBuffer(void *Ptr, int64_t Size, void **BufferHost,
+                                     void **BufferDevice) {
+  size_t BufferSize;
+  DataMapMtx.lock();
+  LookupResult lr = lookupMapping(Ptr, Size);
+  if (lr.Flags.IsContained || lr.Flags.ExtendsBefore || lr.Flags.ExtendsAfter) {
+    auto &HT = *lr.Entry;
+    BufferSize = HT.HstPtrEnd - HT.HstPtrBegin;
+    DP("Overlapping mapping exists with HstPtrBegin=" DPxMOD ", TgtPtrBegin="
+        DPxMOD ", " "Size=%" PRId64 ", RefCount=%s\n",
+        DPxPTR(HT.HstPtrBegin), DPxPTR(HT.TgtPtrBegin), BufferSize,
+        HT.isRefCountInf() ? "INF" : std::to_string(HT.getRefCount()).c_str());
+    if (BufferHost)
+      *BufferHost = (void *)HT.HstPtrBegin;
+    if (BufferDevice)
+      *BufferDevice = (void *)HT.TgtPtrBegin;
+  } else if (RTLs->RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
+    DP("Unified shared memory\n");
+    BufferSize = SIZE_MAX;
+    if (BufferHost)
+      *BufferHost = nullptr;
+    if (BufferDevice)
+      *BufferDevice = nullptr;
+  } else {
+    DP("Host memory is inaccessible from device\n");
+    BufferSize = 0;
+    if (BufferHost)
+      *BufferHost = nullptr;
+    if (BufferDevice)
+      *BufferDevice = nullptr;
+  }
+  DataMapMtx.unlock();
+  return BufferSize;
+}
+
 // Used by targetDataBegin
 // Return the target pointer begin (where the data will be moved).
 // Allocate memory if this is the first occurrence of this mapping.

openmp/libomptarget/src/device.h

@@ -218,6 +218,8 @@ struct DeviceTy {
 
   uint64_t getMapEntryRefCnt(void *HstPtrBegin);
   LookupResult lookupMapping(void *HstPtrBegin, int64_t Size);
+  size_t getAccessibleBuffer(void *Ptr, int64_t Size, void **BufferHost,
+                             void **BufferDevice);
   void *getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase, int64_t Size,
                          bool &IsNew, bool &IsHostPtr, bool IsImplicit,
                          bool UpdateRefCount, bool HasCloseModifier,

openmp/libomptarget/src/exports

@@ -37,6 +37,7 @@ VERS1.0 {
     omp_target_associate_ptr;
     omp_target_disassociate_ptr;
     omp_get_mapped_ptr;
+    omp_get_accessible_buffer;
     omp_target_map_to;
     omp_target_map_from;
     omp_target_map_from_delete;

openmp/runtime/src/include/omp.h.var

@@ -174,6 +174,39 @@
     extern omp_present_t __KAI_KMPC_CONVENTION
     omp_target_range_is_present(void *, size_t, int);
 
+    // Find any mapped or unified shared memory buffer that overlaps with the
+    // specified host memory range.
+    //
+    // ptr and size specify a host memory range to look up.  size=0 has the
+    // same effect as size=1: it looks for a single mapped address instead of a
+    // larger range.
+    //
+    // Skip assignments to *buffer_host or *buffer_device described below if
+    // buffer_host or buffer_device is NULL, respectively.
+    //
+    // Evaluate the results in the following order:
+    // - If device_num is invalid, set *buffer_host and *buffer_device to NULL,
+    //   and return 0.
+    // - If ptr == NULL (regardless of size), or if the specified host memory
+    //   range is accessible from the specified device but not via any mapped
+    //   buffer (because of unified shared memory or because device_num is the
+    //   value returned by omp_get_initial_device()), set *buffer_host and
+    //   *buffer_device to NULL, and return SIZE_MAX.  FIXME: This handling of
+    //   ptr = NULL is inconsistent with the current implementation of
+    //   omp_target_is_accessible in LLVM, but OpenMP 5.1 is unclear about the
+    //   right behavior.  Make them consistent once we know which is right.
+    // - If no byte of the specified host memory range is accessible from the
+    //   specified device, set *buffer_host and *buffer_device to NULL, and
+    //   return 0.
+    // - Set *buffer_host to the start of the earliest (that is, smallest
+    //   starting address) host memory buffer that contains at least one
+    //   byte within the specified host memory range and that is mapped to the
+    //   specified device, set *buffer_device to the start of the mapped device
+    //   buffer, and return the size of that buffer.
+    extern size_t omp_get_accessible_buffer(
+        const void *ptr, size_t size, int device_num, void **buffer_host,
+        void **buffer_device);
+
     // Same as an OpenMP "target enter data" construct with:
     // - A device clause for the specified device number.
     // - A map clause with:

openmp/runtime/src/kmp_ftn_entry.h

@@ -1029,6 +1029,12 @@ int FTN_STDCALL FTN_TARGET_DISASSOCIATE_PTR(void *host_ptr, int device_num) {
 void *FTN_STDCALL FTN_GET_MAPPED_PTR(const void *ptr, int device_num) {
   return NULL;
 }
+
+size_t FTN_STDCALL FTN_GET_ACCESSIBLE_BUFFER(const void *ptr, size_t size,
+                                             int device_num, void **buffer_host,
+                                             void **buffer_device) {
+  return 0;
+}
 #endif // defined(KMP_STUB)
 
 #ifdef KMP_STUB

openmp/runtime/src/kmp_ftn_os.h

@@ -121,6 +121,7 @@
 #define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr
 #define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr
 #define FTN_GET_MAPPED_PTR omp_get_mapped_ptr
+#define FTN_GET_ACCESSIBLE_BUFFER omp_get_accessible_buffer
 #endif
 
 #define FTN_CONTROL_TOOL omp_control_tool
@@ -246,6 +247,7 @@
 #define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr_
 #define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr_
 #define FTN_GET_MAPPED_PTR omp_get_mapped_ptr_
+#define FTN_GET_ACCESSIBLE_BUFFER omp_get_accessible_buffer_
 #endif
 
 #define FTN_CONTROL_TOOL omp_control_tool_
@@ -373,6 +375,7 @@
 #define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR
 #define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR
 #define FTN_GET_MAPPED_PTR OMP_GET_MAPPED_PTR
+#define FTN_GET_ACCESSIBLE_BUFFER OMP_GET_ACCESSIBLE_BUFFER
 #endif
 
 #define FTN_CONTROL_TOOL OMP_CONTROL_TOOL
@@ -498,6 +501,7 @@
 #define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR_
 #define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR_
 #define FTN_GET_MAPPED_PTR OMP_GET_MAPPED_PTR_
+#define FTN_GET_ACCESSIBLE_BUFFER OMP_GET_ACCESSIBLE_BUFFER_
 #endif
 
 #define FTN_CONTROL_TOOL OMP_CONTROL_TOOL_