[AMDGPU][Libomptarget] Remove g_atmi_machine global

[pdhaliwal]

Summary

Turns out the only purpose of this class was verify if device ID
was in range or not which could be done easily by using g_atl_machine.

Still getting rid of g_atl_machine is pending which would be done in
a later patch.

[JonChesterfield]

Iirc it did more things in ATMI. Nice simplification here.

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #include "atmi_runtime.h"
 #include "internal.h"
 #include "rt.h"
 #include <hsa.h>
 #include <hsa_ext_amd.h>
 #include <memory>
 
 /*
- * Machine Info
- */
-atmi_machine_t *atmi_machine_get_info() {
-  return core::Runtime::GetMachineInfo();
-}
-
-/*
  * Data
  */
 
 static hsa_status_t invoke_hsa_copy(hsa_signal_t sig, void *dest,
                                     const void *src, size_t size,
                                     hsa_agent_t agent) {
   const hsa_signal_value_t init = 1;
   const hsa_signal_value_t success = 0;

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #include "atmi_interop_hsa.h"
 #include "internal.h"
+#include "machine.h"
+
+// TODO: need to get rid of this as well
+
+extern ATLMachine g_atl_machine;
 
 hsa_status_t atmi_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) {
   /*
      // Typical usage:
      void *var_addr;
      size_t var_size;
      atmi_interop_hsa_get_symbol_addr(gpu_place, "symbol_name", &var_addr,
      &var_size);
      atmi_memcpy(signal, host_add, var_addr, var_size);
   */
 
-  atmi_machine_t *machine = atmi_machine_get_info();
-  if (!symbol || !var_addr || !var_size || !machine)
+  if (!symbol || !var_addr || !var_size)
     return HSA_STATUS_ERROR;
   if (DeviceId < 0 ||
-      DeviceId >= machine->device_count_by_type[ATMI_DEVTYPE_GPU])
+      DeviceId >= g_atl_machine.processors<ATLGPUProcessor>().size())
     return HSA_STATUS_ERROR;
 
   // get the symbol info
   std::string symbolStr = std::string(symbol);
   auto It = SymbolInfoTable.find(symbolStr);
   if (It != SymbolInfoTable.end()) {
     atl_symbol_info_t info = It->second;
     *var_addr = reinterpret_cast<void *>(info.addr);
hsa_status_t atmi_interop_hsa_get_kernel_info(
   /*
      // Typical usage:
      uint32_t value;
      atmi_interop_hsa_get_kernel_addr(gpu_place, "kernel_name",
                                   HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_SIZE,
                                   &val);
   */
 
-  atmi_machine_t *machine = atmi_machine_get_info();
-  if (!kernel_name || !value || !machine)
+  if (!kernel_name || !value)
     return HSA_STATUS_ERROR;
   if (DeviceId < 0 ||
-      DeviceId >= machine->device_count_by_type[ATMI_DEVTYPE_GPU])
+      DeviceId >= g_atl_machine.processors<ATLGPUProcessor>().size())
     return HSA_STATUS_ERROR;
 
   hsa_status_t status = HSA_STATUS_SUCCESS;
   // get the kernel info
   std::string kernelStr = std::string(kernel_name);
   auto It = KernelInfoTable.find(kernelStr);
   if (It != KernelInfoTable.end()) {
     atl_kernel_info_t info = It->second;

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

 hsa_status_t atmi_module_register_from_memory_to_place(
     void *module_bytes, size_t module_size, atmi_place_t place,
     hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                          void *cb_state),
     void *cb_state);
 
 /** @} */
 
-/** \defgroup machine ATMI Machine
- * @{
- */
-/**
- * @brief ATMI's device discovery function to get the current machine's
- * topology.
- *
- * @detail The @p atmi_machine_t structure is a tree-based representation of the
- * compute and memory elements in the current node. Once ATMI is initialized,
- * this function can be called to retrieve the pointer to this global structure.
- *
- * @return Returns a pointer to a global structure of tyoe @p atmi_machine_t.
- * Returns NULL if ATMI is not initialized.
- */
-atmi_machine_t *atmi_machine_get_info();
-/** @} */
-
 hsa_status_t atmi_memcpy_h2d(hsa_signal_t signal, void *deviceDest,
                              const void *hostSrc, size_t size,
                              hsa_agent_t agent);
 
 hsa_status_t atmi_memcpy_d2h(hsa_signal_t sig, void *hostDest,
                              const void *deviceSrc, size_t size,
                              hsa_agent_t agent);
 
 /** @} */
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // INCLUDE_ATMI_RUNTIME_H_

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

 
 class Runtime final {
 public:
   static Runtime &getInstance() {
     static Runtime instance;
     return instance;
   }
 
-  // machine info
-  static atmi_machine_t *GetMachineInfo();
   // modules
   static hsa_status_t RegisterModuleFromMemory(
       void *, size_t, atmi_place_t,
       hsa_status_t (*on_deserialized_data)(void *data, size_t size,
                                            void *cb_state),
       void *cb_state, std::vector<hsa_executable_t> &HSAExecutables);
 
   // data

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

static const std::map<std::string, KernelArgMD::ValueKind> ArgValueKind = {
     {"hidden_default_queue", KernelArgMD::ValueKind::HiddenDefaultQueue},
     {"hidden_completion_action",
      KernelArgMD::ValueKind::HiddenCompletionAction},
     {"hidden_multigrid_sync_arg",
      KernelArgMD::ValueKind::HiddenMultiGridSyncArg},
     {"hidden_hostcall_buffer", KernelArgMD::ValueKind::HiddenHostcallBuffer},
 };
 
-// global variables. TODO: Get rid of these
-atmi_machine_t g_atmi_machine;
 ATLMachine g_atl_machine;
 
 std::vector<hsa_amd_memory_pool_t> atl_gpu_kernarg_pools;
 
 /*
    atlc is all internal global values.
    The structure atl_context_t is defined in atl_internal.h
    Most references will use the global structure prefix atlc.
 */
 atl_context_t atlc = {.struct_initialized = false};
 
 namespace core {
-/* Machine Info */
-atmi_machine_t *Runtime::GetMachineInfo() {
-  if (!atlc.g_hsa_initialized)
-    return NULL;
-  return &g_atmi_machine;
-}
 
 hsa_status_t allow_access_to_all_gpu_agents(void *ptr) {
   std::vector<ATLGPUProcessor> &gpu_procs =
       g_atl_machine.processors<ATLGPUProcessor>();
   std::vector<hsa_agent_t> agents;
   for (uint32_t i = 0; i < gpu_procs.size(); i++) {
     agents.push_back(gpu_procs[i].agent());
   }
for (auto &gpu_mem : gpu_proc.memories()) {
           // this means not NEVER, but could be YES or NO
           // add this memory pool to the proc
           cpu_proc.addMemory(gpu_mem);
         }
       }
     }
   }
 
-  g_atmi_machine.device_count_by_type[ATMI_DEVTYPE_CPU] = cpu_procs.size();
-  g_atmi_machine.device_count_by_type[ATMI_DEVTYPE_GPU] = gpu_procs.size();
-
   size_t num_procs = cpu_procs.size() + gpu_procs.size();
-  // g_atmi_machine.devices = (atmi_device_t *)malloc(num_procs *
-  // sizeof(atmi_device_t));
   atmi_device_t *all_devices = reinterpret_cast<atmi_device_t *>(
       malloc(num_procs * sizeof(atmi_device_t)));
   int num_iGPUs = 0;
   int num_dGPUs = 0;
   for (uint32_t i = 0; i < gpu_procs.size(); i++) {
     if (gpu_procs[i].type() == ATMI_DEVTYPE_iGPU)
       num_iGPUs++;
     else
       num_dGPUs++;
   }
   assert(num_iGPUs + num_dGPUs == gpu_procs.size() &&
          "Number of dGPUs and iGPUs do not add up");
   DEBUG_PRINT("CPU Agents: %lu\n", cpu_procs.size());
   DEBUG_PRINT("iGPU Agents: %d\n", num_iGPUs);
   DEBUG_PRINT("dGPU Agents: %d\n", num_dGPUs);
   DEBUG_PRINT("GPU Agents: %lu\n", gpu_procs.size());
 
-  g_atmi_machine.device_count_by_type[ATMI_DEVTYPE_iGPU] = num_iGPUs;
-  g_atmi_machine.device_count_by_type[ATMI_DEVTYPE_dGPU] = num_dGPUs;
-
   int cpus_begin = 0;
   int cpus_end = cpu_procs.size();
   int gpus_begin = cpu_procs.size();
   int gpus_end = cpu_procs.size() + gpu_procs.size();
-  g_atmi_machine.devices_by_type[ATMI_DEVTYPE_CPU] = &all_devices[cpus_begin];
-  g_atmi_machine.devices_by_type[ATMI_DEVTYPE_GPU] = &all_devices[gpus_begin];
-  g_atmi_machine.devices_by_type[ATMI_DEVTYPE_iGPU] = &all_devices[gpus_begin];
-  g_atmi_machine.devices_by_type[ATMI_DEVTYPE_dGPU] = &all_devices[gpus_begin];
   int proc_index = 0;
   for (int i = cpus_begin; i < cpus_end; i++) {
     all_devices[i].type = cpu_procs[proc_index].type();
 
     std::vector<ATLMemory> memories = cpu_procs[proc_index].memories();
     int fine_memories_size = 0;
     int coarse_memories_size = 0;
     DEBUG_PRINT("CPU memory types:\t");