Minor improvements

CMakeLists.txt

@@ -10,10 +10,9 @@ set(CUDA_DIR "${SRC_DIR}/cuda")
 set(HSA_DIR "${SRC_DIR}/hsa")
 set(INTEL_DIR "${SRC_DIR}/intel")
 
-# Make sure that at least one backend is enabled.
+# Enable Intel backend by default
-# It does not make sense that the user has not specified any backend.
+if(NOT DEFINED ENABLE_INTEL_BACKEND)
-if(NOT ENABLE_INTEL_BACKEND AND NOT ENABLE_CUDA_BACKEND AND NOT ENABLE_HSA_BACKEND)
+    set(ENABLE_INTEL_BACKEND true)
-  message(FATAL_ERROR "No backend was enabled! Please enable at least one backend with -DENABLE_XXX_BACKEND")
 endif()
 
 if(ENABLE_CUDA_BACKEND)
@@ -67,30 +66,7 @@ if(ENABLE_HSA_BACKEND)
   endif()
 endif()
 
-set(GPUFECH_COMMON
-    ${COMMON_DIR}/main.cpp
-    ${COMMON_DIR}/args.cpp
-    ${COMMON_DIR}/gpu.cpp
-    ${COMMON_DIR}/global.cpp
-    ${COMMON_DIR}/printer.cpp
-    ${COMMON_DIR}/master.cpp
-    ${COMMON_DIR}/uarch.cpp
-)
-
-set(GPUFETCH_LINK_TARGETS z)
-
-if(NOT(ENABLE_HSA_BACKEND AND NOT ENABLE_CUDA_BACKEND AND NOT ENABLE_INTEL_BACKEND))
-  # Look for pciutils only if not building HSA only.
-  #
-  # This has the (intented) secondary effect that if only HSA backend is enabled
-  # by the user, but ROCm cannot be found, pciutils will still be compiled in
-  # order to show the list of GPUs available on the system, so that the user will
-  # get at least some feedback even if HSA is not found.
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
-  list(APPEND GPUFECH_COMMON ${COMMON_DIR}/pci.cpp ${COMMON_DIR}/sort.cpp)
-  list(APPEND GPUFETCH_LINK_TARGETS pci)
-  set(CMAKE_ENABLE_PCIUTILS ON)
-
 find_package(PCIUTILS)
 if(NOT ${PCIUTILS_FOUND})
   message(STATUS "${BoldYellow}pciutils not found, downloading and building a local copy...${ColorReset}")
@@ -113,17 +89,12 @@ if(NOT(ENABLE_HSA_BACKEND AND NOT ENABLE_CUDA_BACKEND AND NOT ENABLE_INTEL_BACKE
   # Needed for linking libpci in FreeBSD
   link_directories(/usr/local/lib/)
 endif()
-endif()
 
-add_executable(gpufetch ${GPUFECH_COMMON})
+add_executable(gpufetch ${COMMON_DIR}/main.cpp ${COMMON_DIR}/args.cpp ${COMMON_DIR}/gpu.cpp ${COMMON_DIR}/pci.cpp ${COMMON_DIR}/sort.cpp ${COMMON_DIR}/global.cpp ${COMMON_DIR}/printer.cpp ${COMMON_DIR}/master.cpp ${COMMON_DIR}/uarch.cpp)
 set(SANITY_FLAGS -Wfloat-equal -Wshadow -Wpointer-arith -Wall -Wextra -pedantic -fstack-protector-all -pedantic)
 target_compile_features(gpufetch PRIVATE cxx_std_11)
 target_compile_options(gpufetch PRIVATE ${SANITY_FLAGS})
 
-if (CMAKE_ENABLE_PCIUTILS)
-  target_compile_definitions(gpufetch PUBLIC BACKEND_USE_PCI)
-endif()
-
 if(ENABLE_INTEL_BACKEND)
   target_compile_definitions(gpufetch PUBLIC BACKEND_INTEL)
 
@@ -185,7 +156,7 @@ if(ENABLE_HSA_BACKEND)
   target_link_libraries(gpufetch hsa_backend)
 endif()
 
-target_link_libraries(gpufetch ${GPUFETCH_LINK_TARGETS})
+target_link_libraries(gpufetch pci z)
 install(TARGETS gpufetch DESTINATION bin)
 
 if(NOT WIN32)

build.sh

@@ -1,24 +1,5 @@
 #!/bin/bash
 
-print_help() {
-  cat << EOF
-Usage: $0 <backends> [build_type]
-
-  <backends>    MANDATORY. Comma-separated list of 
-                backends to enable.
-                Valid options: hsa, intel, cuda
-                Example: hsa,cuda
-
-  [build_type]  OPTIONAL. Build type. Valid options:
-                debug, release (default: release)
-
-Examples:
-  $0 hsa,intel debug
-  $0 cuda
-  $0 hsa,intel,cuda release
-EOF
-}
-
 # gpufetch build script
 set -e
 
@@ -26,79 +7,19 @@ rm -rf build/ gpufetch
 mkdir build/
 cd build/
 
-if [ "$1" == "--help" ]
+if [ "$1" == "debug" ]
 then
-  echo "gpufetch build script"
+  BUILD_TYPE="Debug"
-  echo
-  print_help
-  exit 0
-fi
-
-if [[ $# -lt 1 ]]; then
-  echo "ERROR: At least one backend must be specified."
-  echo
-  print_help
-  exit 1
-fi
-
-# Determine if last argument is build type
-LAST_ARG="${!#}"
-if [[ "$LAST_ARG" == "debug" || "$LAST_ARG" == "release" ]]; then
-  BUILD_TYPE="$LAST_ARG"
-  BACKEND_ARG="${1}"
 else
-  BUILD_TYPE="release"
+  BUILD_TYPE="Release"
-  BACKEND_ARG="${1}"
 fi
 
-# Split comma-separated backends into an array
-IFS=',' read -r -a BACKENDS <<< "$BACKEND_ARG"
-
-# Validate build type 
-if [[ "$BUILD_TYPE" != "debug" && "$BUILD_TYPE" != "release" ]]
-then
-  echo "Error: Invalid build type '$BUILD_TYPE'."
-  echo "Valid options are: debug, release"
-  exit 1
-fi
-
-# From lower to upper case
-CMAKE_FLAGS="-DCMAKE_BUILD_TYPE=${BUILD_TYPE^}"
-
-# Validate backends
-VALID_BACKENDS=("hsa" "intel" "cuda")
-
-for BACKEND in "${BACKENDS[@]}"; do
-  case "$BACKEND" in
-    hsa)
-      CMAKE_FLAGS+=" -DENABLE_HSA_BACKEND=ON"
-      ;;
-    intel)
-      CMAKE_FLAGS+=" -DENABLE_INTEL_BACKEND=ON"
-      ;;
-    cuda)
-      CMAKE_FLAGS+=" -DENABLE_CUDA_BACKEND=ON"
-      ;;
-    *)
-      echo "ERROR: Invalid backend '$BACKEND'."
-      echo "Valid options: ${VALID_BACKENDS[*]}"
-      exit 1
-      ;;
-  esac
-done
-
-# You can also manually specify the compilation flags.
-# If you need to, just run the cmake command directly
-# instead of using this script.
-#
-# Here you will find some help:
-#
 # In case you have CUDA installed but it is not detected,
 # - set CMAKE_CUDA_COMPILER to your nvcc binary:
 # - set CMAKE_CUDA_COMPILER_TOOLKIT_ROOT to the CUDA root dir
 # for example:
 # cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc -DCMAKE_CUDA_COMPILER_TOOLKIT_ROOT=/usr/local/cuda/ ..
-#
+
 # In case you want to explicitely disable a backend, you can:
 # Disable CUDA backend:
 # cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DENABLE_CUDA_BACKEND=OFF ..
@@ -107,9 +28,7 @@ done
 # Disable Intel backend:
 # cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DENABLE_INTEL_BACKEND=OFF ..
 
-echo "$0: Running cmake $CMAKE_FLAGS"
+cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-echo 
-cmake $CMAKE_FLAGS ..
 
 os=$(uname)
 if [ "$os" == 'Linux' ]; then

src/common/gpu.cpp

@@ -101,17 +101,6 @@ char* get_str_bus_width(struct gpu_info* gpu) {
   return string;
 }
 
-char* get_str_lds_size(struct gpu_info* gpu) {
-  // TODO: Show XX KB (XX MB Total) like in cpufetch
-  uint32_t size = 3+1+3+1;
-  assert(strlen(STRING_UNKNOWN)+1 <= size);
-  char* string = (char *) ecalloc(size, sizeof(char));
-
-  sprintf(string, "%d KB", gpu->mem->lds_size / 1024);
-
-  return string;
-}
-
 char* get_str_memory_clock(struct gpu_info* gpu) {
   return get_freq_as_str_mhz(gpu->mem->freq);
 }

src/common/gpu.hpp

@@ -3,6 +3,8 @@
 
 #include <cstdint>
 
+#include "../cuda/pci.hpp"
+
 #define UNKNOWN_FREQ -1
 
 enum {
@@ -46,10 +48,6 @@ struct topology_c {
 // HSA topology
 struct topology_h {
   int32_t compute_units;
-  int32_t num_shader_engines;
-  int32_t simds_per_cu;
-  int32_t num_xcc;
-  int32_t matrix_cores;
 };
 
 // Intel topology
@@ -65,7 +63,6 @@ struct memory {
   int32_t bus_width;
   int32_t freq;
   int32_t clk_mul; // clock multiplier
-  int32_t lds_size; // HSA specific for now
 };
 
 struct gpu_info {
@@ -93,7 +90,6 @@ char* get_str_freq(struct gpu_info* gpu);
 char* get_str_memory_size(struct gpu_info* gpu);
 char* get_str_memory_type(struct gpu_info* gpu);
 char* get_str_bus_width(struct gpu_info* gpu);
-char* get_str_lds_size(struct gpu_info* gpu);
 char* get_str_memory_clock(struct gpu_info* gpu);
 char* get_str_l2(struct gpu_info* gpu);
 char* get_str_peak_performance(struct gpu_info* gpu);

src/common/main.cpp

@@ -8,10 +8,6 @@
 #include "../cuda/cuda.hpp"
 #include "../cuda/uarch.hpp"
 
-#ifdef BACKEND_USE_PCI
-#include "pci.hpp"
-#endif
-
 static const char* VERSION = "0.30";
 
 void print_help(char *argv[]) {
@@ -83,12 +79,8 @@ int main(int argc, char* argv[]) {
   }
 
   if(get_num_gpus_available(list) == 0) {
-#ifdef BACKEND_USE_PCI    
     printErr("No GPU was detected! Available GPUs are:");
     print_gpus_list_pci();
-#else
-    printErr("No GPU was detected!");
-#endif    
     printf("Please, make sure that the appropiate backend is enabled:\n");
     print_enabled_backends();
     printf("Visit https://github.com/Dr-Noob/gpufetch#2-backends for more information\n");

src/common/master.cpp

@@ -1,10 +1,7 @@
 #include <cstdlib>
 #include <cstdio>
 
-#ifdef BACKEND_USE_PCI
 #include "pci.hpp"
-#endif  
-
 #include "global.hpp"
 #include "colors.hpp"
 #include "master.hpp"
@@ -22,9 +19,7 @@ struct gpu_list {
 
 struct gpu_list* get_gpu_list() {
   int idx = 0;
-#ifdef BACKEND_USE_PCI
   struct pci_dev *devices = get_pci_devices_from_pciutils();
-#endif
   struct gpu_list* list = (struct gpu_list*) malloc(sizeof(struct gpu_list));
   list->num_gpus = 0;
   list->gpus = (struct gpu_info**) malloc(sizeof(struct info*) * MAX_GPUS);
@@ -45,7 +40,7 @@ struct gpu_list* get_gpu_list() {
   bool valid = true;
 
   while(valid) {
-    list->gpus[idx] = get_gpu_info_hsa(idx);
+    list->gpus[idx] = get_gpu_info_hsa(devices, idx);
     if(list->gpus[idx] != NULL) idx++;
     else valid = false;
   }

src/common/printer.cpp

@@ -32,60 +32,64 @@
 #define MAX_ATTRIBUTES      100
 #define MAX_TERM_SIZE       1024
 
-typedef struct {
-  int id;
-  const char *name;
-  const char *shortname;
-} AttributeField;
-
-// AttributeField IDs
-//                         Used by
 enum {
-  ATTRIBUTE_NAME,          // ALL
+  ATTRIBUTE_NAME,
-  ATTRIBUTE_CHIP,          // ALL
+  ATTRIBUTE_CHIP,
-  ATTRIBUTE_UARCH,         // ALL
+  ATTRIBUTE_UARCH,
-  ATTRIBUTE_TECHNOLOGY,    // ALL
+  ATTRIBUTE_TECHNOLOGY,
-  ATTRIBUTE_FREQUENCY,     // ALL
+  ATTRIBUTE_GT,
-  ATTRIBUTE_PEAK,          // ALL
+  ATTRIBUTE_FREQUENCY,
-  ATTRIBUTE_COMPUTE_UNITS, // HSA
+  ATTRIBUTE_STREAMINGMP,
-  ATTRIBUTE_MATRIX_CORES,  // HSA
+  ATTRIBUTE_CORESPERMP,
-  ATTRIBUTE_XCDS,          // HSA
+  ATTRIBUTE_CUDA_CORES,
-  ATTRIBUTE_LDS_SIZE,      // HSA
+  ATTRIBUTE_TENSOR_CORES,
-  ATTRIBUTE_STREAMINGMP,   // CUDA
+  ATTRIBUTE_EUS,
-  ATTRIBUTE_CORESPERMP,    // CUDA
+  ATTRIBUTE_L2,
-  ATTRIBUTE_CUDA_CORES,    // CUDA
+  ATTRIBUTE_MEMORY,
-  ATTRIBUTE_TENSOR_CORES,  // CUDA
+  ATTRIBUTE_MEMORY_FREQ,
-  ATTRIBUTE_L2,            // CUDA
+  ATTRIBUTE_BUS_WIDTH,
-  ATTRIBUTE_MEMORY,        // CUDA,HSA
+  ATTRIBUTE_PEAK,
-  ATTRIBUTE_MEMORY_FREQ,   // CUDA
+  ATTRIBUTE_PEAK_TENSOR,
-  ATTRIBUTE_BUS_WIDTH,     // CUDA,HSA
-  ATTRIBUTE_PEAK_TENSOR,   // CUDA
-  ATTRIBUTE_EUS,           // Intel
-  ATTRIBUTE_GT,            // Intel
 };
 
-static const AttributeField ATTRIBUTE_INFO[] = {
+static const char* ATTRIBUTE_FIELDS [] = {
-  { ATTRIBUTE_NAME,          "Name:",                   "Name:" },
+  "Name:",
-  { ATTRIBUTE_CHIP,          "GPU processor:",          "Processor:" },
+  "GPU processor:",
-  { ATTRIBUTE_UARCH,         "Microarchitecture:",      "uArch:" },
+  "Microarchitecture:",
-  { ATTRIBUTE_TECHNOLOGY,    "Technology:",             "Technology:" },
+  "Technology:",
-  { ATTRIBUTE_FREQUENCY,     "Max Frequency:",          "Max Freq.:" },
+  "Graphics Tier:",
-  { ATTRIBUTE_PEAK,          "Peak Performance:",       "Peak Perf.:" },
+  "Max Frequency:",
-  { ATTRIBUTE_COMPUTE_UNITS, "Compute Units (CUs):",    "CUs" },
+  "SMs:",
-  { ATTRIBUTE_MATRIX_CORES,  "Matrix Cores:",           "Matrix Cores:" },
+  "Cores/SM:",
-  { ATTRIBUTE_XCDS,          "XCDs:",                   "XCDs" },
+  "CUDA Cores:",
-  { ATTRIBUTE_LDS_SIZE,      "LDS size:",               "LDS:" },
+  "Tensor Cores:",
-  { ATTRIBUTE_STREAMINGMP,   "SMs:",                    "SMs:" },
+  "Execution Units:",
-  { ATTRIBUTE_CORESPERMP,    "Cores/SM:",               "Cores/SM:" },
+  "L2 Size:",
-  { ATTRIBUTE_CUDA_CORES,    "CUDA Cores:",             "CUDA Cores:" },
+  "Memory:",
-  { ATTRIBUTE_TENSOR_CORES,  "Tensor Cores:",           "Tensor Cores:" },
+  "Memory frequency:",
-  { ATTRIBUTE_L2,            "L2 Size:",                "L2 Size:" },
+  "Bus width:",
-  { ATTRIBUTE_MEMORY,        "Memory:",                 "Memory:" },
+  "Peak Performance:",
-  { ATTRIBUTE_MEMORY_FREQ,   "Memory frequency:",       "Memory freq.:" },
+  "Peak Performance (MMA):",
-  { ATTRIBUTE_BUS_WIDTH,     "Bus width:",              "Bus width:" },
+};
-  { ATTRIBUTE_PEAK_TENSOR,   "Peak Performance (MMA):", "Peak Perf.(MMA):" },
+
-  { ATTRIBUTE_EUS,           "Execution Units:",        "EUs:" },
+static const char* ATTRIBUTE_FIELDS_SHORT [] = {
-  { ATTRIBUTE_GT,            "Graphics Tier:",          "GT:" },
+  "Name:",
+  "Processor:",
+  "uArch:",
+  "Technology:",
+  "GT:",
+  "Max Freq.:",
+  "SMs:",
+  "Cores/SM:",
+  "CUDA Cores:",
+  "Tensor Cores:",
+  "EUs:",
+  "L2 Size:",
+  "Memory:",
+  "Memory freq.:",
+  "Bus width:",
+  "Peak Perf.:",
+  "Peak Perf.(MMA):",
 };
 
 struct terminal {
@@ -203,6 +207,8 @@ bool ascii_fits_screen(int termw, struct ascii_logo logo, int lf) {
 void replace_bgbyfg_color(struct ascii_logo* logo) {
   // Replace background by foreground color
   for(int i=0; i < 2; i++) {
+    if(logo->color_ascii[i] == NULL) break;
+
     if(strcmp(logo->color_ascii[i], C_BG_BLACK) == 0) strcpy(logo->color_ascii[i], C_FG_BLACK);
     else if(strcmp(logo->color_ascii[i], C_BG_RED) == 0) strcpy(logo->color_ascii[i], C_FG_RED);
     else if(strcmp(logo->color_ascii[i], C_BG_GREEN) == 0) strcpy(logo->color_ascii[i], C_FG_GREEN);
@@ -270,14 +276,13 @@ void choose_ascii_art(struct ascii* art, struct color** cs, struct terminal* ter
   }
 }
 
-uint32_t longest_attribute_length(struct ascii* art, bool use_short) {
+uint32_t longest_attribute_length(struct ascii* art, const char** attribute_fields) {
   uint32_t max = 0;
   uint64_t len = 0;
 
   for(uint32_t i=0; i < art->n_attributes_set; i++) {
     if(art->attributes[i]->value != NULL) {
-      const char* str = use_short ? ATTRIBUTE_INFO[art->attributes[i]->type].shortname : ATTRIBUTE_INFO[art->attributes[i]->type].name;
+      len = strlen(attribute_fields[art->attributes[i]->type]);
-      len = strlen(str);
       if(len > max) max = len;
     }
   }
@@ -301,7 +306,7 @@ uint32_t longest_field_length(struct ascii* art, int la) {
   return max;
 }
 
-void print_ascii_generic(struct ascii* art, uint32_t la, int32_t text_space, bool use_short) {
+void print_ascii_generic(struct ascii* art, uint32_t la, int32_t text_space, const char** attribute_fields) {
   struct ascii_logo* logo = art->art;
   int attr_to_print = 0;
   int attr_type;
@@ -345,13 +350,11 @@ void print_ascii_generic(struct ascii* art, uint32_t la, int32_t text_space, boo
       attr_value = art->attributes[attr_to_print]->value;
       attr_to_print++;
 
-      const char* attr_str = use_short ? ATTRIBUTE_INFO[attr_type].shortname : ATTRIBUTE_INFO[attr_type].name;
+      space_right = 1 + (la - strlen(attribute_fields[attr_type]));
-
-      space_right = 1 + (la - strlen(attr_str));
       current_space = max(0, text_space);
 
-      printf("%s%.*s%s", logo->color_text[0], current_space, attr_str, art->reset);
+      printf("%s%.*s%s", logo->color_text[0], current_space, attribute_fields[attr_type], art->reset);
-      current_space = max(0, current_space - (int) strlen(attr_str));
+      current_space = max(0, current_space - (int) strlen(attribute_fields[attr_type]));
       printf("%*s", min(current_space, space_right), "");
       current_space = max(0, current_space - min(current_space, space_right));
       printf("%s%.*s%s", logo->color_text[1], current_space, attr_value, art->reset);
@@ -385,19 +388,19 @@ bool print_gpufetch_intel(struct gpu_info* gpu, STYLE s, struct color** cs, stru
   setAttribute(art, ATTRIBUTE_EUS, eus);
   setAttribute(art, ATTRIBUTE_PEAK, pp);
 
-  bool use_short = false;
+  const char** attribute_fields = ATTRIBUTE_FIELDS;
-  uint32_t longest_attribute = longest_attribute_length(art, use_short);
+  uint32_t longest_attribute = longest_attribute_length(art, attribute_fields);
   uint32_t longest_field = longest_field_length(art, longest_attribute);
   choose_ascii_art(art, cs, term, longest_field);
 
   if(!ascii_fits_screen(term->w, *art->art, longest_field)) {
     // Despite of choosing the smallest logo, the output does not fit
     // Choose the shorter field names and recalculate the longest attr
-    use_short = true;
+    attribute_fields = ATTRIBUTE_FIELDS_SHORT;
-    longest_attribute = longest_attribute_length(art, use_short);
+    longest_attribute = longest_attribute_length(art, attribute_fields);
   }
 
-  print_ascii_generic(art, longest_attribute, term->w - art->art->width, use_short);
+  print_ascii_generic(art, longest_attribute, term->w - art->art->width, attribute_fields);
 
   return true;
 }
@@ -454,19 +457,19 @@ bool print_gpufetch_cuda(struct gpu_info* gpu, STYLE s, struct color** cs, struc
     setAttribute(art, ATTRIBUTE_PEAK_TENSOR, pp_tensor);
   }
 
-  bool use_short = false;
+  const char** attribute_fields = ATTRIBUTE_FIELDS;
-  uint32_t longest_attribute = longest_attribute_length(art, use_short);
+  uint32_t longest_attribute = longest_attribute_length(art, attribute_fields);
   uint32_t longest_field = longest_field_length(art, longest_attribute);
   choose_ascii_art(art, cs, term, longest_field);
 
   if(!ascii_fits_screen(term->w, *art->art, longest_field)) {
     // Despite of choosing the smallest logo, the output does not fit
     // Choose the shorter field names and recalculate the longest attr
-    use_short = true;
+    attribute_fields = ATTRIBUTE_FIELDS_SHORT;
-    longest_attribute = longest_attribute_length(art, use_short);
+    longest_attribute = longest_attribute_length(art, attribute_fields);
   }
 
-  print_ascii_generic(art, longest_attribute, term->w - art->art->width, use_short);
+  print_ascii_generic(art, longest_attribute, term->w - art->art->width, attribute_fields);
 
   free(manufacturing_process);
   free(max_frequency);
@@ -491,13 +494,8 @@ bool print_gpufetch_amd(struct gpu_info* gpu, STYLE s, struct color** cs, struct
   char* gpu_chip = get_str_chip(gpu->arch);
   char* uarch = get_str_uarch_hsa(gpu->arch);
   char* manufacturing_process = get_str_process(gpu->arch);
-  char* cus = get_str_cu(gpu);
+  char* sms = get_str_cu(gpu);
-  char* matrix_cores = get_str_matrix_cores(gpu);
-  char* xcds = get_str_xcds(gpu);
   char* max_frequency = get_str_freq(gpu);
-  char* bus_width = get_str_bus_width(gpu);
-  char* mem_size = get_str_memory_size(gpu);
-  char* lds_size = get_str_lds_size(gpu);
 
   setAttribute(art, ATTRIBUTE_NAME, gpu_name);
   if (gpu_chip != NULL) {
@@ -506,28 +504,21 @@ bool print_gpufetch_amd(struct gpu_info* gpu, STYLE s, struct color** cs, struct
   setAttribute(art, ATTRIBUTE_UARCH, uarch);
   setAttribute(art, ATTRIBUTE_TECHNOLOGY, manufacturing_process);
   setAttribute(art, ATTRIBUTE_FREQUENCY, max_frequency);
-  setAttribute(art, ATTRIBUTE_COMPUTE_UNITS, cus);
+  setAttribute(art, ATTRIBUTE_STREAMINGMP, sms);
-  setAttribute(art, ATTRIBUTE_MATRIX_CORES, matrix_cores);
-  if (xcds != NULL) {
-    setAttribute(art, ATTRIBUTE_XCDS, xcds);
-  }
-  setAttribute(art, ATTRIBUTE_LDS_SIZE, lds_size);
-  setAttribute(art, ATTRIBUTE_MEMORY, mem_size);
-  setAttribute(art, ATTRIBUTE_BUS_WIDTH, bus_width);
 
-  bool use_short = false;
+  const char** attribute_fields = ATTRIBUTE_FIELDS;
-  uint32_t longest_attribute = longest_attribute_length(art, use_short);
+  uint32_t longest_attribute = longest_attribute_length(art, attribute_fields);
   uint32_t longest_field = longest_field_length(art, longest_attribute);
   choose_ascii_art(art, cs, term, longest_field);
 
   if(!ascii_fits_screen(term->w, *art->art, longest_field)) {
     // Despite of choosing the smallest logo, the output does not fit
     // Choose the shorter field names and recalculate the longest attr
-    use_short = true;
+    attribute_fields = ATTRIBUTE_FIELDS_SHORT;
-    longest_attribute = longest_attribute_length(art, use_short);
+    longest_attribute = longest_attribute_length(art, attribute_fields);
   }
 
-  print_ascii_generic(art, longest_attribute, term->w - art->art->width, use_short);
+  print_ascii_generic(art, longest_attribute, term->w - art->art->width, attribute_fields);
 
   free(art->attributes);
   free(art);

src/cuda/cuda.cpp

@@ -1,6 +1,3 @@
-
-// patched cuda.cpp for cuda13 by cloudy
-
 #include <cuda_runtime.h>
 #include <cstring>
 #include <cstdlib>
@@ -8,8 +5,8 @@
 
 #include "cuda.hpp"
 #include "uarch.hpp"
-#include "pci.hpp"
 #include "gpufetch_helper_cuda.hpp"
+#include "../common/pci.hpp"
 #include "../common/global.hpp"
 #include "../common/uarch.hpp"
 
@@ -17,22 +14,29 @@ bool print_gpu_cuda(struct gpu_info* gpu) {
   char* cc = get_str_cc(gpu->arch);
   printf("%s (Compute Capability %s)\n", gpu->name, cc);
   free(cc);
+
   return true;
 }
 
 struct cache* get_cache_info(cudaDeviceProp prop) {
   struct cache* cach = (struct cache*) emalloc(sizeof(struct cache));
+
   cach->L2 = (struct cach*) emalloc(sizeof(struct cach));
   cach->L2->size = prop.l2CacheSize;
   cach->L2->num_caches = 1;
   cach->L2->exists = true;
+
   return cach;
 }
 
 int get_tensor_cores(struct uarch* arch, int sm, int major) {
   if(major == 7) {
-    if (is_chip_TU116(arch))
+    // TU116 does not have tensor cores!
+    // https://www.anandtech.com/show/13973/nvidia-gtx-1660-ti-review-feat-evga-xc-gaming/2
+    if(arch->chip == CHIP_TU116   || arch->chip == CHIP_TU116BM ||
+       arch->chip == CHIP_TU116GL || arch->chip == CHIP_TU116M) {
       return 0;
+    }
     return sm * 8;
   }
   else if(major == 8) return sm * 4;
@@ -41,57 +45,57 @@ int get_tensor_cores(struct uarch* arch, int sm, int major) {
 
 struct topology_c* get_topology_info(struct uarch* arch, cudaDeviceProp prop) {
   struct topology_c* topo = (struct topology_c*) emalloc(sizeof(struct topology_c));
+
   topo->streaming_mp = prop.multiProcessorCount;
   topo->cores_per_mp = _ConvertSMVer2Cores(prop.major, prop.minor);
   topo->cuda_cores = topo->streaming_mp * topo->cores_per_mp;
   topo->tensor_cores = get_tensor_cores(arch, topo->streaming_mp, prop.major);
+
   return topo;
 }
 
 int32_t guess_clock_multipilier(struct gpu_info* gpu, struct memory* mem) {
+  // Guess clock multiplier
   int32_t clk_mul = 1;
+
   int32_t clk8 = abs((mem->freq/8) - gpu->freq);
   int32_t clk4 = abs((mem->freq/4) - gpu->freq);
   int32_t clk2 = abs((mem->freq/2) - gpu->freq);
   int32_t clk1 = abs((mem->freq/1) - gpu->freq);
+
   int32_t min = mem->freq;
   if(clkm_possible_for_uarch(8, gpu->arch) && min > clk8) { clk_mul = 8; min = clk8; }
   if(clkm_possible_for_uarch(4, gpu->arch) && min > clk4) { clk_mul = 4; min = clk4; }
   if(clkm_possible_for_uarch(2, gpu->arch) && min > clk2) { clk_mul = 2; min = clk2; }
   if(clkm_possible_for_uarch(1, gpu->arch) && min > clk1) { clk_mul = 1; min = clk1; }
+
   return clk_mul;
 }
 
 struct memory* get_memory_info(struct gpu_info* gpu, cudaDeviceProp prop) {
   struct memory* mem = (struct memory*) emalloc(sizeof(struct memory));
-  int val = 0;
 
   mem->size_bytes = (unsigned long long) prop.totalGlobalMem;
-
+  mem->freq = prop.memoryClockRate * 0.001f;
-  if (cudaDeviceGetAttribute(&val, cudaDevAttrMemoryClockRate, gpu->idx) == cudaSuccess) {
-      if (val > 1000000)
-          mem->freq = (float)val / 1000000.0f;
-      else
-          mem->freq = (float)val * 0.001f;
-  } else {
-      mem->freq = 0.0f;
-  }
-
   mem->bus_width = prop.memoryBusWidth;
   mem->clk_mul = guess_clock_multipilier(gpu, mem);
   mem->type = guess_memtype_from_cmul_and_uarch(mem->clk_mul, gpu->arch);
 
-  if (mem->clk_mul > 0)
+  // Fix frequency returned from CUDA to show real frequency
   mem->freq = mem->freq  / mem->clk_mul;
 
   return mem;
 }
 
+// Compute peak performance when using CUDA cores
 int64_t get_peak_performance_cuda(struct gpu_info* gpu) {
   return gpu->freq * 1000000 * gpu->topo_c->cuda_cores * 2;
 }
 
+// Compute peak performance when using tensor cores
 int64_t get_peak_performance_tcu(cudaDeviceProp prop, struct gpu_info* gpu) {
+  // Volta / Turing tensor cores performs 4x4x4 FP16 matrix multiplication
+  // Ampere tensor cores performs 8x4x8 FP16 matrix multiplicacion
   if(prop.major == 7) return gpu->freq * 1000000 * 4 * 4 * 4  * 2 * gpu->topo_c->tensor_cores;
   else if(prop.major == 8) return gpu->freq * 1000000 * 8 * 4 * 8 * 2 * gpu->topo_c->tensor_cores;
   else return 0;
@@ -113,7 +117,8 @@ struct gpu_info* get_gpu_info_cuda(struct pci_dev *devices, int gpu_idx) {
   }
 
   int num_gpus = -1;
-  cudaError_t err = cudaGetDeviceCount(&num_gpus);
+  cudaError_t err = cudaSuccess;
+  err = cudaGetDeviceCount(&num_gpus);
 
   if(gpu_idx == 0) {
     printf("\r%*c\r", (int) strlen(CUDA_DRIVER_START_WARNING), ' ');
@@ -131,6 +136,7 @@ struct gpu_info* get_gpu_info_cuda(struct pci_dev *devices, int gpu_idx) {
   }
 
   if(gpu->idx+1 > num_gpus) {
+    // Master is trying to query an invalid GPU
     return NULL;
   }
 
@@ -140,25 +146,15 @@ struct gpu_info* get_gpu_info_cuda(struct pci_dev *devices, int gpu_idx) {
     return NULL;
   }
 
-  int core_clk = 0;
+  gpu->freq = deviceProp.clockRate * 1e-3f;
-  if (cudaDeviceGetAttribute(&core_clk, cudaDevAttrClockRate, gpu->idx) == cudaSuccess) {
-      if (core_clk > 1000000)
-          gpu->freq = core_clk / 1000000.0f;
-      else
-          gpu->freq = core_clk * 0.001f;
-  } else {
-      gpu->freq = 0.0f;
-  }
-
   gpu->vendor = GPU_VENDOR_NVIDIA;
-  gpu->name = (char *) emalloc(strlen(deviceProp.name) + 1);
+  gpu->name = (char *) emalloc(sizeof(char) * (strlen(deviceProp.name) + 1));
   strcpy(gpu->name, deviceProp.name);
 
   if((gpu->pci = get_pci_from_pciutils(devices, PCI_VENDOR_ID_NVIDIA, gpu_idx)) == NULL) {
     printErr("Unable to find a valid device for vendor id 0x%.4X using pciutils", PCI_VENDOR_ID_NVIDIA);
     return NULL;
   }
-
   gpu->arch = get_uarch_from_cuda(gpu);
   gpu->cach = get_cache_info(deviceProp);
   gpu->mem = get_memory_info(gpu, deviceProp);
@@ -169,7 +165,19 @@ struct gpu_info* get_gpu_info_cuda(struct pci_dev *devices, int gpu_idx) {
   return gpu;
 }
 
-char* get_str_sm(struct gpu_info* gpu) { return get_str_generic(gpu->topo_c->streaming_mp); }
+char* get_str_sm(struct gpu_info* gpu) {
-char* get_str_cores_sm(struct gpu_info* gpu) { return get_str_generic(gpu->topo_c->cores_per_mp); }
+  return get_str_generic(gpu->topo_c->streaming_mp);
-char* get_str_cuda_cores(struct gpu_info* gpu) { return get_str_generic(gpu->topo_c->cuda_cores); }
+}
-char* get_str_tensor_cores(struct gpu_info* gpu) { return get_str_generic(gpu->topo_c->tensor_cores); }
+
+char* get_str_cores_sm(struct gpu_info* gpu) {
+  return get_str_generic(gpu->topo_c->cores_per_mp);
+}
+
+char* get_str_cuda_cores(struct gpu_info* gpu) {
+  return get_str_generic(gpu->topo_c->cuda_cores);
+}
+
+char* get_str_tensor_cores(struct gpu_info* gpu) {
+  return get_str_generic(gpu->topo_c->tensor_cores);
+}
+

src/cuda/uarch.cpp

@@ -8,7 +8,6 @@
 #include "../common/uarch.hpp"
 #include "../common/global.hpp"
 #include "../common/gpu.hpp"
-#include "pci.hpp"
 #include "chips.hpp"
 
 // Any clock multiplier
@@ -362,8 +361,3 @@ void free_uarch_struct(struct uarch* arch) {
   free(arch->chip_str);
   free(arch);
 }
-
-bool is_chip_TU116(struct uarch* arch) {
-  return arch->chip == CHIP_TU116   || arch->chip == CHIP_TU116BM ||
-         arch->chip == CHIP_TU116GL || arch->chip == CHIP_TU116M;
-}

src/cuda/uarch.hpp

@@ -13,6 +13,5 @@ char* get_str_cc(struct uarch* arch);
 char* get_str_chip(struct uarch* arch);
 char* get_str_process(struct uarch* arch);
 void free_uarch_struct(struct uarch* arch);
-bool is_chip_TU116(struct uarch* arch);
 
 #endif

src/hsa/hsa.cpp

@@ -13,6 +13,7 @@
 
 #include "hsa.hpp"
 #include "uarch.hpp"
+#include "../common/pci.hpp"
 #include "../common/global.hpp"
 #include "../common/uarch.hpp"
 
@@ -22,16 +23,7 @@ struct agent_info {
   char vendor_name[64];
   char device_mkt_name[64];
   uint32_t max_clock_freq;
-  // Memory
-  uint32_t bus_width;
-  uint32_t lds_size;
-  uint64_t global_size;
-  // Topology
   uint32_t compute_unit;
-  uint32_t num_shader_engines;
-  uint32_t simds_per_cu;
-  uint32_t num_xcc;            // Acccelerator Complex Dies (XCDs)
-  uint32_t matrix_cores;       // Cores with WMMA/MFMA capabilities
 };
 
 #define RET_IF_HSA_ERR(err) { \
@@ -49,51 +41,6 @@ struct agent_info {
   }                                                                           \
 }
 
-hsa_status_t memory_pool_callback(hsa_amd_memory_pool_t pool, void* data) {
-  struct agent_info* info = reinterpret_cast<struct agent_info *>(data);
-
-  hsa_amd_segment_t segment;
-  hsa_status_t err = hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, &segment);
-  RET_IF_HSA_ERR(err);
-
-  if (segment == HSA_AMD_SEGMENT_GROUP) {
-    // LDS memory
-    // We want to make sure that this memory pool is not repeated.
-    if (info->lds_size != 0) {
-      printErr("Found HSA_AMD_SEGMENT_GROUP twice!");
-      return HSA_STATUS_ERROR;
-    }
-    uint32_t size = 0;
-
-    err = hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SIZE, &size);
-    RET_IF_HSA_ERR(err);
-
-    info->lds_size = size;    
-  }
-  else if (segment == HSA_AMD_SEGMENT_GLOBAL) {
-    // Global memory
-    uint32_t global_flags = 0;
-    
-    err = hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, &global_flags);
-    RET_IF_HSA_ERR(err);
-
-    if (global_flags & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_EXTENDED_SCOPE_FINE_GRAINED) {
-      if (info->global_size != 0) {
-        printErr("Found HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_EXTENDED_SCOPE_FINE_GRAINED twice!");
-        return HSA_STATUS_ERROR;
-      }
-
-      uint64_t size = 0;
-
-      err = hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SIZE, &size);
-      RET_IF_HSA_ERR(err);
-
-      info->global_size = size;
-    }    
-  }
-  return HSA_STATUS_SUCCESS;
-}
-
 hsa_status_t agent_callback(hsa_agent_t agent, void *data) {
   struct agent_info* info = reinterpret_cast<struct agent_info *>(data);
 
@@ -116,26 +63,6 @@ hsa_status_t agent_callback(hsa_agent_t agent, void *data) {
 
     err = hsa_agent_get_info(agent, (hsa_agent_info_t) HSA_AMD_AGENT_INFO_COMPUTE_UNIT_COUNT, &info->compute_unit);
     RET_IF_HSA_ERR(err);
-
-    // According to the documentation, this is deprecated. But what should I be using then?
-    err = hsa_agent_get_info(agent, (hsa_agent_info_t) HSA_AMD_AGENT_INFO_MEMORY_WIDTH, &info->bus_width);
-    RET_IF_HSA_ERR(err);
-
-    err = hsa_agent_get_info(agent, (hsa_agent_info_t) HSA_AMD_AGENT_INFO_NUM_SHADER_ENGINES, &info->num_shader_engines);
-    RET_IF_HSA_ERR(err);
-
-    err = hsa_agent_get_info(agent, (hsa_agent_info_t) HSA_AMD_AGENT_INFO_NUM_SIMDS_PER_CU, &info->simds_per_cu);
-    RET_IF_HSA_ERR(err);
-
-    err = hsa_agent_get_info(agent, (hsa_agent_info_t) HSA_AMD_AGENT_INFO_NUM_XCC, &info->num_xcc);
-    RET_IF_HSA_ERR(err);
-
-    // We will check against zero to see if it was set beforehand.
-    info->global_size = 0;
-    info->lds_size = 0;
-    // This will fill global_size and lds_size.
-    err = hsa_amd_agent_iterate_memory_pools(agent, memory_pool_callback, data);
-    RET_IF_HSA_ERR(err);
   }
 
   return HSA_STATUS_SUCCESS;
@@ -145,27 +72,11 @@ struct topology_h* get_topology_info(struct agent_info info) {
   struct topology_h* topo = (struct topology_h*) emalloc(sizeof(struct topology_h));
 
   topo->compute_units = info.compute_unit;
-  topo->num_shader_engines = info.num_shader_engines; // not printed at the moment
-  topo->simds_per_cu = info.simds_per_cu;             // not printed at the moment
-  topo->num_xcc = info.num_xcc;
-  // Old GPUs (GCN I guess) might not have matrix cores.
-  // Not sure what would happen here?
-  topo->matrix_cores = topo->compute_units * topo->simds_per_cu;
 
   return topo;
 }
 
-struct memory* get_memory_info(struct gpu_info* gpu, struct agent_info info) {
+struct gpu_info* get_gpu_info_hsa(struct pci_dev *devices, int gpu_idx) {
-  struct memory* mem = (struct memory*) emalloc(sizeof(struct memory));
-  
-  mem->bus_width = info.bus_width;
-  mem->lds_size = info.lds_size;
-  mem->size_bytes = info.global_size;
-
-  return mem;
-}
-
-struct gpu_info* get_gpu_info_hsa(int gpu_idx) {
   struct gpu_info* gpu = (struct gpu_info*) emalloc(sizeof(struct gpu_info));
   gpu->pci = NULL;
   gpu->idx = gpu_idx;
@@ -208,7 +119,6 @@ struct gpu_info* get_gpu_info_hsa(int gpu_idx) {
   gpu->name = (char *) emalloc(sizeof(char) * (strlen(info.device_mkt_name) + 1));
   strcpy(gpu->name, info.device_mkt_name);
   gpu->arch = get_uarch_from_hsa(gpu, info.gpu_name);
-  gpu->mem = get_memory_info(gpu, info);
 
   if (gpu->arch == NULL) {
     return NULL;
@@ -226,17 +136,3 @@ struct gpu_info* get_gpu_info_hsa(int gpu_idx) {
 char* get_str_cu(struct gpu_info* gpu) {
   return get_str_generic(gpu->topo_h->compute_units);
 }
-
-char* get_str_xcds(struct gpu_info* gpu) {
-  // If there is a single XCD, then we dont want to
-  // print it.
-  if (gpu->topo_h->num_xcc == 1) {
-    return NULL;
-  }
-  return get_str_generic(gpu->topo_h->num_xcc);
-}
-
-char* get_str_matrix_cores(struct gpu_info* gpu) {
-  // TODO: Show XX (WMMA/MFMA)
-  return get_str_generic(gpu->topo_h->matrix_cores);
-}

src/hsa/hsa.hpp

@@ -3,9 +3,7 @@
 
 #include "../common/gpu.hpp"
 
-struct gpu_info* get_gpu_info_hsa(int gpu_idx);
+struct gpu_info* get_gpu_info_hsa(struct pci_dev *devices, int gpu_idx);
 char* get_str_cu(struct gpu_info* gpu);
-char* get_str_xcds(struct gpu_info* gpu);
-char* get_str_matrix_cores(struct gpu_info* gpu);
 
 #endif

src/hsa/uarch.cpp

@@ -127,7 +127,7 @@ enum {
 #define CHECK_UARCH_START if (false) {}
 #define CHECK_UARCH(arch, chip_, str, uarch, process) \
    else if (arch->chip == chip_) fill_uarch(arch, str, uarch, process);
-#define CHECK_UARCH_END else { if(arch->chip != CHIP_UNKNOWN_HSA) printBug("map_chip_to_uarch_hsa: Unknown chip id: %d", arch->chip); fill_uarch(arch, STRING_UNKNOWN, UARCH_UNKNOWN, UNK); }
+#define CHECK_UARCH_END else { if(arch->chip != CHIP_UNKNOWN_CUDA) printBug("map_chip_to_uarch_hsa: Unknown chip id: %d", arch->chip); fill_uarch(arch, STRING_UNKNOWN, UARCH_UNKNOWN, UNK); }
 
 void fill_uarch(struct uarch* arch, char const *str, MICROARCH u, uint32_t process) {
   arch->chip_str = (char *) emalloc(sizeof(char) * (strlen(str)+1));