[AMDGPU][Libomptarget] Remove atlc global

[pdhaliwal]

Summary

This global struct used to hold various flags for monitoring the
initialization of hsa.

[JonChesterfield]

Nice, thanks. The task support was nominally deleted some time ago, iirc the init() part survived because the variable was used elsewhere as well. Good to see it go.

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

144

Is the type atl_context_t now unused too?

458

This may mean parts of g_atl_machine can be deleted too

[pdhaliwal]

Remove atl_context_t struct

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

144

Yes, it is unused. Will also include deletion of that in this patch.

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #include <gelf.h>
 #include <libelf.h>
 
 #include <cassert>
 #include <cstdarg>
 #include <fstream>
 #include <iomanip>
 #include <iostream>
 #include <set>
static const std::map<std::string, KernelArgMD::ValueKind> ArgValueKind = {
     {"hidden_completion_action",
      KernelArgMD::ValueKind::HiddenCompletionAction},
     {"hidden_multigrid_sync_arg",
      KernelArgMD::ValueKind::HiddenMultiGridSyncArg},
     {"hidden_hostcall_buffer", KernelArgMD::ValueKind::HiddenHostcallBuffer},
 };
 
 ATLMachine g_atl_machine;
 
-/*
-   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 {
 
 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());
   }
   return hsa_amd_agents_allow_access(agents.size(), &agents[0], NULL, ptr);
 }
 
-static void atmi_init_context_structs() {
-  atlc.struct_initialized = true; /* This only gets called one time */
-  atlc.g_hsa_initialized = false;
-  atlc.g_gpu_initialized = false;
-  atlc.g_tasks_initialized = false;
-}
-
 // Implement memory_pool iteration function
 static hsa_status_t get_memory_pool_info(hsa_amd_memory_pool_t memory_pool,
                                          void *data) {
   ATLProcessor *proc = reinterpret_cast<ATLProcessor *>(data);
   hsa_status_t err = HSA_STATUS_SUCCESS;
   // Check if the memory_pool is allowed to allocate, i.e. do not return group
   // memory
   bool alloc_allowed = false;
static hsa_status_t init_compute_and_memory() {
   }
   if (num_procs > 0)
     return HSA_STATUS_SUCCESS;
   else
     return HSA_STATUS_ERROR_NOT_INITIALIZED;
 }
 
 hsa_status_t init_hsa() {
-  if (atlc.g_hsa_initialized == false) {
-    DEBUG_PRINT("Initializing HSA...");
-    hsa_status_t err = hsa_init();
-    if (err != HSA_STATUS_SUCCESS) {
-      printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
-             "Initializing the hsa runtime", get_error_string(err));
-      return err;
-    }
-    if (err != HSA_STATUS_SUCCESS)
-      return err;
 
-    err = init_compute_and_memory();
-    if (err != HSA_STATUS_SUCCESS)
-      return err;
-    if (err != HSA_STATUS_SUCCESS) {
-      printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
-             "After initializing compute and memory", get_error_string(err));
-      return err;
-    }
 
-    atlc.g_hsa_initialized = true;
-    DEBUG_PRINT("done\n");
-  }
   return HSA_STATUS_SUCCESS;
 }
 
-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++) {
-    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 (event->event_type == HSA_AMD_GPU_MEMORY_FAULT_EVENT) {
 #else
   if (event->event_type == GPU_MEMORY_FAULT_EVENT) {
 #endif
     hsa_amd_gpu_memory_fault_info_t memory_fault = event->memory_fault;
#endif
     }
     fprintf(stderr, "%s\n", err_string.c_str());
     return HSA_STATUS_ERROR;
   }
   return HSA_STATUS_SUCCESS;
 }
 
 hsa_status_t atl_init_gpu_context() {
-  if (atlc.struct_initialized == false)
-    atmi_init_context_structs();
-  if (atlc.g_gpu_initialized != false)
-    return HSA_STATUS_SUCCESS;
-
   hsa_status_t err;
   err = init_hsa();
   if (err != HSA_STATUS_SUCCESS)
     return HSA_STATUS_ERROR;
 
   err = hsa_amd_register_system_event_handler(callbackEvent, NULL);
   if (err != HSA_STATUS_SUCCESS) {
     printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
            "Registering the system for memory faults", get_error_string(err));
     return HSA_STATUS_ERROR;
   }
 
-  init_tasks();
-  atlc.g_gpu_initialized = true;
   return HSA_STATUS_SUCCESS;
 }
 
 static bool isImplicit(KernelArgMD::ValueKind value_kind) {
   switch (value_kind) {
   case KernelArgMD::ValueKind::HiddenGlobalOffsetX:
   case KernelArgMD::ValueKind::HiddenGlobalOffsetY:
   case KernelArgMD::ValueKind::HiddenGlobalOffsetZ: