MYSQL数据库MySQL OOM 系统二 OOM Killer

作者：VEPHP 时间 2017-10-27

《MYSQL数据库MySQL OOM 系统二 OOM Killer》要点：
本文介绍了MYSQL数据库MySQL OOM 系统二 OOM Killer，希望对您有用。如果有疑问，可以联系我们。

MYSQL应用这里就涉及到一个问题,到底Kill掉谁呢?一般稍微了解一些Linux内核的同学第一反应是谁用的最多,就Kill掉谁.这当然是Linux内核首先考虑的一种重要因素,但是也不完全是这样的,我们查一些Linux的内核方面的材料,可以知道其实Kill谁是由/proc/<pid>/oom_score来决定的,这个值每个进程一个,是由Linux内核的oom_badness()函数负责计算的.那下面我们来仔细读一读badness()函数.

MYSQL应用在badness()函数的注释部门,写明了badness()函数的处理思路：

MYSQL应用         1) we lose the minimum amount of work done
         2) we recover a large amount of memory
         3) we don't kill anything innocent of eating tons of memory
         4) we want to kill the minimum amount of processes (one)
         5) we try to kill the process the user expects us to kill, this algorithm has been meticulously tuned to meet the principle of least surprise ... (be careful when you change it)

MYSQL应用总的来说便是Kill掉最小数量的进程来获取最大数量的内存,这与我们Kill掉占用内存最大的进程是吻合的.

MYSQL应用        /*
         * The memory size of the process is the basis for the badness.
         */

MYSQL应用 points = p->mm->total_vm;

MYSQL应用分数的起始是进程实际使用的RAM内存,注意这里不包含SWAP,即OOM Killer只会与进程实际的物理内存有关,与Swap是没有关系的,并且我们可以看到,进程实际使用的物理内存越多,分数就越高,分数越高就越容易被牺牲掉.

MYSQL应用        /*
         * Processes which fork a lot of child processes are likely
         * a good choice. We add the vmsize of the childs if they
         * have an own mm. This prevents forking servers to flood the
         * machine with an endless amount of childs
         */
          ...
                  if (chld->mm != p->mm && chld->mm)
                        points += chld->mm->total_vm;

MYSQL应用这段表现子进程占用的内存都会计算到父进程上.

MYSQL应用        s = int_sqrt(cpu_time);
        if (s)
                points /= s;
        s = int_sqrt(int_sqrt(run_time));
        if (s)
                points /= s;

MYSQL应用这注解进程占用的CPU时间越长或者进程运行的时间越长,分数越低,越不容易被Kill掉.

MYSQL应用       /*
        * Niced processes are most likely less important, so double
        * their badness points.
        */
        if (task_nice(p) > 0)
                points *= 2;

MYSQL应用如果进程优先级低(nice值,正值低优先级,负值高优先级),则Point翻倍.

MYSQL应用       /*
        * Superuser processes are usually more important, so we make it
        * less likely that we kill those.
        */
        if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_ADMIN) ||
                                p->uid == 0 || p->euid == 0)
                points /= 4;

MYSQL应用 super用户的进程优先级较低.

MYSQL应用        /*
         * We don't want to kill a process with direct hardware access.
         * Not only could that mess up the hardware, but usually users
         * tend to only have this flag set on applications they think
         * of as important.
         */
        if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_RAWIO))
                points /= 4;

MYSQL应用直接可以拜访原始设备的进程优先级较高.

MYSQL应用        /*
         * Adjust the score by oomkilladj.
         */
        if (p->oomkilladj) {
                if (p->oomkilladj > 0)
                        points <<= p->oomkilladj;
                else
                        points >>= -(p->oomkilladj);

MYSQL应用 }

MYSQL应用每个进程有个oomkilladj 可以设置该进程被kill的优先级,这个参数看上去对Point影响还是比拟大的,oomkilladj 最大+15,最小是-17,越大越容易被干掉,这个值由于是移位运算,所以影响还是比拟大的.

MYSQL应用下面我写个小程序实验一下:

MYSQL应用
 #define MEGABYTE 1024*1024*1024
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 int main(int argc, char *argv[])
{
void *myblock = NULL;
myblock = (void *) malloc(MEGABYTE);
printf("Currently allocating 1GB\n");
sleep(1);
int count = 0;
while( count < 10)
{
 memset(myblock,1,100*1024*1024);
 myblock = myblock + 100*1024*1024;
 count++;
 printf("Currently allocating %d00 MB\n",count);
 sleep(10);
  }
  exit(0);
 }

MYSQL应用上面的程序先申请一个1G的内存空间,然后100M为单位,填充这些内存空间.在一个2G内存,400M Swap空间的机器上跑3个上面的进程.我们看一下运行结果：