FreeBSD: corrections to the used memory calculations

Resolves #1725

Author: Pierre-Marie Baty

MemoryMeter.c

@@ -78,9 +78,13 @@ static void MemoryMeter_display(const Object* cast, RichString* out) {
       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);
+   /* 'buffers' memory field might be hidden by a setting in some OS
+      ports (e.g. FreeBSD). */
+   if (isNonnegative(this->values[MEMORY_METER_BUFFERS])) {
+      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:");

freebsd/FreeBSDMachine.c

@@ -43,10 +43,8 @@ static int MIB_vm_stats_vm_v_page_count[4];
 
 static int MIB_vm_stats_vm_v_wire_count[4];
 static int MIB_vm_stats_vm_v_active_count[4];
-static int MIB_vm_stats_vm_v_cache_count[4];
+static int MIB_vm_stats_vm_v_laundry_count[4];
 static int MIB_vm_stats_vm_v_inactive_count[4];
-static int MIB_vm_stats_vm_v_free_count[4];
-static int MIB_vm_vmtotal[2];
 
 static int MIB_vfs_bufspace[2];
 
@@ -77,10 +75,8 @@ Machine* Machine_new(UsersTable* usersTable, uid_t userId) {
 
    len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len);
    len = 4; sysctlnametomib("vm.stats.vm.v_active_count", MIB_vm_stats_vm_v_active_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);
+   len = 4; sysctlnametomib("vm.stats.vm.v_laundry_count", MIB_vm_stats_vm_v_laundry_count, &len);
    len = 4; sysctlnametomib("vm.stats.vm.v_inactive_count", MIB_vm_stats_vm_v_inactive_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_free_count", MIB_vm_stats_vm_v_free_count, &len);
-   len = 2; sysctlnametomib("vm.vmtotal", MIB_vm_vmtotal, &len);
 
    len = 2; sysctlnametomib("vfs.bufspace", MIB_vfs_bufspace, &len);
 
@@ -310,65 +306,68 @@ static inline void FreeBSDMachine_scanCPU(Machine* super) {
 static void FreeBSDMachine_scanMemoryInfo(Machine* super) {
    FreeBSDMachine* this = (FreeBSDMachine*) super;
 
-   // @etosan:
-   // memory counter relationships seem to be these:
-   //  total = active + wired + inactive + cache + free
-   //  htop_used (unavail to anybody)   = active + wired + inactive - buffer
-   //  htop_cache (for cache meter)     = buffer + cache
-   //  htop_user_free (avail to procs)  = buffer + cache + free
-   //  htop_buffers (disk write buffer) = 0 (not applicable to FreeBSD)
+   // comment by Pierre-Marie Baty <[email protected]>
    //
-   // 'buffer' contain cache used by most file systems other than ZFS, and is
-   // included in 'wired'
+   // FreeBSD has the following memory classes:
+   //    active:   userland pages currently mapped to physical memory (i.e. in use)
+   //    inactive: userland pages that are no longer active, can be (re)allocated to processes
+   //    laundry:  userland pages that were just released, now being flushed, will become inactive
+   //    wired:    kernel pages currently mapped to physical memory, cannot be paged out nor swapped
+   //       buffers: subcategory of 'wired' corresponding to the filesystem caches
+   //    free:     pages that haven't been allocated yet, or have been released
    //
-   // with ZFS ARC situation becomes bit muddled, as ARC behaves like "user_free"
-   // and belongs into cache, but is reported as wired by kernel
+   // htop has the following memory classes:
+   //    super->usedMem:      can be mapped to FreeBSD's ('wired' - 'buffers') + 'laundry' + 'active'
+   //    super->buffersMem:   can be mapped to FreeBSD's 'buffers'
+   //    super->cachedMem:    can be mapped to FreeBSD's 'inactive'. Inactive pages are cached allocations.
    //
-   // htop_used   = active + (wired - arc)
-   // htop_cache  = buffers + cache + arc
+   // With ZFS, the ARC area is NOT counted in the 'buffers' class, but is still counted in the 'wired'
+   // class. The ARC total must thus be substracted from the 'wired' class AND added to the 'buffer' class,
+   // so that the result (ARC being shown in buffersMem) is consistent with what ZFS users would expect.
+   // This adjustment is done in Platform_setMemoryValues() in freebsd/Platform.c.
+
    u_long totalMem;
-   u_int memActive, memWire, memInactive, cachedMem;
+   u_int memActive, memWire, memInactive, memLaundry;
    long buffersMem;
    size_t len;
    struct vmtotal vmtotal;
 
-   //disabled for now, as it is always smaller than phycal amount of memory...
-   //...to avoid "where is my memory?" questions
-   //sysctl(MIB_vm_stats_vm_v_page_count, 4, &(super->totalMem), &len, NULL, 0);
-   //super->totalMem *= this->pageSizeKb;
+   // total memory
    len = sizeof(totalMem);
    sysctl(MIB_hw_physmem, 2, &(totalMem), &len, NULL, 0);
-   totalMem /= 1024;
-   super->totalMem = totalMem;
+   super->totalMem = totalMem / 1024;
 
+   // 'active' pages
    len = sizeof(memActive);
    sysctl(MIB_vm_stats_vm_v_active_count, 4, &(memActive), &len, NULL, 0);
    memActive *= this->pageSizeKb;
 
+   // 'wired' pages
    len = sizeof(memWire);
    sysctl(MIB_vm_stats_vm_v_wire_count, 4, &(memWire), &len, NULL, 0);
    memWire *= this->pageSizeKb;
 
+   // 'inactive' pages
    len = sizeof(memInactive);
    sysctl(MIB_vm_stats_vm_v_inactive_count, 4, &(memInactive), &len, NULL, 0);
    memInactive *= this->pageSizeKb;
 
+   // 'laundry' pages
+   len = sizeof(memLaundry);
+   sysctl(MIB_vm_stats_vm_v_laundry_count, 4, &(memLaundry), &len, NULL, 0);
+   memLaundry *= this->pageSizeKb;
+
+   // 'buffers' pages (separate read, should be deducted from 'wired')
    len = sizeof(buffersMem);
    sysctl(MIB_vfs_bufspace, 2, &(buffersMem), &len, NULL, 0);
    buffersMem /= 1024;
-   super->cachedMem = buffersMem;
-
-   len = sizeof(cachedMem);
-   sysctl(MIB_vm_stats_vm_v_cache_count, 4, &(cachedMem), &len, NULL, 0);
-   cachedMem *= this->pageSizeKb;
-   super->cachedMem += cachedMem;
-
-   len = sizeof(vmtotal);
-   sysctl(MIB_vm_vmtotal, 2, &(vmtotal), &len, NULL, 0);
-   super->sharedMem = vmtotal.t_rmshr * this->pageSizeKb;
 
-   super->usedMem = memActive + memWire + memInactive - buffersMem;
+   // now fill in the htop categories
+   super->usedMem = (memWire - buffersMem) + memLaundry + memActive;
+   super->cachedMem = memInactive;
+   super->buffersMem = buffersMem;
 
+   // swap
    struct kvm_swap swap[16];
    int nswap = kvm_getswapinfo(this->kd, swap, ARRAYSIZE(swap), 0);
    super->totalSwap = 0;

freebsd/Platform.c

@@ -243,18 +243,23 @@ void Platform_setMemoryValues(Meter* this, double* totalUsed) {
       if (fhost->zfs.size > fhost->zfs.min)
          shrinkableSize = fhost->zfs.size - fhost->zfs.min;
       this->values[MEMORY_METER_USED] -= shrinkableSize;
-      this->values[MEMORY_METER_CACHE] += shrinkableSize;
+      this->values[MEMORY_METER_BUFFERS] += shrinkableSize;
       // this->values[MEMORY_METER_AVAILABLE] += shrinkableSize;
    }
 
    *totalUsed = this->values[MEMORY_METER_USED];
    *totalUsed += this->values[MEMORY_METER_SHARED];
    // *totalUsed += this->values[MEMORY_METER_COMPRESSED];
+   // In FreeBSD, 'buffers' memory is a subcategory of 'wired' and is
+   // not reclaimable. It can be considered as 'used' as well.
+   *totalUsed += this->values[MEMORY_METER_BUFFERS];
 
-   if (this->mode == BAR_METERMODE || this->mode == GRAPH_METERMODE) {
-      Settings *settings = host->settings;
-      if (!settings->showCachedMemory) {
-         this->values[MEMORY_METER_BUFFERS] = 0;
+   Settings *settings = host->settings;
+   if (!settings->showCachedMemory) {
+      this->values[MEMORY_METER_USED] += this->values[MEMORY_METER_BUFFERS];
+      this->values[MEMORY_METER_BUFFERS] = NAN;
+
+      if (this->mode == BAR_METERMODE || this->mode == GRAPH_METERMODE) {
          this->values[MEMORY_METER_CACHE] = 0;
       }
    }