1.Linux系统的源码OOM Killer处理机制
2.Linux内核源码解析---cgroup实现之整体架构与初始化
3.在离线混部-Koordinator Cpu Burst 特性 源码调研

Linux系统的OOM Killer处理机制

       最近有位 VPS 客户抱怨 MySQL 无缘无故挂掉，还有位客户抱怨 VPS 经常死机，源码登陆到终端看了一下，源码都是源码常见的 Out of memory 问题。这通常是源码因为某时刻应用程序大量请求内存导致系统内存不足造成的，这通常会触发 Linux 内核里的源码ue源码系列大全 Out of Memory (OOM) killer，OOM killer 会杀掉某个进程以腾出内存留给系统用，源码不致于让系统立刻崩溃。源码如果检查相关的源码日志文件(/var/log/messages)就会看到下面类似的 Out of memory: Kill process 信息：

       ...

       Out of memory: Kill process (mysqld) score 9 or sacrifice child

       Killed process , UID , (mysqld) total-vm:kB, anon-rss:kB, file-rss:kB

       m: mit memory)的办法来间接利用这部分 “空闲” 的内存，提高整体内存的源码使用效率。一般来说这样做没有问题，源码但当大多数应用程序都消耗完自己的源码内存的时候麻烦就来了，因为这些应用程序的源码内存需求加起来超出了物理内存(包括 swap)的容量，内核(OOM killer)必须杀掉一些进程才能腾出空间保障系统正常运行。源码用银行的源码例子来讲可能更容易懂一些，部分人取钱的时候银行不怕，银行有足够的智能温控仪单片机源码软件存款应付，当全国人民(或者绝大多数)都取钱而且每个人都想把自己钱取完的时候银行的麻烦就来了，银行实际上是没有这么多钱给大家取的。

       内核检测到系统内存不足、挑选并杀掉某个进程的过程可以参考内核源代码 linux/mm/oom_kill.c，当系统内存不足的时候，out_of_memory() 被触发，然后调用 select_bad_process() 选择一个 “bad” 进程杀掉，如何判断和选择一个 “bad” 进程呢，总不能随机选吧?挑选的过程由 oom_badness() 决定，挑选的算法和想法都很简单很朴实：最 bad 的那个进程就是那个最占用内存的进程。

       /

       * oom_badness - heuristic function to determine which candidate task to kill

       * @p: task struct of which task we should calculate

       * @totalpages: total present RAM allowed for page allocation

       * The heuristic for determining which task to kill is made to be as simple and

       * predictable as possible. The goal is to return the highest value for the

       * task consuming the most memory to avoid subsequent oom failures.

       */

       unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,

       const nodemask_t *nodemask, unsigned long totalpages)

       {

       long points;

       long adj;

       if (oom_unkillable_task(p, memcg, nodemask))

       return 0;

       p = find_lock_task_mm(p);

       if (!p)

       return 0;

       adj = (long)p-signal-oom_score_adj;

       if (adj == OOM_SCORE_ADJ_MIN) {

       task_unlock(p);

       return 0;

       }

       /

       * The baseline for the badness score is the proportion of RAM that each

       * task's rss, pagetable and swap space use.

       */

       points = get_mm_rss(p-mm) + p-mm-nr_ptes +

       get_mm_counter(p-mm, MM_SWAPENTS);

       task_unlock(p);

       /

       * Root processes get 3% bonus, just like the __vm_enough_memory()

       * implementation used by LSMs.

       */

       if (has_capability_noaudit(p, CAP_SYS_ADMIN))

       adj -= ;

       /* Normalize to oom_score_adj units */

       adj *= totalpages / ;

       points += adj;

       /

       * Never return 0 for an eligible task regardless of the root bonus and

       * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).

       */

       return points 0 ? points : 1;

       }

       上面代码里的注释写的很明白，理解了这个算法我们就理解了为啥 MySQL 躺着也能中枪了，因为它的体积总是最大(一般来说它在系统上占用内存最多)，所以如果 Out of Memeory (OOM) 的话总是不幸第一个被 kill 掉。解决这个问题最简单的办法就是增加内存，或者想办法优化 MySQL 使其占用更少的合则买副图公式源码无未来内存，除了优化 MySQL 外还可以优化系统(优化 Debian 5，优化 CentOS 5.x)，让系统尽可能使用少的内存以便应用程序(如 MySQL) 能使用更多的内存，还有一个临时的办法就是调整内核参数，让 MySQL 进程不容易被 OOM killer 发现。

       我们可以通过一些内核参数来调整 OOM killer 的行为，避免系统在那里不停的杀进程。比如我们可以在触发 OOM 后立刻触发 kernel panic，kernel panic 秒后自动重启系统。

       # sysctl -w vm.panic_on_oom=1

       vm.panic_on_oom = 1

       # sysctl -w kernel.panic=

       kernel.panic =

       # echo "vm.panic_on_oom=1" /etc/sysctl.conf

       # echo "kernel.panic=" /etc/sysctl.conf

       从上面的 oom_kill.c 代码里可以看到 oom_badness() 给每个进程打分，根据 points 的高低来决定杀哪个进程，这个 points 可以根据 adj 调节，root 权限的进程通常被认为很重要，不应该被轻易杀掉，所以打分的时候可以得到 3% 的优惠(adj -= ; 分数越低越不容易被杀掉)。我们可以在用户空间通过操作每个进程的通达信巨阴选股公式源码 oom_adj 内核参数来决定哪些进程不这么容易被 OOM killer 选中杀掉。比如，如果不想 MySQL 进程被轻易杀掉的话可以找到 MySQL 运行的进程号后，调整 oom_score_adj 为 -(注意 points 越小越不容易被杀)：

       # ps aux | grep mysqld

       mysql 1.6 2.1 ? Ssl : 0: /usr/sbin/mysqld

       # cat /proc//oom_score_adj

       0

       # echo - /proc//oom_score_adj

       当然，如果需要的话可以完全关闭 OOM killer(不推荐用在生产环境)：

       # sysctl -w vm.overcommit_memory=2

       # echo "vm.overcommit_memory=2" /etc/sysctl.conf

       我们知道了在用户空间可以通过操作每个进程的 oom_adj 内核参数来调整进程的分数，这个分数也可以通过 oom_score 这个内核参数看到，比如查看进程号为的 omm_score，这个分数被上面提到的 omm_score_adj 参数调整后(-)，就变成了3：

       # cat /proc//oom_score

       # echo - /proc//oom_score_adj

       # cat /proc//oom_score

       3

       下面这个 bash 脚本可用来打印当前系统上 oom_score 分数最高(最容易被 OOM Killer 杀掉)的进程：

       # vi oomscore.sh

       #!/bin/bash

       for proc in $(find /proc -maxdepth 1 -regex '/proc/[0-9]+'); do

       printf "%2d %5d %sn"

       "$(cat $proc/oom_score)"

       "$(basename $proc)"

       "$(cat $proc/cmdline | tr '' ' ' | head -c )"

       done 2/dev/null | sort -nr | head -n

       # chmod +x oomscore.sh

       # ./oomscore.sh

        /usr/sbin/mysqld

       4 -bash

       4 -bash

       1 sshd: root@pts/6

       1 sshd: vpsee [priv]

       1 -bash

       1 sudo -i

       1 sshd: root@pts/3

       1 sshd: vpsee [priv]

       1 /usr/sbin/sshd -D

Linux内核源码解析---cgroup实现之整体架构与初始化

       cgroup在年由Google工程师开发，于年被融入Linux 2.6.内核。它旨在管理不同进程组，监控一组进程的行为和资源分配，是Docker和Kubernetes的基石，同时也被高版本内核中的LXC技术所使用。本文基于最早融入内核中的代码进行深入分析。

       理解cgroup的核心，首先需要掌握其内部的手机内核源码能做什么用途常用术语，如子系统、层级、cgroupfs_root、cgroup、css_set、cgroup_subsys_state、cg_cgroup_link等。子系统负责控制不同进程的行为，例如CPU子系统可以控制一组进程在CPU上执行的时间占比。层级在内核中表示为cgroupfs_root，一个层级控制一批进程，层级内部绑定一个或多个子系统，每个进程只能在一个层级中存在，但一个进程可以被多个层级管理。cgroup以树形结构组织，每一棵树对应一个层级，层级内部可以关联一个或多个子系统。

       每个层级内部包含的节点代表一个cgroup，进程结构体内部包含一个css_set，用于找到控制该进程的所有cgroup，多个进程可以共用一个css_set。cgroup_subsys_state用于保存一系列子系统，数组中的每一个元素都是cgroup_subsys_state。cg_cgroup_link收集不同层级的cgroup和css_set，通过该结构可以找到与之关联的进程。

       了解了这些概念后，可以进一步探索cgroup内部用于结构转换的函数，如task_subsys_state、find_existing_css_set等，这些函数帮助理解cgroup的内部运作。此外，cgroup_init_early和cgroup_init函数是初始化cgroup的关键步骤，它们负责初始化rootnode和子系统的数组，为cgroup的使用做准备。

       最后，需要明确Linux内一切皆文件，cgroup基于VFS实现。内核启动时进行初始化，以确保系统能够正确管理进程资源。cgroup的初始化过程分为早期初始化和常规初始化，其中早期初始化用于准备cpuset和CPU子系统，确保它们在系统运行时能够正常工作。通过这些步骤，我们可以深入理解cgroup如何在Linux内核中实现资源管理和进程控制。

在离线混部-Koordinator Cpu Burst 特性 源码调研

       在离线混部场景下，Koordinator引入了Cpu Burst特性来优化CPU资源管理。这个特性源自Linux内核的CPU Burst技术，旨在处理突发的CPU使用需求，减少CPU限流带来的影响。cgroups的参数如cpu.share、cpu.cfs_quota_us和cpu.cfs_burst，分别控制了CPU使用率、配额和突发缓冲效果。在Kubernetes中，资源请求（requests.cpu）和限制（limits.cpu）通过这些参数来实现动态调整，以保证容器间公平的CPU分配。

       对于资源调度，Kubernetes的Bandwidth Controller通过时间片限制进程的CPU消耗，针对延迟敏感业务，如抖音视频服务，通过设置合理的CPU limits避免服务质量下降，同时也考虑资源的高效利用。然而，常规的限流策略可能导致容器部署密度降低，因为时间片间隔可能不足以应对突发的CPU需求。CPU Burst技术正是为了解决这个问题，通过收集未使用的CPU资源，允许在突发时使用，从而提高CPU利用率并减少throttled_time。

       在Koordinator的配置中，通过configMap可以调整CPU Burst的百分比，以及在负载过高时的调整策略。例如，当CPU利用率低于阈值时，允许动态扩展cfs_quota，以应对突发的CPU使用。源码中，会根据节点负载状态和Pod的QoS策略来调整每个容器的CPU Burst和cfs_quota。

       总的来说，Cpu Burst特性适用于资源利用率不高且短作业较多的场景，能有效提升核心业务的CPU资源使用效率，同时对相邻容器的影响较小。在某些情况下，结合cpuset的核绑定和NUMA感知调度可以进一步减少CPU竞争。理解并灵活运用这些技术，有助于优化云计算环境中的资源分配和性能管理。