Preliminary support for NVIDIA Jetson boards

NVIDIA Jetson device is an insdustrial Linux based embedded aarch64
platfrom with powerful builtin GPU, which is used for AI tasks,
mostly for CV purposes.

The support is provided via --enable-nvidia-jetson switch in the
configure script.

All the source code related to the NVIDIA Jetson is placed in the
linux/NvidiaJetson.{h,c} source files and hidden by 'NVIDIA_JETSON'
C preprocessor define. So, for x86_64 platforms the
source code stays unchanged.

Additional functionality added by this commit:
1. Fix for the CPU temperature reading. The Jetson device is not
supported by libsensors. The CPU has 8 cores with only one CPU
temperature sensor for all of them located in the thermal zone file.
libsensor might be compiled in or turned off. The additional care was
taken to provide successfull build with/without libsensors.
2. The Jetson GPU Meter was added: current load, frequency and
temperature.

== Technical details ==

The code tries to find out the correct sensors during the application
startup. As an example, the sensors location for NVIDIA Jetson Orin
are the following:
- CPU temperature: /sys/devices/virtual/thermal/thermal_zone0/type
- GPU temperature: /sys/devices/virtual/thermal/thermal_zone1/type
- GPU frequency: /sys/class/devfreq/17000000.gpu/cur_freq
- GPU curr load: /sys/class/devfreq/17000000.gpu/device/load

Measure:
- The GPU frequency is provided in Hz, shown in MHz.
- The CPU/GPU temperatures are provided in Celsius multipled by 1000
  (milli Celsius), shown in Cesius

P.S. The GUI shows all temperatures for NVIDIA Jetson with additional
precision comparing to the default x86_64 platform.

== NVIDIA Jetson models  ==

Tested for NVIDIA Jetson Orin and Xavier boards.

Author: dmitriy-philimonov

CPUMeter.c

@@ -98,17 +98,30 @@ static void CPUMeter_updateValues(Meter* this) {
       }
    }
 
+   #ifdef NVIDIA_JETSON
+   if (settings->showCPUTemperature) {
+      char c = 'C';
+      double cpuTemperature = this->values[CPU_METER_TEMPERATURE];
+      if (settings->degreeFahrenheit) {
+         c = 'F';
+         cpuTemperature = ConvCelsiusToFahrenheit(cpuTemperature);
+      }
+      /* snprintf correctly represents double NAN numbers as 'nan' */
+      xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%.1f%s%c", cpuTemperature, CRT_degreeSign, c);
+   }
+   #else
    #ifdef BUILD_WITH_CPU_TEMP
    if (settings->showCPUTemperature) {
       double cpuTemperature = this->values[CPU_METER_TEMPERATURE];
       if (isNaN(cpuTemperature))
          xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "N/A");
       else if (settings->degreeFahrenheit)
-         xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%3d%sF", (int)(cpuTemperature * 9 / 5 + 32), CRT_degreeSign);
+         xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%3d%sF", (int)(ConvCelsiusToFahrenheit(cpuTemperature)), CRT_degreeSign);
       else
          xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%d%sC", (int)cpuTemperature, CRT_degreeSign);
    }
    #endif
+   #endif
 
    xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "%s%s%s%s%s",
              cpuUsageBuffer,

DisplayOptionsPanel.c

@@ -173,10 +173,10 @@ DisplayOptionsPanel* DisplayOptionsPanel_new(Settings* settings, ScreenManager*
    Panel_add(super, (Object*) CheckItem_newByRef("Also show CPU frequency", &(settings->showCPUFrequency)));
    #ifdef BUILD_WITH_CPU_TEMP
    Panel_add(super, (Object*) CheckItem_newByRef(
-   #if defined(HTOP_LINUX)
-                                                 "Also show CPU temperature (requires libsensors)",
-   #elif defined(HTOP_FREEBSD)
+   #if defined(HTOP_FREEBSD) || defined(NVIDIA_JETSON)
                                                  "Also show CPU temperature",
+   #elif defined(HTOP_LINUX)
+                                                 "Also show CPU temperature (requires libsensors)",
    #else
    #error Unknown temperature implementation!
    #endif

Makefile.am

@@ -215,6 +215,11 @@ linux_platform_sources = \
 	zfs/ZfsArcMeter.c \
 	zfs/ZfsCompressedArcMeter.c
 
+if NVIDIA_JETSON
+linux_platform_headers += linux/NvidiaJetson.h
+linux_platform_sources += linux/NvidiaJetson.c
+endif
+
 if HAVE_DELAYACCT
 linux_platform_headers += linux/LibNl.h
 linux_platform_sources += linux/LibNl.c

XUtils.h

@@ -119,6 +119,13 @@ char* xStrndup(const char* str, size_t len);
 
 ATTR_NONNULL ATTR_ACCESS3_W(2, 3)
 ssize_t xReadfile(const char* pathname, void* buffer, size_t count);
+#ifdef NVIDIA_JETSON /* uncomment if you need this functionality somewhere else */
+ATTR_NONNULL ATTR_ACCESS3_W(2, 3)
+static inline double xReadNumberFromFile(const char *pathname, char *buf, const size_t len) {
+   ssize_t nread = xReadfile(pathname, buf, len);
+   return nread > 0 ? strtod(buf, NULL) : NAN;
+}
+#endif
 ATTR_NONNULL ATTR_ACCESS3_W(3, 4)
 ssize_t xReadfileat(openat_arg_t dirfd, const char* pathname, void* buffer, size_t count);
 
@@ -174,4 +181,9 @@ static inline int xDirfd(DIR* dirp) {
    return r;
 }
 
+
+static inline double ConvCelsiusToFahrenheit(const double celsius) {
+   return celsius * 9 / 5 + 32;
+}
+
 #endif

configure.ac

@@ -1095,7 +1095,47 @@ case "$enable_sensors" in
       AC_MSG_ERROR([bad value '$enable_sensors' for --enable-sensors])
       ;;
 esac
-if test "$enable_sensors" = yes || test "$my_htop_platform" = freebsd; then
+
+AC_ARG_ENABLE([nvidia-jetson],
+              [AS_HELP_STRING([--enable-nvidia-jetson],
+                              [enable nvidia jetson support @<:@default=check@:>@])],
+              [],
+              [enable_nvidia_jetson=check])
+case "$enable_nvidia_jetson" in
+   no)
+      ;;
+   check)
+      if test -f "/etc/nv_tegra_release"; then
+         if grep -q "BOARD" "/etc/nv_tegra_release"; then
+            enable_nvidia_jetson=yes
+         fi
+      fi
+      ;;
+   yes)
+      if test -f "/etc/nv_tegra_release"; then
+         if grep -q "BOARD" "/etc/nv_tegra_release"; then
+            enable_nvidia_jetson=yes
+         else
+            enable_nvidia_jetson=no
+         fi
+      else
+         enable_nvidia_jetson=no
+      fi
+      ;;
+   *)
+      AC_MSG_ERROR([bad value '$enable_nvidia_jetson' for --enable-nvidia-jetson])
+      ;;
+esac
+
+if test "$enable_nvidia_jetson" = yes; then
+   AC_DEFINE([NVIDIA_JETSON], [1], [Detected correct NVIDIA Jetson board])
+else
+   AC_MSG_NOTICE([This is not a NVIDIA Jetson board])
+fi
+
+AM_CONDITIONAL([NVIDIA_JETSON], [test "$enable_nvidia_jetson" = yes])
+
+if test "$enable_sensors" = yes || test "$my_htop_platform" = freebsd || test "$enable_nvidia_jetson" = yes; then
    AC_DEFINE([BUILD_WITH_CPU_TEMP], [1], [Define if CPU temperature option should be enabled.])
 fi
 
@@ -1233,6 +1273,7 @@ AC_MSG_RESULT([
   (Linux) delay accounting:  $enable_delayacct
   (Linux) sensors:           $enable_sensors
   (Linux) capabilities:      $enable_capabilities
+  (Linux) nvidia-jeston      $enable_nvidia_jetson
   unicode:                   $enable_unicode
   affinity:                  $enable_affinity
   unwind:                    $enable_unwind

linux/LinuxMachine.c

@@ -32,6 +32,7 @@ in the source distribution for its full text.
 #include "UsersTable.h"
 #include "XUtils.h"
 
+#include "linux/NvidiaJetson.h"
 #include "linux/Platform.h" // needed for GNU/hurd to get PATH_MAX  // IWYU pragma: keep
 
 #ifdef HAVE_SENSORS_SENSORS_H
@@ -736,15 +737,20 @@ void Machine_scan(Machine* super) {
    const Settings* settings = super->settings;
    if (settings->showCPUFrequency
 #ifdef HAVE_SENSORS_SENSORS_H
-       || settings->showCPUTemperature
+       || settings->showCPUTemperature /* TODO: looks like this line in the condition might be removed */
 #endif
    )
       LinuxMachine_scanCPUFrequency(this);
 
+   #ifdef NVIDIA_JETSON
+   if (settings->showCPUTemperature)
+      NvidiaJetson_getCPUTemperatures(this->cpuData, super->existingCPUs);
+   #else
    #ifdef HAVE_SENSORS_SENSORS_H
    if (settings->showCPUTemperature)
       LibSensors_getCPUTemperatures(this->cpuData, super->existingCPUs, super->activeCPUs);
    #endif
+   #endif
 }
 
 Machine* Machine_new(UsersTable* usersTable, uid_t userId) {
@@ -787,6 +793,10 @@ Machine* Machine_new(UsersTable* usersTable, uid_t userId) {
    // Initialize CPU count
    LinuxMachine_updateCPUcount(this);
 
+   #ifdef NVIDIA_JETSON
+   NvidiaJetson_FindSensors();
+   #endif
+
    #ifdef HAVE_SENSORS_SENSORS_H
    // Fetch CPU topology
    LinuxMachine_fetchCPUTopologyFromCPUinfo(this);

linux/LinuxMachine.h

@@ -46,9 +46,10 @@ typedef struct CPUData_ {
 
    double frequency;
 
-   #ifdef HAVE_SENSORS_SENSORS_H
+   #ifdef BUILD_WITH_CPU_TEMP
    double temperature;
-
+   #endif
+   #ifdef HAVE_SENSORS_SENSORS_H
    int physicalID;      /* different for each CPU socket */
    int coreID;          /* same for hyperthreading */
    int ccdID;           /* same for each AMD chiplet */

linux/NvidiaJetson.c

@@ -0,0 +1,197 @@
+#include "config.h"
+#ifdef NVIDIA_JETSON
+
+
+#include "CRT.h"
+#include "Meter.h"
+#include "XUtils.h"
+#include "linux/NvidiaJetson.h"
+
+
+#include <ctype.h>
+#include <dirent.h>
+
+
+/*
+
+NVIDIA Jetson devices support is located here.
+
+Jetson has:
+- one CPU temperature sensor per 8 cores.
+- one GPU temperature sensor, on Jetson Orin it goes off if no GPU load: user gets error on file open
+
+The code tries to find out the correct sensors during the application startup. As an example, the sensors
+location for NVIDIA Jetson Orin:
+- CPU temperature: /sys/devices/virtual/thermal/thermal_zone0/type
+- GPU temperature: /sys/devices/virtual/thermal/thermal_zone1/type
+- GPU frequency: /sys/class/devfreq/17000000.gpu/cur_freq
+- GPU curr load: /sys/class/devfreq/17000000.gpu/device/load
+
+Measure:
+- The GPU frequency is provided in Hz, shown in MHz.
+- The CPU/GPU temperatures are provided in Celsius multipled by 1000 (milli Celsius), shown in Cesius
+- The Farenheit support is not provided
+*/
+
+
+/* global paths per each sensor */
+char CPU_TEMP_SENSOR_PATH[64];
+char GPU_TEMP_SENSOR_PATH[64];
+char GPU_FREQ_SENSOR_PATH[64];
+char GPU_LOAD_SENSOR_PATH[64];
+
+
+static inline bool IsJetsonOrinGPU(const char *name) {
+   return strstr(name, "gpu");
+}
+
+
+static inline bool IsJetsonXavierGPU(const char *name) {
+   return strstr(name, "gv11");
+}
+
+
+static void NvidiaJetson_FindGPUDevice(void) {
+   const struct dirent* entry;
+
+   DIR* dir = opendir("/sys/class/devfreq");
+   if (!dir)
+      return;
+
+   while ((entry = readdir(dir)) != NULL) {
+      const char* name = entry->d_name;
+
+      if (String_eq(name, ".") || String_eq(name, ".."))
+         continue;
+
+      if (IsJetsonOrinGPU(name) || IsJetsonXavierGPU(name)) {
+         xSnprintf(GPU_FREQ_SENSOR_PATH, sizeof(GPU_FREQ_SENSOR_PATH), "/sys/class/devfreq/%s/cur_freq", name);
+         xSnprintf(GPU_LOAD_SENSOR_PATH, sizeof(GPU_LOAD_SENSOR_PATH), "/sys/class/devfreq/%s/device/load", name);
+         break;
+      }
+   }
+   closedir(dir);
+}
+
+
+static void NvidiaJetson_GoThroughThermalZones(void) {
+   char path[64], content[4];
+   const struct dirent* entry;
+
+   DIR* dir = opendir("/sys/devices/virtual/thermal");
+   if (!dir)
+      return;
+
+   while ((entry = readdir(dir)) != NULL && (CPU_TEMP_SENSOR_PATH[0] == 0 || GPU_TEMP_SENSOR_PATH[0] == 0)) {
+      const char* name = entry->d_name;
+      ssize_t ret;
+
+      if (String_eq(name, ".") || String_eq(name, ".."))
+         continue;
+
+      if (!String_startsWith(name, "thermal_zone"))
+         continue;
+
+      xSnprintf(path, sizeof(path), "/sys/devices/virtual/thermal/%s/type", name);
+      ret = xReadfile(path, content, sizeof(content));
+      if (ret <= 0)
+         continue;
+
+      content[0] = tolower(content[0]);
+      content[1] = tolower(content[1]);
+      content[2] = tolower(content[2]);
+      content[3] = tolower(content[3]);
+
+      if (CPU_TEMP_SENSOR_PATH[0] == 0 && String_startsWith(content, "cpu")) {
+         xSnprintf(CPU_TEMP_SENSOR_PATH, sizeof(CPU_TEMP_SENSOR_PATH), "/sys/devices/virtual/thermal/%s/temp", name);
+      }
+      if (GPU_TEMP_SENSOR_PATH[0] == 0 && String_startsWith(content, "gpu")) {
+         xSnprintf(GPU_TEMP_SENSOR_PATH, sizeof(GPU_TEMP_SENSOR_PATH), "/sys/devices/virtual/thermal/%s/temp", name);
+      }
+   }
+   closedir(dir);
+}
+
+
+void NvidiaJetson_FindSensors(void) {
+   NvidiaJetson_GoThroughThermalZones();
+   NvidiaJetson_FindGPUDevice();
+}
+
+
+void NvidiaJetson_getCPUTemperatures(CPUData* cpus, unsigned int existingCPUs) {
+   char buffer[22];
+   double temp = xReadNumberFromFile(CPU_TEMP_SENSOR_PATH, buffer, sizeof(buffer)) / 1000.0;
+   for (unsigned int i=0; i<=existingCPUs; ++i)
+      cpus[i].temperature = temp;
+}
+
+
+enum JetsonValues {
+   JETSON_GPU_LOAD = 0,
+   JETSON_GPU_TEMP = 1,
+   JETSON_GPU_FREQ = 2,
+   JETSON_GPU_TOTAL_COUNT,
+};
+
+
+static void JetsonGPUMeter_updateValues(Meter* this) {
+   char buffer[22];
+   this->values[JETSON_GPU_LOAD] = xReadNumberFromFile(GPU_LOAD_SENSOR_PATH, buffer, sizeof(buffer));
+   this->curItems = 1; /* only show bar for JETSON_GPU_LOAD */
+
+   this->values[JETSON_GPU_TEMP] = xReadNumberFromFile(GPU_TEMP_SENSOR_PATH, buffer, sizeof(buffer)) / 1000.0;
+   this->values[JETSON_GPU_FREQ] = xReadNumberFromFile(GPU_FREQ_SENSOR_PATH, buffer, sizeof(buffer)) / 1000000.0;
+   double percent = this->values[0] / 10.0;
+
+   char c = 'C';
+   double gpuTemperature = this->values[JETSON_GPU_TEMP];
+   if (this->host->settings->degreeFahrenheit) {
+      gpuTemperature = ConvCelsiusToFahrenheit(gpuTemperature);
+      c = 'F';
+   }
+
+   unsigned int gpuFrequency = this->values[JETSON_GPU_FREQ];
+   xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "%.1f%% %3uMHz %.1f%s%c",
+      percent, gpuFrequency, gpuTemperature, CRT_degreeSign, c
+   );
+}
+
+static void JetsonGPUMeter_display(const Object* cast, RichString* out) {
+   char buffer[32];
+   const Meter* this = (const Meter*)cast;
+
+   RichString_writeAscii(out, CRT_colors[METER_TEXT], ":");
+   xSnprintf(buffer, sizeof(buffer), "%.1f", this->values[JETSON_GPU_LOAD]);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " freq:");
+   xSnprintf(buffer, sizeof(buffer), "%3uMHz", (unsigned)this->values[JETSON_GPU_FREQ]);
+   RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+
+   RichString_appendAscii(out, CRT_colors[METER_TEXT], " temp:");
+   xSnprintf(buffer, sizeof(buffer), "%.1f%sC", this->values[JETSON_GPU_TEMP], CRT_degreeSign);
+   RichString_appendWide(out, CRT_colors[METER_VALUE], buffer);
+}
+
+static const int JetsonGPUMeter_attributes[] = {
+   DEFAULT_COLOR
+};
+
+const MeterClass JetsonGPUMeter_class = {
+   .super = {
+      .extends = Class(Meter),
+      .delete = Meter_delete,
+      .display = JetsonGPUMeter_display,
+   },
+   .updateValues = JetsonGPUMeter_updateValues,
+   .defaultMode = BAR_METERMODE,
+   .supportedModes = METERMODE_DEFAULT_SUPPORTED,
+   .maxItems = JETSON_GPU_TOTAL_COUNT,
+   .total = 1000.0,
+   .attributes = JetsonGPUMeter_attributes,
+   .name = "jetson_gpu",
+   .uiName = "Jetson GPU",
+   .caption = "GPU"
+};
+#endif