內存加壓 | mem-pressure

介紹內存加壓小工具：mem-pressure

本文代碼基於：Android 12

使用

usage 信息。

emulator_x86_64:/ # mem-pressure  -h                                                                                                                                                                      
Usage: [OPTIONS]

  -d N: Duration in microsecond to sleep between each allocation.
  -i N: Number of iterations to run the alloc process.
  -o N: The oom_score to set the child process to before alloc.
  -s N: Number of bytes to allocate in an alloc process loop.
Aborted 

其實不需要配置參數，這個程序同樣運行的很好，有配置默認參數只是沒放在 help 中，代碼分析時介紹。直接運行 mem-pressure 二進制程序，會有如下的終端輸出和 logcat 日志。

• 終端輸出

130|emulator_x86_64:/ # mem-pressure                                                                                                                                                                      
Child 0 allocated 2654 MB
Child 1 allocated 3985 MB
Child 2 allocated 4614 MB
Child 3 allocated 4907 MB
Child 4 allocated 5097 MB
Child 5 allocated 5140 MB
......
接收 Ctrl + C 信號退出

• logcat

04-04 20:16:24.229   174   174 I lowmemorykiller: Kill 'com.android.inputmethod.latin' (3294), uid 10086, oom_score_adj 200 to free 13172kB rss, 31664kB swap; reason: device is low on swap (0kB < 151184kB) and thrashing (134%)
04-04 20:16:24.431   174   174 I lowmemorykiller: Kill 'android.ext.services' (3275), uid 10100, oom_score_adj 100 to free 11536kB rss, 33032kB swap; reason: device is low on swap (0kB < 151184kB) and thrashing (220%)
04-04 20:16:24.497   174   174 I lowmemorykiller: Kill 'com.android.launcher3' (3244), uid 10090, oom_score_adj 0 to free 22360kB rss, 49604kB swap; reason: device is low on swap (0kB < 151184kB) and thrashing (273%)
04-04 20:16:30.117   174   174 I lowmemorykiller: Kill 'android.process.acore' (3395), uid 10039, oom_score_adj 200 to free 22840kB rss, 33072kB swap; reason: device is low on swap (2372kB < 151184kB) and thrashing (208%)
04-04 20:16:30.324   174   174 I lowmemorykiller: Kill 'com.android.inputmethod.latin' (3376), uid 10086, oom_score_adj 200 to free 13412kB rss, 31656kB swap; reason: device is low on swap (0kB < 151184kB) and thrashing (152%)
04-04 20:16:30.546   174   174 I lowmemorykiller: Kill 'com.android.launcher3' (3339), uid 10090, oom_score_adj 0 to free 22880kB rss, 49428kB swap; reason: device is low on swap (0kB < 151184kB) and thrashing (200%)

從上面的運行反饋來看，可以很好的理解程序的目的： fork 子進程申請盡可能多的內存。由此會觸發 lowmemorykiller 按 oom_adj_score 殺進程的動作。

代碼分析

關鍵參數

system/extras/alloc-stress/mem-pressure.cpp

int main(int argc, char* argv[]) {
    pid_t pid;
    size_t* shared;
    int c, i = 0;

    size_t duration = 1000; //注釋 1：子進程申請內存的時間間隔
    int iterations = 0; //注釋 2：子進程申請內存交互次數
    const char* oom_score = "899"; //注釋 3：子進程 oom_score_adj 的數值
    size_t step_size = 2 * 1024 * 1024;  // 2 MB //注釋 4：子進程每次申請的內存大小
    size_t size = step_size; //注釋 5：子進程基礎內存申請大小

    while ((c = getopt(argc, argv, "hi:d:o:s:")) != -1) {
        switch (c) {
            case 'i':
                iterations = atoi(optarg);
                break;
            case 'd':
                duration = atoi(optarg);
                break;
            case 'o':
                oom_score = optarg;
                break;
            case 's':
                step_size = atoi(optarg);
                break;
            case 'h':
                usage();
                abort();
            default:
                abort();
        }
    }

程序的初始化有這樣的默認值設置，見 //注釋 1 - 5。然后是入參的解析賦值。

主循環

system/extras/alloc-stress/mem-pressure.cpp

    //注釋 1：一個通道，用於獲取子進程所分配的內存大小
    shared = (size_t*)mmap(NULL, sizeof(size_t), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED,
                           0, 0);

    while (iterations == 0 || i < iterations) {//注釋 2：默認無限循環
        *shared = 0;
        pid = fork();
        if (!pid) {
            /* Child *///注釋 3：子進程開始內存加壓
            add_pressure(shared, size, step_size, duration, oom_score);
            /* Shoud not get here */
            exit(0);
        } else {
            wait(NULL);
            //注釋 4：打印子進程的內存分配大小
            printf("Child %d allocated %zd MB\n", i, *shared / 1024 / 1024);
            //注釋 5：更新基礎分配值，用於加速接近內存邊界。
            size = *shared / 2;
        }
        i++;
    }

注釋 2，默認參數下，iterations == 0 所以會持續 fork 並申請內存。

注釋 3，在子進程中申請內存，開始加壓。

注釋 4：壓力爆表后展示申請的大小。

注釋 5：用於加速下一次的內存申請。

下面看注釋 3 的 add_pressure 方法。

system/extras/alloc-stress/mem-pressure.cpp

void* alloc_set(size_t size) {
    void* addr = NULL;

    addr = malloc(size);
    if (!addr) {
        printf("Allocating %zd MB failed\n", size / 1024 / 1024);
    } else {
        memset(addr, 0, size);
    }
    return addr;
}

void add_pressure(size_t* shared, size_t size, size_t step_size, size_t duration,
                  const char* oom_score) {
    int fd, ret;
    //注釋 1：設置優先級
    fd = open("/proc/self/oom_score_adj", O_WRONLY);
    ret = write(fd, oom_score, strlen(oom_score));
    if (ret < 0) {
        printf("Writing oom_score_adj failed with err %s\n", strerror(errno));
    }
    close(fd);
    //注釋 2：申請基礎內存
    if (alloc_set(size)) {
        *shared = size;
    }
    //注釋 3：持續申請內存
    while (alloc_set(step_size)) {
        size += step_size;
        *shared = size;
        usleep(duration);
    }
}

人如其名，有三步動作，見注釋 1 - 3。持續加壓的后果就是內存壓力爆炸，觸發 lmk 殺進程，殺到多少呢？（理論上）殺到子進程的 oom_score_adj 即默認值 899 使得內存得到釋放。

總結

這個工具有什么用？

就這個工具本身來說，是通過不斷申請內存，直至開始 lmk 殺進程，殺的優先級極限（理論上）是我們設置的 -o 參數。其價值更多在於提供了一種思路，如何模擬 Android 系統內存壓力場景。比如說，想得知 launcher 進程在大約多少的內存壓力下會被殺？設置 -o 參數為 launcher 優先級

emulator_x86_64:/ # cat /proc/`pidof com.android.launcher3`/oom_score_adj
0

又比如說，我們想指定消耗掉多少內存后，做某種測試等等。

另外還它的姊妹篇可自行閱讀：alloc-stress