A.7. memory

memory 子系统自动生成 cgroup 任务使用内存资源的报告，并限定这些任务所用内存的大小：

memory.stat

报告大范围内存统计，见下表：

表 A.2. memory.stat 报告的值

统计数据	描述
`cache`	缓存页，包括 `tmpfs`（`shmem`），单位为字节
`rss`	匿名和 swap 缓存，“不”包括 `tmpfs`（`shmem`），单位为字节
`mapped_file`	memory-mapped 映射文件大小，包括 `tmpfs`（`shmem`），单位为字节
`pgpgin`	读入内存的页数
`pgpgout`	从内存中读出的页数
`swap`	swap 用量，单位为字节
`active_anon`	激活的“近期最少使用”（least-recently-used，LRU）列表中的匿名和 swap 缓存，包括 `tmpfs`（`shmem`），单位为字节
`inactive_anon`	未激活的 LRU 列表中的匿名和 swap 缓存，包括 `tmpfs`（`shmem`），单位为字节
`active_file`	激活的 LRU 列表中的 file-backed 内存，以字节为单位
`inactive_file`	未激活 LRU 列表中的 file-backed 内存，以字节为单位
`unevictable`	无法收回的内存，以字节为单位
`hierarchical_memory_limit`	包含 `memory` cgroup 层级的内存限制，单位为字节
`hierarchical_memsw_limit`	包含 `memory` cgroup 层级的内存加 swap 限制，单位为字节

另外，这些文件除 hierarchical_memory_limit 和 hierarchical_memsw_limit 之外，都有一个对应前缀 total，它不仅可在该 cgroup 中报告，还可在其子 cgroup 中报告。例如：swap 报告 cgroup 的 swap 用量，total_swap 报告该 cgroup 及其所有子群组的 swap 用量总和。

当您解读 memory.stat 报告的数值时，请注意各个统计数据之间的关系：

active_anon + inactive_anon = 匿名内存 + tmpfs 文件缓存 + swap 缓存
因此，active_anon + inactive_anon ≠ rss，因为 rss 不包括 tmpfs。
active_file + inactive_file = 缓存 - tmpfs 大小

memory.usage_in_bytes

报告 cgroup 中进程当前所用的内存总量（以字节为单位）。

memory.memsw.usage_in_bytes

报告该 cgroup 中进程当前所用的内存量和 swap 空间总和（以字节为单位）。

memory.max_usage_in_bytes

报告 cgroup 中进程所用的最大内存量（以字节为单位）。

memory.memsw.max_usage_in_bytes

报告该 cgroup 中进程的最大内存用量和最大 swap 空间用量（以字节为单位）。

memory.limit_in_bytes

设定用户内存（包括文件缓存）的最大用量。如果没有指定单位，则该数值将被解读为字节。但是可以使用后缀代表更大的单位 —— k 或者 K 代表千字节，m 或者 M 代表兆字节，g 或者 G 代表千兆字节。

您不能使用 memory.limit_in_bytes 限制 root cgroup；您只能对层级中较低的群组应用这些值。

在 memory.limit_in_bytes 中写入 -1 可以移除全部已有限制。

memory.memsw.limit_in_bytes

设定内存与 swap 用量之和的最大值。如果没有指定单位，则该值将被解读为字节。但是可以使用后缀代表更大的单位 —— k 或者 K 代表千字节，m 或者 M 代表兆字节，g 或者 G 代表千兆字节。

您不能使用 memory.memsw.limit_in_bytes 来限制 root cgroup；您只能对层级中较低的群组应用这些值。

在 memory.memsw.limit_in_bytes 中写入 -1 可以删除已有限制。

重要

在设定 memory.memsw.limit_in_bytes 参数“之前”设定 memory.limit_in_bytes 参数非常重要：顺序颠倒会导致错误。这是因为 memory.memsw.limit_in_bytes 只有在消耗完所有内存限额（之前在 memory.limit_in_bytes 中设定）后方可用。

请参考下列例子：为某一 cgroup 设定 memory.limit_in_bytes = 2G 和 memory.memsw.limit_in_bytes = 4G，可以让该 cgroup 中的进程分得 2GB 内存，并且一旦用尽，只能再分得 2GB swap。memory.memsw.limit_in_bytes 参数表示内存和 swap 的总和。没有设置 memory.memsw.limit_in_bytes 参数的 cgroup 的进程可以使用全部可用 swap （当限定的内存用尽后），并会因为缺少可用 swap 触发 Out of Memory（内存不足）状态。

/etc/cgconfig.conf 文件中 memory.limit_in_bytes 和 memory.memsw.limit_in_bytes 参数的顺序也很重要。以下是正确的配置示例：

memory {
    memory.limit_in_bytes = 1G;
    memory.memsw.limit_in_bytes = 1G;
}

memory.failcnt

报告内存达到 memory.limit_in_bytes 设定的限制值的次数。

memory.memsw.failcnt

报告内存和 swap 空间总和达到 memory.memsw.limit_in_bytes 设定的限制值的次数。

memory.force_empty

当设定为 0 时，该 cgroup 中任务所用的所有页面内存都将被清空。这个接口只可在 cgroup 没有任务时使用。如果无法清空内存，请在可能的情况下将其移动到父 cgroup 中。移除 cgroup 前请使用 memory.force_empty 参数以免将废弃的页面缓存移动到它的父 cgroup 中。

memory.swappiness

将 kernel 倾向设定为换出该 cgroup 中任务所使用的进程内存，而不是从页高速缓冲中再生页面。这与 /proc/sys/vm/swappiness 为整体系统设定的倾向、计算方法相同。默认值为 60。低于 60 会降低 kernel 换出进程内存的倾向；高于 0 会增加 kernel 换出进程内存的倾向。高于 100 时，kernel 将开始换出作为该 cgroup 中进程地址空间一部分的页面。

请注意：值 0 不会阻止进程内存被换出；系统内存不足时，换出仍可能发生，因为全局虚拟内存管理逻辑不读取该 cgroup 值。要完全锁定页面，请使用 mlock() 而不是 cgroup。

您不能更改以下群组的 swappiness：

root cgroup，它使用 /proc/sys/vm/swappiness 设定的 swappiness。
有子群组的 cgroup。

memory.use_hierarchy

包含标签（0 或者 1），它可以设定是否将内存用量计入 cgroup 层级的吞吐量中。如果启用（1），内存子系统会从超过其内存限制的子进程中再生内存。默认情况下（0），子系统不从任务的子进程中再生内存。

memory.oom_control

包含标签（0 或者 1），它可以为 cgroup 启用或者禁用“内存不足”（Out of Memory，OOM）终止程序。如果启用（0），尝试消耗超过其允许内存的任务会被 OOM 终止程序立即终止。默认情况下，所有使用 memory 子系统的 cgroup 都会启用 OOM 终止程序。要禁用它，请在 memory.oom_control 文件中写入 1：

~]# echo 1 > /cgroup/memory/lab1/memory.oom_control

禁用 OOM 杀手程序后，尝试使用超过其允许内存的任务会被暂停，直到有额外内存可用。

memory.oom_control 文件也在 under_oom 条目下报告当前 cgroup 的 OOM 状态。如果该 cgroup 缺少内存，则会暂停它里面的任务。under_oom 条目报告值为 1。

memory.oom_control 文件可以使用 API 通知来报告 OOM 情况的出现。。

A.7.1. 示例应用

例 A.3. OOM 控制和通知

以下示例将演示当 cgroup 中任务尝试使用超过其允许的内存时， OOM 终止程序的工作过程，以及通知处理程序是如何报告 OOM 状态的：

在层级中附加 memory 子系统，并创建一个 cgroup：

~]# mount -t memory -o memory memory /cgroup/memory
~]# mkdir /cgroup/memory/blue

将 blue cgroup 中任务可用的内存量设定为 100MB：
```
~]# echo 104857600 > memory.limit_in_bytes
```

进入 blue 目录并确定已启用 OOM 终止程序：

~]# cd /cgroup/memory/blue
blue]# cat memory.oom_control
oom_kill_disable 0
under_oom 0

将当前 shell 进程移动到 blue cgroup 的 tasks 文件中，以便在这个 shell 中启动的其它所有进程会自动移至 blue cgroup：
```
blue]# echo $$ > tasks
```

启动测试程序，尝试分配超过您在步骤 2 中设定限额的内存量。blue cgroup 消耗完内存后，OOM 终止程序会终止测试程序，并在标准输出中报告 Killed：

blue]# ~/mem-hog
Killed

以下是测试程序实例 ^[1]：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define KB (1024)
#define MB (1024 * KB)
#define GB (1024 * MB)

int main(int argc, char *argv[])
{
	char *p;

again:
	while ((p = (char *)malloc(GB)))
		memset(p, 0, GB);

	while ((p = (char *)malloc(MB)))
		memset(p, 0, MB);

	while ((p = (char *)malloc(KB)))
		memset(p, 0,
				KB);

	sleep(1);

	goto again;

	return 0;
}

禁用 OOM 杀手程序，然后重新运行测试程序。这次该测试程序会暂停并等待额外的内存释放：
```
blue]# echo 1 > memory.oom_control
blue]# ~/mem-hog
```
虽然测试程序处于暂停状态，但请注意该 cgroup 的 under_oom 状态已更改，表示该 cgroup 缺少可用内存：
```
~]# cat /cgroup/memory/blue/memory.oom_control
oom_kill_disable 1
under_oom 1
```
重启 OOM 终止程序可以立即终止该测试程序。

如要收到关于每一个 OOM 的通知，请创建一个指定的程序。例如 ^[2]：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/eventfd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

static inline void die(const char *msg)
{
	fprintf(stderr, "error: %s: %s(%d)\n", msg, strerror(errno), errno);
	exit(EXIT_FAILURE);
}

static inline void usage(void)
{
	fprintf(stderr, "usage: oom_eventfd_test <cgroup.event_control> <memory.oom_control>\n");
	exit(EXIT_FAILURE);
}

#define BUFSIZE 256

int main(int argc, char *argv[])
{
	char buf[BUFSIZE];
	int efd, cfd, ofd, rb, wb;
	uint64_t u;

	if (argc != 3)
		usage();

	if ((efd = eventfd(0, 0)) == -1)
		die("eventfd");

	if ((cfd = open(argv[1], O_WRONLY)) == -1)
		die("cgroup.event_control");

	if ((ofd = open(argv[2], O_RDONLY)) == -1)
		die("memory.oom_control");

	if ((wb = snprintf(buf, BUFSIZE, "%d %d", efd, ofd)) >= BUFSIZE)
		die("buffer too small");

	if (write(cfd, buf, wb) == -1)
		die("write cgroup.event_control");

	if (close(cfd) == -1)
		die("close cgroup.event_control");

	for (;;) {
		if (read(efd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
			die("read eventfd");

		printf("mem_cgroup oom event received\n");
	}

	return 0;
}

上述程序会探测 OOM 状态（从被命令列指定为参数的 cgroup 中），并使用 mem_cgroup oom event received 字符串在标准输出中报告。

在一个独立的控制台中运行上述通知处理程序，并将 blue cgroup 的控制文件指定为参数：
```
~]$ ./oom_notification /cgroup/memory/blue/cgroup.event_control /cgroup/memory/blue/memory.oom_control
```
在另一个控制台中运行 mem_hog 测试程序，以便生成 OOM 状态，并查看 oom_notification 程序在标准输出中的报告：
```
blue]# ~/mem-hog
```

^[1] 源代码由 Red Hat 的工程师 František Hrbata 提供。

^[2] 源代码由 Red Hat 的工程师 František Hrbata 提供。

Where did the comment section go?

Red Hat's documentation publication system recently went through an upgrade to enable speedier, more mobile-friendly content. We decided to re-evaluate our commenting platform to ensure that it meets your expectations and serves as an optimal feedback mechanism. During this redesign, we invite your input on providing feedback on Red Hat documentation via the discussion platform.

Log in to Your Red Hat Account

Red Hat Account

Customer Portal

Select Your Language

Infrastructure and Management

Cloud Computing

Storage

JBoss Development and Management

JBoss Integration and Automation

Mobile

Services

Tools

Red Hat Product Security Center

Security Updates

Resources

Customer Portal Community

Customer Events

Stories

A.7. memory

A.7.1. 示例应用

Where did the comment section go?