[AMDGPU][Libomptarget][NFC] Remove atmi_place_t

[pdhaliwal]

Summary

atmi_place_t has been replaced with int DeviceId.

[JonChesterfield]

LG, thanks!

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

 
 /** @} */
 
 /** \defgroup common Common ATMI Structures
  *  @{
  */
 
 /**
- * @brief ATMI Compute Place
- */
-typedef struct atmi_place_s {
-  /**
-   * The node in a cluster where computation should occur.
-   * Default is node_id = 0 for local computations.
-   */
-  unsigned int node_id;
-  /**
-   * Device type: CPU, GPU or DSP
-   */
-  atmi_devtype_t type;
-  /**
-   * The device ordinal number ordered by runtime; -1 for any
-   */
-  int device_id;
-} atmi_place_t;
-
-/**
  * @brief ATMI Memory Space/region Structure
  */
 typedef struct atmi_memory_s {
   /**
    * Memory capacity
    */
   unsigned long int capacity;
   /**

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

  * @param[in] cb_state void* passed to on_deserialized_data callback
  *
  * @retval ::HSA_STATUS_SUCCESS The function has executed successfully.
  *
  * @retval ::HSA_STATUS_ERROR The function encountered errors.
  *
  */
 hsa_status_t atmi_module_register_from_memory_to_place(
-    void *module_bytes, size_t module_size, atmi_place_t place,
+    void *module_bytes, size_t module_size, int DeviceId,
     hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                          void *cb_state),
     void *cb_state);
 
 /** @} */
 
 hsa_status_t atmi_memcpy_h2d(hsa_signal_t signal, void *deviceDest,
                              const void *hostSrc, size_t size,

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

private:
   std::vector<ATLCPUProcessor> cpu_processors_;
   std::vector<ATLGPUProcessor> gpu_processors_;
 };
 
 hsa_amd_memory_pool_t get_memory_pool(const ATLProcessor &proc,
                                       const int mem_id);
 
 extern ATLMachine g_atl_machine;
-template <typename T> T &get_processor(atmi_place_t place) {
-  int dev_id = place.device_id;
+template <typename T> T &get_processor(int dev_id) {
   if (dev_id == -1) {
     // user is asking runtime to pick a device
     // best device of this type? pick 0 for now
     dev_id = 0;
   }
   return g_atl_machine.processors<T>()[dev_id];
 }
 
 #endif // SRC_RUNTIME_INCLUDE_MACHINE_H_

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

 public:
   static Runtime &getInstance() {
     static Runtime instance;
     return instance;
   }
 
   // modules
   static hsa_status_t RegisterModuleFromMemory(
-      void *, size_t, atmi_place_t,
+      void *, size_t, int DeviceId,
       hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                            void *cb_state),
       void *cb_state, std::vector<hsa_executable_t> &HSAExecutables);
 
   // data
   static hsa_status_t Memcpy(hsa_signal_t, void *, const void *, size_t);
   static hsa_status_t Memfree(void *);
   static hsa_status_t HostMalloc(void **ptr, size_t size);

openmp/libomptarget/plugins/amdgpu/impl/system.cpp

 }
 
 void init_tasks() {
   if (atlc.g_tasks_initialized != false)
     return;
   std::vector<hsa_agent_t> gpu_agents;
   int gpu_count = g_atl_machine.processorCount<ATLGPUProcessor>();
   for (int gpu = 0; gpu < gpu_count; gpu++) {
-    atmi_place_t place = ATMI_PLACE_GPU(0, gpu);
-    ATLGPUProcessor &proc = get_processor<ATLGPUProcessor>(place);
+    ATLGPUProcessor &proc = get_processor<ATLGPUProcessor>(gpu);
     gpu_agents.push_back(proc.agent());
   }
   atlc.g_tasks_initialized = true;
 }
 
 hsa_status_t callbackEvent(const hsa_amd_event_t *event, void *data) {
 #if (ROCM_VERSION_MAJOR >= 3) ||                                               \
     (ROCM_VERSION_MAJOR >= 2 && ROCM_VERSION_MINOR >= 3)
if (type == HSA_SYMBOL_KIND_KERNEL) {
     DEBUG_PRINT("Symbol is an indirect function\n");
   }
   return HSA_STATUS_SUCCESS;
 }
 
 hsa_status_t RegisterModuleFromMemory(
     std::map<std::string, atl_kernel_info_t> &KernelInfoTable,
     std::map<std::string, atl_symbol_info_t> &SymbolInfoTable,
-    void *module_bytes, size_t module_size, atmi_place_t place,
+    void *module_bytes, size_t module_size, int gpu,
     hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                          void *cb_state),
     void *cb_state, std::vector<hsa_executable_t> &HSAExecutables) {
   hsa_status_t err;
-  int gpu = place.device_id;
   assert(gpu >= 0);
 
   DEBUG_PRINT("Trying to load module to GPU-%d\n", gpu);
-  ATLGPUProcessor &proc = get_processor<ATLGPUProcessor>(place);
+  ATLGPUProcessor &proc = get_processor<ATLGPUProcessor>(gpu);
   hsa_agent_t agent = proc.agent();
   hsa_executable_t executable = {0};
   hsa_profile_t agent_profile;
 
   err = hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_profile);
   if (err != HSA_STATUS_SUCCESS) {
     printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
            "Query the agent profile", get_error_string(err));

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

 #endif
 
 #include "elf_common.h"
 
 namespace core {
 hsa_status_t RegisterModuleFromMemory(
     std::map<std::string, atl_kernel_info_t> &KernelInfo,
     std::map<std::string, atl_symbol_info_t> &SymbolInfoTable, void *, size_t,
-    atmi_place_t,
+    int DeviceId,
     hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                          void *cb_state),
     void *cb_state, std::vector<hsa_executable_t> &HSAExecutables);
 }
 
 /// Keep entries table per device
 struct FuncOrGblEntryTy {
   __tgt_target_table Table;
KernelTy(int8_t _ExecutionMode, int16_t _ConstWGSize, int32_t _device_id,
     }
   }
 };
 
 /// List that contains all the kernels.
 /// FIXME: we may need this to be per device and per library.
 std::list<KernelTy> KernelsList;
 
-// ATMI API to get gpu and gpu memory place
-static atmi_place_t get_gpu_place(int device_id) {
-  return ATMI_PLACE_GPU(0, device_id);
-}
-
 static std::vector<hsa_agent_t> find_gpu_agents() {
   std::vector<hsa_agent_t> res;
 
   hsa_status_t err = hsa_iterate_agents(
       [](hsa_agent_t agent, void *data) -> hsa_status_t {
         std::vector<hsa_agent_t> *res =
             static_cast<std::vector<hsa_agent_t> *>(data);
 
if (rc == 0) {
     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,
-    void *module_bytes, size_t module_size, atmi_place_t place, C cb,
+    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, place, L,
+      KernelInfoTable, SymbolInfoTable, module_bytes, module_size, 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
__tgt_target_table *__tgt_rtl_load_binary_locked(int32_t device_id,
 
   {
     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,
-        get_gpu_place(device_id),
+        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);