Linux – tmpfs and vm.swappiness

Since kernel version 2.6.28, Linux uses a Split Least Recently Used (LRU) page replacement strategy. Pages with a filesystem source, such as program text or shared libraries belong to the file cache. Pages without filesystem backing are called anonymous pages, and consist of runtime data such as the stack space reserved for applications etc. Typically pages belonging to the file cache are cheaper to evict from memory (as these can simple be read back from disk when needed). Since anonymous pages have no filesystem backing, they must remain in memory as long as they are needed by a program unless there is swap space to store them to.

The vm.swappiness option comes into play in get_scan_count() defined in mm/vmscan.c. get_scan_count() determines how aggressively the anonymous and file LRU lists should be scanned when looking for pages to evict. The value of each case is is determined by the floating average of recently rotated and recently scanned ratios where more recent references have more weight than older ones in order take into account the changing workload of the system.

The vm.swappiness is a modifier that changes the balance between swapping out file cache pages in favour of anonymous pages. vm.swappiness is the priority value given to anonymous pages, by default set to 60. The file cache is given an priority value of 200 from which the vm.swappiness modifier is deducted (file_prio=200-anon_prio). This means that, by default, the priority weights stand moderately in favour of anonymous pages (anon_prio=60, file_prio=200-60=140). However, when the system is close to an out-of-memory condition, the both anonymous and file LRU lists are scanned equally, unless vm.swappiness is set to zero.

When vm.swappiness is set to 100, the priorities would be equal (anon_prio=100, file_prio=200-100=100). Setting vm.swappiness to zero will prevent the kernel from evicting anonymous pages in favour of pages from the file cache.

If all goes well, your kernel should decide to "do the right thing" all by itself. It uses a lot of fancy heuristics to decide what to swap out and what to keep when there is memory pressure. Those heuristics have been carefully built by really smart people with a lot of experience in memory management and are already good enough that they're pretty hard to improve upon.

The kernel uses a combination of things like this to decide what to swap out:

• How recently the memory has been used.
• Whether the memory has been modified since it was mapped. So for example a shared library will be pushed out ahead of heap memory because the heap memory is dirty and needs to be written to swap, whereas the shared library mapped memory can be loaded again from the original file on disk in case it is needed again, so no need to write those pages to swap. Here you should realize that tmpfs memory is always dirty (unless it's a fresh page filled with zeros) because it is not backed by anything.
• Hints from mprotect().
• Likely many more.

Short answer: no, you can't directly override the kernel's decisions about how to manage memory.