MySQL OOM 系統二 OOM Killer_MySQL-mysql教程-PHP中文網

這裡就牽涉到一個問題，到底Kill掉誰呢？一般稍微了解一些Linux內核的同學第一反應是誰用的最多，就Kill掉誰。這當然是Linux核心首先考慮的重要因素，但是也不完全是這樣的，我們查一些Linux的核心方面的資料，可以知道其實Kill誰是由/proc//oom_score來決定的，這個值每個行程一個，是由Linux核心的oom_badness()函數負責計算的。那下面我們來仔細讀一讀badness()函數。

在badness()函數的註解部分，寫明了badness()函數的處理思路：

         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 meticulously tuned to meet the principle of least surprise ... (be careful when you carere;

總的來說就是Kill掉最小數量的進程來獲取最大數量的內存，這與我們Kill掉佔用內存最大的進程是吻合的。

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

points = p->mm->total_vm;

分數的起始是進程實際使用的RAM內存，注意這裡不包括SWAP，即OOM Killer只會與進程實際的物理內存有關，與Swap是沒有關係的，並且我們可以看到，進程實際使用的物理記憶體越多，分數越高，分數越高就越容易被犧牲掉。

         * 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;

這段表示子進程佔用的記憶體都會計算到父進程上。

s = int_sqrt(cpu_time);

        if (s)
                points /= s;
        s = int_sqrt(int_sqrt(run_time));
        if (s)
                points /= s;

這表示進程佔用的CPU時間越長或進程運作的時間越長，分數越低，越不容易被Kill掉。

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

若以行程優先順序較低（nice值，且正值低優先級，且負值高優先級），則Point翻倍。

       /*
        * 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;

super使用者的進程優先順序較低。

        /*
         * 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;

直接可存取原廠的進程優先順序較高。

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

}

每個行程有個oomkilladj 可以設定該行程被kill的優先權，這個參數看上去對Point影響還是比較大的，oomkilladj 最大+15，最小是-17，越大越容易被幹掉，這個值由於是移位運算，所以影響還是比較大的。

下面我寫個小程式實驗一下:

 #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);
 }

登入後複製

上面的程式先申請一個1G的記憶體空間，然後100M為單位，填滿這些記憶體空間。在一個2G內存，400M Swap空間的機器上跑3個上面的進程。我們來看看運行結果：