FreeBSD: corrections to the used memory calculations

Resolves #1725

Author: Pierre-Marie Baty

MemoryMeter.c

@@ -41,7 +41,9 @@ static void MemoryMeter_updateValues(Meter* this) {
    this->values[MEMORY_METER_AVAILABLE] = NAN;
    Platform_setMemoryValues(this);
    if ((this->mode == GRAPH_METERMODE || this->mode == BAR_METERMODE) && !settings->showCachedMemory) {
+#if !defined(HTOP_FREEBSD)
       this->values[MEMORY_METER_BUFFERS] = 0;
+#endif // !defined(HTOP_FREEBSD)
       this->values[MEMORY_METER_CACHE] = 0;
    }
    /* Do not print available memory in bar mode */
@@ -55,6 +57,10 @@ static void MemoryMeter_updateValues(Meter* this) {
       used += this->values[MEMORY_METER_SHARED];
    if (isPositive(this->values[MEMORY_METER_COMPRESSED]))
       used += this->values[MEMORY_METER_COMPRESSED];
+#if defined(HTOP_FREEBSD)
+   if (isPositive(this->values[MEMORY_METER_BUFFERS]))
+      used += this->values[MEMORY_METER_BUFFERS];
+#endif // defined(HTOP_FREEBSD)
 
    written = Meter_humanUnit(buffer, used, size);
    METER_BUFFER_CHECK(buffer, size, written);

freebsd/FreeBSDMachine.c

@@ -43,9 +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,9 +76,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 +308,75 @@ 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 <pm@pmbaty.com>
    //
-   // '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' - shared)
+   //    super->buffersMem:   can be mapped to FreeBSD's 'buffers'
+   //    super->cachedMem:    can be mapped to FreeBSD's 'inactive'. Inactive pages are cached allocations.
+   //    super->sharedMem:    must be read separately and deduced from the 'active' set
    //
-   // 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;
-   long buffersMem;
+   u_int memActive, memWire, memInactive, memLaundry;
+   long buffersMem, sharedMem;
    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 deduced 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;
 
+   // 'shared' pages (separate read, should be deduced from 'active')
    len = sizeof(vmtotal);
    sysctl(MIB_vm_vmtotal, 2, &(vmtotal), &len, NULL, 0);
-   super->sharedMem = vmtotal.t_rmshr * this->pageSizeKb;
+   sharedMem = vmtotal.t_rmshr * this->pageSizeKb;
 
-   super->usedMem = memActive + memWire + memInactive - buffersMem;
+   // now fill in the htop categories
+   super->usedMem = (memWire - buffersMem) + memLaundry + (memActive - sharedMem);
+   super->cachedMem = memInactive;
+   super->buffersMem = buffersMem;
+   super->sharedMem = sharedMem;
 
+   // swap
    struct kvm_swap swap[16];
    int nswap = kvm_getswapinfo(this->kd, swap, ARRAYSIZE(swap), 0);
    super->totalSwap = 0;

freebsd/Platform.c

@@ -243,7 +243,7 @@ void Platform_setMemoryValues(Meter* this) {
       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;
    }
 }