关于Swap和swappiness

Swap（交换分区）是操作系统就内存不足的一个缓解。当内存紧张时候，会适当的根据一些配置值和当前的统计值进行一次判断，会把一些anon内存（分配出去的内存）交换到Swap分区中。

Swappiness是系统的一个参数，可以调节swap的使用优先级。Linux文档描述如下：

swappiness

This control is used to define how aggressive the kernel will swap
memory pages. Higher values will increase aggressiveness, lower values
decrease the amount of swap. A value of 0 instructs the kernel not to
initiate swap until the amount of free and file-backed pages is less
than the high water mark in a zone.

The default value is 60.

翻译过来就是
这个参数是定义内核交换内存页的×××性（aggressive）。更大的值将增加×××性，较低的值会减少swap的数量。0值会命令内核不要使用swap，只有当free和文件使用的内存页数量少于一个zone的高水位，才会使用swap。

默认值是60。

关于这里的aggressive，看的是云里雾里。只知道这个值大概意义。在一些环境，用户一直抱怨为什么Swap使用量这么多，明明还有挺多的available内存。

Linux内存申请

Linux 内存申请一般来说会打上一些flag标志，会对申请流程产生一些影响，这里不细讲。主要是讲一般情况下（用户态的申请和大部分内核态的社区都是可以等待内存释放的）的内存申请。

__alloc_pages 一般第一次遍历每一个内存区域（zone）寻找第一个可用的足够的内存块。如果一个区域满了，那么会寻找下一个区域。单数如果 CPUSETS被设置了，他就会触发内存reclaim回收。

这里Swappiness主要是在内存reclaim时候生效。

Reclaim的方式

基本上Reclaim的方式为一个是将file相关的内存进行回收，一个是将anon部分内存（即被分配出去的内存）交换到Swap分区。
Linux的内存使用的一个宗旨是尽可能使用内存。在文件被读写的时候，文件的cache会一直保留在系统内存中，一直到内存不够时候，没有主动释放这部分内存的逻辑。这样在下次读取被缓存的文件时候可以直接从内存读取，不必从磁盘进行IO操作，这样文件读取速度会更加快速。

造成的结果是其实available的内存还很多的情况下，仍然会有内存不够，触发Reclaim逻辑，将一部分内存交换到Swap分区。

Swappiness生效方式

Swappiness是在get_scan_count函数使用的。
如下代码显示：Swap满时候，这个参数无影响。

2195 / If we have no swap space, do not bother scanning anon pages. /
2196 if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2197 scan_balance = SCAN_FILE;
2198 goto out;
2199 }

在Cgroup的mem还没达到limit时候，并且Swappiness为0，也仅仅扫描file cache部分。即不会考虑交换出去。

2201 /
2202 Global reclaim will swap to prevent OOM even with no
2203 swappiness, but memcg users want to use this knob to
2204 disable swapping for individual groups completely when
2205 using the memory controller‘s swap limit feature would be
2206 too expensive.
2207 */
2208 if (!global_reclaim(sc) && !swappiness) {
2209 scan_balance = SCAN_FILE;
2210 goto out;
2211 }

当系统接近OOM时候，并且swapiness非0，那么会平等的扫描anon和file的内存。

2213 /
2214 Do not apply any pressure balancing cleverness when the
2215 system is close to OOM, scan both anon and file equally
2216 (unless the swappiness setting disagrees with swapping).
2217 */
2218 if (!sc->priority && swappiness) {
2219 scan_balance = SCAN_EQUAL;
2220 goto out;
2221 }
当内存达到limit时候，会只释放申请的内存。这里结合前面提到的分支，可以知道，当Swappiness为0时候，没有达到limit只释放file cache，当达到limit时候，才考虑切换内存到swap中。

    /*
     * Prevent the reclaimer from falling into the cache trap: as
     * cache pages start out inactive, every cache fault will tip
     * the scan balance towards the file LRU.  And as the file LRU
     * shrinks, so does the window for rotation from references.
     * This means we have a runaway feedback loop where a tiny
     * thrashing file LRU becomes infinitely more attractive than
     * anon pages.  Try to detect this based on file LRU size.
     */
    if (global_reclaim(sc)) {
            unsigned long pgdatfile;
            unsigned long pgdatfree;
            int z;
            unsigned long total_high_wmark = 0;

            pgdatfree = sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES);
            pgdatfile = node_page_state(pgdat, NR_ACTIVE_FILE) +
                       node_page_state(pgdat, NR_INACTIVE_FILE);

            for (z = 0; z < MAX_NR_ZONES; z++) {
                    struct zone *zone = &pgdat->node_zones[z];
                    if (!managed_zone(zone))
                            continue;

                    total_high_wmark += high_wmark_pages(zone);
            }

            if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
                    /*
                     * Force SCAN_ANON if there are enough inactive
                     * anonymous pages on the LRU in eligible zones.
                     * Otherwise, the small LRU gets thrashed.
                     */
                    if (!inactive_list_is_low(lruvec, false, memcg, sc, false) &&
                        lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
                                    >> sc->priority) {
                            scan_balance = SCAN_ANON;
                            goto out;
                    }
            }
    }

当inactive的cache页足够的时候，只释放file cache。

    /*
     * If there is enough inactive page cache, i.e. if the size of the
     * inactive list is greater than that of the active list *and* the
     * inactive list actually has some pages to scan on this priority, we
     * do not reclaim anything from the anonymous working set right now.
     * Without the second condition we could end up never scanning an
     * lruvec even if it has plenty of old anonymous pages unless the
     * system is under heavy pressure.
     */
    if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
        lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
            scan_balance = SCAN_FILE;
            goto out;
    }

这里强调一下，swappiness的一般作用这里开始涉及。是把anon_prio设成相应的swappiness，file_prio 设成200-anon_prio。

    scan_balance = SCAN_FRACT;

    /*
     * With swappiness at 100, anonymous and file have the same priority.
     * This scanning priority is essentially the inverse of IO cost.
     */
    anon_prio = swappiness;
    file_prio = 200 - anon_prio;

这里进一步使用anon_prio和file_prio来获取ap和fp

    /*
     * The amount of pressure on anon vs file pages is inversely
     * proportional to the fraction of recently scanned pages on
     * each list that were recently referenced and in active use.
     */
    ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
    ap /= reclaim_stat->recent_rotated[0] + 1;

    fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
    fp /= reclaim_stat->recent_rotated[1] + 1;

具体其他的细节或者后续的算法，留待后续分析。

总结

Swappiness的控制方式主要是在内存紧张时候才会触发（这里是指free的内存低）。具体如下：

1. 当swappiness为0，那么在available内存充足情况，只释放file cache，当available内存不足情况下，那么会将一些内存交换到swap空间。
2. Swappiness不为0，那么他的值大小主要是控制每次内存紧张时候，切换到swap和文件缓存释放的比例。

注意：大部分人误以为是控制内存剩余比例到swappiness值时，去切换内存到swap，这个是错误的。

原文：http://blog.51cto.com/99cloud/2147569