Fixes

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/printer.cpp

@@ -32,54 +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_STREAMINGMP,   // CUDA
+  ATTRIBUTE_CORESPERMP,
-  ATTRIBUTE_CORESPERMP,    // CUDA
+  ATTRIBUTE_CUDA_CORES,
-  ATTRIBUTE_CUDA_CORES,    // CUDA
+  ATTRIBUTE_TENSOR_CORES,
-  ATTRIBUTE_TENSOR_CORES,  // CUDA
+  ATTRIBUTE_EUS,
-  ATTRIBUTE_L2,            // CUDA
+  ATTRIBUTE_L2,
-  ATTRIBUTE_MEMORY,        // CUDA
+  ATTRIBUTE_MEMORY,
-  ATTRIBUTE_MEMORY_FREQ,   // CUDA
+  ATTRIBUTE_MEMORY_FREQ,
-  ATTRIBUTE_BUS_WIDTH,     // CUDA
+  ATTRIBUTE_BUS_WIDTH,
-  ATTRIBUTE_PEAK_TENSOR,   // CUDA
+  ATTRIBUTE_PEAK,
-  ATTRIBUTE_EUS,           // Intel
+  ATTRIBUTE_PEAK_TENSOR,
-  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_STREAMINGMP,   "SMs:",                    "SMs:" },
+  "Cores/SM:",
-  { ATTRIBUTE_CORESPERMP,    "Cores/SM:",               "Cores/SM:" },
+  "CUDA Cores:",
-  { ATTRIBUTE_CUDA_CORES,    "CUDA Cores:",             "CUDA Cores:" },
+  "Tensor Cores:",
-  { ATTRIBUTE_TENSOR_CORES,  "Tensor Cores:",           "Tensor Cores:" },
+  "Execution Units:",
-  { ATTRIBUTE_L2,            "L2 Size:",                "L2 Size:" },
+  "L2 Size:",
-  { ATTRIBUTE_MEMORY,        "Memory:",                 "Memory:" },
+  "Memory:",
-  { ATTRIBUTE_MEMORY_FREQ,   "Memory frequency:",       "Memory freq.:" },
+  "Memory frequency:",
-  { ATTRIBUTE_BUS_WIDTH,     "Bus width:",              "Bus width:" },
+  "Bus width:",
-  { ATTRIBUTE_PEAK_TENSOR,   "Peak Performance (MMA):", "Peak Perf.(MMA):" },
+  "Peak Performance:",
-  { ATTRIBUTE_EUS,           "Execution Units:",        "EUs:" },
+  "Peak Performance (MMA):",
-  { ATTRIBUTE_GT,            "Graphics Tier:",          "GT:" },
+};
+
+static const char* ATTRIBUTE_FIELDS_SHORT [] = {
+  "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 {
@@ -197,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);
@@ -264,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;
     }
   }
@@ -295,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;
@@ -339,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);
@@ -379,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;
 }
@@ -448,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);
@@ -485,7 +494,7 @@ 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* max_frequency = get_str_freq(gpu);
 
   setAttribute(art, ATTRIBUTE_NAME, gpu_name);
@@ -495,21 +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);
 
-  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);