MemoryMeter: rework to allow full platform-specific control

FreeBSD required several corrections to memory calculations that
proved impossible to reconcile with existing memory categories.

Resolves #1725

Author: Pierre-Marie Baty

Action.c

@@ -27,6 +27,7 @@ in the source distribution for its full text.
 #include "ListItem.h"
 #include "Macros.h"
 #include "MainPanel.h"
+#include "MemoryMeter.h"
 #include "OpenFilesScreen.h"
 #include "Process.h"
 #include "ProcessLocksScreen.h"
@@ -750,16 +751,22 @@ static Htop_Reaction actionHelp(State* st) {
    attrset(CRT_colors[DEFAULT_COLOR]);
    mvaddstr(line++, 0, "Memory bar:    ");
    addattrstr(CRT_colors[BAR_BORDER], "[");
-   addbartext(CRT_colors[MEMORY_USED], "", "used");
-   addbartext(CRT_colors[MEMORY_SHARED], "/", "shared");
-   addbartext(CRT_colors[MEMORY_COMPRESSED], "/", "compressed");
-   if (st->host->settings->showCachedMemory) {
-      addbartext(CRT_colors[MEMORY_BUFFERS_TEXT], "/", "buffers");
-      addbartext(CRT_colors[MEMORY_CACHE], "/", "cache");
-      addbartext(CRT_colors[BAR_SHADOW], "          ", "used");
-   } else {
-      addbartext(CRT_colors[BAR_SHADOW], "                        ", "used");
+   // memory classes are OS-specific and provided in their <os>/Platform.c implementation
+   // ideal length of memory bar == 56 chars. Any length < 45 requires padding to 45.
+   // [0        1         2         3         4         5      ]
+   // [12345678901234567890123456789012345678901234567890123456]
+   // [                                            ^    5      ]
+   // [class1/class2/class3/.../classN               used/total]
+   int barTxtLen = 0;
+   for (unsigned int i = 0; i < Platform_numberOfMemoryClasses; i++) {
+      if (!st->host->settings->showCachedMemory && Platform_memoryClasses[i].countsAsCache)
+         continue; // skip reclaimable cache memory classes if "show cached memory" is not ticked
+      addbartext(CRT_colors[Platform_memoryClasses[i].color], (i == 0 ? "" : "/"), Platform_memoryClasses[i].label);
+      barTxtLen += (i == 0 ? 0 : 1) + strlen (Platform_memoryClasses[i].label);
    }
+   for (int i = barTxtLen; i < 45; i++)
+      addattrstr(CRT_colors[BAR_SHADOW], " "); // pad to 45 chars if necessary
+   addbartext(CRT_colors[BAR_SHADOW], " ", "used");
    addbartext(CRT_colors[BAR_SHADOW], "/", "total");
    addattrstr(CRT_colors[BAR_BORDER], "]");
 

CRT.h

@@ -161,6 +161,8 @@ typedef enum ColorElements_ {
    LAST_COLORELEMENT
 } ColorElements;
 
+#define NUMBER_OF_DYNAMIC_COLORS 9 // number of DYNAMIC_<ColorName> entries in ColorElements
+
 void CRT_fatalError(const char* note) ATTR_NORETURN;
 
 #ifdef NDEBUG

Machine.h

@@ -50,12 +50,7 @@ typedef struct Machine_ {
    bool topologyOk;
    #endif
 
-   memory_t totalMem;
-   memory_t usedMem;
-   memory_t buffersMem;
-   memory_t cachedMem;
-   memory_t sharedMem;
-   memory_t availableMem;
+   /* NOTE: memory details were moved to the OS-specific machine subclass */
 
    memory_t totalSwap;
    memory_t usedSwap;

MemoryMeter.c

@@ -20,13 +20,8 @@ in the source distribution for its full text.
 #include "RichString.h"
 
 
-static const int MemoryMeter_attributes[] = {
-   MEMORY_USED,
-   MEMORY_SHARED,
-   MEMORY_COMPRESSED,
-   MEMORY_BUFFERS,
-   MEMORY_CACHE
-};
+extern const int Platform_memoryMeter_attributes[]; // OS-specific
+
 
 static void MemoryMeter_updateValues(Meter* this) {
    char* buffer = this->txtBuffer;
@@ -35,26 +30,30 @@ static void MemoryMeter_updateValues(Meter* this) {
 
    Settings *settings = this->host->settings;
 
-   /* shared, compressed and available memory are not supported on all platforms */
-   this->values[MEMORY_METER_SHARED] = NAN;
-   this->values[MEMORY_METER_COMPRESSED] = NAN;
-   this->values[MEMORY_METER_AVAILABLE] = NAN;
+   /* not all memory classes are supported on all platforms */
+   for (unsigned int memoryClassIdx = 0; memoryClassIdx < Platform_numberOfMemoryClasses; memoryClassIdx++) {
+      this->values[memoryClassIdx] = NAN;
+   }
+
    Platform_setMemoryValues(this);
+   this->curItems = (uint8_t) Platform_numberOfMemoryClasses;
+
+   /* compute the used memory */
+   double used = 0.0;
+   for (unsigned int memoryClassIdx = 0; memoryClassIdx < Platform_numberOfMemoryClasses; memoryClassIdx++) {
+      if (Platform_memoryClasses[memoryClassIdx].countsAsUsed) {
+         used += this->values[memoryClassIdx];
+      }
+   }
+
+   /* clear the values we don't want to see */
    if ((this->mode == GRAPH_METERMODE || this->mode == BAR_METERMODE) && !settings->showCachedMemory) {
-      this->values[MEMORY_METER_BUFFERS] = 0;
-      this->values[MEMORY_METER_CACHE] = 0;
+      for (unsigned int memoryClassIdx = 0; memoryClassIdx < Platform_numberOfMemoryClasses; memoryClassIdx++) {
+         if (Platform_memoryClasses[memoryClassIdx].countsAsCache) {
+            this->values[memoryClassIdx] = NAN;
+         }
+      }
    }
-   /* Do not print available memory in bar mode */
-   static_assert(MEMORY_METER_AVAILABLE + 1 == MEMORY_METER_ITEMCOUNT,
-      "MEMORY_METER_AVAILABLE is not the last item in MemoryMeterValues");
-   this->curItems = MEMORY_METER_AVAILABLE;
-
-   /* we actually want to show "used + shared + compressed" */
-   double used = this->values[MEMORY_METER_USED];
-   if (isPositive(this->values[MEMORY_METER_SHARED]))
-      used += this->values[MEMORY_METER_SHARED];
-   if (isPositive(this->values[MEMORY_METER_COMPRESSED]))
-      used += this->values[MEMORY_METER_COMPRESSED];
 
    written = Meter_humanUnit(buffer, used, size);
    METER_BUFFER_CHECK(buffer, size, written);
@@ -73,37 +72,16 @@ static void MemoryMeter_display(const Object* cast, RichString* out) {
    Meter_humanUnit(buffer, this->total, sizeof(buffer));
    RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
 
-   Meter_humanUnit(buffer, this->values[MEMORY_METER_USED], sizeof(buffer));
-   RichString_appendAscii(out, CRT_colors[METER_TEXT], " used:");
-   RichString_appendAscii(out, CRT_colors[MEMORY_USED], buffer);
-
-   /* shared memory is not supported on all platforms */
-   if (isNonnegative(this->values[MEMORY_METER_SHARED])) {
-      Meter_humanUnit(buffer, this->values[MEMORY_METER_SHARED], sizeof(buffer));
-      RichString_appendAscii(out, CRT_colors[METER_TEXT], " shared:");
-      RichString_appendAscii(out, CRT_colors[MEMORY_SHARED], buffer);
-   }
-
-   /* compressed memory is not supported on all platforms */
-   if (isNonnegative(this->values[MEMORY_METER_COMPRESSED])) {
-      Meter_humanUnit(buffer, this->values[MEMORY_METER_COMPRESSED], sizeof(buffer));
-      RichString_appendAscii(out, CRT_colors[METER_TEXT], " compressed:");
-      RichString_appendAscii(out, CRT_colors[MEMORY_COMPRESSED], buffer);
-   }
-
-   Meter_humanUnit(buffer, this->values[MEMORY_METER_BUFFERS], sizeof(buffer));
-   RichString_appendAscii(out, settings->showCachedMemory ? CRT_colors[METER_TEXT] : CRT_colors[METER_SHADOW], " buffers:");
-   RichString_appendAscii(out, settings->showCachedMemory ? CRT_colors[MEMORY_BUFFERS_TEXT] : CRT_colors[METER_SHADOW], buffer);
-
-   Meter_humanUnit(buffer, this->values[MEMORY_METER_CACHE], sizeof(buffer));
-   RichString_appendAscii(out, settings->showCachedMemory ? CRT_colors[METER_TEXT] : CRT_colors[METER_SHADOW], " cache:");
-   RichString_appendAscii(out, settings->showCachedMemory ? CRT_colors[MEMORY_CACHE] : CRT_colors[METER_SHADOW], buffer);
+   /* print the OS-specific memory classes in the order supplied by their implementation */
+   for (unsigned int memoryClassIdx = 0; memoryClassIdx < Platform_numberOfMemoryClasses; memoryClassIdx++) {
+      if (!settings->showCachedMemory && Platform_memoryClasses[memoryClassIdx].countsAsCache)
+         continue; // skip reclaimable cache memory classes if "show cached memory" is not ticked
 
-   /* available memory is not supported on all platforms */
-   if (isNonnegative(this->values[MEMORY_METER_AVAILABLE])) {
-      Meter_humanUnit(buffer, this->values[MEMORY_METER_AVAILABLE], sizeof(buffer));
-      RichString_appendAscii(out, CRT_colors[METER_TEXT], " available:");
-      RichString_appendAscii(out, CRT_colors[METER_VALUE], buffer);
+      Meter_humanUnit(buffer, this->values[memoryClassIdx], sizeof(buffer));
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], " ");
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], Platform_memoryClasses[memoryClassIdx].label);
+      RichString_appendAscii(out, CRT_colors[METER_TEXT], ":");
+      RichString_appendAscii(out, CRT_colors[Platform_memoryClasses[memoryClassIdx].color], buffer);
    }
 }
 
@@ -116,10 +94,10 @@ const MeterClass MemoryMeter_class = {
    .updateValues = MemoryMeter_updateValues,
    .defaultMode = BAR_METERMODE,
    .supportedModes = METERMODE_DEFAULT_SUPPORTED,
-   .maxItems = MEMORY_METER_ITEMCOUNT,
+   .maxItems = NUMBER_OF_DYNAMIC_COLORS, // all the range of DYNAMIC_xxxx colors are allowed
    .isPercentChart = true,
    .total = 100.0,
-   .attributes = MemoryMeter_attributes,
+   .attributes = Platform_memoryMeter_attributes, // OS-specific
    .name = "Memory",
    .uiName = "Memory",
    .caption = "Mem"

MemoryMeter.h

@@ -9,15 +9,15 @@ in the source distribution for its full text.
 
 #include "Meter.h"
 
-typedef enum {
-   MEMORY_METER_USED = 0,
-   MEMORY_METER_SHARED = 1,
-   MEMORY_METER_COMPRESSED = 2,
-   MEMORY_METER_BUFFERS = 3,
-   MEMORY_METER_CACHE = 4,
-   MEMORY_METER_AVAILABLE = 5,
-   MEMORY_METER_ITEMCOUNT = 6, // number of entries in this enum
-} MemoryMeterValues;
+typedef struct MemoryClass_s {
+   const char *label; // e.g. "used", "shared", "compressed", etc. Should reflect the system-specific 'top' classes
+   bool countsAsUsed; // whether this memory class counts as "used" memory
+   bool countsAsCache; // whether this memory class can be reclaimed under pressure (and displayed when "show cached memory" is checked)
+   ColorElements color; // one of the DYNAMIC_xxx CRT color values
+} MemoryClass;
+
+extern const MemoryClass Platform_memoryClasses[]; // defined in the platform-specific code
+extern const unsigned int Platform_numberOfMemoryClasses; // defined in the platform-specific code
 
 extern const MeterClass MemoryMeter_class;
 

darwin/DarwinMachine.h

@@ -19,11 +19,7 @@ typedef struct DarwinMachine_ {
    Machine super;
 
    host_basic_info_data_t host_info;
-#ifdef HAVE_STRUCT_VM_STATISTICS64
    vm_statistics64_data_t vm_stats;
-#else
-   vm_statistics_data_t vm_stats;
-#endif
    processor_cpu_load_info_t prev_load;
    processor_cpu_load_info_t curr_load;
 

darwin/Platform.c

@@ -113,6 +113,33 @@ const SignalItem Platform_signals[] = {
 
 const unsigned int Platform_numberOfSignals = ARRAYSIZE(Platform_signals);
 
+const MemoryClass Platform_memoryClasses[] = {
+#define MEMORY_CLASS_WIRED       0
+   { .label = "wired",       .countsAsUsed = true,  .countsAsCache = false, .color = DYNAMIC_RED     }, // pages wired down to physical memory (kernel)
+#define MEMORY_CLASS_SPECULATIVE 1
+   { .label = "speculative", .countsAsUsed = true,  .countsAsCache = true,  .color = DYNAMIC_MAGENTA }, // readahead optimization caches
+#define MEMORY_CLASS_ACTIVE      2
+   { .label = "active",      .countsAsUsed = true,  .countsAsCache = false, .color = DYNAMIC_GREEN   }, // userland pages actively being used
+#define MEMORY_CLASS_PURGEABLE   3
+   { .label = "purgeable",   .countsAsUsed = false, .countsAsCache = true,  .color = DYNAMIC_YELLOW  }, // userland pages voluntarily marked "discardable" by apps
+#define MEMORY_CLASS_COMPRESSED  4
+   { .label = "compressed",  .countsAsUsed = true,  .countsAsCache = false, .color = DYNAMIC_BLUE    }, // userland pages being compressed (means memory pressure++)
+#define MEMORY_CLASS_INACTIVE    5
+   { .label = "inactive",    .countsAsUsed = true,  .countsAsCache = true,  .color = DYNAMIC_GRAY    }, // pages no longer used; macOS counts them as "used" anyway...
+}; // N.B. the chart will display categories in this order
+
+const unsigned int Platform_numberOfMemoryClasses = ARRAYSIZE(Platform_memoryClasses);
+
+const int Platform_memoryMeter_attributes[] = {
+   Platform_memoryClasses[0].color,
+   Platform_memoryClasses[1].color,
+   Platform_memoryClasses[2].color,
+   Platform_memoryClasses[3].color,
+   Platform_memoryClasses[4].color,
+   Platform_memoryClasses[5].color
+}; // there MUST be as many entries in this attributes array as memory classes
+
+
 const MeterClass* const Platform_meterTypes[] = {
    &CPUMeter_class,
    &ClockMeter_class,
@@ -389,41 +416,41 @@ void Platform_setGPUValues(Meter* mtr, double* totalUsage, unsigned long long* t
 
 void Platform_setMemoryValues(Meter* mtr) {
    const DarwinMachine* dhost = (const DarwinMachine*) mtr->host;
-#ifdef HAVE_STRUCT_VM_STATISTICS64
-   const struct vm_statistics64* vm = &dhost->vm_stats;
-#else
-   const struct vm_statistics* vm = &dhost->vm_stats;
-#endif
+   const Settings* settings = mtr->host->settings;
    double page_K = (double)vm_page_size / (double)1024;
 
-   mtr->total = dhost->host_info.max_mem / 1024;
-
 #ifdef HAVE_STRUCT_VM_STATISTICS64
+   const struct vm_statistics64* vm = &dhost->vm_stats;
    #ifdef HAVE_STRUCT_VM_STATISTICS64_EXTERNAL_PAGE_COUNT
    const natural_t external_page_count = vm->external_page_count;
    #else
    const natural_t external_page_count = 0;
    #endif
-   const natural_t used_counts_from_statistics64 = vm->inactive_count + vm->speculative_count
-                    - vm->purgeable_count - external_page_count;
+   #ifdef HAVE_STRUCT_VM_STATISTICS64_COMPRESSOR_PAGE_COUNT
+   const natural_t compressor_page_count = vm->compressor_page_count;
+   #else
+   const natural_t compressor_page_count = 0;
+   #endif
 #else
-   const natural_t used_counts_from_statistics64 = 0;
+   const struct vm_statistics* vm = &dhost->vm_stats;
+   const natural_t external_page_count = 0;
+   const natural_t compressor_page_count = 0;
 #endif // HAVE_STRUCT_VM_STATISTICS64
-   const natural_t used_count = vm->active_count + vm->wire_count + used_counts_from_statistics64;
-   mtr->values[MEMORY_METER_USED] = (double)used_count * page_K;
-   // mtr->values[MEMORY_METER_SHARED] = "shared memory, like tmpfs and shm"
-#ifdef HAVE_STRUCT_VM_STATISTICS64
-#ifdef HAVE_STRUCT_VM_STATISTICS64_COMPRESSOR_PAGE_COUNT
-   mtr->values[MEMORY_METER_COMPRESSED] = (double)vm->compressor_page_count * page_K;
-#else
-   // mtr->values[MEMORY_METER_COMPRESSED] = "compressed memory not available"
-#endif
-#else
-   // mtr->values[MEMORY_METER_COMPRESSED] = "compressed memory, like zswap on linux"
-#endif
-   mtr->values[MEMORY_METER_BUFFERS] = (double)vm->purgeable_count * page_K;
-   mtr->values[MEMORY_METER_CACHE] = (double)vm->inactive_count * page_K;
-   // mtr->values[MEMORY_METER_AVAILABLE] = "available memory"
+
+   mtr->total = dhost->host_info.max_mem / 1024;
+   mtr->values[MEMORY_CLASS_WIRED]       = page_K * vm->wire_count;
+   if (settings->showCachedMemory) {
+      mtr->values[MEMORY_CLASS_SPECULATIVE] = page_K * vm->speculative_count;
+      mtr->values[MEMORY_CLASS_ACTIVE]      = page_K * (vm->active_count - vm->purgeable_count - external_page_count); // external pages are pages swapped out
+      mtr->values[MEMORY_CLASS_PURGEABLE]   = page_K * vm->purgeable_count; // purgeable pages are flagged in the active pages
+   }
+   else { // if showCachedMemory is disabled, merge speculative and purgeable into the active pages
+      mtr->values[MEMORY_CLASS_SPECULATIVE] = 0;
+      mtr->values[MEMORY_CLASS_ACTIVE]      = page_K * (vm->speculative_count + vm->active_count - external_page_count); // external pages are pages swapped out
+      mtr->values[MEMORY_CLASS_PURGEABLE]   = 0;
+   }
+   mtr->values[MEMORY_CLASS_COMPRESSED]  = page_K * compressor_page_count;
+   mtr->values[MEMORY_CLASS_INACTIVE]    = page_K * vm->inactive_count; // for some reason macOS counts inactive pages in the "used" memory...
 }
 
 void Platform_setSwapValues(Meter* mtr) {