Help with understanding memory usage discrepancy

Comments

• vk6flab@lemmy.radio ⁨1⁩ ⁨day⁩ ago

  Linux aggressively caches things.

  4 GB of RAM is not running out of memory.

  If you start using swap, you’re running into a situation where you might run out of memory.

  If oomkiller starts killing processes, then you’re running out of memory.

  source

  • tal@lemmy.today ⁨1⁩ ⁨day⁩ ago

    If oomkiller starts killing processes, then you’re running out of memory.

    Well, you could want to not dig into swap.

    source

    • a_fancy_kiwi@lemmy.world ⁨1⁩ ⁨day⁩ ago

      That’s pretty much where I’m at on this. As far as I’m concerned, if my system touches SWAP at all, it’s run out of memory. At this point, I’m hoping to figure out what percent of the memory in use is unimportant cache that can be closed vs important files that process need to function.

      source

      • -> View More Comments
  • a_fancy_kiwi@lemmy.world ⁨1⁩ ⁨day⁩ ago

    Is there a good way to tell what percent of RAM in use is used by less important caching of files that could be closed without any adverse effects vs files that if closed, the whole app stops functioning?

    Basically, I’m hoping htop isn’t broken and is reporting I have 8GB of important showstopping files open and everything else is cache that is unimportant/closable without the need to touch SWAP.

    source

    • tal@lemmy.today ⁨1⁩ ⁨day⁩ ago

      I am guessing that htop is in the wrong.

      If you look in /proc/meminfo, you’ll see a MemAvailable field and a MemTotal field.

      It looks to me like this is approximately (I didn’t check top’s source) what top is using: MemTotal - MemAvailable.

      stackoverflow.com/…/difference-between-memfree-an…

      Rik van Riel’s comments when adding MemAvailable to /proc/meminfo:

      /proc/meminfo: MemAvailable: provide estimated available memory

      Many load balancing and workload placing programs check /proc/meminfo to estimate how much free memory is available. They generally do this by adding up “free” and “cached”, which was fine ten years ago, but is pretty much guaranteed to be wrong today.

      It is wrong because Cached includes memory that is not freeable as page cache, for example shared memory segments, tmpfs, and ramfs, and it does not include reclaimable slab memory, which can take up a large fraction of system memory on mostly idle systems with lots of files.

      Currently, the amount of memory that is available for a new workload, without pushing the system into swap, can be estimated from MemFree, Active(file), Inactive(file), and SReclaimable, as well as the “low” watermarks from /proc/zoneinfo.

      However, this may change in the future, and user space really should not be expected to know kernel internals to come up with an estimate for the amount of free memory.

      It is more convenient to provide such an estimate in /proc/meminfo. If things change in the future, we only have to change it in one place.

      Looking at the htop source:

      github.com/htop-dev/htop/blob/main/MemoryMeter.c

         /* 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);
      

      It’s adding used, shared, and compressed memory, to get the amount actually tied up, but disregarding cached memory, which, based on the above comment, is problematic.

      top, on the other hand, is using the kernel’s MemAvailable directly.

      gitlab.com/procps-ng/procps/-/blob/…/free.c

      	printf(" %11s", scale_size(MEMINFO_GET(mem_info, MEMINFO_MEM_AVAILABLE, ul_int), args.exponent, flags & FREE_SI, flags & FREE_HUMANREADABLE));
      

      source

      • -> View More Comments
    • vk6flab@lemmy.radio ⁨1⁩ ⁨day⁩ ago

      This is the job for the OS.

      You can run most Linux systems with stupid amounts of swap and the only thing you’ll notice is that stuff starts slowing down.

      In my experience, only in extremely rare cases are you smarter than the OS, and in 25+ years of using Linux daily I’ve seen it exactly once, where oomkiller killed running mysqld processes, which would have been fine if the developer had used transactions. Suffice to say, they did not.

      I used a 1 minute cron job to reprioritize the process, problem “solved” … for a system that hadn’t been updated for 12 years but was still live while we documented what it was doing and what was required to upgrade it.

      source
• Shimitar@downonthestreet.eu ⁨1⁩ ⁨day⁩ ago

  You actually WANT to be with low free memory. Provided that most of it is used by cache.

  Free memory is a waste, when you could cache stuff for faster access.

  That’s how Linux memory management works, and it make sense if you relflect on it. Better cache that page or that file that is used often, since free memory is just wasted. Cache can be freed and memory reclaimed in a fraction of a millisecond when needed.

  So don’t bother too much. Unless your SWAP usage is high, don’t bother.

  Also consider that Linux kernel will use your swap a bit even if you have lots of cache, because the kernel knows better than you how to improve your performances. Swapping out never used stuff is better than killing cached items.

  Again, don’t oberthink memory on Linux, the best alarm is when swap is constantly happening, then yes you need more ram (or to kill that broken process that keeps hogging due to a bug)

  source

  • a_fancy_kiwi@lemmy.world ⁨1⁩ ⁨day⁩ ago

    This is why I’d like to know what tool shows the most useful number. If I only have 4GB out of 30GB left, is that 26GB difference mostly important processes or mostly closable cache? Like, is htop borked and not showing me useful info or is it saying 8GB of the 26GB used is important showstopping stuff?

    source

    • rtxn@lemmy.world ⁨1⁩ ⁨day⁩ ago

      The most useful is probably cat /proc/meminfo. The first couple of lines tell you everything you need to know.

      • MemTotal is the total useful memory.
      • MemFree is how much memory is not used by anything.
      • Cached is memory used by various caches, e.g. ZFS. This memory can be reallocated.
      • MemAvailable is how much memory can be allocated, i.e. MemFree + Cached.

      source

      • -> View More Comments
• TomAwezome@lemmy.world ⁨1⁩ ⁨day⁩ ago

  Yeah Linux likes to fill the cache entirely. If you want it to do that less and performance isn’t a concern, set up something that drops the caches every few hours running this as root: echo 1 > /proc/sys/vm/drop_caches

  source