Kubernetes 之 Swap 浅析
Kubernetes 之 Swap 浅析
在进行部署 Kubernetes 时，我们往往会发现这样一种场景：官方强烈建议在环境初始化时关闭 Swap 空间 。比如在进行 K8S 相关操作时，给予如下提示：
Running with swap on is not supported, please disable swap! or set --fail-swap-on flag to false或者抛以下错误信息：
[ERROR Swap]: running with swap on is not supported. Please disable swap当然，其实，不止 Kubernetes ，其他的组件，例如，Hadoop、ES 等等集群同样也不建议开启 Swap。
那么，什么是 Swap 呢？
通常来讲，Swap Space 是开辟在操作系统磁盘上的一块区域，此块区域可以是一个分区，也可以是一个文件，或者是他们的组合。基于其场景特性，也就是说：当操作系统物理内存不够用时，Linux 系统会将内存中不常访问的数据同步至 Swap 上，这样系统就有更多的物理内存为各个进程服务；反之，当操作系统需要访问 Swap 上存储的内容时，再将Swap 上的数据加载到内存中，这就是我们常说的 Swap Out 和 Swap In。
关于 Swap In 和 Swap Out 相关活动状态关联，可参考如下示意图：
针对Swap分区的大小以及使用情况，通常可以借助 free -m 命令行进行查看，具体如下所示：
[administrator@JavaLangOutOfMemory ~ %] free -m
total used free shared buffers cached
Mem: 32167 2055 20785 0 28 296
-/+ buffers/cache: 530 470
Swap: 0 0 0基于上述查询结果所示，Swap 大小为 0 M，表明当前操作系统没有使用 Swap 分区。除此，我们还可以使用 Swapon 命令查看当前 Swap 相关信息：例如 Swap 空间是 Swap Partition，Swap Size，以及使用情况等详细信息，具体如下所示：
[administrator@JavaLangOutOfMemory ~ %] swapon -s基于当前的操作系统属性，Linux中存在两种形式的 Swap 分区：Swap Disk 和 Swap File。Swap Disk 是一个专门用于做 Swap 的块设备，作为裸设备提供给 Swap 机制操作；而后者 Swap File 则是存放在文件系统上的一个特定文件，其实现依赖于不同的文件系统，会有所差异，我们可通过如下参考示意图，具体如下所示：
（此图源自：http://jake.dothome.co.kr/wp-content/uploads/2019/10/swap-8a.png）
针对上述两种不同的 Swap 分区，我们可通过 mkswap 命令可以将一个 Swap Disk 或Swap File 转换为 Swap 分区的格式。随后可通过 Swapon 和 Swapoff 命令开启或关闭对应的 Swap 分区。通过 cat /proc/swaps 或 swapon -s 可以查看使用中的 Swap 分区的状态。针对 Swap 的数据结构，在 Linux 操作系统中，内核中使用 swap_info_struct 结构体对 Swap 分区进行管理，具体如下所示：
/*
* The in-memory structure used to track swap areas.
*/
struct swap_info_struct {
unsigned long flags; /* SWP_USED etc: see above */
signed short prio; /* swap priority of this type */
struct plist_node list; /* entry in swap_active_head */
signed char type; /* strange name for an index */
unsigned int max; /* extent of the swap_map */
unsigned char *swap_map; /* vmalloc'ed array of usage counts */
struct swap_cluster_info *cluster_info; /* cluster info. Only for SSD */
struct swap_cluster_list free_clusters; /* free clusters list */
unsigned int lowest_bit; /* index of first free in swap_map */
unsigned int highest_bit; /* index of last free in swap_map */
unsigned int pages; /* total of usable pages of swap */
unsigned int inuse_pages; /* number of those currently in use */
unsigned int cluster_next; /* likely index for next allocation */
unsigned int cluster_nr; /* countdown to next cluster search */
struct percpu_cluster __percpu *percpu_cluster; /* per cpu's swap location */
struct swap_extent *curr_swap_extent;
struct swap_extent first_swap_extent;
struct block_device *bdev; /* swap device or bdev of swap file */
struct file *swap_file; /* seldom referenced */
unsigned int old_block_size; /* seldom referenced */
#ifdef CONFIG_FRONTSWAP
unsigned long *frontswap_map; /* frontswap in-use, one bit per page */
atomic_t frontswap_pages; /* frontswap pages in-use counter */
#endif
spinlock_t lock; /*
* protect map scan related fields like
* swap_map, lowest_bit, highest_bit,
* inuse_pages, cluster_next,
* cluster_nr, lowest_alloc,
* highest_alloc, free/discard cluster
* list. other fields are only changed
* at swapon/swapoff, so are protected
* by swap_lock. changing flags need
* hold this lock and swap_lock. If
* both locks need hold, hold swap_lock
* first.
*/
spinlock_t cont_lock; /*
* protect swap count continuation page
* list.
*/
struct work_struct discard_work; /* discard worker */
struct swap_cluster_list discard_clusters; /* discard clusters list */
struct plist_node avail_lists[0]; /*
* entries in swap_avail_heads, one
* entry per node.
* Must be last as the number of the
* array is nr_node_ids, which is not
* a fixed value so have to allocate
* dynamically.
* And it has to be an array so that
* plist_for_each_* can work.
*/
};如上所示，一个 swap_info_struct 对应一个 Swap 分区。Swap 分区内部会以 Page 大小为单位划分出多个 Swap Slot，同时通过 swap_map 对每个 Slot 的使用情况进行记录，为 0 代表空闲，大于 0 则代表该 Slot 被 Map 的进程数量。
在此，基于源码角度，我们来简要了解下 Swap In 和 Swap Out 的相关工作流程，具体如下。
Swap In
Swap In 的入口为 do_swap_page，由于物理页面被回收了，所以进程再次访问一块虚拟地址时，就会产生缺页中断，最终进入到 do_swap_page，在这个函数中会重新分配新的页面，然后再从 Swap 分区读回这块虚拟地址对应的数据。部分代码分析如下所示：
int do_swap_page(struct vm_fault *vmf)
{
……
entry = pte_to_swp_entry(vmf->orig_pte); //从pte中获取swap entry，即把orig_pte 强制类型转换成swp_entry_t类型
……
page = lookup_swap_cache(entry, vma, vmf->address); //在 swap cache 中查找entry 对应的page
swapcache = page;
if (!page) { //如果在swap cache中没找到，则进入if代码段
struct swap_info_struct *si = swp_swap_info(entry); //获取swap分区描述符
……
page = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, vmf); //分配一个page，并从swap分区中读出数据填充到page中，再把page放入swap cache中缓存，此时page的PG_lock被置位了，需要等待IO读操作完成才清零，即page被lock住，如果别人想lock该page，则需要等待该page被unlock
swapcache = page;
……
}
locked = lock_page_or_retry(page, vma->vm_mm, vmf->flags); //此时尝试去lock该page，成功则返回1，失败则返回0
….
if (!locked) { //显然此时返回是0，即page的IO读操作仍末完成。
ret |= VM_FAULT_RETRY; //设置返回标记为retry
goto out_release; //返回重新尝试 do_swap_page，但在重新尝试do_swap_page时则可以从page cache 中直接获取到该page，不需要再从swap分区中读数据了
}
//程序走到这表明该page的IO读操作已经完成
……
pte = mk_pte(page, vmf->vma_page_prot); //根据page的物理地址，以及该page的保护位生成pte
if ((vmf->flags & FAULT_FLAG_WRITE) && reuse_swap_page(page, NULL)) { //如果该缺页中断为写访问异常时，并且page只有一个进程使用，则把该page从swap cache 中删除，并清除对应在swap分区中的数据，下面会分析reuse_swap_page函数
pte = maybe_mkwrite(pte_mkdirty(pte), vmf->vma_flags); //设置pte中的可写保护位和PTE_DIRTY位
vmf->flags &= ~FAULT_FLAG_WRITE;
ret |= VM_FAULT_WRITE;
exclusive = RMAP_EXCLUSIVE;
}
……
set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte); 更新该虚拟地址对应的pte
……
do_page_add_anon_rmap(page, vma, vmf->address, exclusive); //建立新的匿名映射
mem_cgroup_commit_charge(page, memcg, true, false);
activate_page(page); //把该page放入active anonymouns lru链表中
……
swap_free(entry); //更新页槽的counter，即减一，如果counter等于0，说明需要该存储块数据的人已经全部读回到内存，并且该page也不在swap cache 中，那么直接清除存储块数据，即回收页槽，释放更多的swap空间
if (mem_cgroup_swap_full(page) ||
(vmf->vma_flags & VM_LOCKED) || PageMlocked(page))
try_to_free_swap(page); //如果swap分区满了，则尝试回收无用页槽
unlock_page(page); //解锁 PG_lock
……
out:
return ret;
……
}Swap Out
Swap Out 的入口是在 shrink_page_list, 此函数对 page_list 链表中的内存依次处理，回收满足条件的内存即当系统需要回收物理内存时发生 Swap Out 的动作。第一次 Shrink时，内存页会通过 add_to_swap 分配到对应的 Swap Slot，设置为脏页并进行回写，最后将该 Page 加入到 Swap Cache 中，但不进行回收。第二次 Shrink 时，若脏页已经回写完成，则将该 Page 从 Swap Cache 中删除并回收。部分代码分析如下所示：
static unsigned long shrink_page_list(struct list_head *page_list,
struct pglist_data *pgdat,
struct scan_control *sc,
enum ttu_flags ttu_flags,
struct reclaim_stat *stat,
bool force_reclaim)
{
LIST_HEAD(ret_pages); //初始化返回的链表，即把此次shrink无法回收的页面放入该链表中
LIST_HEAD(free_pages); //初始化回收的链表，即把此次shrink 可以回收的页面放入该链表中
…
while (!list_empty(page_list)) {
…
page = lru_to_page(page_list);
list_del(&page->lru); // 从 page_list 中取出一个 page，page_list 需要回收的page链表
if (!trylock_page(page)) //先判断是用否有别的进程在使用该页面，如果没有则设置PG_lock，并返回1, 这个flag多用于io读, 但此时第一次shrink时大多数情况下是没有别的进程在使用该页面的，所以接着往下走
goto keep;
may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));
if (PageAnon(page) && PageSwapBacked(page)) { //判断是否是匿名页面并且不是lazyfree的页面，显然这个条件是满足的
if (!PageSwapCache(page)) { //判断该匿名页面是否是 swapcache ，即通过page的 PG_swapcache 的flag 来判断，此时该页面第一次 shrink，所以这里是否，进入if里面的流程
…
if (!add_to_swap(page)) //为该匿名页面创建swp_entry_t，并存放到page->private变量中，把page放入 swap cache，设置page的PG_swapcache和PG_dirty的flag，并更新swap_info_struct的页槽信息，该函数是通往 swap core 和swap cache的接口函数，下面会分析
{
…
goto activate_locked; // 失败后返回
}
…
/* Adding to swap updated mapping */
mapping = page_mapping(page); // 根据page中的swp_entry_t获取对应的swapper_spaces[type][offset]，这里可回顾一下数据结构章节中的swapper_spaces的介绍。
}
} else if (unlikely(PageTransHuge(page))) {
/* Split file THP */
if (split_huge_page_to_list(page, page_list))
goto keep_locked;
}
/*
* The page is mapped into the page tables of one or more
* processes. Try to unmap it here.
*/
if (page_mapped(page)) {
enum ttu_flags flags = ttu_flags | TTU_BATCH_FLUSH;
if (unlikely(PageTransHuge(page)))
flags |= TTU_SPLIT_HUGE_PMD;
if (!try_to_unmap(page, flags, sc->target_vma)) { // unmap， 即与上层的虚拟地址解除映射关系，并修改pte，使其值等于 page->private，即swp_entry_t变量，等到swapin 时就直接把pte强制类型转换成swp_entry_t 类型的值，就可以得到entry了。
nr_unmap_fail++;
goto activate_locked;
}
}
if (PageDirty(page)) { //由于add_to_swap 函数最后把该页面设置为脏页面，所以该if成立，进入if里面
…
/*
* Page is dirty. Flush the TLB if a writable entry
* potentially exists to avoid CPU writes after IO
* starts and then write it out here.
*/
try_to_unmap_flush_dirty();
switch (pageout(page, mapping, sc)) { // 发起 io 回写请求，并把该page 的flag 设置为PG_writeback，然后把PG_dirty清除掉
……
case PAGE_SUCCESS: //如果请求成功，返回 PAGE_SUCCESS
if (PageWriteback(page)) //该条件成立，跳转到 keep
goto keep;
……
}
}
……
keep:
list_add(&page->lru, &ret_pages); //把该页面放到 ret_pages链表里，返回时会把该链表中的所有页面都放回收lru 链表中，即不回收页面
VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
}
……
list_splice(&ret_pages, page_list);
……
return nr_reclaimed;
}
接下来再看一下add_to_swap函数实现
int add_to_swap(struct page *page)
{
swp_entry_t entry;
int err;
……
entry = get_swap_page(page); //为该页面分配一个swp_entry_t，并更新swap_info_struct的页槽信息
if (!entry.val)
return 0;
……
err = add_to_swap_cache(page, entry,
__GFP_HIGH|__GFP_NOMEMALLOC|__GFP_NOWARN); //把页面加入到swap cache 中，设置PG_swapcache，并把entry 保存到page->private变量中，跟随page传递
/* -ENOMEM radix-tree allocation failure */
set_page_dirty(page); // 设置该页面为脏页
return 1;
……
}
以上仅显示部分代码，针对代码中的相关函数解析，在后续的文章中进行描述。敬请关注。
接下来，我们再思考下，操作系统在什么环境下以及在怎样的场景下会使用 Swap Space 呢？其实，从本质上而言，是 Linux 通过一个参数 Swappiness 来控制。当然还涉及到复杂的算法。
Swappiness，Linux内核参数，控制换出运行时内存的相对权重。Swappiness 参数值可设置范围在0到100之间。低参数值会让系统内核尽量避免使用 Swap，更高参数值会使内核更多的去使用 Swap Space。默认值为60（参考网络资料：当剩余物理内存低于40% 时，开始使用 Swap Space）。对于大多数操作系统，设置为100可能会影响整体性能，而设置为更低值（甚至为0）则可能减少响应延迟。具体，可参考如下：
vm.swappiness = 0 仅在内存不足的情况下，当剩余空闲内存低于vm.min_free_kbytes limit时，使用交换空间。
vm.swappiness = 1 内核版本 V3.5及以上、Red Hat 内核版本 2.6.32-303 及以上，进行最少量的交换，而不禁用交换。
vm.swappiness = 10 当系统存在足够内存时，推荐设置为该值以提高性能。
vm.swappiness = 60 默认值
vm.swappiness = 100 内核将积极的使用交换空间。
对于内核版本为 V3.5及以上，Red Hat 内核版本 2.6.32-303 及以上，多数情况下，设置为1可能比较好，0 则适用于理想的情况下（it is likely better to use 1 for cases where 0 used to be optimal）。具体如下所示：
[administrator@JavaLangOutOfMemory ~ %] cat /proc/sys/vm/swappiness
30针对 Swappiness 参数的调整，主要有以下策略：基于临时调整和永久性调整，针对临时性策略，其命令行操作如下：
[administrator@JavaLangOutOfMemory ~ %] echo 10 > /proc/sys/vm/swappiness或如下命令行操作：
[administrator@JavaLangOutOfMemory ~ %] sysctl vm.swappiness=10针对永久性调整策略，在配置文件 /etc/sysctl.conf 里面修改 vm.swappiness 参数的值，然后重启系统。其命令行操作如下：
[administrator@JavaLangOutOfMemory ~ %] echo 'vm.swappiness=10' >>/etc/sysctl.conf摒弃操作系统内核层面的诉求，在实际的业务场景中，基于 Swap Space 的使用，总结下来主要取决于以下层面，具体如下所示：
1、基于目标的导向
在某些特定的业务场景，我们更倾向于内存加速，比如，Mysql 内存索引、Redis 等场景环境下，尽可能避免使用 Swap 。
正如之前所述，不仅仅 Hadoop，包括 ES 在内绝大部分 Java 的应用都强烈建议关闭 Swap，毕竟，此类场景和 JVM 的 GC 相关，当虚拟机进行 GC 的时候会遍历所有分配到的堆内存，如果这部分内存是被 Swap 出去，遍历的时候就会对磁盘 IO 产生较大影响。
2、基于结果的优化
在某些特定的业务场景需求下，在我们所构建的集群环境中，尽可能不希望出现任何抖动、增加延迟以及出现响应延迟等现象，基于系统所固有的横向伸缩的能力，可以完全严格不使用 Swap。
其实，从某种意义上讲，Swap 可以认为是针对之前内存小的一种优化，不过现在几乎大部分主机的内存容量都较为充裕，故在某些特定的业务场景中进行开启。
那么，针对 Kubernetes ，为什么要禁用 Swap 呢？当然，此种策略跟其底层原理相关联。基于其出发点，Kubernetes 云原生的实现目的是将运行实例紧密包装到尽可能接近 100％。所有的部署、运行环境应该与 CPU 以及内存限定在一个可控的空间内。所以如果调度程序发送一个 Pod 到某一台节点机器，它不应该使用 Swap。 毕竟，若开启 Swap ，将会减慢速度。因此，关闭 Swap 主要是为了性能考虑。当然，除此之外，基于资源节省的场景角度考虑，比如，能尽可能最大限量运行较多的容器数量。
腾讯云开发者
