当前位置: 欧洲杯竞猜 > 服务器运维 > 正文

欧洲杯竞猜Cgroup和Namespace在测试中的使用,内存

时间:2019-11-14 22:14来源:服务器运维
Linux下CGroup举办CPU、内部存款和储蓄器等能源支配,linuxcgroup 留存 from:   and  CGroup 介绍 CGroup 是 Control Groups 的缩写,是 Linux内核提供的生龙活虎种能够界定、记录、隔开分离进度组 (

Linux下CGroup举办CPU、内部存款和储蓄器等能源支配,linuxcgroup

留存

from:   and 

CGroup 介绍
CGroup 是 Control Groups 的缩写,是 Linux 内核提供的生龙活虎种能够界定、记录、隔开分离进度组 (process groups) 所使用的财力财富 (如 cpu memory i/o 等等) 的编写制定。2006 年步入 Linux 2.6.24 内核,CGroups 不是全新创造的,它将经过管理从 cpuset 中脱离出来,笔者是 Google 的 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 卡塔 尔(英语:State of Qatar)。比方:memory子系统可以为进度组织设立定三个memory使用上限,后生可畏旦进度组使用的内部存款和储蓄器到达限额再申请内部存款和储蓄器,就能够出发OOM(out of memory卡塔 尔(英语:State of Qatar)。
2卡塔 尔(英语:State of Qatar)进度组的预先级调节(Prioritization 卡塔尔国。比如:能够采用cpu子系统为某些进度组分配一定cpu share。
3卡塔 尔(英语:State of Qatar)记录进程组使用的财富数量(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卡塔 尔(英语:State of Qatar)层级(hierarchy卡塔尔国。调节族群能够团体成 hierarchical 的方式,既大器晚成颗调整族群树。调控族群树上的子节点调节族群是父节点调节族群的孩子,世袭父调整族群的一定的性质;
4卡塔尔子系统(subsystem卡塔尔。二个子系统正是叁个能源调节器,譬如 cpu 子系统正是决定 cpu 时间分配的三个调控器。子系统必需附加(attach卡塔 尔(阿拉伯语:قطر‎到二个层级上技艺起效率,一个子系统附加到有个别层级今后,那些层级上的具有调控族群都受到这么些子系统的支配。

相互关系
1卡塔 尔(英语:State of Qatar)每回在系统中开创新层级时,该种类中的全数任务都以拾叁分层级的私下认可cgroup(我们誉为 root cgroup,此 cgroup 在开创层级时自动创造,前面在该层级中开创的 cgroup 都以此 cgroup 的后生卡塔 尔(英语:State of Qatar)的始发成员;
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(在多核系统卡塔 尔(英语:State of Qatar)和内部存款和储蓄器节点。
devices -- 这么些子系统可允许也许谢绝 cgroup 中的职责访谈设备。
freezer -- 这些子系统挂起也许复苏 cgroup 中的职责。
memory -- 那么些子系统设定 cgroup 中职责选择的内部存款和储蓄器约束,并自动生成由那一个职务使用的内部存款和储蓄器资源报告。
net_cls -- 那一个子系统应用阶段识别符(classid卡塔 尔(英语:State of Qatar)标识网络数据包,可允许 Linux 流量调节造进度序(tc卡塔 尔(英语:State of Qatar)识别从现实 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:子系统的特性及其属性值

用作叁个正值做着容器项目标人,知道容器技艺是借助Cgroup和Namespace来完成的。在容器中,cpu和内部存款和储蓄器能源是采纳Cgroup来调整,PID、IPC、网络等财富是通过Namespace来划分。在前后相继还没配备在容器的情状下,大家仍是可以够运用Cgoup和Namespace来组织场景完毕都部队分特别测验,如运用Cgroup的财富支配机能做能源满载的测量试验;利用Namespace的财富隔开分离天性做一些互联网极其测量检验而不影响此外程序的周转。

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卡塔 尔(阿拉伯语:قطر‎,挂载目的。

Cgroup介绍

Cgroup是张开分组化管理的Linux内核作用,具体的能源管理是通过子系统来成功的。能够领略为子系统就是财富调节器,各个子系统正是三个能源的分配器,比方cpu子系统是调节cpu时间分配的,使用办法如下

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 ,修正配置文件后四个劳务需求重启,且顺序不能够错。

安装(ubuntu)

#apt-get install cgroup-bin

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

主题命令

cgclassify -- cgclassify命令是用来将运转的职责移动到八个可能七个cgroup。

cgclear -- cgclear 命令是用来删除层级中的全体cgroup。

cgconfig.conf -- 在cgconfig.conf文件中定义cgroup。

cgconfigparser -- cgconfigparser命令剖析cgconfig.conf文件和并挂载层级。

cgcreate -- cgcreate在层级中创设新cgroup。

cgdelete -- cgdelete命令删除钦命的cgroup。

cgexec -- cgexec命令在钦点的cgroup中运行任务。

cgget -- cgget命令展现cgroup参数。

cgred.conf -- cgred.conf是cgred服务的布局文件。

cgrules.conf -- cgrules.conf 包括用来调控曾几何时职责术语有些 cgroup的平整。

cgrulesengd -- cgrulesengd 在 cgroup 中发布职分。

cgset -- cgset 命令为 cgroup 设定参数。

lscgroup -- lscgroup 命令列出层级中的 cgroup。

lssubsys -- lssubsys 命令列出含有钦点子系统的层级

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约束在了第多少个基本上,且对第八个着力的使用范围在四分之二。

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

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

子系统验证

能够接收lssubsys -a来列出系统援救多少种子系统,和:比方cpu是决定cpu时间片的,memory是调控内部存款和储蓄器使用的

#lssubsys -a

cpuset

cpu,cpuacct

memory

devices

freezer

net_cls,net_prio

blkio

perf_event

hugetlb

重要的二种子系统验证如下:

blkio 这几个子系统装置限制种种块设备的输入输出调控。例如:磁盘,光盘以致usb等等。

cpu 那个子系统应用调解程序为cgroup职责提供cpu的探问。

cpuacct 产生cgroup任务的cpu能源报告。

cpuset 倘使是多中央的cpu,那些子系统会为cgroup任务分配单独的cpu和内部存款和储蓄器。

devices 允许或谢绝cgroup义务对配备的拜候。

freezer 暂停和回复cgroup职分。

memory 设置各类cgroup的内部存款和储蓄器节制以至发生内部存储器财富报告。

net_cls 标识每种网络包以供cgroup方便使用。

ns 名称空间子系统

perf_event: 扩大了对每group的监测追踪的力量,即能够监测归于有些特定的group的富有线程以至运维在特定CPU上的线程

要为Cgroup分配约束的能源,首先要挂载子系统,然后才有调节组,比方想要对目的程序进行内存约束,那就须要挂载memory子系统

行使lssubsys -am来展现已经挂载的子系统

#lssubsys -am

cpuset /sys/fs/cgroup/cpuset

cpu,cpuacct /sys/fs/cgroup/cpu,cpuacct

memory /sys/fs/cgroup/memory

devices /sys/fs/cgroup/devices

freezer /sys/fs/cgroup/freezer

net_cls,net_prio /sys/fs/cgroup/net_cls,net_prio

blkio /sys/fs/cgroup/blkio

perf_event /sys/fs/cgroup/perf_event

hugetlb /sys/fs/cgroup/hugetlb

能够手动挂载只怕卸载子系统,如进行umount /sys/fs/cgroup/memory,memory子系统就被卸载了,此时手动实行# mount -t cgroup -o memory memory /sys/fs/cgroup/memory就又挂载上了。
要保管需求的子系统都挂上了,不然成立调整组的时候会报错 is not mounted

#cgcreate -g memory,cpu:/hzmali_test

cgcreate: can't create cgroup /hzmali_test: Cgroup one of the needed subsystems is not mounted

怎么样创立control group(即供给财富管理的组卡塔尔国呢, 这里用cgcreate命令,当然也许有任何方法, 如cgconfig.conf等

#cgcreate -g memory,cpu:/hzmali_test

此地有个举足轻重特色:二个组能够而且做四个财富的界定,如这里自个儿还要节制了memory和cpu,然后memory和cpu子系统目录下会自动生成这些组的目录和些文件,如memory

#/sys/fs/cgroup/memory/hzmali_test$ ls -lrt

-rw-r--r-- 1 root root 0 Jul 26 20:56 tasks

-rw-r--r-- 1 root root 0 Jul 26 20:56 notify_on_release

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.use_hierarchy

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.usage_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.swappiness

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.stat

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.soft_limit_in_bytes

---------- 1 root root 0 Jul 26 20:56 memory.pressure_level

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.oom_control

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.numa_stat

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.move_charge_at_immigrate

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.max_usage_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.limit_in_bytes

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.usage_in_bytes

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.tcp.usage_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.tcp.max_usage_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.tcp.limit_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.tcp.failcnt

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.slabinfo

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.max_usage_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.limit_in_bytes

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.failcnt

--w------- 1 root root 0 Jul 26 20:56 memory.force_empty

-rw-r--r-- 1 root root 0 Jul 26 20:56 memory.failcnt

-rw-r--r-- 1 root root 0 Jul 26 20:56 cgroup.procs

--w--w--w- 1 root root 0 Jul 26 20:56 cgroup.event_control

-rw-r--r-- 1 root root 0 Jul 26 20:56 cgroup.clone_children

文本过多,选多少个首要的讲下:

  • tasks 能够将想要限定财富的进程都加到那个文件中
  • memory.max_usage_in_bytes内部存款和储蓄器的最大使用量,用来界定能源
    -memory.soft_limit_in_bytes 和 memory.limit_in_bytes 的反差是,这几个约束并不会堵住进度使用超越限额的内部存款和储蓄器,只是在系统内部存款和储蓄器不足时,会事先回笼超越限额的经过占用的内部存款和储蓄器,使之向限制值围拢。
  • memory.oom_control
    包蕴二个申明(0或1卡塔尔国来展开大概关闭cgroup的OOM killer。如若翻开(1卡塔尔,任务假如尝试申请内部存款和储蓄器当先允许,就能够被系统OOM killer终止。OOM killer在每种使用cgroup内部存储器子系统中都是暗许开启的。要是急需关闭,则能够向memory.oom_control文件写入1:

# echo 1 > /sys/fs/cgroup/memory.oom_control
若是OOM killer关闭,那么进度尝试申请的内部存款和储蓄器超越允许,那么它就能够被中断,直到额外的内部存款和储蓄器被放出

  • memory.mem.usage_in_bytes 当前经过内存用量,因为前天尚未经过加到组里,就是0了
  • memory.mem.failcnt体现内存达到约束值的次数

cgroup实例深入分析(手工业动态验证卡塔 尔(英语:State of Qatar)

过来配置文件/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查看能源消耗。

Cgroup文档

Cgroup的运用细节,子系统和参数设置都得以可以在中找到,世袭等风味由于篇幅所限,能够看下文书档案

1卡塔 尔(英语:State of Qatar)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的进度号。

Cgroup实战

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

内部存储器使用获得了平价调整。

内存限定测量检验

用调节组约束目的程序内部存款和储蓄器使用为1000000 byte,当然,须要root实践
echo "1000000" >memory.limit_in_bytes

日常更推荐用cgset来设置数值

cgset -r memory.limit_in_bytes=1000000 hzmali_test

下一场构造三个吃内部存款和储蓄器的主次,每运营三回内部存储器使用就小幅加多

#vim memtest.sh

x="hahaha"

while [ True ];do

x=$x$x$x$x$x$x$x$x$x$x

sleep 1

done;

然后运路程序,并将经过pid写入mem上面调控组的tasks中

#./memtest.sh &

[1] 17638

# echo 17638 > /sys/fs/cgroup/memory/hzmali_test/tasks

动用cgclassify 能够将运维中的进度加到task中,假设调控组有多个能源的主宰,使用命令会比echo方便广大

cgclassify -g mem:hzmali_test 17638

接下来那货就在任何时间任何地点占内部存款和储蓄器,由于并未有安装disable oom killing,所以最终会oom被kill掉

# cat /sys/fs/cgroup/memory/hzmali_test/memory.usage_in_bytes

966656

# cat /sys/fs/cgroup/memory/hzmali_test/memory.usage_in_bytes

978944

# cat /sys/fs/cgroup/memory/hzmali_test/memory.usage_in_bytes

995328

#

[1] Killed ./memtest.sh

3卡塔 尔(英语:State of Qatar)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

CPU节制测量试验

自个儿的机器上有2个核

%Cpu0 : 0.0 us, 0.3 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

%Cpu1 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

写个死循环脚本cpu_test.sh跑一下

x=a

while [ True ];do

x=$x

done;

风姿洒脱旦笔者不想把机器跑死,这里想要约束组里的历程的CPU使用,有2种做法
1.在cpu子系统中决定cpu调节的分配的定额
先看下当前cpu分配景况

cat /sys/fs/cgroup/cpu/hzmali_test/cpu.cfs_quota_us

-1

cat /sys/fs/cgroup/cpu/hzmali_test/cpu.cfs_period_us

100000

-1象征无界定,这里改为50000,即相对于cpu.cfs_period_us 来说为50000/100000约占1个核50%的cpu时间

#./cpu_test.sh &

[1] 17709

# echo 17709 >/sys/fs/cgroup/cpu/hzmali_test/tasks

或许直接利用命令cgexec实施

cgexec -g cpu:hzmali_test ./cpu_test.sh

top了下基本上便是在二分之一的cpu占用

%Cpu0 : 50.5 us, 0.0 sy, 0.0 ni, 49.5 id, 0.0 wa, 0.0 hi, 0.0 si,0.0 st

%Cpu1 : 0.0 us, 0.3 sy,0.0 ni, 99.7 id,0.0 wa, 0.0 hi,0.0 si, 0.0 st

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME COMMAND17709 root 20 0 25368 20201764 R 50.2 0.1 1:14.74 bash

2.在cpuset调控物理cpu的抽成
时下利用了下面的点子后,大家开掘经过的CPU使用都在Cpu0上,此次希望只用Cpu1来跑这么些小程序
所以把调节组也加到cpuset

# cgcreate -g cpuset:/hzmali_test

看一下现行反革命应用的cpu的安装

# cat /sys/fs/cgroup/cpuset/hzmali_test/cpuset.cpus

0-1

改为只用Cpu1,输入以下命令

# echo 1 > /sys/fs/cgroup/cpuset/hzmali_test/cpuset.cpus

# echo 17709 > /sys/fs/cgroup/cpuset/hzmali_test/tasks

或用命令

# cgset -r cpuset.cpus='1' hzmali_test

# cgclassify -g cpu,cpuset:hzmali_test 17709

top一下,内部存储器的行使从CPU0到CPU1了

%Cpu0 : 0.0 us, 0.0 sy,0.0 ni, 99.7 id,0.0 wa, 0.0 hi,0.3 si, 0.0 st

%Cpu1 : 50.3 us, 0.0 sy, 0.0 ni, 49.7 id, 0.0 wa, 0.0 hi, 0.0 si,0.0 st

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME COMMAND

17709 root 200 25368 2108 2076 R 50.10.1 8:56.78 bash

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 1000 的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总能源的 51%
        挂载 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个核上都发出 百分百的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使用率相加都是 百分之百,
    鉴于自己测量试验的微处理机是双核, top所见到的CPU最大使用率是 200%, 所以和预期风流倜傥致, A和B组各占CPU总财富的 1/4
     
    实例2 - A group 占用全部CPU财富的 2/3, B group 占用全体CPU能源的 50%
        情形同 实例1, 不再重复挂载 cgroup 文件系统, 也不在重新营造 A 和 B
        A group 的 cpu.shares 文件不改变, 值为 1024
        B group 的 cpu.shares 文件中的值改为 512, 那样, 相当于B占用CPU总能源的 54% (因为 512 / (512 1024) = 56%)
        同实例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
    # 在第4个 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总数的 1/4 左右.
     
    实例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
    # 再张开首个 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
    # 在第4个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...

IO限定测量检验

用dd对硬盘进行写操作

# dd if=/dev/sda of=/dev/null &

打开iotop看下IO速度

Total DISK READ : 100.37M/s | Total DISK WRITE : 0.00 B/s

Actual DISK READ: 100.37 M/s | Actual DISK WRITE: 0.00 B/s

TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND

18081 be/4 root 100.37 M/s 0.00 B/s 0.00 % 1.34 % ddif=/dev/sda of=/dev/null

为了调控IO速度,在blkio上创立调节组

# cgcreate -g blkio:/hzmali_test

翻开下硬盘号

# ls -l /dev/sda

brw-rw---- 1 root disk 8, 0 Jul 25 22:46 /dev/sda

安装硬盘号和呼应的读取速度约束,然后实施同风流洒脱的一声令下

# cgset -r blkio.throttle.read_bps_device="8:0 1000000" hzmali_test

# cgexec -g blkio:hzmali_test "dd if=/dev/sda of=/dev/null"

用iotop查看下,速度果然就减低到1M以下

Total DISK READ : 996.55 K/s | Total DISK WRITE : 0.00 B/s

Actual DISK READ: 996.55 K/s | Actual DISK WRITE: 0.00 B/s

TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND

18188 be/4 root 996.55 K/s0.00 B/s 0.00 % 99.99 % dd if=/dev/sda of=/dev/null

 

编辑:服务器运维 本文来源:欧洲杯竞猜Cgroup和Namespace在测试中的使用,内存

关键词: 欧洲杯竞猜