[OpenMP][WIP] Refactor global handling in plugins

[jdoerfert]

Summary

Global symbol handling is one of the common things the plugins do and we
should be uniform wrt. functionality, messaging, etc. The new
GlobalHandler will do most of the heavy lifting and the plugins simply
need to provide some information to it. Error checking and such is done
the same way for all plugins and more refactoring opportunities arise.

This removes two "functions" of the AMDGPU plugins for now:

1. Write the device environment into the image. This is something we should investigate for CUDA and add to the GlobalHandler. For now, it is a single HtoD transfer we pay extra.
2. If the device environment could not be transferred we used to check the architecture. The code needs to be ported to the llvm ELF handling and then we can do this again.

[JonChesterfield]

Discussed a bit offline. I'd like to keep the capability to read/write to symbols in the device images, without first having to load the image onto the device and then call into cuda/hsa/etc to access the values that were originally in host memory. readGlobalFromImage exists in this patch, writeGlobalToImage would be very similar in implementation.

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

1231

The memory optimisation that allocated omptarget_nvptx_device_State one per process instead of once per device image is obsolete with the new runtime

openmp/libomptarget/plugins/common/GlobalHandler/GlobalHandler.h

91

Confusing naming here - coping globals / copying from global symbols?

[jdoerfert]

In D113833#3129445, @JonChesterfield wrote:

Discussed a bit offline. I'd like to keep the capability to read/write to symbols in the device images, without first having to load the image onto the device and then call into cuda/hsa/etc to access the values that were originally in host memory. readGlobalFromImage exists in this patch, writeGlobalToImage would be very similar in implementation.

We kept the capability to read symbols from device images with this patch. writeGlobalToImage is something that wasn't easily changeable to a generic scheme so I added a TODO and left it. Overall extra cost: 1x H2D.

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

1231

I know. Once we don't need to keep the old for AMD we delete this :)

openmp/libomptarget/plugins/common/GlobalHandler/GlobalHandler.h

91

Not sure what you mean. Suggestions for rewording welcome.

openmp/libomptarget/plugins/amdgpu/CMakeLists.txt

if (${hsa-runtime64_FOUND} AND NOT LIBOMPTARGET_FORCE_DLOPEN_LIBHSA)
   set(LIBOMPTARGET_DEP_LIBRARIES hsa-runtime64::hsa-runtime64)
 else()
   libomptarget_say("Building AMDGPU plugin for dlopened libhsa")
   include_directories(dynamic_hsa)
   set(LIBOMPTARGET_EXTRA_SOURCE dynamic_hsa/hsa.cpp)
   set(LIBOMPTARGET_DEP_LIBRARIES)
 endif()
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
+
 add_library(omptarget.rtl.amdgpu SHARED
       impl/impl.cpp
       impl/interop_hsa.cpp
       impl/data.cpp
       impl/get_elf_mach_gfx_name.cpp
       impl/system.cpp
       impl/msgpack.cpp
       src/rtl.cpp

 else()
   set(LDFLAGS_UNDEFINED "-Wl,-z,defs")
 endif()
 
 set_property(TARGET omptarget.rtl.amdgpu PROPERTY INSTALL_RPATH "$ORIGIN")
 target_link_libraries(
   omptarget.rtl.amdgpu
   PRIVATE
+  DeviceInterface
+  GlobalHandler
   elf_common
   ${LIBOMPTARGET_DEP_LIBRARIES}
   ${CMAKE_DL_LIBS}
   ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
   ${OPENMP_PTHREAD_LIB}
   "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports"
   ${LDFLAGS_UNDEFINED}
   )

openmp/libomptarget/plugins/amdgpu/impl/interop_hsa.h

 //===--- amdgpu/impl/interop_hsa.h -------------------------------- 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef INCLUDE_INTEROP_HSA_H_
 #define INCLUDE_INTEROP_HSA_H_
 
-#include "impl_runtime.h"
 #include "hsa_api.h"
+#include "impl_runtime.h"
 #include "internal.h"
 
 #include <map>
 #include <string>
 
 extern "C" {
 
-hsa_status_t interop_hsa_get_symbol_info(
-    const std::map<std::string, atl_symbol_info_t> &SymbolInfoTable,
-    int DeviceId, const char *symbol, void **var_addr, unsigned int *var_size);
-
-hsa_status_t interop_hsa_get_kernel_info(
-    const std::map<std::string, atl_kernel_info_t> &KernelInfoTable,
-    int DeviceId, const char *kernel_name, hsa_executable_symbol_info_t info,
-    uint32_t *value);
+typedef std::map<std::string, atl_symbol_info_t> SymbolInfoTableTy;
+typedef std::map<std::string, atl_kernel_info_t> KernelInfoTableTy;
 
+hsa_status_t
+interop_hsa_get_symbol_info(const SymbolInfoTableTy &SymbolInfoTable,
+                            int DeviceId, const char *symbol, void **var_addr,
+                            unsigned int *var_size);
+
+hsa_status_t
+interop_hsa_get_kernel_info(const KernelInfoTableTy &KernelInfoTable,
+                            int DeviceId, const char *kernel_name,
+                            hsa_executable_symbol_info_t info, uint32_t *value);
 }
 
 #endif // INCLUDE_INTEROP_HSA_H_

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

 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <assert.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <functional>
-#include <libelf.h>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <shared_mutex>
 #include <unordered_map>
 #include <vector>
 
-#include "interop_hsa.h"
+#include "Debug.h"
 #include "impl_runtime.h"
+#include "interop_hsa.h"
 
 #include "internal.h"
+#include "omptarget.h"
 #include "rt.h"
 
 #include "DeviceEnvironment.h"
+
+#include "GlobalHandler.h"
+
 #include "get_elf_mach_gfx_name.h"
 #include "omptargetplugin.h"
 #include "print_tracing.h"
 
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 
+using namespace llvm::omp::plugin;
+
+int32_t llvm::omp::plugin::GlobalHandlerTy::getGlobalMetadataFromDevice(
+    int32_t DeviceId, GlobalTy &DeviceGlobal, void *SymbolInfoTablePtr) {
+  SymbolInfoTableTy &SymbolInfoTable =
+      *static_cast<SymbolInfoTableTy *>(SymbolInfoTablePtr);
+  void *DevPtr;
+  unsigned DevSize;
+  const char *Name = DeviceGlobal.getName().c_str();
+  hsa_status_t Err = interop_hsa_get_symbol_info(SymbolInfoTable, DeviceId,
+                                                 Name, &DevPtr, &DevSize);
+
+  if (Err != HSA_STATUS_SUCCESS) {
+    // Inform the user what symbol prevented offloading
+    DP("Loading global '%s' (Failed)\n", Name);
+    return OFFLOAD_FAIL;
+  }
+
+  if (DevSize != DeviceGlobal.getSize()) {
+    DP("Loading global '%s' - size mismatch (%u != %u)\n", Name, DevSize,
+       DeviceGlobal.getSize());
+    return OFFLOAD_FAIL;
+  }
+
+  DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
+     DPxPTR(e - HostBegin), Name, DPxPTR(DevPtr));
+  DeviceGlobal.setPtr(DevPtr);
+  return OFFLOAD_SUCCESS;
+}
+
 // hostrpc interface, FIXME: consider moving to its own include these are
 // statically linked into amdgpu/plugin if present from hostrpc_services.a,
 // linked as --whole-archive to override the weak symbols that are used to
 // implement a fallback for toolchains that do not yet have a hostrpc library.
 extern "C" {
 unsigned long hostrpc_assign_buffer(hsa_agent_t agent, hsa_queue_t *this_Q,
                                     uint32_t device_id);
 hsa_status_t hostrpc_init();
public:
   EnvironmentVariables Env;
 
   // OpenMP Requires Flags
   int64_t RequiresFlags;
 
   // Resource pools
   SignalPoolT FreeSignalPool;
 
+  GlobalHandlerTy GlobalHandler;
+
   bool hostcall_required = false;
 
   std::vector<hsa_executable_t> HSAExecutables;
 
-  std::vector<std::map<std::string, atl_kernel_info_t>> KernelInfoTable;
-  std::vector<std::map<std::string, atl_symbol_info_t>> SymbolInfoTable;
+  std::vector<KernelInfoTableTy> KernelInfoTables;
+  std::vector<SymbolInfoTableTy> SymbolInfoTables;
 
   hsa_amd_memory_pool_t KernArgPool;
 
   // fine grained memory pool for host allocations
   hsa_amd_memory_pool_t HostFineGrainedMemoryPool;
 
   // fine and coarse-grained memory pools per offloading device
   std::vector<hsa_amd_memory_pool_t> DeviceFineGrainedMemoryPools;
RTLDeviceInfoTy() {
     ThreadsPerGroup.resize(NumberOfDevices);
     ComputeUnits.resize(NumberOfDevices);
     GPUName.resize(NumberOfDevices);
     GroupsPerDevice.resize(NumberOfDevices);
     WarpSize.resize(NumberOfDevices);
     NumTeams.resize(NumberOfDevices);
     NumThreads.resize(NumberOfDevices);
     deviceStateStore.resize(NumberOfDevices);
-    KernelInfoTable.resize(NumberOfDevices);
-    SymbolInfoTable.resize(NumberOfDevices);
+    KernelInfoTables.resize(NumberOfDevices);
+    SymbolInfoTables.resize(NumberOfDevices);
     DeviceCoarseGrainedMemoryPools.resize(NumberOfDevices);
     DeviceFineGrainedMemoryPools.resize(NumberOfDevices);
 
     err = setupDevicePools(HSAAgents);
     if (err != HSA_STATUS_SUCCESS) {
       DP("Setup for Device Memory Pools failed\n");
       return;
     }
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");
   }
   return r;
 }
 
-uint32_t elf_e_flags(__tgt_device_image *image) {
-  char *img_begin = (char *)image->ImageStart;
-  size_t img_size = (char *)image->ImageEnd - img_begin;
-
-  Elf *e = elf_memory(img_begin, img_size);
-  if (!e) {
-    DP("Unable to get ELF handle: %s!\n", elf_errmsg(-1));
-    return 0;
-  }
-
-  Elf64_Ehdr *eh64 = elf64_getehdr(e);
-
-  if (!eh64) {
-    DP("Unable to get machine ID from ELF file!\n");
-    elf_end(e);
-    return 0;
-  }
-
-  uint32_t Flags = eh64->e_flags;
-
-  elf_end(e);
-  DP("ELF Flags: 0x%x\n", Flags);
-  return Flags;
-}
 } // namespace
 
 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *image) {
   return elf_machine_id_is_amdgcn(image);
 }
 
 int __tgt_rtl_number_of_devices() {
   // If the construction failed, no methods are safe to call
DP("Device %d: wavefront size %d, total threads %d x %d = %d\n", device_id,
      DeviceInfo.GroupsPerDevice[device_id],
      DeviceInfo.GroupsPerDevice[device_id] *
          DeviceInfo.ThreadsPerGroup[device_id]);
 
   return OFFLOAD_SUCCESS;
 }
 
 namespace {
-Elf64_Shdr *find_only_SHT_HASH(Elf *elf) {
-  size_t N;
-  int rc = elf_getshdrnum(elf, &N);
-  if (rc != 0) {
-    return nullptr;
-  }
-
-  Elf64_Shdr *result = nullptr;
-  for (size_t i = 0; i < N; i++) {
-    Elf_Scn *scn = elf_getscn(elf, i);
-    if (scn) {
-      Elf64_Shdr *shdr = elf64_getshdr(scn);
-      if (shdr) {
-        if (shdr->sh_type == SHT_HASH) {
-          if (result == nullptr) {
-            result = shdr;
-          } else {
-            // multiple SHT_HASH sections not handled
-            return nullptr;
-          }
-        }
-      }
-    }
-  }
-  return result;
-}
-
-const Elf64_Sym *elf_lookup(Elf *elf, char *base, Elf64_Shdr *section_hash,
-                            const char *symname) {
-
-  assert(section_hash);
-  size_t section_symtab_index = section_hash->sh_link;
-  Elf64_Shdr *section_symtab =
-      elf64_getshdr(elf_getscn(elf, section_symtab_index));
-  size_t section_strtab_index = section_symtab->sh_link;
-
-  const Elf64_Sym *symtab =
-      reinterpret_cast<const Elf64_Sym *>(base + section_symtab->sh_offset);
-
-  const uint32_t *hashtab =
-      reinterpret_cast<const uint32_t *>(base + section_hash->sh_offset);
-
-  // Layout:
-  // nbucket
-  // nchain
-  // bucket[nbucket]
-  // chain[nchain]
-  uint32_t nbucket = hashtab[0];
-  const uint32_t *bucket = &hashtab[2];
-  const uint32_t *chain = &hashtab[nbucket + 2];
-
-  const size_t max = strlen(symname) + 1;
-  const uint32_t hash = elf_hash(symname);
-  for (uint32_t i = bucket[hash % nbucket]; i != 0; i = chain[i]) {
-    char *n = elf_strptr(elf, section_strtab_index, symtab[i].st_name);
-    if (strncmp(symname, n, max) == 0) {
-      return &symtab[i];
-    }
-  }
-
-  return nullptr;
-}
-
-struct symbol_info {
-  void *addr = nullptr;
-  uint32_t size = UINT32_MAX;
-  uint32_t sh_type = SHT_NULL;
-};
-
-int get_symbol_info_without_loading(Elf *elf, char *base, const char *symname,
-                                    symbol_info *res) {
-  if (elf_kind(elf) != ELF_K_ELF) {
-    return 1;
-  }
-
-  Elf64_Shdr *section_hash = find_only_SHT_HASH(elf);
-  if (!section_hash) {
-    return 1;
-  }
-
-  const Elf64_Sym *sym = elf_lookup(elf, base, section_hash, symname);
-  if (!sym) {
-    return 1;
-  }
-
-  if (sym->st_size > UINT32_MAX) {
-    return 1;
-  }
-
-  if (sym->st_shndx == SHN_UNDEF) {
-    return 1;
-  }
-
-  Elf_Scn *section = elf_getscn(elf, sym->st_shndx);
-  if (!section) {
-    return 1;
-  }
-
-  Elf64_Shdr *header = elf64_getshdr(section);
-  if (!header) {
-    return 1;
-  }
-
-  res->addr = sym->st_value + base;
-  res->size = static_cast<uint32_t>(sym->st_size);
-  res->sh_type = header->sh_type;
-  return 0;
-}
-
-int get_symbol_info_without_loading(char *base, size_t img_size,
-                                    const char *symname, symbol_info *res) {
-  Elf *elf = elf_memory(base, img_size);
-  if (elf) {
-    int rc = get_symbol_info_without_loading(elf, base, symname, res);
-    elf_end(elf);
-    return rc;
-  }
-  return 1;
-}
-
-hsa_status_t interop_get_symbol_info(char *base, size_t img_size,
-                                     const char *symname, void **var_addr,
-                                     uint32_t *var_size) {
-  symbol_info si;
-  int rc = get_symbol_info_without_loading(base, img_size, symname, &si);
-  if (rc == 0) {
-    *var_addr = si.addr;
-    *var_size = si.size;
-    return HSA_STATUS_SUCCESS;
-  } else {
-    return HSA_STATUS_ERROR;
-  }
-}
-
 template <typename C>
 hsa_status_t module_register_from_memory_to_place(
-    std::map<std::string, atl_kernel_info_t> &KernelInfoTable,
-    std::map<std::string, atl_symbol_info_t> &SymbolInfoTable,
+    KernelInfoTableTy &KernelInfoTable, SymbolInfoTableTy &SymbolInfoTable,
     void *module_bytes, size_t module_size, int DeviceId, C cb,
     std::vector<hsa_executable_t> &HSAExecutables) {
   auto L = [](void *data, size_t size, void *cb_state) -> hsa_status_t {
     C *unwrapped = static_cast<C *>(cb_state);
     return (*unwrapped)(data, size);
   };
   return core::RegisterModuleFromMemory(
       KernelInfoTable, SymbolInfoTable, module_bytes, module_size,
       DeviceInfo.HSAAgents[DeviceId], L, static_cast<void *>(&cb),
       HSAExecutables);
 }
 } // namespace
 
-static uint64_t get_device_State_bytes(char *ImageStart, size_t img_size) {
-  uint64_t device_State_bytes = 0;
-  {
-    // If this is the deviceRTL, get the state variable size
-    symbol_info size_si;
-    int rc = get_symbol_info_without_loading(
-        ImageStart, img_size, "omptarget_nvptx_device_State_size", &size_si);
-
-    if (rc == 0) {
-      if (size_si.size != sizeof(uint64_t)) {
-        DP("Found device_State_size variable with wrong size\n");
-        return 0;
-      }
-
-      // Read number of bytes directly from the elf
-      memcpy(&device_State_bytes, size_si.addr, sizeof(uint64_t));
-    }
-  }
-  return device_State_bytes;
-}
-
 static __tgt_target_table *
 __tgt_rtl_load_binary_locked(int32_t device_id, __tgt_device_image *image);
 
 static __tgt_target_table *
 __tgt_rtl_load_binary_locked(int32_t device_id, __tgt_device_image *image);
 
 __tgt_target_table *__tgt_rtl_load_binary(int32_t device_id,
                                           __tgt_device_image *image) {
   DeviceInfo.load_run_lock.lock();
   __tgt_target_table *res = __tgt_rtl_load_binary_locked(device_id, image);
   DeviceInfo.load_run_lock.unlock();
   return res;
 }
 
-struct device_environment {
-  // initialise an DeviceEnvironmentTy in the deviceRTL
-  // patches around differences in the deviceRTL between trunk, aomp,
-  // rocmcc. Over time these differences will tend to zero and this class
-  // simplified.
-  // Symbol may be in .data or .bss, and may be missing fields, todo:
-  // review aomp/trunk/rocm and simplify the following
-
-  // The symbol may also have been deadstripped because the device side
-  // accessors were unused.
-
-  // If the symbol is in .data (aomp, rocm) it can be written directly.
-  // If it is in .bss, we must wait for it to be allocated space on the
-  // gpu (trunk) and initialize after loading.
-  const char *sym() { return "omptarget_device_environment"; }
-
-  DeviceEnvironmentTy host_device_env;
-  symbol_info si;
-  bool valid = false;
-
-  __tgt_device_image *image;
-  const size_t img_size;
-
-  device_environment(int device_id, int number_devices,
-                     __tgt_device_image *image, const size_t img_size)
-      : image(image), img_size(img_size) {
-
-    host_device_env.NumDevices = number_devices;
-    host_device_env.DeviceNum = device_id;
-    host_device_env.DebugKind = 0;
-    host_device_env.DynamicMemSize = 0;
-    if (char *envStr = getenv("LIBOMPTARGET_DEVICE_RTL_DEBUG")) {
-      host_device_env.DebugKind = std::stoi(envStr);
-    }
-
-    int rc = get_symbol_info_without_loading((char *)image->ImageStart,
-                                             img_size, sym(), &si);
-    if (rc != 0) {
-      DP("Finding global device environment '%s' - symbol missing.\n", sym());
-      return;
-    }
-
-    if (si.size > sizeof(host_device_env)) {
-      DP("Symbol '%s' has size %u, expected at most %zu.\n", sym(), si.size,
-         sizeof(host_device_env));
-      return;
-    }
-
-    valid = true;
-  }
-
-  bool in_image() { return si.sh_type != SHT_NOBITS; }
-
-  hsa_status_t before_loading(void *data, size_t size) {
-    if (valid) {
-      if (in_image()) {
-        DP("Setting global device environment before load (%u bytes)\n",
-           si.size);
-        uint64_t offset = (char *)si.addr - (char *)image->ImageStart;
-        void *pos = (char *)data + offset;
-        memcpy(pos, &host_device_env, si.size);
-      }
-    }
-    return HSA_STATUS_SUCCESS;
-  }
-
-  hsa_status_t after_loading() {
-    if (valid) {
-      if (!in_image()) {
-        DP("Setting global device environment after load (%u bytes)\n",
-           si.size);
-        int device_id = host_device_env.DeviceNum;
-        auto &SymbolInfo = DeviceInfo.SymbolInfoTable[device_id];
-        void *state_ptr;
-        uint32_t state_ptr_size;
-        hsa_status_t err = interop_hsa_get_symbol_info(
-            SymbolInfo, device_id, sym(), &state_ptr, &state_ptr_size);
-        if (err != HSA_STATUS_SUCCESS) {
-          DP("failed to find %s in loaded image\n", sym());
-          return err;
-        }
-
-        if (state_ptr_size != si.size) {
-          DP("Symbol had size %u before loading, %u after\n", state_ptr_size,
-             si.size);
-          return HSA_STATUS_ERROR;
-        }
-
-        return DeviceInfo.freesignalpool_memcpy_h2d(state_ptr, &host_device_env,
-                                                    state_ptr_size, device_id);
-      }
-    }
-    return HSA_STATUS_SUCCESS;
-  }
-};
-
 static hsa_status_t impl_calloc(void **ret_ptr, size_t size, int DeviceId) {
   uint64_t rounded = 4 * ((size + 3) / 4);
   void *ptr;
   hsa_amd_memory_pool_t MemoryPool = DeviceInfo.getDeviceMemoryPool(DeviceId);
   hsa_status_t err = hsa_amd_memory_pool_allocate(MemoryPool, rounded, 0, &ptr);
   if (err != HSA_STATUS_SUCCESS) {
     return err;
   }
 
   hsa_status_t rc = hsa_amd_memory_fill(ptr, 0, rounded / 4);
   if (rc != HSA_STATUS_SUCCESS) {
     DP("zero fill device_state failed with %u\n", rc);
     core::Runtime::Memfree(ptr);
     return HSA_STATUS_ERROR;
   }
 
   *ret_ptr = ptr;
   return HSA_STATUS_SUCCESS;
 }
 
-static bool image_contains_symbol(void *data, size_t size, const char *sym) {
-  symbol_info si;
-  int rc = get_symbol_info_without_loading((char *)data, size, sym, &si);
-  return (rc == 0) && (si.addr != nullptr);
-}
-
 __tgt_target_table *__tgt_rtl_load_binary_locked(int32_t device_id,
                                                  __tgt_device_image *image) {
   // This function loads the device image onto gpu[device_id] and does other
   // per-image initialization work. Specifically:
   //
   // - Initialize an DeviceEnvironmentTy instance embedded in the
   //   image at the symbol "omptarget_device_environment"
   //   Fields DebugKind, DeviceNum, NumDevices. Used by the deviceRTL.
__tgt_target_table *__tgt_rtl_load_binary_locked(int32_t device_id,
 
   // We do not need to set the ELF version because the caller of this function
   // had to do that to decide the right runtime to use
 
   if (!elf_machine_id_is_amdgcn(image)) {
     return NULL;
   }
 
+  // send device environment data to the device
   {
-    auto env = device_environment(device_id, DeviceInfo.NumberOfDevices, image,
-                                  img_size);
-
-    auto &KernelInfo = DeviceInfo.KernelInfoTable[device_id];
-    auto &SymbolInfo = DeviceInfo.SymbolInfoTable[device_id];
-    hsa_status_t err = module_register_from_memory_to_place(
-        KernelInfo, SymbolInfo, (void *)image->ImageStart, img_size, device_id,
-        [&](void *data, size_t size) {
-          if (image_contains_symbol(data, size, "needs_hostcall_buffer")) {
-            __atomic_store_n(&DeviceInfo.hostcall_required, true,
-                             __ATOMIC_RELEASE);
-          }
-          return env.before_loading(data, size);
-        },
-        DeviceInfo.HSAExecutables);
-
-    check("Module registering", err);
-    if (err != HSA_STATUS_SUCCESS) {
-      const char *DeviceName = DeviceInfo.GPUName[device_id].c_str();
-      const char *ElfName = get_elf_mach_gfx_name(elf_e_flags(image));
-
-      if (strcmp(DeviceName, ElfName) != 0) {
-        DP("Possible gpu arch mismatch: device:%s, image:%s please check"
-           " compiler flag: -march=<gpu>\n",
-           DeviceName, ElfName);
-      } else {
-        DP("Error loading image onto GPU: %s\n", get_error_string(err));
-      }
-
-      return NULL;
-    }
-
-    err = env.after_loading();
-    if (err != HSA_STATUS_SUCCESS) {
-      return NULL;
+    uint32_t DynamicMemorySize = 0;
+    uint32_t DebugKind = 0;
+    if (const char *EnvStr = getenv("LIBOMPTARGET_DEVICE_RTL_DEBUG"))
+      DebugKind = std::stoi(EnvStr);
+
+    // TODO: The device ID used here is not the real device ID used by OpenMP.
+    StaticGlobalTy<DeviceEnvironmentTy> DeviceEnvGlobal(
+        "omptarget_device_environment", DebugKind,
+        static_cast<uint32_t>(DeviceInfo.NumberOfDevices),
+        static_cast<uint32_t>(device_id),
+        static_cast<uint32_t>(DynamicMemorySize));
+    auto &SymbolInfoTable = DeviceInfo.SymbolInfoTables[device_id];
+    // TODO: Implement "writeGlobalToImage" in the GlobalHandler.
+    if (!DeviceInfo.GlobalHandler.writeGlobalToDevice(
+            device_id, DeviceEnvGlobal, &SymbolInfoTable)) {
+      INFO(OMP_INFOTYPE_PLUGIN_KERNEL, device_id,
+           "Failed to write device environment, abort.");
+      // TODO: Check the device gfx name against the image gfx name.
+      return nullptr;
     }
   }
 
   DP("AMDGPU module successfully loaded!\n");
 
   {
     // the device_State array is either large value in bss or a void* that
     // needs to be assigned to a pointer to an array of size device_state_bytes
     // If absent, it has been deadstripped and needs no setup.
-
-    void *state_ptr;
-    uint32_t state_ptr_size;
-    auto &SymbolInfoMap = DeviceInfo.SymbolInfoTable[device_id];
-    hsa_status_t err = interop_hsa_get_symbol_info(
-        SymbolInfoMap, device_id, "omptarget_nvptx_device_State", &state_ptr,
-        &state_ptr_size);
-
-    if (err != HSA_STATUS_SUCCESS) {
-      DP("No device_state symbol found, skipping initialization\n");
+    StaticGlobalTy<void *> DeviceStateGlobal("omptarget_nvptx_device_State");
+    auto &SymbolInfoMap = DeviceInfo.SymbolInfoTables[device_id];
+    if (!DeviceInfo.GlobalHandler.getGlobalMetadataFromDevice(
+            device_id, DeviceStateGlobal, &SymbolInfoMap)) {
+      DP("No device_state pointer symbol found, skipping initialization\n");
     } else {
-      if (state_ptr_size < sizeof(void *)) {
-        DP("unexpected size of state_ptr %u != %zu\n", state_ptr_size,
-           sizeof(void *));
-        return NULL;
-      }
-
-      // if it's larger than a void*, assume it's a bss array and no further
-      // initialization is required. Only try to set up a pointer for
-      // sizeof(void*)
-      if (state_ptr_size == sizeof(void *)) {
-        uint64_t device_State_bytes =
-            get_device_State_bytes((char *)image->ImageStart, img_size);
-        if (device_State_bytes == 0) {
-          DP("Can't initialize device_State, missing size information\n");
-          return NULL;
-        }
-
-        auto &dss = DeviceInfo.deviceStateStore[device_id];
-        if (dss.first.get() == nullptr) {
-          assert(dss.second == 0);
-          void *ptr = NULL;
-          hsa_status_t err = impl_calloc(&ptr, device_State_bytes, device_id);
-          if (err != HSA_STATUS_SUCCESS) {
-            DP("Failed to allocate device_state array\n");
-            return NULL;
-          }
-          dss = {
-              std::unique_ptr<void, RTLDeviceInfoTy::implFreePtrDeletor>{ptr},
-              device_State_bytes,
-          };
-        }
+      StaticGlobalTy<uint64_t> DeviceStateSizeGlobal(
+          "omptarget_nvptx_device_State_size");
+      if (!DeviceInfo.GlobalHandler.readGlobalFromImage(
+              device_id, DeviceStateGlobal, (char *)image->ImageStart,
+              img_size)) {
+      hsa_status_t Err;
+      uint64_t DeviceStateSize = DeviceStateSizeGlobal.getValue();
+      auto &DSS = DeviceInfo.deviceStateStore[device_id];
+      if (DSS.first.get() == nullptr) {
+        assert(DSS.second == 0);
+        void *Ptr = NULL;
+        Err = impl_calloc(&Ptr, DeviceStateSize, device_id);
+        if (Err != HSA_STATUS_SUCCESS) {
+        DSS = {
+            std::unique_ptr<void, RTLDeviceInfoTy::implFreePtrDeletor>{Ptr},
+            DeviceStateSize,
 
-        void *ptr = dss.first.get();
-        if (device_State_bytes != dss.second) {
-          DP("Inconsistent sizes of device_State unsupported\n");
-          return NULL;
-        }
+      if (DeviceStateSize != DSS.second) {
 
-        // write ptr to device memory so it can be used by later kernels
-        err = DeviceInfo.freesignalpool_memcpy_h2d(state_ptr, &ptr,
-                                                   sizeof(void *), device_id);
-        if (err != HSA_STATUS_SUCCESS) {
-          DP("memcpy install of state_ptr failed\n");
-          return NULL;
-        }
-      }
-    }
-  }
+      DeviceStateGlobal.setValue(DSS.first.get());
+      if (!DeviceInfo.GlobalHandler.writeGlobalToDevice(
+              device_id, DeviceStateGlobal, &SymbolInfoMap)) {
 
   // Here, we take advantage of the data that is appended after img_end to get
   // the symbols' name we need to load. This data consist of the host entries
   // begin and end as well as the target name (see the offloading linker script
   // creation in clang compiler).
 
   // Find the symbols in the module by name. The name can be obtain by
   // concatenating the host entry name with the target name
 
   __tgt_offload_entry *HostBegin = image->EntriesBegin;
   __tgt_offload_entry *HostEnd = image->EntriesEnd;
 
+  // TODO: This is basically the same in the AMDGPU and CUDA plugin,
+  //       refactor.
   for (__tgt_offload_entry *e = HostBegin; e != HostEnd; ++e) {
 
     if (!e->addr) {
       // The host should have always something in the address to
       // uniquely identify the target region.
       DP("Analyzing host entry '<null>' (size = %lld)...\n",
          (unsigned long long)e->size);
       return NULL;
     }
 
     if (e->size) {
       __tgt_offload_entry entry = *e;
 
-      void *varptr;
-      uint32_t varsize;
-
-      auto &SymbolInfoMap = DeviceInfo.SymbolInfoTable[device_id];
-      hsa_status_t err = interop_hsa_get_symbol_info(
-          SymbolInfoMap, device_id, e->name, &varptr, &varsize);
-
-      if (err != HSA_STATUS_SUCCESS) {
-        // Inform the user what symbol prevented offloading
-        DP("Loading global '%s' (Failed)\n", e->name);
-        return NULL;
-      }
-
-      if (varsize != e->size) {
-        DP("Loading global '%s' - size mismatch (%u != %lu)\n", e->name,
-           varsize, e->size);
-        return NULL;
-      }
-
-      DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
-         DPxPTR(e - HostBegin), e->name, DPxPTR(varptr));
-      entry.addr = (void *)varptr;
+      StaticGlobalTy<void *> Global(e->name);
+      auto &SymbolInfoMap = DeviceInfo.SymbolInfoTables[device_id];
+      if (!DeviceInfo.GlobalHandler.getGlobalMetadataFromDevice(
+              device_id, Global, &SymbolInfoMap))
+        return nullptr;
+      entry.addr = Global.getPtr();
 
       DeviceInfo.addOffloadEntry(device_id, entry);
 
       if (DeviceInfo.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
           e->flags & OMP_DECLARE_TARGET_LINK) {
         // If unified memory is present any target link variables
         // can access host addresses directly. There is no longer a
         // need for device copies.
-        err = DeviceInfo.freesignalpool_memcpy_h2d(varptr, e->addr,
-                                                   sizeof(void *), device_id);
-        if (err != HSA_STATUS_SUCCESS)
-          DP("Error when copying USM\n");
-        DP("Copy linked variable host address (" DPxMOD ")"
-           "to device address (" DPxMOD ")\n",
-           DPxPTR(*((void **)e->addr)), DPxPTR(varptr));
+        Global.setValue(e->addr);
+        if (!DeviceInfo.GlobalHandler.writeGlobalToDevice(device_id, Global,
+                                                          &SymbolInfoMap))
+          return nullptr;
       }
 
       continue;
     }
 
     DP("to find the kernel name: %s size: %lu\n", e->name, strlen(e->name));
 
     uint32_t kernarg_segment_size;
-    auto &KernelInfoMap = DeviceInfo.KernelInfoTable[device_id];
+    auto &KernelInfoMap = DeviceInfo.KernelInfoTables[device_id];
     hsa_status_t err = interop_hsa_get_kernel_info(
         KernelInfoMap, device_id, e->name,
         HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_SIZE,
         &kernarg_segment_size);
+    (void)err;
 
     // each arg is a void * in this openmp implementation
     uint32_t arg_num = kernarg_segment_size / sizeof(void *);
     std::vector<size_t> arg_sizes(arg_num);
     for (std::vector<size_t>::iterator it = arg_sizes.begin();
          it != arg_sizes.end(); it++) {
       *it = sizeof(void *);
     }
 
-    // default value GENERIC (in case symbol is missing from cubin file)
-    llvm::omp::OMPTgtExecModeFlags ExecModeVal =
-        llvm::omp::OMPTgtExecModeFlags::OMP_TGT_EXEC_MODE_GENERIC;
-
     // get flat group size if present, else Default_WG_Size
     int16_t WGSizeVal = RTLDeviceInfoTy::Default_WG_Size;
 
     // get Kernel Descriptor if present.
     // Keep struct in sync wih getTgtAttributeStructQTy in CGOpenMPRuntime.cpp
     struct KernDescValType {
       uint16_t Version;
       uint16_t TSize;
       uint16_t WG_Size;
     };
-    struct KernDescValType KernDescVal;
-    std::string KernDescNameStr(e->name);
-    KernDescNameStr += "_kern_desc";
-    const char *KernDescName = KernDescNameStr.c_str();
 
-    void *KernDescPtr;
-    uint32_t KernDescSize;
-    void *CallStackAddr = nullptr;
-    err = interop_get_symbol_info((char *)image->ImageStart, img_size,
-                                  KernDescName, &KernDescPtr, &KernDescSize);
-
-    if (err == HSA_STATUS_SUCCESS) {
-      if ((size_t)KernDescSize != sizeof(KernDescVal))
-        DP("Loading global computation properties '%s' - size mismatch (%u != "
-           "%lu)\n",
-           KernDescName, KernDescSize, sizeof(KernDescVal));
-
-      memcpy(&KernDescVal, KernDescPtr, (size_t)KernDescSize);
-
-      // Check structure size against recorded size.
-      if ((size_t)KernDescSize != KernDescVal.TSize)
-        DP("KernDescVal size %lu does not match advertized size %d for '%s'\n",
-           sizeof(KernDescVal), KernDescVal.TSize, KernDescName);
-
-      DP("After loading global for %s KernDesc \n", KernDescName);
-      DP("KernDesc: Version: %d\n", KernDescVal.Version);
-      DP("KernDesc: TSize: %d\n", KernDescVal.TSize);
-      DP("KernDesc: WG_Size: %d\n", KernDescVal.WG_Size);
-
-      if (KernDescVal.WG_Size == 0) {
-        KernDescVal.WG_Size = RTLDeviceInfoTy::Default_WG_Size;
-        DP("Setting KernDescVal.WG_Size to default %d\n", KernDescVal.WG_Size);
-      }
-      WGSizeVal = KernDescVal.WG_Size;
-      DP("WGSizeVal %d\n", WGSizeVal);
-      check("Loading KernDesc computation property", err);
-    } else {
-      DP("Warning: Loading KernDesc '%s' - symbol not found, ", KernDescName);
-
-      // Flat group size
-      std::string WGSizeNameStr(e->name);
-      WGSizeNameStr += "_wg_size";
-      const char *WGSizeName = WGSizeNameStr.c_str();
-
-      void *WGSizePtr;
-      uint32_t WGSize;
-      err = interop_get_symbol_info((char *)image->ImageStart, img_size,
-                                    WGSizeName, &WGSizePtr, &WGSize);
-
-      if (err == HSA_STATUS_SUCCESS) {
-        if ((size_t)WGSize != sizeof(int16_t)) {
-          DP("Loading global computation properties '%s' - size mismatch (%u "
-             "!= "
-             "%lu)\n",
-             WGSizeName, WGSize, sizeof(int16_t));
-          return NULL;
-        }
-
-        memcpy(&WGSizeVal, WGSizePtr, (size_t)WGSize);
-
-        DP("After loading global for %s WGSize = %d\n", WGSizeName, WGSizeVal);
-
-        if (WGSizeVal < RTLDeviceInfoTy::Default_WG_Size ||
-            WGSizeVal > RTLDeviceInfoTy::Max_WG_Size) {
-          DP("Error wrong WGSize value specified in HSA code object file: "
-             "%d\n",
+    // Read the kernel description global from the binary.
+    StaticGlobalTy<KernDescValType> KernelDescGlobal(e->name, "_kern_desc");
+    if (!DeviceInfo.GlobalHandler.readGlobalFromImage(
+            device_id, KernelDescGlobal, (char *)image->ImageStart, img_size)) {
+      // No kernel description available, fallback to work group size global:
+      // Read work group size global from the binary.
+      StaticGlobalTy<int16_t> WGSizeGlobal(e->name, "_wg_size");
+      if (!DeviceInfo.GlobalHandler.readGlobalFromImage(
+              device_id, WGSizeGlobal, (char *)image->ImageStart, img_size)) {
+        WGSizeGlobal.setValue(WGSizeVal);
+        INFO(OMP_INFOTYPE_DATA_TRANSFER, device_id,
+             "Failed to work group size for %s, defaulting to %i.", e->name,
              WGSizeVal);
-          WGSizeVal = RTLDeviceInfoTy::Default_WG_Size;
-        }
-      } else {
-        DP("Warning: Loading WGSize '%s' - symbol not found, "
-           "using default value %d\n",
-           WGSizeName, WGSizeVal);
-      }
-
-      check("Loading WGSize computation property", err);
+      WGSizeVal = WGSizeGlobal.getValue();
+    } else if (KernelDescGlobal.getValue().WG_Size) {
+      if (sizeof(KernDescValType) != KernelDescGlobal.getValue().TSize)
+        DP("KernDescVal size %lu does not match advertized size %d for '%s'\n",
+           sizeof(KernDescValType), KernelDescGlobal.getValue().TSize,
+           KernelDescGlobal.getName().c_str());
+      WGSizeVal = KernelDescGlobal.getValue().WG_Size;
     }
 
-    // Read execution mode from global in binary
-    std::string ExecModeNameStr(e->name);
-    ExecModeNameStr += "_exec_mode";
-    const char *ExecModeName = ExecModeNameStr.c_str();
-
-    void *ExecModePtr;
-    uint32_t varsize;
-    err = interop_get_symbol_info((char *)image->ImageStart, img_size,
-                                  ExecModeName, &ExecModePtr, &varsize);
-
-    if (err == HSA_STATUS_SUCCESS) {
-      if ((size_t)varsize != sizeof(llvm::omp::OMPTgtExecModeFlags)) {
-        DP("Loading global computation properties '%s' - size mismatch(%u != "
-           "%lu)\n",
-           ExecModeName, varsize, sizeof(llvm::omp::OMPTgtExecModeFlags));
-        return NULL;
-      }
+    // Read execution mode global from the binary
+    StaticGlobalTy<llvm::omp::OMPTgtExecModeFlags> ExecModeGlobal(e->name,
+                                                                  "_exec_mode");
+    if (!DeviceInfo.GlobalHandler.readGlobalFromImage(
+            device_id, ExecModeGlobal, (char *)image->ImageStart, img_size)) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, device_id,
+           "Failed to read execution mode for %s, defaulting to SPMD.",
+           e->name);
+      ExecModeGlobal.setValue(llvm::omp::OMP_TGT_EXEC_MODE_SPMD);
 
-      memcpy(&ExecModeVal, ExecModePtr, (size_t)varsize);
-
-      DP("After loading global for %s ExecMode = %d\n", ExecModeName,
-         ExecModeVal);
-
-      if (ExecModeVal < 0 ||
-          ExecModeVal > llvm::omp::OMP_TGT_EXEC_MODE_GENERIC_SPMD) {
-        DP("Error wrong exec_mode value specified in HSA code object file: "
-           "%d\n",
-           ExecModeVal);
-        return NULL;
-      }
-    } else {
-      DP("Loading global exec_mode '%s' - symbol missing, using default "
-         "value "
-         "GENERIC (1)\n",
-         ExecModeName);
-    }
-    check("Loading computation property", err);
-
-    KernelsList.push_back(KernelTy(ExecModeVal, WGSizeVal, device_id,
-                                   CallStackAddr, e->name, kernarg_segment_size,
-                                   DeviceInfo.KernArgPool));
+    void *CallStackAddr = nullptr;
+    KernelsList.push_back(
+        KernelTy(ExecModeGlobal.getValue(), WGSizeVal, device_id, CallStackAddr,
+                 e->name, kernarg_segment_size, DeviceInfo.KernArgPool));
     __tgt_offload_entry entry = *e;
     entry.addr = (void *)&KernelsList.back();
     DeviceInfo.addOffloadEntry(device_id, entry);
     DP("Entry point %ld maps to %s\n", e - HostBegin, e->name);
   }
 
   return DeviceInfo.getOffloadEntriesTable(device_id);
 }
for (int32_t i = 0; i < arg_num; ++i) {
     ptrs[i] = (void *)((intptr_t)tgt_args[i] + tgt_offsets[i]);
     args[i] = &ptrs[i];
     DP("Offseted base: arg[%d]:" DPxMOD "\n", i, DPxPTR(ptrs[i]));
   }
 
   KernelTy *KernelInfo = (KernelTy *)tgt_entry_ptr;
 
   std::string kernel_name = std::string(KernelInfo->Name);
-  auto &KernelInfoTable = DeviceInfo.KernelInfoTable;
-  if (KernelInfoTable[device_id].find(kernel_name) ==
-      KernelInfoTable[device_id].end()) {
+  auto &KernelInfoTables = DeviceInfo.KernelInfoTables;
+  if (KernelInfoTables[device_id].find(kernel_name) ==
+      KernelInfoTables[device_id].end()) {
     DP("Kernel %s not found\n", kernel_name.c_str());
     return OFFLOAD_FAIL;
   }
 
   const atl_kernel_info_t KernelInfoEntry =
-      KernelInfoTable[device_id][kernel_name];
+      KernelInfoTables[device_id][kernel_name];
   const uint32_t group_segment_size = KernelInfoEntry.group_segment_size;
   const uint32_t sgpr_count = KernelInfoEntry.sgpr_count;
   const uint32_t vgpr_count = KernelInfoEntry.vgpr_count;
   const uint32_t sgpr_spill_count = KernelInfoEntry.sgpr_spill_count;
   const uint32_t vgpr_spill_count = KernelInfoEntry.vgpr_spill_count;
 
   assert(arg_num == (int)KernelInfoEntry.num_args);
 

openmp/libomptarget/plugins/common/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 #
 # 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
 #
 ##===----------------------------------------------------------------------===##
 #
 # Common parts which can be used by all plugins
 #
 ##===----------------------------------------------------------------------===##
 
+add_subdirectory(DeviceInterface)
 add_subdirectory(elf_common)
 add_subdirectory(MemoryManager)
+add_subdirectory(GlobalHandler)

openmp/libomptarget/plugins/common/DeviceInterface/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 #
 # 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
 #
 ##===----------------------------------------------------------------------===##
-#
-# Common parts which can be used by all plugins
-#
-##===----------------------------------------------------------------------===##
 
-add_subdirectory(elf_common)
-add_subdirectory(MemoryManager)
+add_library(DeviceInterface INTERFACE)
+
+target_include_directories(DeviceInterface INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

openmp/libomptarget/plugins/common/DeviceInterface/DeviceInterface.h

+//===- DeviceInterface.h - Target independent plugin device interface -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_DEVICEINTERFACE_DEVICEINTERFACE_H
+#define LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_DEVICEINTERFACE_DEVICEINTERFACE_H
+
+#include "omptarget.h"
+
+extern "C" {
+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 *AsyncInfo);
+int32_t __tgt_rtl_data_retrieve(int32_t ID, void *HostPtr, void *TargetPtr,
+                                int64_t Size);
+int32_t __tgt_rtl_data_retrieve_async(int32_t ID, void *HostPtr,
+                                      void *TargetPtr, int64_t Size,
+                                      __tgt_async_info *AsyncInfo);
+}
+
+namespace llvm {
+namespace omp {
+namespace plugin {
+
+struct DeviceInterfaceTy {
+  static int32_t memcpyDtoH(int32_t DeviceId, void *Dst, const void *Src,
+                            int32_t Size) {
+    return __tgt_rtl_data_retrieve(DeviceId, Dst, const_cast<void *>(Src),
+                                   Size);
+  }
+  static int32_t memcpyHtoD(int32_t DeviceId, void *Dst, const void *Src,
+                            int32_t Size) {
+    return __tgt_rtl_data_submit(DeviceId, Dst, const_cast<void *>(Src), Size);
+  }
+};
+
+} // namespace plugin
+} // namespace omp
+} // namespace llvm
+
+#endif // LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_DEVICEINTERFACE_DEVICEINTERFACE_H

openmp/libomptarget/plugins/common/GlobalHandler/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 #
 # 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
 #
 ##===----------------------------------------------------------------------===##
-#
-# Common parts which can be used by all plugins
-#
-##===----------------------------------------------------------------------===##
 
-add_subdirectory(elf_common)
-add_subdirectory(MemoryManager)
+add_library(GlobalHandler INTERFACE)
+
+target_include_directories(GlobalHandler INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

openmp/libomptarget/plugins/common/GlobalHandler/GlobalHandler.h

+//===- GlobalHandler.h - Target independent global & enviroment handling --===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Target independent global handler and environment manager.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_GLOBALHANDLER_GLOBALHANDLER_H
+#define LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_GLOBALHANDLER_GLOBALHANDLER_H
+
+#include <string>
+
+#include "Debug.h"
+#include "omptarget.h"
+#include "llvm/Object/ELFObjectFile.h"
+
+#include "DeviceInterface.h"
+
+namespace llvm {
+namespace omp {
+namespace plugin {
+
+using namespace llvm::object;
+
+/// Common abstraction for globals that live on the host and device.
+/// It simply encapsulates the symbol name, symbol size, and symbol address
+/// (which might be host or device depending on the context).
+/// TODO: We should probably keep both the host and device pointer in this
+/// structure to avoid multiple lookups, e.g. when we write device globals
+/// in USM mode after we looked up their device address.
+class GlobalTy {
+  std::string Name;
+  uint32_t Size;
+  void *Ptr;
+
+public:
+  GlobalTy(const std::string &Name, uint32_t Size, void *Ptr = nullptr)
+      : Name(Name), Size(Size), Ptr(Ptr) {}
+
+  const std::string &getName() const { return Name; }
+  uint32_t getSize() const { return Size; }
+  void *getPtr() const { return Ptr; }
+
+  void setSize(int32_t S) { Size = S; }
+  void setPtr(void *P) { Ptr = P; }
+};
+
+/// Subclass of GlobalTy that holds the memory for a global of \p Ty.
+template <typename Ty> class StaticGlobalTy : public GlobalTy {
+  Ty Data;
+
+public:
+  template <typename... Args>
+  StaticGlobalTy(const std::string &Name, Args &&...args)
+      : GlobalTy(Name, sizeof(Ty), &Data),
+        Data(Ty{std::forward<Args>(args)...}) {}
+  template <typename... Args>
+  StaticGlobalTy(const char *Name, Args &&...args)
+      : GlobalTy(Name, sizeof(Ty), &Data),
+        Data(Ty{std::forward<Args>(args)...}) {}
+  template <typename... Args>
+  StaticGlobalTy(const char *Name, const char *Suffix, Args &&...args)
+      : GlobalTy(std::string(Name) + Suffix, sizeof(Ty), &Data),
+        Data(Ty{std::forward<Args>(args)...}) {}
+
+  Ty &getValue() { return Data; }
+  const Ty &getValue() const { return Data; }
+  void setValue(const Ty &V) { Data = V; }
+};
+
+/// Subclass of GlobalTy that holds the memory which may exceed the global type
+/// \p Ty.
+template <typename Ty> class DynamicGlobalTy : public GlobalTy {
+public:
+  DynamicGlobalTy(const std::string &Name, uint32_t Size)
+      : GlobalTy(Name, Size, malloc(Size)) {}
+  DynamicGlobalTy(const char *Name, const char *Suffix, uint32_t Size)
+      : GlobalTy(std::string(Name) + Suffix, Size, malloc(Size)) {}
+  ~DynamicGlobalTy() { free(getPtr()); }
+
+  Ty &getValue() { return *static_cast<Ty *>(getPtr()); }
+  const Ty &getValue() const { return *static_cast<Ty *>(getPtr()); }
+  void setValue(const Ty &V) { *getPtr() = V; }
+};
+
+/// Helper class to do the heavy lifting when it comes to moving globals between
+/// host and device. Through the DeviceInterfaceTy we access memcpyDtoH and
+/// HtoD, which means the only things specialized by the subclass is the
+/// retrival of global metadata (size, addr) from the device
+/// (\see getGlobalMetadataFromDevice).
+class GlobalHandlerTy {
+  /// Actually move memory between host and device. See readGlobalFromDevice and
+  /// writeGlobalToDevice for the interface description.
+  int32_t moveGlobalBetweenDeviceAndHost(int32_t DeviceId,
+                                         const GlobalTy &HostGlobal,
+                                         bool Device2Host, void *Payload) {
+    GlobalTy DeviceGlobal(HostGlobal.getName(), HostGlobal.getSize());
+    int32_t Err = getGlobalMetadataFromDevice(DeviceId, DeviceGlobal, Payload);
+    if (Err) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+           "Failed to read global symbol metadata for '%s' from the device",
+           HostGlobal.getName().c_str());
+      return Err;
+    }
+
+    if (Device2Host)
+      Err = DeviceInterfaceTy::memcpyDtoH(DeviceId, HostGlobal.getPtr(),
+                                          DeviceGlobal.getPtr(),
+                                          HostGlobal.getSize());
+    else
+      Err = DeviceInterfaceTy::memcpyHtoD(DeviceId, DeviceGlobal.getPtr(),
+                                          HostGlobal.getPtr(),
+                                          HostGlobal.getSize());
+
+    if (Err) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+           "Failed to %s %u bytes associated with global symbol '%s' %s "
+           "the device",
+           Device2Host ? "read" : "write", HostGlobal.getSize(),
+           HostGlobal.getName().c_str(), Device2Host ? "from" : "to");
+      return Err;
+    }
+
+    INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+         "Successfully %s %u bytes associated with global symbol '%s' %s "
+         "the device (%p -> %p)",
+         Device2Host ? "read" : "write", HostGlobal.getSize(),
+         HostGlobal.getName().c_str(), Device2Host ? "from" : "to",
+         DeviceGlobal.getPtr(), HostGlobal.getPtr());
+    return OFFLOAD_SUCCESS;
+  }
+
+  /// Get the address and size of a global in the image. Return success
+  /// or failure. Address and size are return in \p ImageGlobal, the global name
+  /// is passed in \p ImageGlobal.
+  int32_t getGlobalMetadateFromImage(int32_t DeviceId, GlobalTy &ImageGlobal,
+                                     const char *ImageStart,
+                                     uint64_t ImageSize) {
+    // TODO: We should wrap ELF handling into a caching object.
+    MemoryBufferRef MBR(StringRef(ImageStart, ImageSize), "Image");
+    Expected<ELF64LEObjectFile> ELF = ELF64LEObjectFile::create(MBR);
+    if (!ELF) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId, "Unable to open ELF image.");
+      return OFFLOAD_FAIL;
+    }
+
+    // Then extract the base address of elf image.
+    Expected<uint64_t> StartAddr = ELF.get().getStartAddress();
+    if (!StartAddr) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+           "Unable to determine ELF start address.");
+      return OFFLOAD_FAIL;
+    }
+    char *ELFStartAddr = reinterpret_cast<char *>(StartAddr.get());
+
+    for (auto &It : ELF.get().symbols()) {
+      // Fist check the name, continue if we don't match.
+      Expected<StringRef> Name = It.getName();
+      if (!Name || !Name.get().equals(ImageGlobal.getName()))
+        continue;
+
+      // If we match we will either succeed or fail with retriving the content,
+      // either way, the loop is done. First step is to verify the size.
+      ImageGlobal.setSize(It.getSize());
+
+      // Then extract the relative offset from the elf image base.
+      Expected<uint64_t> Offset = It.getValue();
+      if (!Offset) {
+        INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+             "Global symbol '%s' was found in the elf image but address could "
+             "not be determined.",
+             ImageGlobal.getName().c_str());
+        return OFFLOAD_FAIL;
+      }
+      ImageGlobal.setPtr(ELFStartAddr + Offset.get());
+
+      return OFFLOAD_SUCCESS;
+    }
+
+    INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+         "Global symbol '%s' was not found in the elf image.",
+         ImageGlobal.getName().c_str());
+    return OFFLOAD_FAIL;
+  }
+
+public:
+  /// Copy the memory associated with a global from the host to its counterpart
+  /// on the device. The name, size, and destination are defined by
+  /// \p HostGlobal. Return success or failure. Payload is specific to the
+  /// plugin.
+  int32_t writeGlobalToDevice(int32_t DeviceId, const GlobalTy &HostGlobal,
+                              void *Payload) {
+    return moveGlobalBetweenDeviceAndHost(DeviceId, HostGlobal,
+                                          /* Device2Host */ false, Payload);
+  }
+
+  /// Read the memory associated with a global from the image and store it on
+  /// the host. The name, size, and destination are defined by \p HostGlobal.
+  /// Return success or failure. Payload is specific to the plugin.
+  int32_t readGlobalFromImage(int32_t DeviceId, const GlobalTy &HostGlobal,
+                              const char *ImageStart, uint64_t ImageSize) {
+    GlobalTy ImageGlobal(HostGlobal.getName(), -1);
+    int32_t Err = getGlobalMetadateFromImage(DeviceId, ImageGlobal, ImageStart,
+                                             ImageSize);
+    if (Err)
+      return Err;
+
+    if (ImageGlobal.getSize() != HostGlobal.getSize()) {
+      INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+           "Global symbol '%s' has %u bytes in the elf image but %u bytes "
+           "on the host, abort transfer.",
+           HostGlobal.getName().c_str(), ImageGlobal.getSize(),
+           HostGlobal.getSize());
+      return OFFLOAD_FAIL;
+    }
+
+    INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+         "Global symbol '%s' was found in the elf image and %u bytes will "
+         "copied from %p to %p.",
+         HostGlobal.getName().c_str(), HostGlobal.getSize(),
+         ImageGlobal.getPtr(), HostGlobal.getPtr());
+    memcpy(HostGlobal.getPtr(), ImageGlobal.getPtr(), HostGlobal.getSize());
+    return OFFLOAD_SUCCESS;
+  }
+
+  /// Get the address and size of a global from the device. Return success
+  /// or failure. Address is return in \p DeviceGlobal, the global name and
+  /// expected size are passed in \p DeviceGlobal. Payload is specific to the
+  /// plugin.
+  int32_t getGlobalMetadataFromDevice(int32_t DeviceId, GlobalTy &DeviceGlobal,
+                                      void *Payload);
+
+  /// Copy the memory associated with a global from the device to its
+  /// counterpart on the host. The name, size, and destination are defined by
+  /// \p HostGlobal. Return success or failure. Payload is specific to the
+  /// plugin.
+  int32_t readGlobalFromDevice(int32_t DeviceId, const GlobalTy &HostGlobal,
+                               void *Payload) {
+    return moveGlobalBetweenDeviceAndHost(DeviceId, HostGlobal,
+                                          /* Device2Host */ true, Payload);
+  }
+};
+
+} // namespace plugin
+} // namespace omp
+} // namespace llvm
+
+#endif // LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_GLOBALHANDLER_GLOBALHANDLER_H

openmp/libomptarget/plugins/cuda/CMakeLists.txt

else()
   add_library(omptarget.rtl.cuda SHARED src/rtl.cpp dynamic_cuda/cuda.cpp)
   set (LIBOMPTARGET_DEP_LIBRARIES ${CMAKE_DL_LIBS})
 endif()
 
 # Install plugin under the lib destination folder.
 install(TARGETS omptarget.rtl.cuda LIBRARY DESTINATION "${OPENMP_INSTALL_LIBDIR}")
 
 target_link_libraries(omptarget.rtl.cuda
+  DeviceInterface
   elf_common
   MemoryManager
+  GlobalHandler
   ${LIBOMPTARGET_DEP_LIBRARIES}
   ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
   ${OPENMP_PTHREAD_LIB}
   "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports"
   "-Wl,-z,defs")
 
 # Report to the parent scope that we are building a plugin for CUDA.
 # This controls whether tests are run for the nvptx offloading target
 # Run them if libcuda is available, or if the user explicitly asked for dlopen
 # Otherwise this plugin is being built speculatively and there may be no cuda available
 if (LIBOMPTARGET_CAN_LINK_LIBCUDA OR LIBOMPTARGET_FORCE_DLOPEN_LIBCUDA)
   libomptarget_say("Enable tests using CUDA plugin")
   set(LIBOMPTARGET_SYSTEM_TARGETS "${LIBOMPTARGET_SYSTEM_TARGETS} nvptx64-nvidia-cuda nvptx64-nvidia-cuda-newRTL" PARENT_SCOPE)
 else()
   libomptarget_say("Disabling tests using CUDA plugin as cuda may not be available")
 endif()

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

 
 #include "Debug.h"
 #include "DeviceEnvironment.h"
 #include "omptargetplugin.h"
 
 #define TARGET_NAME CUDA
 #define DEBUG_PREFIX "Target " GETNAME(TARGET_NAME) " RTL"
 
+#include "GlobalHandler.h"
 #include "MemoryManager.h"
 
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
+using namespace llvm::omp::plugin;
+
 // Utility for retrieving and printing CUDA error string.
 #ifdef OMPTARGET_DEBUG
 #define CUDA_ERR_STRING(err)                                                   \
   do {                                                                         \
     if (getDebugLevel() > 0) {                                                 \
       const char *errStr = nullptr;                                            \
       CUresult errStr_status = cuGetErrorString(err, &errStr);                 \
       if (errStr_status == CUDA_ERROR_INVALID_VALUE)                           \
for (CUstream &S : StreamPool[DeviceId])
       if (!S)
         return false;
 
     return true;
   }
 };
 
 class DeviceRTLTy {
+  /// The debug/configuration kind we read from LIBOMPTARGET_DEVICE_RTL_DEBUG
+  uint32_t DebugKind;
+
   int NumberOfDevices;
   // OpenMP environment properties
   int EnvNumTeams;
   int EnvTeamLimit;
   int EnvTeamThreadLimit;
   // OpenMP requires flags
   int64_t RequiresFlags;
   // Amount of dynamic shared memory to use at launch.
   uint64_t DynamicMemorySize;
 
   static constexpr const int HardTeamLimit = 1U << 16U; // 64k
   static constexpr const int HardThreadLimit = 1024;
   static constexpr const int DefaultNumTeams = 128;
   static constexpr const int DefaultNumThreads = 128;
 
   std::unique_ptr<StreamManagerTy> StreamManager;
   std::vector<DeviceDataTy> DeviceData;
   std::vector<CUmodule> Modules;
+  GlobalHandlerTy GlobalHandler;
 
   /// A class responsible for interacting with device native runtime library to
   /// allocate and free memory.
   class CUDADeviceAllocatorTy : public DeviceAllocatorTy {
     const int DeviceId;
     const std::vector<DeviceDataTy> &DeviceData;
     std::unordered_map<void *, TargetAllocTy> HostPinnedAllocs;
 
__tgt_target_table *loadBinary(const int DeviceId,
     DP("CUDA module successfully loaded!\n");
 
     Modules.push_back(Module);
 
     // Find the symbols in the module by name.
     const __tgt_offload_entry *HostBegin = Image->EntriesBegin;
     const __tgt_offload_entry *HostEnd = Image->EntriesEnd;
 
+    // TODO: This is basically the same in the AMDGPU and CUDA plugin,
+    //       refactor.
     std::list<KernelTy> &KernelsList = DeviceData[DeviceId].KernelsList;
     for (const __tgt_offload_entry *E = HostBegin; E != HostEnd; ++E) {
       if (!E->addr) {
         // We return nullptr when something like this happens, the host should
         // have always something in the address to uniquely identify the target
         // region.
         DP("Invalid binary: host entry '<null>' (size = %zd)...\n", E->size);
         return nullptr;
       }
 
       if (E->size) {
         __tgt_offload_entry Entry = *E;
-        CUdeviceptr CUPtr;
-        size_t CUSize;
-        Err = cuModuleGetGlobal(&CUPtr, &CUSize, Module, E->name);
-        // We keep this style here because we need the name
-        if (Err != CUDA_SUCCESS) {
-          REPORT("Loading global '%s' Failed\n", E->name);
-          CUDA_ERR_STRING(Err);
+        StaticGlobalTy<void *> Global(E->name);
+        if (!GlobalHandler.getGlobalMetadataFromDevice(DeviceId, Global,
+                                                       Module))
           return nullptr;
-        }
-
-        if (CUSize != E->size) {
-          DP("Loading global '%s' - size mismatch (%zd != %zd)\n", E->name,
-             CUSize, E->size);
-          return nullptr;
-        }
-
-        DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
-           DPxPTR(E - HostBegin), E->name, DPxPTR(CUPtr));
-
-        Entry.addr = (void *)(CUPtr);
+        Entry.addr = Global.getPtr();
 
         // Note: In the current implementation declare target variables
         // can either be link or to. This means that once unified
         // memory is activated via the requires directive, the variable
         // can be used directly from the host in both cases.
         // TODO: when variables types other than to or link are added,
         // the below condition should be changed to explicitly
         // check for to and link variables types:
         // (RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY && (e->flags &
         // OMP_DECLARE_TARGET_LINK || e->flags == OMP_DECLARE_TARGET_TO))
         if (RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
           // If unified memory is present any target link or to variables
           // can access host addresses directly. There is no longer a
           // need for device copies.
-          cuMemcpyHtoD(CUPtr, E->addr, sizeof(void *));
-          DP("Copy linked variable host address (" DPxMOD
-             ") to device address (" DPxMOD ")\n",
-             DPxPTR(*((void **)E->addr)), DPxPTR(CUPtr));
+          Global.setValue(E->addr);
+          if (!GlobalHandler.writeGlobalToDevice(DeviceId, Global, Module))
+            return nullptr;
         }
 
         addOffloadEntry(DeviceId, Entry);
 
         continue;
       }
 
       CUfunction Func;
       Err = cuModuleGetFunction(&Func, Module, E->name);
       // We keep this style here because we need the name
       if (Err != CUDA_SUCCESS) {
         REPORT("Loading '%s' Failed\n", E->name);
         CUDA_ERR_STRING(Err);
         return nullptr;
       }
 
       DP("Entry point " DPxMOD " maps to %s (" DPxMOD ")\n",
          DPxPTR(E - HostBegin), E->name, DPxPTR(Func));
 
-      // default value GENERIC (in case symbol is missing from cubin file)
-      llvm::omp::OMPTgtExecModeFlags ExecModeVal;
-      std::string ExecModeNameStr(E->name);
-      ExecModeNameStr += "_exec_mode";
-      const char *ExecModeName = ExecModeNameStr.c_str();
-
-      CUdeviceptr ExecModePtr;
-      size_t CUSize;
-      Err = cuModuleGetGlobal(&ExecModePtr, &CUSize, Module, ExecModeName);
-      if (Err == CUDA_SUCCESS) {
-        if (CUSize != sizeof(llvm::omp::OMPTgtExecModeFlags)) {
-          DP("Loading global exec_mode '%s' - size mismatch (%zd != %zd)\n",
-             ExecModeName, CUSize, sizeof(llvm::omp::OMPTgtExecModeFlags));
-          return nullptr;
-        }
-
-        Err = cuMemcpyDtoH(&ExecModeVal, ExecModePtr, CUSize);
-        if (Err != CUDA_SUCCESS) {
-          REPORT("Error when copying data from device to host. Pointers: "
-                 "host = " DPxMOD ", device = " DPxMOD ", size = %zd\n",
-                 DPxPTR(&ExecModeVal), DPxPTR(ExecModePtr), CUSize);
-          CUDA_ERR_STRING(Err);
-          return nullptr;
-        }
-      } else {
-        DP("Loading global exec_mode '%s' - symbol missing, using default "
-           "value GENERIC (1)\n",
-           ExecModeName);
+      StaticGlobalTy<llvm::omp::OMPTgtExecModeFlags> ExecModeGlobal(
+          E->name, "_exec_mode");
+      // TODO: We should be able to read it from the image instead.
+      if (!GlobalHandler.readGlobalFromDevice(DeviceId, ExecModeGlobal,
+                                              Module)) {
+        INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+             "Failed to read execution mode for %s, defaulting to SPMD.",
+             E->name);
+        ExecModeGlobal.setValue(llvm::omp::OMP_TGT_EXEC_MODE_SPMD);
       }
 
-      KernelsList.emplace_back(Func, ExecModeVal);
+      KernelsList.emplace_back(Func, ExecModeGlobal.getValue());
 
       __tgt_offload_entry Entry = *E;
       Entry.addr = &KernelsList.back();
       addOffloadEntry(DeviceId, Entry);
     }
 
     // send device environment data to the device
     {
-      // TODO: The device ID used here is not the real device ID used by OpenMP.
-      DeviceEnvironmentTy DeviceEnv{0, static_cast<uint32_t>(NumberOfDevices),
-                                    static_cast<uint32_t>(DeviceId),
-                                    static_cast<uint32_t>(DynamicMemorySize)};
-
       if (const char *EnvStr = getenv("LIBOMPTARGET_DEVICE_RTL_DEBUG"))
-        DeviceEnv.DebugKind = std::stoi(EnvStr);
+        DebugKind = std::stoi(EnvStr);
 
-      const char *DeviceEnvName = "omptarget_device_environment";
-      CUdeviceptr DeviceEnvPtr;
-      size_t CUSize;
-
-      Err = cuModuleGetGlobal(&DeviceEnvPtr, &CUSize, Module, DeviceEnvName);
-      if (Err == CUDA_SUCCESS) {
-        if (CUSize != sizeof(DeviceEnv)) {
-          REPORT(
-              "Global device_environment '%s' - size mismatch (%zu != %zu)\n",
-              DeviceEnvName, CUSize, sizeof(int32_t));
-          CUDA_ERR_STRING(Err);
-          return nullptr;
-        }
-
-        Err = cuMemcpyHtoD(DeviceEnvPtr, &DeviceEnv, CUSize);
-        if (Err != CUDA_SUCCESS) {
-          REPORT("Error when copying data from host to device. Pointers: "
-                 "host = " DPxMOD ", device = " DPxMOD ", size = %zu\n",
-                 DPxPTR(&DeviceEnv), DPxPTR(DeviceEnvPtr), CUSize);
-          CUDA_ERR_STRING(Err);
-          return nullptr;
-        }
-
-        DP("Sending global device environment data %zu bytes\n", CUSize);
-      } else {
-        DP("Finding global device environment '%s' - symbol missing.\n",
-           DeviceEnvName);
-        DP("Continue, considering this is a device RTL which does not accept "
-           "environment setting.\n");
+      // TODO: The device ID used here is not the real device ID used by OpenMP.
+      StaticGlobalTy<DeviceEnvironmentTy> DeviceEnvGlobal(
+          "omptarget_device_environment", DebugKind,
+          static_cast<uint32_t>(NumberOfDevices),
+          static_cast<uint32_t>(DeviceId),
+          static_cast<uint32_t>(DynamicMemorySize));
+      if (!GlobalHandler.writeGlobalToDevice(DeviceId, DeviceEnvGlobal,
+                                             Module)) {
+        // TODO: I think this should be fatal.
+        INFO(OMP_INFOTYPE_DATA_TRANSFER, DeviceId,
+             "Failed to write device environment, continue without.");
       }
     }
 
     return getOffloadEntriesTable(DeviceId);
   }
 
   void *dataAlloc(const int DeviceId, const int64_t Size,
                   const TargetAllocTy Kind) {
int waitEvent(const int DeviceId, __tgt_async_info *AsyncInfo,
 
     return OFFLOAD_SUCCESS;
   }
 };
 
 DeviceRTLTy DeviceRTL;
 } // namespace
 
+int32_t llvm::omp::plugin::GlobalHandlerTy::getGlobalMetadataFromDevice(
+    int32_t DeviceId, GlobalTy &DeviceGlobal, void *ModulePtr) {
+  CUmodule Module = static_cast<CUmodule>(ModulePtr);
+  CUdeviceptr CUPtr;
+  size_t CUSize;
+  const char *Name = DeviceGlobal.getName().c_str();
+  CUresult Err = cuModuleGetGlobal(&CUPtr, &CUSize, Module, Name);
+  if (Err != CUDA_SUCCESS) {
+    REPORT("Loading global '%s' Failed\n", Name);
+    CUDA_ERR_STRING(Err);
+    return OFFLOAD_FAIL;
+  }
+  if (CUSize != DeviceGlobal.getSize()) {
+    DP("Loading global '%s' - size mismatch (%zd != %zd)\n", Name, CUSize,
+       DeviceGlobal.getSize());
+    return OFFLOAD_FAIL;
+  }
+
+  DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
+     DPxPTR(E - HostBegin), Name, DPxPTR(CUPtr));
+  DeviceGlobal.setPtr(reinterpret_cast<void*>(CUPtr));
+  return OFFLOAD_SUCCESS;
+}
+
 // Exposed library API function
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *image) {
   return elf_check_machine(image, /* EM_CUDA */ 190);
 }