CGroup 金沙网址:子系统有控制内存的 Memory

Linux下CGroup进行CPU、内存等财富支配,linuxcgroup

留存

from:   and 

CGroup 介绍
CGroup 是 Control Groups 的缩写,是 Linux
内核提供的一种能够界定、记录、隔开分离进度组 (process groups)
所使用的财力能源 (如 cpu memory i/o 等等) 的建制。二〇〇五 年进来 Linux
2.6.24 内核,CGroups 不是斩新成立的,它将经过管理从 cpuset
中脱离出去,笔者是 谷歌 的 Paul Menage。CGroups 也是 LXC
为促成设想化所选取的能源处理手腕。

CGroup 成效及组成
CGroup 是将轻巧进度张开分组化管理的 Linux 内核成效。CGroup
本人是提供将经过张开分组化管理的效应和接口的功底结构,I/O
或内部存款和储蓄器的分红调控等实际的财富管理职能是经过那几个效应来落实的。那个实际的能源管理效果称为
CGroup 子系统或调整器。CGroup 子系统有调控内存的 Memory
调控器、调节进度调解的 CPU 调控器等。运维中的内核能够应用的 Cgroup
子系统由/proc/cgroup 来确认。
CGroup 提供了一个 CGroup
设想文件系统,作为实行分组管理和各子系统装置的客户接口。要采取CGroup,必需挂载 CGroup 文件系统。那时通过挂载选项钦点使用哪个子系统。

Cgroups提供了以下职能:
1)限制进程组能够应用的资源数量(Resource limiting
)。举个例子:memory子系统可认为进度组织设立定二个memory使用上限,一旦进程组使用的内部存款和储蓄器达到限额再申请内部存款和储蓄器,就能够出发OOM(out
of memory)。
2)进度组的优先级调整(Prioritization
)。例如:可以应用cpu子系统为某些进程组分配一定cpu share。
3)记录进度组使用的财富数量(Accounting
)。举例:能够动用cpuacct子系统记录有些进度组使用的cpu时间
4)进程组隔开分离(Isolation)。比方:使用ns子系统能够使差别的进度组使用分化的namespace,以到达隔离的目标,分歧的历程组有各自的历程、互连网、文件系统挂载空间。
5)进度组决定(Control)。举个例子:使用freezer子系统能够将经过组挂起和苏醒。

CGroup 援助的文本体系
表 1. CGroup 协助的文书连串

文件名 R/W 用途

Release_agent

RW

删除分组时执行的命令,这个文件只存在于根分组

Notify_on_release

RW

设置是否执行 release_agent。为 1 时执行

Tasks

RW

属于分组的线程 TID 列表

Cgroup.procs

R

属于分组的进程 PID 列表。仅包括多线程进程的线程 leader 的 TID,这点与 tasks 不同

Cgroup.event_control

RW

监视状态变化和分组删除事件的配置文件

CGroup 相关概念解释
1)任务(task)。在 cgroups 中,职务就是系统的三个经过;
2)调控族群(control
group)。调控族群正是一组依据某种标准划分的进程。Cgroups
中的资源支配都以以调整族群为单位贯彻。八个经过可以进入到某个调节族群,也从叁个进度组迁移到另二个调控族群。贰个过程组的长河能够使用
cgroups 以调整族群为单位分配的能源,同有时候遭到 cgroups
以调控族群为单位设定的限量;
3)层级(hierarchy)。调整族群能够团体成 hierarchical
的花样,既一颗调节族群树。调控族群树上的子节点调节族群是父节点调节族群的儿女,承继父调控族群的特定的品质;
4)子系统(subsystem)。三个子种类就是叁个能源调整器,举例 cpu
子系统正是决定 cpu
时间分配的四个调节器。子系统必得附加(attach)到一个层级上才干起效果,贰个子连串附加到某些层级以往,这一个层级上的有所调节族群都受到这么些子系统的支配。

相互关系
1)每回在系统中开创新层级时,该系统中的全数义务都以特别层级的暗许cgroup(我们称为 root cgroup,此 cgroup
在开立层级时自动创立,前边在该层级中创造的 cgroup 都是此 cgroup
的遗族)的上马成员;
2)一个子体系最五只好叠合到多个层级;
3)三个层级能够附加多少个子系统;
4)叁个任务能够是多个 cgroup 的成员,可是那么些 cgroup
必需在不相同的层级;
5)系统中的进程(职分)创设子进程(任务)时,该子职分自动形成其父进度所在
cgroup 的分子。然后可根据须要将该子职分移动到差异的 cgroup
中,但最先时它总是继承其父任务的 cgroup。

图 1. CGroup 层级图

图 1 所示的 CGroup 层级关系显得,CPU 和 Memory
八个子系统有和好单独的层级种类,而又通过 Task Group 猎取关联关系。

CGroup 特点
在 cgroups 中,义务正是系统的二个经过。
调控族群(control
group)。调控族群正是一组遵照某种典型划分的经过。Cgroups
中的财富支配都以以调节族群为单位落成。一个经过能够步向到某些调节族群,也从二个进程组迁移到另三个调节族群。三个进度组的进度能够使用
cgroups 以调整族群为单位分配的财富,同期面对 cgroups
以调整族群为单位设定的范围。
层级(hierarchy)。调整族群能够组织成 hierarchical
的款式,既一颗调控族群树。调整族群树上的子节点调控族群是父节点调控族群的儿女,承继父调控族群的一定的习性。
子系统(subsytem)。一个子连串正是二个能源调整器,比方 cpu
子系统便是决定 cpu
时间分配的二个调节器。子系统必需叠合(attach)到二个层级上技艺起成效,二个子系统附加到有个别层级以往,那些层级上的有所调控族群都受到那个子系统的决定。

子系统的牵线
blkio —
这么些子系统为块设备设定输入/输出限制,比方物理设备(磁盘,机械硬盘,USB
等等)。
cpu — 那一个子系统应用调治程序提供对 CPU 的 cgroup 义务访问。
cpuacct — 那些子系统自动生成 cgroup 中职责所利用的 CPU 报告。
cpuset — 那么些子系统为 cgroup 中的职责分配独立
CPU(在多核系统)和内存节点。
devices — 那个子系统可允许只怕拒绝 cgroup 中的任务访谈设备。
freezer — 这些子系统挂起或然恢复生机 cgroup 中的任务。
memory — 那么些子系统设定 cgroup
中职分采纳的内部存款和储蓄器限制,并自动生成由那一个任务使用的内部存款和储蓄器财富报告。
net_cls — 那么些子系统使用阶段识别符(classid)标识互联网数据包,可允许
Linux 流量调节造进度序(tc)识别从实际 cgroup 中变化的数据包。

图 2. CGroup 规范应用架构图

如图 2 所示,CGroup 本领能够被用来在操作系统底层限制物理财富,起到
Container 的效果。图中每三个 JVM 进度对应二个 Container Cgroup
层级,通过 CGroup 提供的各样子系统,能够对每一个 JVM
进度对应的线程等第举办物理限制,那一个限制包括CPU、内部存款和储蓄器等等非常多品种的能源。下一部分会切实对应用程序进行 CPU
财富隔开分离进行自己要作为表率坚守规则。

cgroup的安装
实际安装很简单,最好施行正是yum直接设置(centos下)

布置文件

1 2 3 4 5 6 7 8 9 10 [[email protected] ~]# vim /etc/cgconfig.conf mount {          cpuset  = /cgroup/cpuset;                           cpu     =/cgroup/cpu;                           cpuacct =/cgroup/cpuacct;                           memory  =/cgroup/memory;                           devices =/cgroup/devices;                           freezer =/cgroup/freezer;                           net_cls =/cgroup/net_cls;                           blkio   =/cgroup/blkio;                                      }

cgroup section的语法格式如下:
group <name> { 
     [<permissions>] 
     <controller> { 
        <param name> = <param value>; 
        … 
     } 
      …}

其中:
name: 指定cgroup的名称
permissions:可采用,内定cgroup对应的挂载点文件系统的权杖,root客户具备具有权力。
controller:子系统的名号
param name 和 param value:子系统的性质及其属性值

1.布局对mysql实例的财富限制

1.1 修改cgconfig.conf文件

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 mount      cpuset  =/cgroup/cpuset     cpu =/cgroup/cpu     cpuacct =/cgroup/cpuacct     memory  =/cgroup/memory     blkio   =/cgroup/blkio     group mysql_g1 {        cpu {              cpu.cfs_quota_us = 50000;              cpu.cfs_period_us = 100000;           cpuset {                cpuset.cpus ="3";                cpuset.mems ="0";        }        cpuacct{               memory {                memory.limit_in_bytes=104857600;              memory.swappiness=0;              # memory.max_usage_in_bytes=104857600;              # memory.oom_control=0;      }       blkio  {             blkio.throttle.read_bps_device="8:0 524288"            blkio.throttle.write_bps_device="8:0 524288"     }   }

1.2 配置文件的一部分解释
cpu:cpu使用时间限额

cpu.cfs_period_us和cpu.cfs_quota_us来限制该组中的全数进度在单位时间里能够运用的cpu时间。这里的cfs是全然公平级调动度器的缩写。cpu.cfs_period_us就是时间周期(皮秒),默感觉100000,即百飞秒。cpu.cfs_quota_us就是在那时期内可选用的cpu时间(阿秒),暗中同意-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就能够限定在双核上完全选拔)。
cpuset:cpu绑定
咱俩限制该组只好在0一共1个超线程上运维。cpuset.mems是用来设置内部存款和储蓄器节点的。
本例限制使用超线程0上的第八个cpu线程。
实在cgconfig也正是帮您把布置文件中的配置整理到/cgroup/cpuset这些目录里面,譬如你必要动态设置mysql_group1/
cpuset.cpus的CPU超线程号,能够使用如下的格局。
[[email protected]
~]# echo “0” > mysql_group1/ cpuset.cpus
cpuacct:cpu能源报告
memory:内部存款和储蓄器限制
 
内部存款和储蓄器限制大家最主要范围了MySQL能够选用的内部存款和储蓄器最大尺寸memory.limit_in_bytes=256M。而设置swappiness为0是为了让操作系统不会将MySQL的内部存款和储蓄器佚名页调换出去。
blkio:BLOCK IO限额
blkio.throttle.read_bps_device=”8:0 524288″; #每秒读数据上限
blkio.throttle.write_bps_device=”8:0 524288″; #每秒写多少上限
里头8:0对应主设备号和副设备号,能够由此ls -l /dev/sda查看
[[email protected]
~]# ls -l /dev/sda 
brw-rw—-. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

1.3 拓宽文化
今昔较新的服务器CPU都是numa结构<非同等内部存款和储蓄器访谈结构(NUMA:Non-Uniform
Memory Access)>,使用numactl
–hardware能够看看numa各种节点的CPU超线程号,以及相应的节点号。

本例结果如下:
[[email protected]
~]# numactl –hardware 
available: 1 nodes (0) 
node 0 cpus: 0 1 2 3 
node 0 size: 1023 MB 
node 0 free: 68 MB 
node distances: 
node 0 
0: 10 
以下是较高级服务器的numa消息,仅作参照
[[email protected]
~]# numactl –hardware 
available: 4 nodes (0-3) 
node 0 cpus: 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 
node 0 size: 16338 MB 
node 0 free: 391 MB 
node 1 cpus: 1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 
node 1 size: 16384 MB 
node 1 free: 133 MB 
node 2 cpus: 2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62 
node 2 size: 16384 MB 
node 2 free: 137 MB 
node 3 cpus: 3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63 
node 3 size: 16384 MB 
node 3 free: 186 MB 
node distances: 
node 0 1 2 3 
0: 10 20 30 20 
1: 20 10 20 30 
2: 30 20 10 20 
3: 20 30 20 10

1.4 修改cgrules.conf文件
[[email protected]
~]# vim /etc/cgrules.conf 
# /etc/cgrules.conf 
#The format of this file is described in cgrules.conf(5) 
#manual page. 

# Example: 
#<user> <controllers> <destination> 
#@student cpu,memory usergroup/student/ 
#peter cpu test1/ 
#% memory test2/ 
*:/usr/local/mysql/bin/mysqld * mysql_g1 
注:共分为3个部分,分别为索要限制的实例,限制的原委(如cpu,memory),挂载目的。

2 使配置生效

[[email protected]
~]# /etc/init.d/cgconfig restart 
Stopping cgconfig service: [ OK ] 
Starting cgconfig service: [ OK ] 
[[email protected]
~]# /etc/init.d/cgred restart 
Stopping CGroup Rules Engine Daemon… [ OK ] 
Starting CGroup Rules Engine Daemon: [ OK ] 
注:重启顺序为cgconfig -> cgred
,改换配置文件后五个劳务须求重启,且顺序不能够错。

3 运维MySQL,查看MySQL是或不是处在cgroup的界定中

[[email protected]
~]# ps -eo pid,cgroup,cmd | grep -i mysqld 
29871
blkio:/;net_cls:/;freezer:/;devices:/;memory:/;cpuacct:/;cpu:/;cpuset:/
/bin/sh ./bin/mysqld_safe –defaults-file=/etc/my.cnf
–basedir=/usr/local/mysql/ –datadir=/usr/local/mysql/data/
30219
blkio:/;net_cls:/;freezer:/;devices:/;memory:/;cpuacct:/;cpu:/;cpuset:/mysql_g1
/usr/local/mysql/bin/mysqld –defaults-file=/etc/my.cnf
–basedir=/usr/local/mysql/ –datadir=/usr/local/mysql/data/
–plugin-dir=/usr/local/mysql//lib/plugin –user=mysql
–log-error=/usr/local/mysql/data//localhost.localdomain.err
–pid-file=/usr/local/mysql/data//localhost.localdomain.pid
–socket=/tmp/mysql.sock –port=3306
30311
blkio:/;net_cls:/;freezer:/;devices:/;memory:/;cpuacct:/;cpu:/;cpuset:/
grep -i mysqld

4 能源限制验证

动用mysqlslap对mysql实行压力测量检验,看mysql使用能源是或不是超过限定

4.1 在shell窗口1用mysqlslap对mysql实行压力测验
[[email protected]
~]# /usr/local/mysql/bin/mysqlslap –defaults-file=/etc/my.cnf
–concurrency=150 –iterations=1 –number-int-cols=8 –auto-generate-sql
–auto-generate-sql-load-type=mixed –engine=innodb
–number-of-queries=100000 -ujesse -pjesse –number-char-cols=35
–auto-generate-sql-add-autoincrement –debug-info -P3306 -h127.0.0.1

4.2 在shell窗口2查看mysql对cpu,内部存款和储蓄器的运用

足见:cpu限制在了第3个大旨上,且对第三个主导的应用范围在一半。

4.3 在shell窗口3查看io的消耗

可知:mysql对io的读及写消耗均限制在2M每秒以内。

cgroup实例剖判(手工业动态验证)

复原配置文件/etc/cgconfig.conf及/etc/cgrules.conf
为暗许配置。测验实例依然为mysql,测量检验工具为mysqlslap。

开启cgconfig及cgrules 服务
[[email protected]
~]# /etc/init.d/cgconfig restart 
Stopping cgconfig service: [ OK ] 
Starting cgconfig service: [ OK ] 
[[email protected]
/]# /etc/init.d/cgred restart 
Stopping CGroup Rules Engine Daemon… [ OK ] 
Starting CGroup Rules Engine Daemon: [ OK ]

拉开mysqlslap压力测量检验程序
[[email protected]
/]# /usr/local/mysql/bin/mysqlslap –defaults-file=/etc/my.cnf
–concurrency=150 –iterations=1 –number-int-cols=8 –auto-generate-sql
–auto-generate-sql-load-type=mixed –engine=innodb
–number-of-queries=100000 -ujesse -pjesse –number-char-cols=35
–auto-generate-sql-add-autoincrement –debug-info -P3306 -h127.0.0.1

通过htop查看财富消耗。

1)cpu限制实例

限制mysql使用三个核,如第二个核,且对该核的行使不抢先二分之一
[[email protected]
~]# mkdir -p /cgroup/cpu/foo/ 
[[email protected]
~]# mkdir -p /cgroup/cpuset/foo/ 
[[email protected]
~]# echo 50000 > /cgroup/cpu/foo/cpu.cfs_quota_us 
[[email protected]
~]# echo 100000 > /cgroup/cpu/foo/cpu.cfs_period_us 
[[email protected]
~]# echo “0” > /cgroup/cpuset/foo/cpuset.mems 
[[email protected]
~]# echo “1” > /cgroup/cpuset/foo/cpuset.cpus 
[[email protected]
~]# echo 28819 > /cgroup/cpu/foo/tasks

里头:28819为mysqld的进度号。

2) 内部存款和储蓄器限制实例

限制mysql使用内部存款和储蓄器为不超越512M
跑二个消耗内部存储器脚本

1 2 3 4 #!/bin/bash<br>x='a'  while [ True ];do      x=$x$x  done;

内部存款和储蓄器的成本在任何时间任何地点加码,对其开展限定,使其选用内设有500M以内
[[email protected]
~]# mkdir -p /cgroup/memory/foo 
[[email protected]
~]# echo 524288000 > /cgroup/memory/foo/memory.limit_in_bytes 
[[email protected]
~]# echo 44476 > /cgroup/memory/foo/tasks

内部存储器使用得到了有效调控。

3)IO限制实例

跑四个消耗IO的测验
[[email protected]
~]# dd if=/dev/sda of=/dev/null 
通过iotop看io占用处境,磁盘读取速度到了50M/s

 
界定读取速度为10M/S

[[email protected]
~]# mkdir -p /cgroup/blkio/foo 
[[email protected]
~]# echo ‘8:0 10485760’ >
/cgroup/blkio/foo/blkio.throttle.read_bps_device
[[email protected]
~]# echo 45033 > /cgroup/blkio/foo/tasks 
注1:45033为dd的经过号
注2:8:0对应主设备号和副设备号,能够经过ls -l /dev/sda查看
[[email protected]
~]# ls -l /dev/sda 
brw-rw—-. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

cgroup小结

使用cgroup有时对进度张开调治,直接通过命令就能够,如若要长久化对进程展费用配,即重启后还是有效,必要写进配置文件/etc/cgconfig.conf及/etc/cgrules.conf 

***************当你开采自个儿的才华撑不起野心时,就请安静下来学习呢***************

==================================================================

¥¥=’$$’

 Linux财富支配-CPU和内存

首要介绍Linux下, 假若对经过的CPU和内部存款和储蓄器能源的使用意况实行支配的点子。
 
CPU财富支配
每一种进程能够攻下CPU多久,
何时可以攻下CPU是和类别的调治密切相关的.
Linux系统中有两种调治攻略, 种种调节战术有其适用的光景,
也很难说哪一类调节战略是最优的.
Linux的调节战术可以参见代码: include/linux/sched.h
/*
 * Scheduling policies
 */
#define SCHED_NORMAL        0
#define SCHED_FIFO        1
#define SCHED_RR        2
#define SCHED_BATCH        3
/* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE        5
/* Can be ORed in to make sure the process is reverted back to
SCHED_NORMAL on fork */
#define SCHED_RESET_ON_FORK     0x40000000
 
Linux 系统也提供了修改调整计谋的下令和体系调用接口.
调用接口请查询相关文书档案, 这里关键介绍一下改变调解计谋的授命 – chrt.
# 在三个极限中举行
sleep 1000
# 张开另贰个终端
ps -ef | grep sleep  # 寻找 sleep 一千 的pid, 这里假诺是 1234
chrt -p 1234         # 能够查看 pid=1234 的历程的 调整计策, 输入如下:
      pid 1234’s current scheduling policy: SCHED_OTHER
      pid 1234’s current scheduling priority: 0
chrt -p -f 10 1234   # 修改调治计策为 SCHED_FIFO, 并且优先级为10
chrt -p 1234         # 再一次查看调节攻略
      pid 1234’s current scheduling policy: SCHED_FIFO
      pid 1234’s current scheduling priority: 10
 
补充:
    chrt 也得以一贯内定一条命令, 并设置那条命令的预先级的调治战术,
具体查看 chrt –help
    查看三个进程的调节计策, 除了采纳 chrt 命令之外, 仍是能够 cat
/proc/<PID>/sched
 
实时进程的CPU调控
所谓的实时进程, 也等于那多少个对响应时间须要比较高的进程.
那类进度供给在限制的岁月内部管理理顾客的恳求, 由此, 在界定的如今内,
要求占用全体CPU财富, 并且不可能被其余进程打断.
在这种状态下, 假诺实时进程中出现了周围死循环之类的情状,
就能够招致整个种类无响应.
因为实时进程的CPU优先级高, 何况未处理完之前是不会自由CPU能源的.
 
因而, 内核中供给有一种办法来界定实时进程的CPU财富占用.
 
系统完整安装

  1. 获取当前系统的装置
    sysctl -n kernel.sched_rt_period_us   # 实时经过调解的单位CPU时间 1

    1000000
    sysctl -n kernel.sched_rt_runtime_us  # 实时经过在 1
    秒中其实据有的CPU时间, 0.95秒
    950000
    本条设置验证实时进程在运作时并非截然占用CPU的,
    每1秒中有0.05秒的年月足以给别的进度运维.
    这么既不会对实时进程的响应时间产生太大的震慑,
    也制止了实时进程卡住时变成整个种类无响应.
     
  2. 安装实时进程占用CPU时间
    上边的暗许设置中, 实时经过占用 95% 的CPU时间. 就算感到占用的太多或太少,
    都以能够调动的.举个例子:
    sysctl -w kernel.sched_rt_runtime_us=900000    #
    设置实时进度每1秒中只占0.9秒的CPU时间
    kernel.sched_rt_runtime_us = 900000
    sysctl -n kernel.sched_rt_runtime_us 
    900000
     
    cgroup 中的设置
    完全安装是本着任何种类的, 大家也得以透过 cgroup
    来对一组经过的CPU资源扩充调整.
    万一想在 cgroup 中对 sched_rt_period_us 和 sched_rt_runtime_us
    实行调整, 必要内核编写翻译选项 CONFIG_RT_GROUP_SCHED=y
    翻开当前系统的内核编译选项方法如下: (debian 7.6 系统)
    cat /boot/config-`uname -r`
    查看 CONFIG_RT_GROUP_SCHED 是不是启用
    cat /boot/config-`uname -r` | grep -i rt_group
    # CONFIG_RT_GROUP_SCHED is not set
    debian 7.6 暗许未有运维那几个选项, 所以挂载cgroup之后, 未有安装
    sched_rt_period_us 和 sched_rt_runtime_us 的文件
    mkdir /mnt/cgroup
    mount -t cgroup cgroup /mnt/cgroup/
    cd /mnt/cgroup/
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 09:06 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 09:06 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 09:06 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 09:06 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 09:06 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 09:06 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 09:06
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpu.shares
    –w——- 1 root root 0 Aug 28 09:06 devices.allow
    –w——- 1 root root 0 Aug 28 09:06 devices.deny
    -r–r–r– 1 root root 0 Aug 28 09:06 devices.list
    -rw-r–r– 1 root root 0 Aug 28 09:06 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 09:06 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 09:06 release_agent
    -rw-r–r– 1 root root 0 Aug 28 09:06 tasks
     
    果然, 只有cpu.share, 没有 cpu.sched_rt_period_us 和
    cpu.sched_rt_runtime_us
    不能, 重新编写翻译内核, 编写翻译内核的具体方法参见:  编写翻译Linux内核
    为了省去时间, 大家用 make localmodconfig 来创制 .config 文件,
    然后修改当中的 CONFIG_RT_GROUP_SCHED=y
    下载源码等等参见: 编译Linux内核, 首要步骤如下:
    cd /path/to/linux-source-3.2
    make localmodconfig
    vim .config   # 设置 CONFIG_RT_GROUP_SCHED=y 并保存
    make
    make modules_install
    make install
    reboot      # 重启在此以前看看 /boot/grub/grub.cfg 中,
    暗中同意运行的是或不是新装置的木本
     
    起步到新基础, 再一次查看内核选项 CONFIG_RT_GROUP_SCHED 是或不是启用
    cat /boot/config-`uname -r` | grep -i rt_group
    CONFIG_RT_GROUP_SCHED=y       # 已启用
     
    再一次挂载 cgroup 文件系统, 开采多了2个布局文件, cpu.rt_period_us 和
    cpu.rt_runtime_us
    mount -t cgroup cgroup /mnt/cgroup/
    cd /mnt/cgroup/
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 09:53 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 09:53 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 09:53 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 09:53 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 09:53 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 09:53 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.rt_period_us
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.rt_runtime_us
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 09:53
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.shares
    –w——- 1 root root 0 Aug 28 09:53 devices.allow
    –w——- 1 root root 0 Aug 28 09:53 devices.deny
    -r–r–r– 1 root root 0 Aug 28 09:53 devices.list
    -rw-r–r– 1 root root 0 Aug 28 09:53 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 09:53 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 09:53 release_agent
    -rw-r–r– 1 root root 0 Aug 28 09:53 tasks
    cat cpu.rt_period_us 
    1000000
    cat cpu.rt_runtime_us 
    950000
     
    由此安排 cpu.rt_period_us 和 cpu.rt_runtime_us 就足以对 cgroup
    中的进度组中的实时进度张开 CPU使用时间的调节.
     
    财富支配实例
    下面根本介绍能源的部分争辨功底, 上面通过一些实例演示假诺因而 cgroup
    来调节进程所利用的 CPU和内存 能源.
    Linux对CPU 和 内部存款和储蓄器的垄断有相应的 cgroup 子系统 cpuset 和 memory
     
    实例: cgroup 中对中间 *子cgroup* 的CPU财富支配
    对各个 *子cgroup* 的CPU占用率举行调控重大重视每一种 *子cgroup* 的
    cpu.shares 文件
    一贯用试验进程来发话, 个中插手了部分注释.
    # 安装须要的软件
    apt-get install stress     # 让CPU达到 百分之百 的下压力工具
    apt-get install sysstat    # 查看系统CPU, 内部存储器, 磁盘,
    网络等能源利用处境的工具
     
    实例1 – 暗中认可情形, A 和 B 各占CPU总财富的 三分之二
        挂载 cgroup 文件系统 (注意加上 -o cpu 的取舍)
        在 cgroup中创建 2个子cgroup A 和 B
        私下认可情形下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都是 1024
        在 A 和 B 中用 stress 工具使其 CPU占用率到达 百分百
        top 命令查看 A 和 B 中经过分别攻克的 CPU (应该都以 一半)
     
    # 挂载 cgroup 文件系统
    mount -t cgroup -o cpu cgroup /mnt/cgroup/
    cd /mnt/cgroup
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 11:29 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 11:29 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 11:29 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 11:29 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 11:29 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 11:29 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 11:29
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpu.shares
    –w——- 1 root root 0 Aug 28 11:29 devices.allow
    –w——- 1 root root 0 Aug 28 11:29 devices.deny
    -r–r–r– 1 root root 0 Aug 28 11:29 devices.list
    -rw-r–r– 1 root root 0 Aug 28 11:29 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 11:29 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 11:29 release_agent
    -rw-r–r– 1 root root 0 Aug 28 11:29 tasks
    # 创建 子cgroup A 和 B
    mkdir {A,B}
    cat A/cpu.shares 
    1024
    cat B/cpu.shares 
    1024
    # 在 A 和 B 中分头通过 stress 工具使其CPU使用率高达 百分百
    echo ¥¥ > A/tasks  # 将眼下的 SHELL 到场到 cgroup A中
    stress -c 2    # 这里-c 2 是因为测验机器是双核, 要在2个核上都发出 100%的CPU 占用率
    # 别的张开四个 shell 窗口, 并将以此shell 参预到 cgroup B中
    echo ¥¥ > B/tasks  # 将近来的 SHELL 插足到 cgroup B中
    stress -c 2    # 在2个核上都发出 百分之百 的CPU 占用率
    # 再展开一个 shell 窗口, 用top命令查看 CPU占用情形
    top
    top – 14:10:32 up 43 min,  3 users,  load average: 2.31, 1.24, 0.62
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   114744 used,  1773128 free,    10472
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    45068
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3350 root      20   0  6524   92    0 R  49.9  0.0   0:08.73
    stress                                                                                                                     
     
    3351 root      20   0  6524   92    0 R  49.9  0.0   0:08.67
    stress                                                                                                                     
     
    3353 root      20   0  6524   92    0 R  49.9  0.0   0:07.35
    stress                                                                                                                     
     
    3354 root      20   0  6524   92    0 R  49.9  0.0   0:07.36
    stress                    
    # 查看这 4 个stress 进度是或不是分别属于 A 和 B
    cat /mnt/cgroup/A/tasks 
    2945
    3349
    3350   <– stress 进程
    3351   <– stress 进程
    cat /mnt/cgroup/B/tasks 
    2996
    3352
    3353   <– stress 进程
    3354   <– stress 进程
    能够见见, A和B组中的 2个stress 进度的CPU使用率相加都以 百分之百,
    出于小编测量检验的微型Computer是双核, top所看到的CPU最大使用率是 200%, 所以和预期一致,
    A和B组各占CPU总财富的 约得其半
     
    实例2 – A group 占用全部CPU财富的 2/3, B group 占用全体CPU能源的 三分之一
        情状同 实例1, 不再另行挂载 cgroup 文件系统, 也不在重新建立 A 和 B
        A group 的 cpu.shares 文件不改变, 值为 1024
        B group 的 cpu.shares 文件中的值改为 512, 那样,
    相当于B占用CPU总能源的 57% (因为 512 / (512+1024) = 57%)
        同实例1, 通过2个shell窗口, 分别是 A 和 B 的CPU使用率高达 百分百,
    然后透过 top 查看CPU使用状态
     
    # 在 B 中shell 窗口进行以下命令
    cat B/cpu.shares 
    1024
    echo 512 > B/cpu.shares 
    cat B/cpu.shares 
    512
    stress -c 2
    # 在 A 中 shell 窗口举行以下命令
    stress -c 2
    # 在第四个 shell 窗口, 也正是 非A, 非B 的相当 shell 窗口, 用 top
    查看cpu使用情状
    top
    top – 14:13:18 up 46 min,  3 users,  load average: 2.24, 1.92, 1.01
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   114744 used,  1773128 free,    10488
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    45068
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3376 root      20   0  6524   88    0 R  66.6  0.0   0:06.29
    stress                                                                                                                     
     
    3377 root      20   0  6524   88    0 R  66.6  0.0   0:06.30
    stress                                                                                                                     
     
    3373 root      20   0  6524   88    0 R  33.3  0.0   0:04.33
    stress                                                                                                                     
     
    3374 root      20   0  6524   88    0 R  33.3  0.0   0:04.32
    stress               
    # 查看那 4 个stress 进度是不是分别属于 A 和 B
    cat /mnt/cgroup/A/tasks 
    2945
    3375
    3376    <– stress 进程
    3377    <– stress 进程
    cat /mnt/cgroup/B/tasks 
    2996
    3372
    3373    <– stress 进程
    3374    <– stress 进程
    很生硬, A 组中的2个经过占用了CPU总的数量的 2/3 左右,
    B组中的2个进度占用了CPU总量的 48% 左右.
     
    实例3 – 物理CPU的控制
    上边的实例中, 固然能够决定每一个组的CPU的总体占用率,
    可是不可能决定有些组的经过固定在有些物理CPU上运转.
    要想将 cgroup 绑定到有个别固定的CPU上, 必要利用 cpuset 子系统.
    首先, 查看系统是不是帮忙 cpuset 子系统, 也正是看基础编写翻译选项
    CONFIG_CPUSETS 是不是设为y
    cat /boot/config-`uname -r` | grep -i cpusets
    CONFIG_CPUSETS=y
    自己的测量试验系统是支撑的, 如若你的体系不支持, 就需求再一次编译内核了…….
     
    下一场, 用上边包车型地铁事例演示将 A 和 B中的 stress 都内定到1个CPU上后的动静
        卸载当前的 cgroup
        再度挂载 cgroup 文件系统, 并钦命 -o cpuset
        内定 A 的物理CPU为 0 (双核CPU的各种核编号分别是 CPU0, CPU1)
        指定 B 的物理CPU也为 0
        重复 实例1 中的步骤, 旁观发生的转换
     
    umount /mnt/cgroup
    mount -t cgroup -o cpuset cgroup /mnt/cgroup/
    cd /mnt/cgroup
    ls -l
    total 0
    -rw-r–r– 1 root root 0 Aug 28 14:39 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 14:39 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 14:39 cgroup.procs
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.cpus    <–
    这些正是设置关联物理CPU的公文
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 14:39 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 14:39 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 14:39
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 14:39 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 14:39 release_agent
    -rw-r–r– 1 root root 0 Aug 28 14:39 tasks
    # 创建子cgroup A 和 B
    mkdir {A,B}
    cat A/cpuset.cpus   
             <–  默许是空的
    echo 0 > A/cpuset.cpus
    cat A/cpuset.cpus 
    0
    echo 0 > B/cpuset.cpus   # 一样, 设置B组也绑定到CPU0
    # 当前Shell加入到 A组
    echo ¥¥ > /mnt/cgroup/A/tasks 
    -bash: echo: write error: No space left on device
     
    若果出现上述失实, 只需求再设置 /mnt/cgroup/A/cpuset.mems 就可以. (参照他事他说加以考察:
    )
    # 同失常候安装 A 的 cpuset.cpus 和 cpuset.mems
    echo 0 > A/cpuset.cpus
    echo 0 > A/cpuset.mems
    # B组也同样设置
    echo 0 > B/cpuset.cpus
    echo 0 > B/cpuset.mems
    # 将当前 shell 加入到 A组
    echo ¥¥ > /mnt/cgroup/A/tasks   <– 设置过 cpuset.mems 后,
    就未有出错了
    stress -c 2
    # 再张开一个Shell窗口, 并参预到 B组
    echo ¥¥ > /mnt/cgroup/B/tasks
    stress -c 2
    # 再张开第2个 shell 窗口, 用top命令查看CPU使用情况
    top
    top – 15:13:29 up  1:46,  3 users,  load average: 1.01, 0.24, 0.12
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s): 50.0 us,  0.0 sy,  0.0 ni, 50.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   117216 used,  1770656 free,    11144
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    47088
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3830 root      20   0  6524   92    0 R  25.0  0.0   0:04.96
    stress                                                                                                                     
     
    3831 root      20   0  6524   92    0 R  25.0  0.0   0:04.97
    stress                                                                                                                     
     
    3834 root      20   0  6524   92    0 R  25.0  0.0   0:03.56
    stress                                                                                                                     
     
    3833 root      20   0  6524   92    0 R  24.6  0.0   0:03.56 stress
    从上边的结果能够看到, 即便 stress 命令钦命了 -c 2(意思是在2个CPU上运维),
    可是由于A和B都只绑定了CPU0,
    据此固然是双核的机械, 它们所据有的CPU总数却唯有 百分百, 实际不是实例1 中的
    200%.
     
    只要将B组的大意CPU绑定到CPU1, 那么相应享有 stress 的长河都占领 二分一,
    CPU能源的总数变为 200%.
    上边将B组的概况CPU绑定为CPU1, 看看结果是不是和大家的意料同样.
    # 在 B组的 shell 窗口中试行以下命令
    echo 1 > /mnt/cgroup/B/cpuset.cpus
    cat /mnt/cgroup/B/cpuset.cpus
    1
    stress -c 2
    # 在 A组的 shell 窗口中实施以下命令
    stress -c 2
    # 在第一个shell窗口中用top命令查看实行结果
    top
    top – 15:20:07 up  1:53,  3 users,  load average: 0.38, 0.83, 0.56
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   117340 used,  1770532 free,    11168
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    47088
    cached
      PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
     3854 root      20   0  6524   88    0 R  49.9  0.0   0:03.76
    stress                                                                                                                     
     
     3857 root      20   0  6524   92    0 R  49.9  0.0   0:02.29
    stress                                                                                                                     
     
     3858 root      20   0  6524   92    0 R  49.9  0.0   0:02.29
    stress                                                                                                                     
     
     3855 root      20   0  6524   88    0 R  49.6  0.0   0:03.76 stress
    果然, 和预期一致. A组中的 stress 和 B组中的 stress
    在个别的概略CPU上都占领了 百分百 左右的CPU使用率.
     
    实例4 – cgroup 对接纳的内部存款和储蓄器的调整
    cgroup 对内部存款和储蓄器的调控也非常粗略, 只要挂载cgroup时, 钦命 -o memory
    # 首先在此以前挂载的 cpuset 子系统
    umount /mnt/cgroup
    # 挂载cgroup 文件系统, 钦命 -o memeory
    mount -o memory -t cgroup memcg /mnt/cgroup/
    mount: special device memcg does not exist
     
    并发上述错误的来头或许是因为debian系统中, 暗许未有运维 cgroup
    的memory子系统. 能够通过以下办法料定:
    cat /proc/cgroups 
    #subsys_name    hierarchy    num_cgroups    enabled
    cpuset    0    1    1
    cpu    0    1    1
    cpuacct    0    1    1
    memory    1    1    0              <– 这里的 enabled 是 0
    devices    0    1    1
    freezer    0    1    1
    net_cls    0    1    1
    blkio    0    1    1
    perf_event    0    1    1
     
    为了暗中同意启用memory子系统, 能够安装 grub选项
    vim /etc/default/grub
    # 修改 GRUB_CMDLINE_LINUX=””  ==>
    GRUB_CMDLINE_LINUX=”cgroup_enable=memory”
    # 保存后, 更新grub.cfg
    update-grub
    reboot
     
    重启之后, 发掘 /proc/cgroups 中的memory已经 enabled, 而且也足以挂载
    memcg了
    cat /proc/cgroups 
    #subsys_name    hierarchy    num_cgroups    enabled
    cpuset    0    1    1
    cpu    0    1    1
    cpuacct    0    1    1
    memory    1    1    1
    devices    0    1    1
    freezer    0    1    1
    net_cls    0    1    1
    blkio    0    1    1
    perf_event    0    1    1
    # 挂载cgroup 的memory子系统
    mount -t cgroup -o memory memcg /mnt/cgroup
    ls -l /mnt/cgroup/   <– 能够看来有那多少个 memory 相关的安顿
    total 0
    -rw-r–r– 1 root root 0 Aug 28 15:54 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 15:54 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 15:54 cgroup.procs
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.failcnt
    –w——- 1 root root 0 Aug 28 15:54 memory.force_empty
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.limit_in_bytes   <–
    限制内部存储器使用的配置文件
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.max_usage_in_bytes
    -rw-r–r– 1 root root 0 Aug 28 15:54
    memory.move_charge_at_immigrate
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.numa_stat
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.oom_control
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.soft_limit_in_bytes
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.stat
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.swappiness
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.usage_in_bytes
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.use_hierarchy
    -rw-r–r– 1 root root 0 Aug 28 15:54 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 15:54 release_agent
    -rw-r–r– 1 root root 0 Aug 28 15:54 tasks
     
    开首尝试:
        重启系统 (为了确认保障内部存储器的绝望)
        挂载 memcg
        在挂载的 /mnt/cgroup 中开创 组A
        将当前shell 加入到 组A
        不限定组A的内部存款和储蓄器, 压缩内核源码包, 并阅览压缩前后内部存款和储蓄器的浮动
        重复步骤 1 ~ 4
        限制组A的内部存款和储蓄器为 10MB, 再度减少内核源码包, 并观察压缩前后内部存款和储蓄器的变动
     
    # 重启系统
    reboot
    # 挂载 memcg
    mount -t cgroup -o memory memcg /mnt/cgroup
    # 创建 组A
    mkdir /mnt/cgroup/A
    # 将近年来 shell 出席到组A
    echo ¥¥ > /mnt/cgroup/A/tasks
    # 测量检验不限量内部存款和储蓄器时, 内部存款和储蓄器的选取状态, 这里不用linux源码也得以,
    但最佳用个大点的文本夹来收缩, 以便更便于看到内部存款和储蓄器的变化.
    free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/
    > /dev/null; free -m;
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        122       1721          0          9        
    43
    -/+ buffers/cache:         68       1774
    Swap:         3888          0       3888
                 total       used       free     shared    buffers    
    cached
    Mem:          1843       1744         99          0         26      
    1614
    -/+ buffers/cache:        104       1739
    Swap:         3888          0       3888
    # 重启系统
    reboot
    # 挂载 memcg
    mount -t cgroup -o memory memcg /mnt/cgroup
    # 创建 组A
    mkdir /mnt/cgroup/A
    # 将眼下 shell 出席到组A
    echo ¥¥> /mnt/cgroup/A/tasks
    # 限制 组A 的内部存款和储蓄器使用量最大为 10MB
    echo 10M > /mnt/cgroup/A/memory.limit_in_bytes
    # 测量检验限制内部存储器为 10MB 时, 内部存款和储蓄器的行使景况.
    rm -rf linux-source-3.2.tar.gz
    free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/
    > /dev/null; free -m;
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        122       1721          0         10        
    43
    -/+ buffers/cache:         68       1774
    Swap:         3888          0       3888
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        194       1649          0         14        
    48
    -/+ buffers/cache:        131       1712
    Swap:         3888          0       3888
    从上边的结果能够看来限制内部存款和储蓄器是起了效果的.
    不限制内部存款和储蓄器时, tar 压缩前后 buffer + cache 内部存款和储蓄器从 (9MB + 43MB) ==>
    (26MB + 1614MB)  增大了 1588MB
    范围内部存款和储蓄器后, tar 压缩前后 buffer + cache 内部存储器从 (10MB + 43MB) ==>
    (14MB + 48MB)  增大了 9MB
     
    总结
    简言之的执行就开采 cgroup 如此强硬的调节本事(何况配置也很轻松),
    那也就难怪LXC等容器本领能如此有力, 如此流行.
    cgroup 的布署文件过多, 上边的实例中只轻巧利用了中间的几个布局文件,
    尽管想深远摸底 cgroup, 更加好的选取cgroup的话,
    还得找个介绍cgroup配置文件的文书档案来琢磨一下,
    那篇博客提供的剧情还缺乏.

查阅探究

留存 from: and
CGroup…

相关文章