[OpenMP] Add omp_target_is_accessible() to header files

[hbae]

Summary

• Added omp_target_is_accessible to the header files
• Added missing const qualifier to device memory routines

[jdoerfert]

LG

openmp/libomptarget/include/omptarget.h

 #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);
-int omp_target_is_present(void *ptr, int device_num);
-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);
-int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
+int omp_target_is_present(const void *ptr, int device_num);
+int omp_target_memcpy(void *dst, const void *src, size_t length,
+                      size_t dst_offset, size_t src_offset, int dst_device,
+                      int src_device);
+int omp_target_memcpy_rect(void *dst, const void *src, size_t element_size,
                            int num_dims, const size_t *volume,
                            const size_t *dst_offsets, const size_t *src_offsets,
                            const size_t *dst_dimensions,
                            const size_t *src_dimensions, int dst_device,
                            int src_device);
-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);
+int omp_target_associate_ptr(const void *host_ptr, const void *device_ptr,
+                             size_t size, size_t device_offset, int device_num);
+int omp_target_disassociate_ptr(const void *host_ptr, int device_num);
 
 /// Explicit target memory allocators
 /// Using the llvm_ prefix until they become part of the OpenMP standard.
 void *llvm_omp_target_alloc_device(size_t size, int device_num);
 void *llvm_omp_target_alloc_host(size_t size, int device_num);
 void *llvm_omp_target_alloc_shared(size_t size, int device_num);
 
 /// add the clauses of the requires directives in a given file

openmp/libomptarget/src/api.cpp

if (!device_is_ready(device_num)) {
     DP("omp_target_free returns, nothing to do\n");
     return;
   }
 
   PM->Devices[device_num].deleteData(device_ptr);
   DP("omp_target_free deallocated device ptr\n");
 }
 
-EXTERN int omp_target_is_present(void *ptr, int device_num) {
+EXTERN int omp_target_is_present(const void *ptr, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_is_present for device %d and address " DPxMOD "\n",
      device_num, DPxPTR(ptr));
 
   if (!ptr) {
     DP("Call to omp_target_is_present with NULL ptr, returning false\n");
     return false;
   }
if (DevicesSize <= (size_t)device_num) {
     DP("Call to omp_target_is_present with invalid device ID, returning "
        "false\n");
     return false;
   }
 
   DeviceTy &Device = PM->Devices[device_num];
   bool IsLast; // not used
   bool IsHostPtr;
-  void *TgtPtr = Device.getTgtPtrBegin(ptr, 0, IsLast, false, IsHostPtr);
+  void *TgtPtr = Device.getTgtPtrBegin(const_cast<void *>(ptr), 0, IsLast,
+                                       false, IsHostPtr);
   int rc = (TgtPtr != NULL);
   // Under unified memory the host pointer can be returned by the
   // getTgtPtrBegin() function which means that there is no device
   // corresponding point for ptr. This function should return false
   // in that situation.
   if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY)
     rc = !IsHostPtr;
   DP("Call to omp_target_is_present returns %d\n", rc);
   return rc;
 }
 
-EXTERN int omp_target_memcpy(void *dst, void *src, size_t length,
+EXTERN int omp_target_memcpy(void *dst, const void *src, size_t length,
                              size_t dst_offset, size_t src_offset,
                              int dst_device, int src_device) {
   TIMESCOPE();
   DP("Call to omp_target_memcpy, dst device %d, src device %d, "
      "dst addr " DPxMOD ", src addr " DPxMOD ", dst offset %zu, "
      "src offset %zu, length %zu\n",
      dst_device, src_device, DPxPTR(dst), DPxPTR(src), dst_offset, src_offset,
      length);
EXTERN int omp_target_memcpy(void *dst, const void *src, size_t length,
   }
 
   if (dst_device != omp_get_initial_device() && !device_is_ready(dst_device)) {
     REPORT("omp_target_memcpy returns OFFLOAD_FAIL\n");
     return OFFLOAD_FAIL;
   }
 
   int rc = OFFLOAD_SUCCESS;
-  void *srcAddr = (char *)src + src_offset;
+  void *srcAddr = (char *)const_cast<void *>(src) + src_offset;
   void *dstAddr = (char *)dst + dst_offset;
 
   if (src_device == omp_get_initial_device() &&
       dst_device == omp_get_initial_device()) {
     DP("copy from host to host\n");
     const void *p = memcpy(dstAddr, srcAddr, length);
     if (p == NULL)
       rc = OFFLOAD_FAIL;
if (src_device == omp_get_initial_device() &&
     }
     free(buffer);
   }
 
   DP("omp_target_memcpy returns %d\n", rc);
   return rc;
 }
 
-EXTERN int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
-                                  int num_dims, const size_t *volume,
-                                  const size_t *dst_offsets,
-                                  const size_t *src_offsets,
-                                  const size_t *dst_dimensions,
-                                  const size_t *src_dimensions, int dst_device,
-                                  int src_device) {
+EXTERN int omp_target_memcpy_rect(
+    void *dst, const void *src, size_t element_size, int num_dims,
+    const size_t *volume, const size_t *dst_offsets, const size_t *src_offsets,
+    const size_t *dst_dimensions, const size_t *src_dimensions, int dst_device,
   TIMESCOPE();
   DP("Call to omp_target_memcpy_rect, dst device %d, src device %d, "
      "dst addr " DPxMOD ", src addr " DPxMOD ", dst offsets " DPxMOD ", "
      "src offsets " DPxMOD ", dst dims " DPxMOD ", src dims " DPxMOD ", "
      "volume " DPxMOD ", element size %zu, num_dims %d\n",
      dst_device, src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
      DPxPTR(src_offsets), DPxPTR(dst_dimensions), DPxPTR(src_dimensions),
      DPxPTR(volume), element_size, num_dims);
for (int i = 1; i < num_dims; ++i) {
       src_slice_size *= src_dimensions[i];
     }
 
     size_t dst_off = dst_offsets[0] * dst_slice_size;
     size_t src_off = src_offsets[0] * src_slice_size;
     for (size_t i = 0; i < volume[0]; ++i) {
       rc = omp_target_memcpy_rect(
           (char *)dst + dst_off + dst_slice_size * i,
-          (char *)src + src_off + src_slice_size * i, element_size,
-          num_dims - 1, volume + 1, dst_offsets + 1, src_offsets + 1,
-          dst_dimensions + 1, src_dimensions + 1, dst_device, src_device);
+          (char *)const_cast<void *>(src) + src_off + src_slice_size * i,
+          element_size, num_dims - 1, volume + 1, dst_offsets + 1,
+          src_offsets + 1, dst_dimensions + 1, src_dimensions + 1, dst_device,
+          src_device);
 
       if (rc) {
         DP("Recursive call to omp_target_memcpy_rect returns unsuccessfully\n");
         return rc;
       }
     }
   }
 
   DP("omp_target_memcpy_rect returns %d\n", rc);
   return rc;
 }
 
-EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
-                                    size_t size, size_t device_offset,
-                                    int device_num) {
+EXTERN int omp_target_associate_ptr(const void *host_ptr,
+                                    const void *device_ptr, size_t size,
+                                    size_t device_offset, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_associate_ptr with host_ptr " DPxMOD ", "
      "device_ptr " DPxMOD ", size %zu, device_offset %zu, device_num %d\n",
      DPxPTR(host_ptr), DPxPTR(device_ptr), size, device_offset, device_num);
 
   if (!host_ptr || !device_ptr || size <= 0) {
     REPORT("Call to omp_target_associate_ptr with invalid arguments\n");
     return OFFLOAD_FAIL;
   }
 
   if (device_num == omp_get_initial_device()) {
     REPORT("omp_target_associate_ptr: no association possible on the host\n");
     return OFFLOAD_FAIL;
   }
 
   if (!device_is_ready(device_num)) {
     REPORT("omp_target_associate_ptr returns OFFLOAD_FAIL\n");
     return OFFLOAD_FAIL;
   }
 
   DeviceTy &Device = PM->Devices[device_num];
   void *device_addr = (void *)((uint64_t)device_ptr + (uint64_t)device_offset);
-  int rc = Device.associatePtr(host_ptr, device_addr, size);
+  int rc = Device.associatePtr(const_cast<void *>(host_ptr),
+                               const_cast<void *>(device_addr), size);
   DP("omp_target_associate_ptr returns %d\n", rc);
   return rc;
 }
 
-EXTERN int omp_target_disassociate_ptr(void *host_ptr, int device_num) {
+EXTERN int omp_target_disassociate_ptr(const void *host_ptr, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_disassociate_ptr with host_ptr " DPxMOD ", "
      "device_num %d\n",
      DPxPTR(host_ptr), device_num);
 
   if (!host_ptr) {
     REPORT("Call to omp_target_associate_ptr with invalid host_ptr\n");
     return OFFLOAD_FAIL;
   }
 
   if (device_num == omp_get_initial_device()) {
     REPORT(
         "omp_target_disassociate_ptr: no association possible on the host\n");
     return OFFLOAD_FAIL;
   }
 
   if (!device_is_ready(device_num)) {
     REPORT("omp_target_disassociate_ptr returns OFFLOAD_FAIL\n");
     return OFFLOAD_FAIL;
   }
 
   DeviceTy &Device = PM->Devices[device_num];
-  int rc = Device.disassociatePtr(host_ptr);
+  int rc = Device.disassociatePtr(const_cast<void *>(host_ptr));
   DP("omp_target_disassociate_ptr returns %d\n", rc);
   return rc;
 }

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

#   endif
     extern int  __KAI_KMPC_CONVENTION  omp_get_num_teams (void);
     extern int  __KAI_KMPC_CONVENTION  omp_get_team_num (void);
     extern int  __KAI_KMPC_CONVENTION  omp_get_cancellation (void);
 
     /* OpenMP 4.5 */
     extern int   __KAI_KMPC_CONVENTION  omp_get_initial_device (void);
     extern void* __KAI_KMPC_CONVENTION  omp_target_alloc(size_t, int);
     extern void  __KAI_KMPC_CONVENTION  omp_target_free(void *, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_is_present(void *, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy(void *, void *, size_t, size_t, size_t, int, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy_rect(void *, void *, size_t, int, const size_t *,
+    extern int   __KAI_KMPC_CONVENTION  omp_target_is_present(const void *, int);
+    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy(void *, const void *, size_t, size_t, size_t, int, int);
+    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy_rect(void *, const void *, size_t, int, const size_t *,
                                             const size_t *, const size_t *, const size_t *, const size_t *, int, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_associate_ptr(void *, void *, size_t, size_t, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_disassociate_ptr(void *, int);
+    extern int   __KAI_KMPC_CONVENTION  omp_target_associate_ptr(const void *, const void *, size_t, size_t, int);
+    extern int   __KAI_KMPC_CONVENTION  omp_target_disassociate_ptr(const void *, int);
 
     /* OpenMP 5.0 */
     extern int   __KAI_KMPC_CONVENTION  omp_get_device_num (void);
     typedef void * omp_depend_t;
 
     /* OpenMP 5.1 interop */
     typedef intptr_t omp_intptr_t;
 
#   endif
      */
     extern int    __KAI_KMPC_CONVENTION  omp_target_memcpy_rect_async(void *, const void *, size_t, int, const size_t *,
                                              const size_t *, const size_t *, const size_t *, const size_t *, int, int,
                                              int, omp_depend_t *);
     /*!
      * The `omp_get_mapped_ptr` routine returns the device pointer that is associated with a host pointer for a given device.
      */
     extern void * __KAI_KMPC_CONVENTION  omp_get_mapped_ptr(const void *, int);
+    extern int    __KAI_KMPC_CONVENTION  omp_target_is_accessible(const void *, size_t, int);
 
     /* kmp API functions */
     extern int    __KAI_KMPC_CONVENTION  kmp_get_stacksize          (void);
     extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize          (int);
     extern size_t __KAI_KMPC_CONVENTION  kmp_get_stacksize_s        (void);
     extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize_s        (size_t);
     extern int    __KAI_KMPC_CONVENTION  kmp_get_blocktime          (void);
     extern int    __KAI_KMPC_CONVENTION  kmp_get_library            (void);

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

&      device_offset, device_num) bind(c)
 
         function omp_target_disassociate_ptr(ptr, device_num) bind(c)
           use, intrinsic :: iso_c_binding, only : c_ptr, c_int
           integer(c_int) omp_target_disassociate_ptr
           type(c_ptr), value :: ptr
           integer(c_int), value :: device_num
         end function omp_target_disassociate_ptr
 
+        function omp_target_is_accessible(ptr, size, device_num) bind(c)
+          use, intrinsic :: iso_c_binding, only : c_ptr, c_size_t, c_int
+          integer(c_int) omp_target_is_accessible
+          type(c_ptr), value :: ptr
+          integer(c_size_t), value :: size
+          integer(c_int), value :: device_num
+        end function omp_target_is_accessible
+
 !       ***
 !       *** kmp_* entry points
 !       ***
 
         subroutine kmp_set_stacksize(size) bind(c)
           import
           integer (kind=omp_integer_kind), value :: size
         end subroutine kmp_set_stacksize

openmp/runtime/src/include/omp_lib.f90.var

!DIR$ ENDIF
 
           function omp_target_disassociate_ptr(ptr, device_num) bind(c)
             use omp_lib_kinds
             integer(c_int) omp_target_disassociate_ptr
             type(c_ptr), value :: ptr
             integer(c_int), value :: device_num
           end function omp_target_disassociate_ptr
 
+          function omp_target_is_accessible(ptr, size, device_num) bind(c)
+            use omp_lib_kinds
+            use, intrinsic :: iso_c_binding, only : c_ptr, c_size_t, c_int
+            integer(c_int) omp_target_is_accessible
+            type(c_ptr), value :: ptr
+            integer(c_size_t), value :: size
+            integer(c_int), value :: device_num
+          end function omp_target_is_accessible
+
 !         ***
 !         *** kmp_* entry points
 !         ***
 
           subroutine kmp_set_stacksize(size) bind(c)
             use omp_lib_kinds
             integer (kind=omp_integer_kind), value :: size
           end subroutine kmp_set_stacksize