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.
3. The exact GPU memory allocated by each process is loaded from the
nvgpu kernel driver via sysfs and merged to the LinuxProcess data
(field LinuxProcess::gpu_mem). The field "GPU_MEM" visualizes this
field. For root user only.
4. Additional filter for processes which use GPU right now via hot
key 'g', the help is supplied. For root user only.

== 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

@@ -27,9 +27,11 @@ in the source distribution for its full text.
 #include "ListItem.h"
 #include "Macros.h"
 #include "MainPanel.h"
+#include "NvidiaJetson.h"
 #include "OpenFilesScreen.h"
 #include "Process.h"
 #include "ProcessLocksScreen.h"
+#include "ProcessTable.h"
 #include "ProvideCurses.h"
 #include "Row.h"
 #include "RowField.h"
@@ -646,6 +648,26 @@ static Htop_Reaction actionTogglePauseUpdate(State* st) {
    return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_KEEP_FOLLOWING;
 }
 
+#ifdef NVIDIA_JETSON
+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;
@@ -658,6 +680,9 @@ 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" },
+#ifdef NVIDIA_JETSON
+   { .key = "      g: ",  .roInactive = false, .info = "show GPU processes (root only)" },
+#endif
    { .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" },
@@ -933,6 +958,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

@@ -40,6 +40,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,15 +98,33 @@ static void CPUMeter_updateValues(Meter* this) {
       }
    }
 
+   /*
+     --enable-sensors turns on BUILD_WITH_CPU_TEMP only
+     --enable-nvidia-jetson turns on both NVIDIA_JETSON and BUILD_WITH_CPU_TEMP
+   */
    #ifdef BUILD_WITH_CPU_TEMP
    if (settings->showCPUTemperature) {
       double cpuTemperature = this->values[CPU_METER_TEMPERATURE];
-      if (isNaN(cpuTemperature))
+      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);
-      else
-         xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%d%sC", (int)cpuTemperature, CRT_degreeSign);
+      } else if (settings->degreeFahrenheit) {
+         cpuTemperature = ConvCelsiusToFahrenheit(cpuTemperature);
+         /* Fahrenheit scale gives almost x2 more precise value than Celsius scale => no need to show fractional part */
+         xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%3d%sF", (int)cpuTemperature, CRT_degreeSign);
+      } else if (settings->showCPUTemperatureFractional) {
+            /*
+               - Modern CPUs has temperature sensors which give a precise value with 3 digits in the fractional part,
+               see hwmon files, e.g. /sys/class/hwmon/hwmon.../temp1_input, one digit in the fractional part is quite
+               enough right now.
+               - If your CPU is above 100C - you have a real problem, no need to print it pretty.
+               - The formatter "%04.1f" guarantees filling zero in the fractional part, e.g. strings like "37.0C" appears,
+               the side effect is that temperature value '5C' is shown as "05.0C"
+            */
+            xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%04.1f%sC", cpuTemperature, CRT_degreeSign);
+      } else {
+            /* if your CPU is above 100C - you have a real problem, no need to print it pretty */
+            xSnprintf(cpuTemperatureBuffer, sizeof(cpuTemperatureBuffer), "%2d%sC", (int)cpuTemperature, CRT_degreeSign);
+      }
    }
    #endif
 

CRT.c

@@ -202,6 +202,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = ColorPair(Yellow, Black),
       [GPU_ENGINE_3] = ColorPair(Red, Black),
       [GPU_ENGINE_4] = A_BOLD | ColorPair(Blue, Black),
+      [GPU_FILTER] = A_BOLD | ColorPair(Red, Cyan),
       [GPU_RESIDUE] = ColorPair(Magenta, Black),
       [PANEL_EDIT] = ColorPair(White, Blue),
       [SCREENS_OTH_BORDER] = ColorPair(Blue, Blue),
@@ -320,6 +321,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = A_NORMAL,
       [GPU_ENGINE_3] = A_REVERSE | A_BOLD,
       [GPU_ENGINE_4] = A_REVERSE,
+      [GPU_FILTER] = A_REVERSE,
       [GPU_RESIDUE] = A_BOLD,
       [PANEL_EDIT] = A_BOLD,
       [SCREENS_OTH_BORDER] = A_DIM,
@@ -438,6 +440,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = ColorPair(Yellow, White),
       [GPU_ENGINE_3] = ColorPair(Red, White),
       [GPU_ENGINE_4] = ColorPair(Blue, White),
+      [GPU_FILTER] = ColorPair(Blue, White),
       [GPU_RESIDUE] = ColorPair(Magenta, White),
       [PANEL_EDIT] = ColorPair(White, Blue),
       [SCREENS_OTH_BORDER] = A_BOLD | ColorPair(Black, White),
@@ -556,6 +559,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = ColorPair(Yellow, Black),
       [GPU_ENGINE_3] = ColorPair(Red, Black),
       [GPU_ENGINE_4] = ColorPair(Blue, Black),
+      [GPU_FILTER] = A_BOLD | ColorPair(Yellow, Cyan),
       [GPU_RESIDUE] = ColorPair(Magenta, Black),
       [PANEL_EDIT] = ColorPair(White, Blue),
       [SCREENS_OTH_BORDER] = ColorPair(Blue, Black),
@@ -674,6 +678,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = A_BOLD | ColorPair(Yellow, Blue),
       [GPU_ENGINE_3] = A_BOLD | ColorPair(Red, Blue),
       [GPU_ENGINE_4] = A_BOLD | ColorPair(White, Blue),
+      [GPU_FILTER] = A_BOLD | ColorPair(White, Cyan),
       [GPU_RESIDUE] = A_BOLD | ColorPair(Magenta, Blue),
       [PANEL_EDIT] = ColorPair(White, Blue),
       [SCREENS_OTH_BORDER] = A_BOLD | ColorPair(Yellow, Blue),
@@ -790,6 +795,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = ColorPair(Yellow, Black),
       [GPU_ENGINE_3] = ColorPair(Red, Black),
       [GPU_ENGINE_4] = ColorPair(Blue, Black),
+      [GPU_FILTER] = A_BOLD | ColorPair(Yellow, Green),
       [GPU_RESIDUE] = ColorPair(Magenta, Black),
       [PANEL_EDIT] = ColorPair(White, Cyan),
       [SCREENS_OTH_BORDER] = ColorPair(White, Black),
@@ -905,6 +911,7 @@ static int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
       [GPU_ENGINE_2] = A_NORMAL,
       [GPU_ENGINE_3] = A_BOLD | ColorPair(Cyan, Black),
       [GPU_ENGINE_4] = A_BOLD | ColorPair(Cyan, Black),
+      [GPU_FILTER] = A_BOLD | ColorPair(Red, Cyan),
       [GPU_RESIDUE] = A_BOLD,
       [PANEL_EDIT] = A_BOLD,
       [SCREENS_OTH_BORDER] = A_BOLD | ColorPairGrayBlack,

CRT.h

@@ -129,6 +129,7 @@ typedef enum ColorElements_ {
    GPU_ENGINE_2,
    GPU_ENGINE_3,
    GPU_ENGINE_4,
+   GPU_FILTER,
    GPU_RESIDUE,
    PANEL_EDIT,
    SCREENS_OTH_BORDER,

DisplayOptionsPanel.c

@@ -185,14 +185,15 @@ 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
                                                  &(settings->showCPUTemperature)));
+   Panel_add(super, (Object*) CheckItem_newByRef("- Show fractional CPU temperature for Celsius", (&settings->showCPUTemperatureFractional)));
    Panel_add(super, (Object*) CheckItem_newByRef("- Show temperature in degree Fahrenheit instead of Celsius", &(settings->degreeFahrenheit)));
    #endif
    Panel_add(super, (Object*) CheckItem_newByRef("Show cached memory in graph and bar modes", &(settings->showCachedMemory)));

Machine.c

@@ -13,6 +13,7 @@ in the source distribution for its full text.
 #include <stdlib.h>
 #include <unistd.h>
 
+#include "NvidiaJetson.h"
 #include "Object.h"
 #include "Platform.h"
 #include "Row.h"
@@ -129,4 +130,8 @@ void Machine_scanTables(Machine* this) {
 
    Row_setUidColumnWidth(this->maxUserId);
    Row_setPidColumnWidth(this->maxProcessId);
+
+   #ifdef NVIDIA_JETSON
+   NvidiaJetson_LoadGpuProcessTable(this->activeTable->table);
+   #endif
 }

MainPanel.c

@@ -197,6 +197,12 @@ static void MainPanel_drawFunctionBar(Panel* super, bool hideFunctionBar) {
    } else if (this->state->failedUpdate) {
       FunctionBar_append(this->state->failedUpdate, CRT_colors[FAILED_READ]);
    }
+
+#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

Settings.c

@@ -472,6 +472,8 @@ static bool Settings_read(Settings* this, const char* fileName, const Machine* h
       #ifdef BUILD_WITH_CPU_TEMP
       } else if (String_eq(option[0], "show_cpu_temperature")) {
          this->showCPUTemperature = atoi(option[1]);
+      } else if (String_eq(option[0], "show_cpu_temperature_fractional")) {
+         this->showCPUTemperatureFractional = atoi(option[1]);
       } else if (String_eq(option[0], "degree_fahrenheit")) {
          this->degreeFahrenheit = atoi(option[1]);
       #endif
@@ -703,6 +705,7 @@ int Settings_write(const Settings* this, bool onCrash) {
    printSettingInteger("show_cpu_frequency", this->showCPUFrequency);
    #ifdef BUILD_WITH_CPU_TEMP
    printSettingInteger("show_cpu_temperature", this->showCPUTemperature);
+   printSettingInteger("show_cpu_temperature_fractional", this->showCPUTemperatureFractional);
    printSettingInteger("degree_fahrenheit", this->degreeFahrenheit);
    #endif
    printSettingInteger("show_cached_memory", this->showCachedMemory);
@@ -808,6 +811,7 @@ Settings* Settings_new(const Machine* host, Hashtable* dynamicMeters, Hashtable*
    this->showCPUFrequency = false;
    #ifdef BUILD_WITH_CPU_TEMP
    this->showCPUTemperature = false;
+   this->showCPUTemperatureFractional = false;
    this->degreeFahrenheit = false;
    #endif
    this->showCachedMemory = true;