使用 CGroup 实现进程内存控制

参考原文

背景

从 Linux 内核 2.6.25 开始，CGroup 支持对进程内存的隔离和限制，这也是 Docker 等容器技术的底层支撑。

使用 CGroup 有如下好处

在共享的机器上，进程相互隔离，互不影响，对其它进程是种保护。 对于存在内存泄漏的进程，可以设置内存限制，通过系统 OOM 触发的 Kill 信号量来实现重启。

Linux 系统默认支持 CGroup, 而且默认挂载所有选项，可以使用 mount -t cgroup 来查看：

$ mount -t cgroup

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/net_cls type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

以内存为例，创建 climits 内存分组

使用 mkdir /sys/fs/cgroup/memory/climits 来创建属于自己的内存组 climits

$ mkdir /sys/fs/cgroup/memory/climits

此时系统已经在目录 /sys/fs/cgroup/memory/climits 下生成内存相关的所有配置

$ ls -la /sys/fs/cgroup/memory/climits

cgroup.clone_children  memory.kmem.limit_in_bytes          memory.kmem.tcp.usage_in_bytes  memory.memsw.max_usage_in_bytes  memory.soft_limit_in_bytes  tasks
cgroup.event_control   memory.kmem.max_usage_in_bytes      memory.kmem.usage_in_bytes      memory.memsw.usage_in_bytes      memory.stat
cgroup.procs           memory.kmem.slabinfo                memory.limit_in_bytes           memory.move_charge_at_immigrate  memory.swappiness
memory.failcnt         memory.kmem.tcp.failcnt             memory.max_usage_in_bytes       memory.numa_stat                 memory.usage_in_bytes
memory.force_empty     memory.kmem.tcp.limit_in_bytes      memory.memsw.failcnt            memory.oom_control               memory.use_hierarchy
memory.kmem.failcnt    memory.kmem.tcp.max_usage_in_bytes  memory.memsw.limit_in_bytes     memory.pressure_level            notify_on_release

主要配置含义：

  • cgroup.procs: 使用该组配置的进程列表。
  • memory.limit_in_bytes：内存使用限制。
  • memory.memsw.limit_in_bytes：内存和交换分区总计限制。
  • memory.swappiness: 交换分区使用比例。
  • memory.usage_in_bytes： 当前进程内存使用量。
  • memory.stat: 内存使用统计信息。
  • memory.oom_control: OOM 控制参数。

设置内存限制

假设有进程 pid 1234，设置内存限制为 10MB，可以这样操作：

limit_in_bytes 设置为 10MB

echo 10M > /sys/fs/cgroup/memory/climits/memory.limit_in_bytes

swappiness 设置为 0，表示禁用交换分区，实际生产中可以配置合适的比例。

echo 0 > /sys/fs/cgroup/memory/climits/memory.swappiness

添加控制进程

echo 1234 > /sys/fs/cgroup/memory/climits/cgroup.procs

当进程 1234 使用内存超过 10MB 的时候，默认进程 1234 会触发 OOM，被系统 Kill 掉。

Go 实现进程内存限制

用 Go 代码来实现一个简单的进程内存限制以及守护（被 Kill 能够自动重启）

  • 进程测试代码 每隔一秒申请 1MB 存储空间，并且不释放，然后再打印下 Go 的内存申请情况
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import (
    "fmt"
    "os"
    "runtime"
    "time"
)

const (
    MB = 1024 * 1024
)

func main() {
    blocks := make([][MB]byte, 0)
    fmt.Println("Child pid is", os.Getpid())

    for range time.Tick(time.Second) {
        blocks = append(blocks, [MB]byte{})
        printMemUsage()
    }
}

func printMemUsage() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
    fmt.Printf("\tSys = %v MiB \n", bToMb(m.Sys))
}

func bToMb(b uint64) uint64 {
    return b / MB
}

通过 GOOS=linux GOARCH=amd64 go build -o simpleapp example/simple_app.go 命令，编译一个 Linux 版本的可执行程序 simpleapp。

  • 进程守护程序 该守护程序主要实现进程内存限制和进程守护（自动重启）
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

package main

import (
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "os/exec"
    "os/signal"
    "path/filepath"
    "syscall"
)

var (
    rssLimit   int
    cgroupRoot string
)

const (
    procsFile       = "cgroup.procs"
    memoryLimitFile = "memory.limit_in_bytes"
    swapLimitFile   = "memory.swappiness"
)

func init() {
    flag.IntVar(&rssLimit, "memory", 10, "memory limit with MB.")
    flag.StringVar(&cgroupRoot, "root", "/sys/fs/cgroup/memory/climits", "cgroup root path")
}

func main() {
    flag.Parse()

    // set memory limit
    mPath := filepath.Join(cgroupRoot, memoryLimitFile)
    // 修改 memory.limit_in_bytes 限制内存使用量,默认10MB
    whiteFile(mPath, rssLimit*1024*1024)

    // set swap memory limit to zero
    sPath := filepath.Join(cgroupRoot, swapLimitFile)
    // 修改 memory.swappiness 限制交换分区大小，默认0
    whiteFile(sPath, 0)

    go startCmd("./simpleapp")

    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)
    s := <-c
    fmt.Println("Got signal:", s)
}

func whiteFile(path string, value int) {
    if err := ioutil.WriteFile(path, []byte(fmt.Sprintf("%d", value)), 0755); err != nil {
        log.Panic(err)
    }
}

type ExitStatus struct {
    Signal os.Signal
    Code   int
}

func startCmd(command string) {
    restart := make(chan ExitStatus, 1)

    runner := func() {
        cmd := exec.Cmd{
            Path: command,
        }

        cmd.Stdout = os.Stdout

        // start app 启动一个进程
        if err := cmd.Start(); err != nil {
            log.Panic(err)
        }

        fmt.Println("add pid", cmd.Process.Pid, "to file cgroup.procs")

        // set cgroup procs id
        pPath := filepath.Join(cgroupRoot, procsFile)
        // 修改 cgroup.procs
        // 将新生成的进程号 cmd.Process.Pid 写到 cgroup.procs
        whiteFile(pPath, cmd.Process.Pid)

        // 通过 cmd.Wait() 接收命令输出结果
        if err := cmd.Wait(); err != nil {
            fmt.Println("cmd return with error:", err)
        }

        // 接收状态
        status := cmd.ProcessState.Sys().(syscall.WaitStatus)

        options := ExitStatus{
            Code: status.ExitStatus(),
        }

        if status.Signaled() {
            options.Signal = status.Signal()
        }

        cmd.Process.Kill()

        restart <- options
    }

    go runner()

    for {
        status := <-restart

        // 结果为 Kill 信号的时候，能够重启任务
        switch status.Signal {
        case os.Kill:
            fmt.Println("app is killed by system")
        default:
            fmt.Println("app exit with code:", status.Code)
        }

        fmt.Println("restart app..")

        // 重新启动一个进程
        go runner()
    }
}

参考