[libomptarget][amdgpu][nfc] Fix build warnings, drop some headers

[JonChesterfield]

Summary

Removes stdarg header, drops uses of iostream, fix some format string errors.
Also changes a C style struct to C++ style to avoid a warning from clang/

[JonChesterfield]

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

208

atmi_error_string was a subset of get_error_string

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

13

stringstream is currently used for some formatting, don't need to include iostream to get that

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

15

hsa includes essentially the same switch as here, but provides some more context on the error meaning, and avoids warnings about missing cases in the switch

[pdhaliwal]

Looks good! Thanks

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

hsa_status_t atmi_memcpy_h2d(hsa_signal_t signal, void *deviceDest,
   // locking part of a read only segment. Fall back for now.
   if (rc == HSA_STATUS_SUCCESS) {
     return HSA_STATUS_SUCCESS;
   }
 
   void *tempHostPtr;
   hsa_status_t ret = core::Runtime::HostMalloc(&tempHostPtr, size);
   if (ret != HSA_STATUS_SUCCESS) {
-    DEBUG_PRINT("HostMalloc: Unable to alloc %d bytes for temp scratch\n",
+    DEBUG_PRINT("HostMalloc: Unable to alloc %zu bytes for temp scratch\n",
                 size);
     return ret;
   }
   std::unique_ptr<void, atmiFreePtrDeletor> del(tempHostPtr);
   memcpy(tempHostPtr, hostSrc, size);
 
   if (invoke_hsa_copy(signal, deviceDest, tempHostPtr, size, agent) !=
       HSA_STATUS_SUCCESS) {
hsa_status_t atmi_memcpy_d2h(hsa_signal_t signal, void *dest,
   // hsa_memory_copy sometimes fails in situations where
   // allocate + copy succeeds. Looks like it might be related to
   // locking part of a read only segment. Fall back for now.
   if (rc == HSA_STATUS_SUCCESS) {
     return HSA_STATUS_SUCCESS;
   }
 
   void *tempHostPtr;
-
   hsa_status_t ret = core::Runtime::HostMalloc(&tempHostPtr, size);
   if (ret != HSA_STATUS_SUCCESS) {
-    DEBUG_PRINT("HostMalloc: Unable to alloc %d bytes for temp scratch\n",
+    DEBUG_PRINT("HostMalloc: Unable to alloc %zu bytes for temp scratch\n",
                 size);
     return ret;
   }
   std::unique_ptr<void, atmiFreePtrDeletor> del(tempHostPtr);
 
   if (invoke_hsa_copy(signal, tempHostPtr, deviceSrc, size, agent) !=
       HSA_STATUS_SUCCESS) {
     return HSA_STATUS_ERROR;
   }
 
   memcpy(dest, tempHostPtr, size);
   return HSA_STATUS_SUCCESS;
 }

openmp/libomptarget/plugins/amdgpu/impl/data.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 "machine.h"
 #include "rt.h"
 #include <cassert>
 #include <hsa.h>
 #include <hsa_ext_amd.h>
-#include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <thread>
 #include <vector>
 
 using core::TaskImpl;
 extern ATLMachine g_atl_machine;
 

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

 extern bool atl_is_atmi_initialized();
 
 bool handle_group_signal(hsa_signal_value_t value, void *arg);
 
 hsa_status_t allow_access_to_all_gpu_agents(void *ptr);
 } // namespace core
 
 const char *get_error_string(hsa_status_t err);
-const char *get_atmi_error_string(hsa_status_t err);
 
 #endif // SRC_RUNTIME_INCLUDE_INTERNAL_H_

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #ifndef SRC_RUNTIME_INCLUDE_RT_H_
 #define SRC_RUNTIME_INCLUDE_RT_H_
 
 #include "atmi_runtime.h"
 #include "hsa.h"
-#include <cstdarg>
 #include <string>
 
 namespace core {
 
 #define DEFAULT_MAX_QUEUE_SIZE 4096
 #define DEFAULT_DEBUG_MODE 0
 class Environment {
 public:

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>
+#include <sstream>
 #include <string>
 
 #include "internal.h"
 #include "machine.h"
 #include "rt.h"
 
 #include "msgpack.h"
 
do // Existing control flow used continue, preserve that for this patch
       // Mutating the device image here avoids another allocation & memcpy
       void *code_object_alloc_data =
           reinterpret_cast<void *>(code_object.handle);
       hsa_status_t atmi_err =
           on_deserialized_data(code_object_alloc_data, module_size, cb_state);
       if (atmi_err != HSA_STATUS_SUCCESS) {
         printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
                "Error in deserialized_data callback",
-               get_atmi_error_string(atmi_err));
+               get_error_string(atmi_err));
         return atmi_err;
       }
 
       /* Load the code object.  */
       err =
           hsa_executable_load_code_object(executable, agent, code_object, NULL);
       if (err != HSA_STATUS_SUCCESS) {
         DEBUG_PRINT("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,

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

 /*===--------------------------------------------------------------------------
  *              ATMI (Asynchronous Task and Memory Interface)
  *
  * This file is distributed under the MIT License. See LICENSE.txt for details.
  *===------------------------------------------------------------------------*/
 #include "internal.h"
 #include "rt.h"
 
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <errno.h>
-#include <iostream>
-#include <pthread.h>
-#include <sched.h>
 #include <stdio.h>
-
-/*
- * Helper functions
- */
-const char *get_atmi_error_string(hsa_status_t err) {
-  switch (err) {
-  case HSA_STATUS_SUCCESS:
-    return "HSA_STATUS_SUCCESS";
-  case HSA_STATUS_ERROR:
-    return "HSA_STATUS_ERROR";
-  default:
-    return "";
-  }
-}
+#include <string>
 
 const char *get_error_string(hsa_status_t err) {
-  switch (err) {
-  case HSA_STATUS_SUCCESS:
-    return "HSA_STATUS_SUCCESS";
-  case HSA_STATUS_INFO_BREAK:
-    return "HSA_STATUS_INFO_BREAK";
-  case HSA_STATUS_ERROR:
-    return "HSA_STATUS_ERROR";
-  case HSA_STATUS_ERROR_INVALID_ARGUMENT:
-    return "HSA_STATUS_ERROR_INVALID_ARGUMENT";
-  case HSA_STATUS_ERROR_INVALID_QUEUE_CREATION:
-    return "HSA_STATUS_ERROR_INVALID_QUEUE_CREATION";
-  case HSA_STATUS_ERROR_INVALID_ALLOCATION:
-    return "HSA_STATUS_ERROR_INVALID_ALLOCATION";
-  case HSA_STATUS_ERROR_INVALID_AGENT:
-    return "HSA_STATUS_ERROR_INVALID_AGENT";
-  case HSA_STATUS_ERROR_INVALID_REGION:
-    return "HSA_STATUS_ERROR_INVALID_REGION";
-  case HSA_STATUS_ERROR_INVALID_SIGNAL:
-    return "HSA_STATUS_ERROR_INVALID_SIGNAL";
-  case HSA_STATUS_ERROR_INVALID_QUEUE:
-    return "HSA_STATUS_ERROR_INVALID_QUEUE";
-  case HSA_STATUS_ERROR_OUT_OF_RESOURCES:
-    return "HSA_STATUS_ERROR_OUT_OF_RESOURCES";
-  case HSA_STATUS_ERROR_INVALID_PACKET_FORMAT:
-    return "HSA_STATUS_ERROR_INVALID_PACKET_FORMAT";
-  case HSA_STATUS_ERROR_RESOURCE_FREE:
-    return "HSA_STATUS_ERROR_RESOURCE_FREE";
-  case HSA_STATUS_ERROR_NOT_INITIALIZED:
-    return "HSA_STATUS_ERROR_NOT_INITIALIZED";
-  case HSA_STATUS_ERROR_REFCOUNT_OVERFLOW:
-    return "HSA_STATUS_ERROR_REFCOUNT_OVERFLOW";
-  case HSA_STATUS_ERROR_INCOMPATIBLE_ARGUMENTS:
-    return "HSA_STATUS_ERROR_INCOMPATIBLE_ARGUMENTS";
-  case HSA_STATUS_ERROR_INVALID_INDEX:
-    return "HSA_STATUS_ERROR_INVALID_INDEX";
-  case HSA_STATUS_ERROR_INVALID_ISA:
-    return "HSA_STATUS_ERROR_INVALID_ISA";
-  case HSA_STATUS_ERROR_INVALID_ISA_NAME:
-    return "HSA_STATUS_ERROR_INVALID_ISA_NAME";
-  case HSA_STATUS_ERROR_INVALID_CODE_OBJECT:
-    return "HSA_STATUS_ERROR_INVALID_CODE_OBJECT";
-  case HSA_STATUS_ERROR_INVALID_EXECUTABLE:
-    return "HSA_STATUS_ERROR_INVALID_EXECUTABLE";
-  case HSA_STATUS_ERROR_FROZEN_EXECUTABLE:
-    return "HSA_STATUS_ERROR_FROZEN_EXECUTABLE";
-  case HSA_STATUS_ERROR_INVALID_SYMBOL_NAME:
-    return "HSA_STATUS_ERROR_INVALID_SYMBOL_NAME";
-  case HSA_STATUS_ERROR_VARIABLE_ALREADY_DEFINED:
-    return "HSA_STATUS_ERROR_VARIABLE_ALREADY_DEFINED";
-  case HSA_STATUS_ERROR_VARIABLE_UNDEFINED:
-    return "HSA_STATUS_ERROR_VARIABLE_UNDEFINED";
-  case HSA_STATUS_ERROR_EXCEPTION:
-    return "HSA_STATUS_ERROR_EXCEPTION";
-  }
+  const char *res;
+  hsa_status_t rc = hsa_status_string(err, &res);
+  return (rc == HSA_STATUS_SUCCESS) ? res : "HSA_STATUS UNKNOWN.";
 }
 
 namespace core {
 /*
  * Environment variables
  */
 void Environment::GetEnvAll() {
   std::string var = GetEnv("ATMI_HELP");
   if (!var.empty()) {
-    std::cout << "ATMI_MAX_HSA_QUEUE_SIZE : positive integer" << std::endl
-              << "ATMI_DEBUG : 1 for printing out trace/debug info"
-              << std::endl;
+    printf("ATMI_MAX_HSA_QUEUE_SIZE : positive integer\n"
+           "ATMI_DEBUG : 1 for printing out trace/debug info\n");
   }
 
   var = GetEnv("ATMI_MAX_HSA_QUEUE_SIZE");
   if (!var.empty())
     max_queue_size_ = std::stoi(var);
 
   var = GetEnv("ATMI_DEBUG");
   if (!var.empty())
     debug_mode_ = std::stoi(var);
 }
 } // namespace core

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

for (uint32_t i = bucket[hash % nbucket]; i != 0; i = chain[i]) {
     if (strncmp(symname, n, max) == 0) {
       return &symtab[i];
     }
   }
 
   return nullptr;
 }
 
-typedef struct {
+struct symbol_info {
   void *addr = nullptr;
   uint32_t size = UINT32_MAX;
   uint32_t sh_type = SHT_NULL;
-} symbol_info;
+};
 
 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);