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.

If htop starts with root privileges (effective user id is 0), the
experimental code activates. It reads the fixed sysfs file
/sys/kernel/debug/nvmap/iovmm/clients with the following content, e.g.:
```
CLIENT                        PROCESS      PID        SIZE
user                         gpu_burn     7979   23525644K
user                      gnome_shell     8119       5800K
user                             Xorg     2651      17876K
total                                            23549320K
```
Unfortunately, the /sys/kernel/debug/* files are allowed to read only for
the root user, that's why the restriction applies.

The patch also adds a separate field 'GPU_MEM', which reads data from
the added LinuxProcess::gpu_mem field. The field stores memory allocated for GPU
in kilobytes. It is populated by the function NvidiaJetson_LoadGpuProcessTable
(the implementation is located in NvidiaJetson.c), which is called at the end of
the function Machine_scanTables.

Additionally, the new Action is added: actionToggleGpuFilter, which is activated by
'g' hot key (the help is updated appropriately). The GpuFilter shows only the
processes which currently utilize GPU (i.e. highly extended nvmap/iovmm/clients table).
It is achieved by the filtering machinery associated with ProcessTable::pidMatchList.
The code below constructs GPU_PID_MATCH_LIST hash table, then actionToggleGpuFilter
either stores it to the ProcessTable::pidMatchList or restores old value of
ProcessTable::pidMatchList.

The separate LinuxProcess's PROCESS_FLAG_LINUX_GPU_JETSON (or something ...) flag isn't
added for GPU_MEM, because currently the functionality of population LinuxProcess::gpu_mem
is shared with the GPU consumers filter construction.
So, even if GPU_MEM field is not activated, the filter showing GPU consumers should work.
This kind of architecture is chosen intentially since it saves memory for the hash table
GPU_PID_MATCH_LIST (which is now actually a set), and therefore increases performance.
All other approaches convert GPU_PID_MATCH_LIST to a true key/value storage (key = pid,
value = gpu memory allocated) with further merge code.

== NVIDIA Jetson models  ==

Tested for NVIDIA Jetson Orin and Xavier boards.

Author: dmitriy-philimonov

Action.c

@@ -637,6 +637,29 @@ static Htop_Reaction actionTogglePauseUpdate(State* st) {
    return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_KEEP_FOLLOWING;
 }
 
+#ifdef NVIDIA_JETSON
+#include "NvidiaJetson.h"
+#include "ProcessTable.h"
+
+static Htop_Reaction actionToggleGpuFilter(State* st) {
+   static Hashtable *stash = NULL;
+
+   Hashtable *GpuPidMatchList = NvidiaJetson_GetPidMatchList();
+   if (GpuPidMatchList) {
+      st->showGpuProcesses = !st->showGpuProcesses;
+
+      ProcessTable *pt = (ProcessTable *)st->host->activeTable;
+      if (st->showGpuProcesses) {
+         stash = pt->pidMatchList;
+         pt->pidMatchList = GpuPidMatchList;
+      } else {
+         pt->pidMatchList = stash;
+      }
+   }
+   return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_KEEP_FOLLOWING;
+}
+#endif
+
 static const struct {
    const char* key;
    bool roInactive;
@@ -649,6 +672,7 @@ static const struct {
    { .key = "   F3 /: ",  .roInactive = false, .info = "incremental name search" },
    { .key = "   F4 \\: ", .roInactive = false, .info = "incremental name filtering" },
    { .key = "   F5 t: ",  .roInactive = false, .info = "tree view" },
+   { .key = "      g: ",  .roInactive = false, .info = "show processes which use GPU" },
    { .key = "      p: ",  .roInactive = false, .info = "toggle program path" },
    { .key = "      m: ",  .roInactive = false, .info = "toggle merged command" },
    { .key = "      Z: ",  .roInactive = false, .info = "pause/resume process updates" },
@@ -924,6 +948,9 @@ void Action_setBindings(Htop_Action* keys) {
    keys['a'] = actionSetAffinity;
    keys['c'] = actionTagAllChildren;
    keys['e'] = actionShowEnvScreen;
+#ifdef NVIDIA_JETSON
+   keys['g'] = actionToggleGpuFilter;
+#endif
    keys['h'] = actionHelp;
    keys['k'] = actionKill;
    keys['l'] = actionLsof;

Action.h

@@ -39,6 +39,9 @@ typedef struct State_ {
    bool pauseUpdate;
    bool hideSelection;
    bool hideMeters;
+#ifdef NVIDIA_JETSON
+   bool showGpuProcesses;
+#endif
 } State;
 
 static inline bool State_hideFunctionBar(const State* st) {

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,

CRT.c

@@ -231,6 +231,9 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [DYNAMIC_MAGENTA] = ColorPair(Magenta, Black),
       [DYNAMIC_YELLOW] = ColorPair(Yellow, Black),
       [DYNAMIC_WHITE] = ColorPair(White, Black),
+#ifdef NVIDIA_JETSON
+      [GPU_FILTER] = A_BOLD | ColorPair(Red, Cyan),
+#endif
    },
    [COLORSCHEME_MONOCHROME] = {
       [RESET_COLOR] = A_NORMAL,

CRT.h

@@ -158,6 +158,9 @@ typedef enum ColorElements_ {
    DYNAMIC_MAGENTA,
    DYNAMIC_YELLOW,
    DYNAMIC_WHITE,
+#ifdef NVIDIA_JETSON
+   GPU_FILTER,
+#endif
    LAST_COLORELEMENT
 } ColorElements;
 

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

Machine.c

@@ -6,6 +6,7 @@ Released under the GNU GPLv2+, see the COPYING file
 in the source distribution for its full text.
 */
 
+#include "NvidiaJetson.h"
 #include "config.h" // IWYU pragma: keep
 
 #include "Machine.h"
@@ -128,4 +129,8 @@ void Machine_scanTables(Machine* this) {
    }
 
    Row_setUidColumnWidth(this->maxUserId);
+
+   #ifdef NVIDIA_JETSON
+   NvidiaJetson_LoadGpuProcessTable(this->activeTable->table);
+   #endif
 }

MainPanel.c

@@ -195,6 +195,11 @@ static void MainPanel_drawFunctionBar(Panel* super, bool hideFunctionBar) {
    if (this->state->pauseUpdate) {
       FunctionBar_append("PAUSED", CRT_colors[PAUSED]);
    }
+#ifdef NVIDIA_JETSON
+   if (this->state->showGpuProcesses) {
+      FunctionBar_append("GPU", CRT_colors[GPU_FILTER]);
+   }
+#endif
 }
 
 static void MainPanel_printHeader(Panel* super) {

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/LinuxProcess.c

@@ -6,6 +6,7 @@ Released under the GNU GPLv2+, see the COPYING file
 in the source distribution for its full text.
 */
 
+#include "NvidiaJetson.h"
 #include "config.h" // IWYU pragma: keep
 
 #include "linux/LinuxProcess.h"
@@ -112,6 +113,9 @@ const ProcessFieldData Process_fields[LAST_PROCESSFIELD] = {
 #endif
    [GPU_TIME] = { .name = "GPU_TIME", .title = "GPU_TIME ", .description = "Total GPU time", .flags = PROCESS_FLAG_LINUX_GPU, .defaultSortDesc = true, },
    [GPU_PERCENT] = { .name = "GPU_PERCENT", .title = " GPU% ", .description = "Percentage of the GPU time the process used in the last sampling", .flags = PROCESS_FLAG_LINUX_GPU, .defaultSortDesc = true, },
+#ifdef NVIDIA_JETSON
+   [GPU_MEM]= { .name = "GPU_MEM", .title = "GPU_M ", .description = "GPU memory allocated for the process", .flags = 0, .defaultSortDesc = true, },
+#endif
 };
 
 Process* LinuxProcess_new(const Machine* host) {
@@ -362,6 +366,9 @@ static void LinuxProcess_rowWriteField(const Row* super, RichString* str, Proces
          xSnprintf(buffer, n, "N/A  ");
       }
       break;
+#ifdef NVIDIA_JETSON
+   case GPU_MEM: Row_printKBytes(str, lp->gpu_mem, coloring); return;
+#endif
    default:
       Process_writeField(this, str, field);
       return;
@@ -466,6 +473,10 @@ static int LinuxProcess_compareByKey(const Process* v1, const Process* v2, Proce
       return SPACESHIP_NUMBER(p1->gpu_time, p2->gpu_time);
    case ISCONTAINER:
       return SPACESHIP_NUMBER(v1->isRunningInContainer, v2->isRunningInContainer);
+#ifdef NVIDIA_JETSON
+   case GPU_MEM:
+      return SPACESHIP_NUMBER(p1->gpu_mem, p2->gpu_mem);
+#endif
    default:
       return Process_compareByKey_Base(v1, v2, key);
    }

linux/LinuxProcess.h

@@ -115,6 +115,10 @@ typedef struct LinuxProcess_ {
    /* Activity of GPU: 0 if active, otherwise time of last scan in milliseconds */
    uint64_t gpu_activityMs;
 
+   #ifdef NVIDIA_JETSON
+   uint64_t gpu_mem;
+   #endif
+
    /* Autogroup scheduling (CFS) information */
    long int autogroup_id;
    int autogroup_nice;