Docker之Cgroup与接口的使用（二）子系统详解

比眉伴天荒 2022-07-15 06:42 249阅读 0赞

### cpuset子系统 ###

为一组指定的进程分配指定的cpu和内存节点。在NUMA架构的服务器上，通常将进程与指定的cpu和内存节点绑定来达到，提升性能。（具体是怎么提升的有待学习）。  
在这里只介绍主要的2个接口，其余的有时间可以进行深入了解  
1. cpuset.cpus：允许进程使用的cpu列表  
2. cpuset.mems：允许进行使用的内存节点列表（cpu还是理解的但是内存节点？？？？和内存寻址有关系吗？？）

姑且还是看一下cpuset的接口（控制文件）  
\[root@VM\_116\_112\_centos child\]\# ls  
cgroup.clone\_children cpuset.cpu\_exclusive cpuset.mem\_hardwall cpuset.memory\_spread\_page cpuset.sched\_load\_balance tasks  
cgroup.event\_control cpuset.cpus cpuset.memory\_migrate cpuset.memory\_spread\_slab cpuset.sched\_relax\_domain\_level  
cgroup.procs cpuset.mem\_exclusive cpuset.memory\_pressure cpuset.mems notify\_on\_release

### cpu子系统 ###

用于限制进行的cpu占用比率。  
1. cpu比重分配：cpu.shares。举个例子  
`cd /sys/fs/cgroup/cpu`  
`mkdir test1`创建cgroup test1  
`mkdir test2`创建cgroup test2  
`cd test1`  
`echo 1024 > cpu.shares`  
`cd test2`  
`echo 512 > cpu.shares`  
设置完毕后当test1和test2中的进程争抢cpu资源时，test1中将获得比test2中多一倍的cpu占用比率，这只有当争抢cpu时才有效。  
2. cpu带宽限制：cpu.cfs\_period\_us和cpu.cfs\_quota\_us接口（控制文件），单位是微秒。举个例子，我将test1中的period设为1000000（1秒），quota设为500000（0.5秒），那么test1中的进程在1秒内最多只能运行0.5秒,然后被强制睡眠，直到下一个1秒才能继续运行。。  
3. 实时进程的cpu带宽限制：之前的两个接口只能用于普通进程。cpu.rt\_period\_us和cpu.rt\_runtime\_us,用法与上述类似。  
看一下cpu中的所有接口。  
ls  
cgroup.clone\_children cgroup.procs cpuacct.usage cpu.cfs\_period\_us cpu.rt\_period\_us cpu.shares notify\_on\_release  
cgroup.event\_control cpuacct.stat cpuacct.usage\_percpu cpu.cfs\_quota\_us cpu.rt\_runtime\_us cpu.stat tasks

### cpuacct子系统 ###

用来统计各个cgroup的cpu使用情况  
1. cpuacct.stat：查看这个cgroup在内核态和用户态消耗的cpu时间。单位是USER\_HZ（0.01秒）  
如：  
cat cpuacct.stat  
user 3819849  
system 3496899  
2. cpuacct.usage：报告这个cgroup消耗的总的cpu时间，单位纳秒。如：  
\[root@VM\_116\_112\_centos cpuacct\]\# cat cpuacct.usage  
84608407349362  
3. cpuacct.usage\_percpu：顾名思义是这个cgroup在每个cpu上消耗的时间，总和是cpuacct.usage。  
其余接口  
cgroup.clone\_children cgroup.sane\_behavior cpuacct.usage\_percpu cpu.rt\_period\_us cpu.stat release\_agent test1  
cgroup.event\_control cpuacct.stat cpu.cfs\_period\_us cpu.rt\_runtime\_us docker system.slice test2  
cgroup.procs cpuacct.usage cpu.cfs\_quota\_us cpu.shares notify\_on\_release tasks user.slice  
在这里可以看到一个现象，我在cpu中创建的test1 cgroup在cpuacct中也能看见。  
原因是：  
ls -l  
总用量 0  
drwxr-xr-x 5 root root 0 7月 30 08:43 blkio  
lrwxrwxrwx 1 root root 11 7月 30 08:43 cpu -> cpu,cpuacct  
lrwxrwxrwx 1 root root 11 7月 30 08:43 cpuacct -> cpu,cpuacct  
drwxr-xr-x 7 root root 0 7月 30 08:43 cpu,cpuacct  
cpu和cpuacct都是cpu,cpuacct的软连接，所以在cpu中创建的cgroup在cpuacct中也可以看见，其实从功能方面想的话，也应该是这样的，你要统计各个cgroup占用cpu使用情况，你就得了解所有占用过cpu的cgroup对象。  
既然这样，其余接口是和cpu是一样的就不再重复列出。

### memory子系统 ###

用来限制cgroup的内存上限。  
1. memory.limit\_in\_bytes：设置内存上限，单位字节，也可以使用k/K，m/M，g/G，例如`echo 1G > memory.limit_in_bytes`默认情况下，如果cgroup使用的内存超过上限，内核会尝试回收内存，如果仍无法将内存控制在限制以内，系统会触发OOM（它会在系统内存耗尽的情况下，启用自己算法有选择性的kill 掉一些进程），选择并杀死cgroup中的某个进程。  
2. memory.memsw.limit\_in\_bytes：设置内存加上交换分区的总量，通过设置这个值，可以防止进程将交换分区用完。  
3. memory.oom\_control：如果设置为0，则内存使用超过限制，系统不会触发OOM，kill进程，而是阻塞进程直到有内存被释放可供使用时；另一方，系统会向用户态发送事件通知，用户态的监控程序可以根据该事件来做相应的处理，比如提高内存的上限。  
4. memory.stat：汇报内存使用情况  
查看其余接口  
\[root@VM\_116\_112\_centos memory\]\# ls  
cgroup.clone\_children memory.kmem.limit\_in\_bytes memory.limit\_in\_bytes memory.oom\_control release\_agent  
cgroup.event\_control memory.kmem.max\_usage\_in\_bytes memory.max\_usage\_in\_bytes memory.pressure\_level system.slice  
cgroup.procs memory.kmem.slabinfo memory.memsw.failcnt memory.soft\_limit\_in\_bytes tasks  
cgroup.sane\_behavior memory.kmem.tcp.failcnt memory.memsw.limit\_in\_bytes memory.stat user.slice  
docker memory.kmem.tcp.limit\_in\_bytes memory.memsw.max\_usage\_in\_bytes memory.swappiness  
memory.failcnt memory.kmem.tcp.max\_usage\_in\_bytes memory.memsw.usage\_in\_bytes memory.usage\_in\_bytes  
memory.force\_empty memory.kmem.tcp.usage\_in\_bytes memory.move\_charge\_at\_immigrate memory.use\_hierarchy  
memory.kmem.failcnt memory.kmem.usage\_in\_bytes memory.numa\_stat notify\_on\_release

### blkio子系统 ###

用来限制cgroup的blockIO带宽。  
1. blkio.weight：设置权重值，范围在100~1000之间，和cpu.shares类似是比重分配，不是绝对带宽的限制，只有多个cgroup竞争同一个块设备的带宽才会起作用  
2. blkio.weight\_device：设置具体设备权重值，设置了这个值，上面的blkio.weight会被覆盖。  
3. blkio.throttle.read\_bps\_device：对具体设备，设置每秒读磁盘的带宽上限。  
4. blkio.throttle.write\_bps\_device：写上限  
5. blkio.throttle.read\_iops\_device：IOPS（每秒进行读写操作的次数），读上限  
6. blkio.throttle.write\_iops\_device：写上限  
其余接口  
\[root@VM\_116\_112\_centos blkio\]\# ls  
blkio.io\_merged blkio.io\_serviced\_recursive blkio.reset\_stats blkio.throttle.write\_bps\_device cgroup.event\_control tasks  
blkio.io\_merged\_recursive blkio.io\_service\_time blkio.sectors blkio.throttle.write\_iops\_device cgroup.procs user.slice  
blkio.io\_queued blkio.io\_service\_time\_recursive blkio.sectors\_recursive blkio.time cgroup.sane\_behavior  
blkio.io\_queued\_recursive blkio.io\_wait\_time blkio.throttle.io\_service\_bytes blkio.time\_recursive docker  
blkio.io\_service\_bytes blkio.io\_wait\_time\_recursive blkio.throttle.io\_serviced blkio.weight notify\_on\_release  
blkio.io\_service\_bytes\_recursive blkio.leaf\_weight blkio.throttle.read\_bps\_device blkio.weight\_device release\_agent  
blkio.io\_serviced blkio.leaf\_weight\_device blkio.throttle.read\_iops\_device cgroup.clone\_children system.slice

### device子系统 ###

控制cgroup中的进程对哪些设备有访问权限。  
1. devices.list：只读文件，显示目前可以被访问的设备列表。  
\[root@VM\_116\_112\_centos devices\]\# cat devices.list  
`a *:* rwm`  
每一行都分为3部分：

1. 类型：可以是a，b，c，分别代表所有设备，块设备和字符设备
    2. 设备号：格式major:minor
    3. 权限：rwm，分别表示可读，可写，可创建设备节点

2. devices.allow：  
3. devices.deny：  
\[root@VM\_116\_112\_centos devices\]\# ls devices.allow devices.deny -l  
–w——- 1 root root 0 7月 30 08:43 devices.allow  
–w——- 1 root root 0 7月 30 08:43 devices.deny  
\[root@VM\_116\_112\_centos devices\]\# ls devices.list -l  
\-r–r–r– 1 root root 0 7月 30 08:43 devices.list  
从命令输出结果来看，devices.list是只读文件，devices.allow和devices.deny是只写文件，那么向这两个只写文件中写入上述格式的内容可以允许或禁止相应设备的访问。  
（好好思考一下这样做的好处？？？？？对于同一块内容，通过只写和只读的作用是？？？）

PS：剩余的子系统等用到的时候再进行进一步的学习。