[AMDGPU][libomptarget] Remove unused global variables

[pdhaliwal]

Summary

This initial patch removes some unused variables from global namespace.
There will more incoming patches for moving global variables to classes
or static members.

[pdhaliwal]

Fix commit message.

[JonChesterfield]

Nice!

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

121

Nice. Does this mean there's an #include time.h or ctime that can be dropped?

[pdhaliwal]

Removed two more variables, atl_cpu_kernarg_region & atl_gpu_kernarg_region

[pdhaliwal]

I had removed two more variables. @JonChesterfield could you take a look again?

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

121

I don't see those header files included in the deps. It seems that those might be getting included from hsa

[JonChesterfield]

Looks like they've been made function local as opposed to removed, but that's still good. Thanks

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

 /*  All global values go in this global structure */
 typedef struct atl_context_s {
   bool struct_initialized;
   bool g_hsa_initialized;
   bool g_gpu_initialized;
   bool g_tasks_initialized;
 } atl_context_t;
 extern atl_context_t atlc;
-extern atl_context_t *atlc_p;
 
 #ifdef __cplusplus
 }
 #endif
 
 /* ---------------------------------------------------------------------------------
  * Simulated CPU Data Structures and API
  * ---------------------------------------------------------------------------------
typedef struct atl_symbol_info_s {
   uint32_t size;
 } atl_symbol_info_t;
 
 extern std::vector<std::map<std::string, atl_kernel_info_t>> KernelInfoTable;
 extern std::vector<std::map<std::string, atl_symbol_info_t>> SymbolInfoTable;
 
 // ---------------------- Kernel End -------------
 
-extern struct timespec context_init_time;
-
 namespace core {
 class TaskgroupImpl;
 class TaskImpl;
 class Kernel;
 class KernelImpl;
 } // namespace core
 
 struct SignalPoolT {

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #include "machine.h"
 #include "atmi_runtime.h"
 #include "internal.h"
 #include <cassert>
 #include <hsa.h>
 #include <hsa_ext_amd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
 
 extern ATLMachine g_atl_machine;
-extern hsa_region_t atl_cpu_kernarg_region;
 
 void ATLProcessor::addMemory(const ATLMemory &mem) {
   for (auto &mem_obj : memories_) {
     // if the memory already exists, then just return
     if (mem.memory().handle == mem_obj.memory().handle)
       return;
   }
   memories_.push_back(mem);

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

static const std::map<std::string, KernelArgMD::ValueKind> ArgValueKind = {
      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;
 
-hsa_region_t atl_gpu_kernarg_region;
 std::vector<hsa_amd_memory_pool_t> atl_gpu_kernarg_pools;
-hsa_region_t atl_cpu_kernarg_region;
 
 static std::vector<hsa_executable_t> g_executables;
 
 std::map<std::string, std::string> KernelNameMap;
 std::vector<std::map<std::string, atl_kernel_info_t>> KernelInfoTable;
 std::vector<std::map<std::string, atl_symbol_info_t>> SymbolInfoTable;
 
 bool g_atmi_initialized = false;
 bool g_atmi_hostcall_required = false;
 
-struct timespec context_init_time;
-int context_init_time_init = 0;
-
 /*
    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.
-   However the pointer value atlc_p-> is equivalent to atlc.
-
 */
-
 atl_context_t atlc = {.struct_initialized = false};
-atl_context_t *atlc_p = NULL;
 
 namespace core {
 /* Machine Info */
 atmi_machine_t *Runtime::GetMachineInfo() {
   if (!atlc.g_hsa_initialized)
     return NULL;
   return &g_atmi_machine;
 }
printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__, "Shutting down HSA",
            get_error_string(err));
     exit(1);
   }
 
   return ATMI_STATUS_SUCCESS;
 }
 
 static void atmi_init_context_structs() {
-  atlc_p = &atlc;
   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,
for (auto &memory : memories) {
         DEBUG_PRINT("Coarse\t");
       }
     }
     DEBUG_PRINT("\nFine Memories : %d", fine_memories_size);
     DEBUG_PRINT("\tCoarse Memories : %d\n", coarse_memories_size);
     proc_index++;
   }
   proc_index = 0;
+  hsa_region_t atl_cpu_kernarg_region;
   atl_cpu_kernarg_region.handle = (uint64_t)-1;
   if (cpu_procs.size() > 0) {
     err = hsa_agent_iterate_regions(
         cpu_procs[0].agent(), get_fine_grained_region, &atl_cpu_kernarg_region);
     if (err == HSA_STATUS_INFO_BREAK) {
       err = HSA_STATUS_SUCCESS;
     }
     err = (atl_cpu_kernarg_region.handle == (uint64_t)-1) ? HSA_STATUS_ERROR
                                                           : HSA_STATUS_SUCCESS;
     if (err != HSA_STATUS_SUCCESS) {
       printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
              "Finding a CPU kernarg memory region handle",
              get_error_string(err));
       exit(1);
     }
   }
+  hsa_region_t atl_gpu_kernarg_region;
   /* Find a memory region that supports kernel arguments.  */
   atl_gpu_kernarg_region.handle = (uint64_t)-1;
   if (gpu_procs.size() > 0) {
     hsa_agent_iterate_regions(gpu_procs[0].agent(), get_kernarg_memory_region,
                               &atl_gpu_kernarg_region);
     err = (atl_gpu_kernarg_region.handle == (uint64_t)-1) ? HSA_STATUS_ERROR
                                                           : HSA_STATUS_SUCCESS;
     if (err != HSA_STATUS_SUCCESS) {
atmi_status_t atl_init_gpu_context() {
   if (atlc.g_gpu_initialized != false)
     return ATMI_STATUS_SUCCESS;
 
   hsa_status_t err;
   err = init_hsa();
   if (err != HSA_STATUS_SUCCESS)
     return ATMI_STATUS_ERROR;
 
-  if (context_init_time_init == 0) {
-    clock_gettime(CLOCK_MONOTONIC_RAW, &context_init_time);
-    context_init_time_init = 1;
-  }
-
   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));
     exit(1);
   }
 
   init_tasks();