[OpenMP] Rework implementation to be conform to OpenMP 6.0

Removes restriction on Ptr to host pointers.
Provides accessibility check for AMDGPU through HSA + default implementation returning false.

Author: nicebert

offload/include/device.h

@@ -158,8 +158,8 @@ struct DeviceTy {
   /// Ask the device whether the runtime should use auto zero-copy.
   bool useAutoZeroCopy();
 
-  /// Ask the device whether it supports unified memory.
-  bool supportsUnifiedMemory();
+  /// Ask the device whether the storage is accessible.
+  bool isAccessiblePtr(const void *Ptr, size_t Size);
 
   /// Check if there are pending images for this device.
   bool hasPendingImages() const { return HasPendingImages; }

offload/libomptarget/OpenMP/API.cpp

@@ -225,26 +225,7 @@ EXTERN int omp_target_is_accessible(const void *Ptr, size_t Size,
   if (!DeviceOrErr)
     FATAL_MESSAGE(DeviceNum, "%s", toString(DeviceOrErr.takeError()).c_str());
 
-  // TODO: Add check for openmp version compatability
-
-  // for OpenMP 5.1 the routine checks whether a host pointer is accessible from
-  // the device this requires for the device to support unified shared memory
-  if (DeviceOrErr->supportsUnifiedMemory()) {
-    DP("Device %d supports unified memory, returning true\n", DeviceNum);
-    return true;
-  }
-
-  // TODO: Provide stubs & implementation to check whether a pointer is
-  // accessible from a given device using hsa_amd_pointer_info for AMDGPU
-  // implementation for OpenMP 6.x the specification is required to return true
-  // if the accessibility of the pointer can be determined otherwise it's
-  // allowed to return false the specification will be clarified from the
-  // current wording
-
-  // functionality to check whether a device pointer is accessible from a device
-  // (OpenMP 6.0) from the host might not be possible
-  DP("Device %d does not support unified memory, returning false\n", DeviceNum);
-  return false;
+  return DeviceOrErr->isAccessiblePtr(Ptr, Size);
 }
 
 EXTERN int omp_target_memcpy(void *Dst, const void *Src, size_t Length,

offload/libomptarget/device.cpp

@@ -368,6 +368,6 @@ bool DeviceTy::useAutoZeroCopy() {
   return RTL->use_auto_zero_copy(RTLDeviceID);
 }
 
-bool DeviceTy::supportsUnifiedMemory() {
-  return RTL->supports_unified_memory(RTLDeviceID);
-}
+bool DeviceTy::isAccessiblePtr(const void *Ptr, size_t Size) {
+  return RTL->is_accessible_ptr(RTLDeviceID, Ptr, Size);
+}

offload/plugins-nextgen/amdgpu/src/rtl.cpp

@@ -3027,7 +3027,26 @@ struct AMDGPUDeviceTy : public GenericDeviceTy, AMDGenericDeviceTy {
     return ((IsAPU || OMPX_ApuMaps) && IsXnackEnabled);
   }
 
-  bool supportsUnifiedMemoryImpl() override { return IsXnackEnabled; }
+  bool isAccessiblePtrImpl(const void *Ptr, size_t Size) override {
+    hsa_amd_pointer_info_t Info;
+    Info.size = sizeof(hsa_amd_pointer_info_t);
+
+    hsa_agent_t *Agents = nullptr;
+    uint32_t Count = 0;
+    hsa_status_t Status = hsa_amd_pointer_info(Ptr, &Info, malloc, &Count, &Agents);
+    
+    if (Status != HSA_STATUS_SUCCESS)
+      return false;
+
+    // Checks if the pointer is known by HSA and accessible by the device
+    for(uint32_t i = 0; i < Count; i++)
+      if(Agents[i].handle == getAgent().handle)
+        return Info.sizeInBytes >= Size;
+
+    // If the pointer is unknown to HSA it's assumed a host pointer
+    // in that case the device can access it on unified memory support is enabled
+    return IsXnackEnabled;
+  }
 
   /// Getters and setters for stack and heap sizes.
   Error getDeviceStackSize(uint64_t &Value) override {

offload/plugins-nextgen/common/include/PluginInterface.h

@@ -1093,9 +1093,10 @@ struct GenericDeviceTy : public DeviceAllocatorTy {
   bool useAutoZeroCopy();
   virtual bool useAutoZeroCopyImpl() { return false; }
 
-  /// Returns true if the device has unified memory capabilities
-  bool supportsUnifiedMemory();
-  virtual bool supportsUnifiedMemoryImpl() { return false; }
+  /// Returns true if the plugin can guarantee that the associated
+  /// storage is accessible
+  bool isAccessiblePtr(const void *Ptr, size_t Size);
+  virtual bool isAccessiblePtrImpl(const void *Ptr, size_t Size) { return false; }
 
   virtual Expected<omp_interop_val_t *>
   createInterop(int32_t InteropType, interop_spec_t &InteropSpec) {
@@ -1527,8 +1528,8 @@ struct GenericPluginTy {
   /// Returns if the plugin can support automatic copy.
   int32_t use_auto_zero_copy(int32_t DeviceId);
 
-  /// Returns if the the device supports unified memory.
-  int32_t supports_unified_memory(int32_t DeviceId);
+  /// Returns if the associated storage is accessible for a given device.
+  int32_t is_accessible_ptr(int32_t DeviceId, const void *Ptr, size_t Size);
 
   /// Look up a global symbol in the given binary.
   int32_t get_global(__tgt_device_binary Binary, uint64_t Size,

offload/plugins-nextgen/common/src/PluginInterface.cpp

@@ -1607,9 +1607,7 @@ Error GenericDeviceTy::syncEvent(void *EventPtr) {
 
 bool GenericDeviceTy::useAutoZeroCopy() { return useAutoZeroCopyImpl(); }
 
-bool GenericDeviceTy::supportsUnifiedMemory() {
-  return supportsUnifiedMemoryImpl();
-}
+bool GenericDeviceTy::isAccessiblePtr(const void *Ptr, size_t Size) { return isAccessiblePtrImpl(Ptr, Size); }
 
 Error GenericPluginTy::init() {
   if (Initialized)
@@ -2163,8 +2161,8 @@ int32_t GenericPluginTy::use_auto_zero_copy(int32_t DeviceId) {
   return getDevice(DeviceId).useAutoZeroCopy();
 }
 
-int32_t GenericPluginTy::supports_unified_memory(int32_t DeviceId) {
-  return getDevice(DeviceId).supportsUnifiedMemory();
+int32_t GenericPluginTy::is_accessible_ptr(int32_t DeviceId, const void *Ptr, size_t Size) {
+  return getDevice(DeviceId).isAccessiblePtr(Ptr, Size);
 }
 
 int32_t GenericPluginTy::get_global(__tgt_device_binary Binary, uint64_t Size,