澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:Cgroup和Namespace在测试中的

2019-06-08 作者:服务器运维   |   浏览(136)

Linux下CGroup举行CPU、内部存款和储蓄器等财富支配,linuxcgroup

留存

from:   and 

CGroup 介绍
CGroup 是 Control Groups 的缩写,是 Linux 内核提供的1种能够界定、记录、隔断进度组 (process groups) 所使用的财力能源 (如 cpu memory i/o 等等) 的体制。2007 年进来 Linux 贰.陆.二四 内核,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 )。譬喻:memory子系统可认为进程组织设立定三个memory使用上限,一旦进程组使用的内部存款和储蓄器到达限额再提请内存,就能出发OOM(out of memory)。
2)进程组的先行级调整(Prioritization )。比方:能够动用cpu子系统为有些进度组分配一定cpu share。
三)记录进度组使用的能源数量(Accounting )。例如:能够采取cpuacct子系统记录某些进度组使用的cpu时间
④)进度组隔断(Isolation)。比方:使用ns子系统能够使分化的进度组使用差别的namespace,以落成隔绝的目标,差别的进度组有各自的进程、网络、文件系统挂载空间。
伍)进度组决定(Control)。譬喻:使用freezer子系统能够将经过组挂起和苏醒。

CGroup 辅助的公文连串
表 一. 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 相关概念解释
一)任务(task)。在 cgroups 中,职分正是系统的1个经过;
二)调节族群(control group)。调节族群正是1组依照某种标准划分的历程。Cgroups 中的财富支配都以以调节族群为单位贯彻。贰个经过能够进入到有些控制族群,也从二个进度组迁移到另1个调控族群。一个进度组的进度能够运用 cgroups 以调整族群为单位分配的财富,同期遭到 cgroups 以调整族群为单位设定的范围;
3)层级(hierarchy)。调控族群能够协会成 hierarchical 的款型,既壹颗调节族群树。调控族群树上的子节点调节族群是父节点调节族群的儿女,承袭父调整族群的一定的习性;
四)子系统(subsystem)。2个子种类便是一个财富调节器,例如 cpu 子系统便是决定 cpu 时间分配的一个调整器。子系统必须叠加(attach)到一个层级上才具起成效,1个子类别附加到有个别层级以往,那一个层级上的有所调节族群都受到这么些子系统的决定。

互相关系
壹)每一回在系统中创设新层级时,该类别中的全部职分都以13分层级的暗许cgroup(大家誉为 root cgroup,此 cgroup 在创造层级时自动创设,后边在该层级中开创的 cgroup 都是此 cgroup 的后生)的启幕成员;
2)三个子系统最四只可以叠合到三个层级;
三)1个层级能够增大四个子系统;
四)二个职责能够是多少个 cgroup 的积极分子,然而那个 cgroup 必须在差别的层级;
5)系统中的进度(职责)成立子进程(职分)时,该子职责自动产生其父进度所在 cgroup 的成员。然后可依据须要将该子任务移动到不一致的 cgroup 中,但开头时它连接承袭其父义务的 cgroup。

CGroup 介绍

CGroup 是 Control Groups 的缩写,是 Linux 内核提供的1种能够限制、记录、隔绝进程组 (process groups) 所使用的财力资源 (如 cpu memory i/o 等等) 的机制。200柒 年进入 Linux 2.陆.二四 内核,CGroups 不是斩新创制的,它将经过管理从 cpuset 中剥离出来,笔者是 谷歌(Google) 的 Paul Menage。CGroups 也是 LXC 为促成虚拟化所选拔的能源处理花招。

重点介绍Linux下, 假诺对进度的CPU和内部存款和储蓄器能源的应用意况进行调控的措施。

转自:

图 1. CGroup 层级图

图 1 所示的 CGroup 层级关系显得,CPU 和 Memory 七个子系统有温馨单身的层级连串,而又经过 Task Group 获得关联关系。

CGroup 特点
在 cgroups 中,义务正是系统的1个历程。
调节族群(control group)。调整族群正是一组根据某种标准划分的进度。Cgroups 中的财富支配都是以调整族群为单位落到实处。一个历程能够投入到有个别调控族群,也从三个进度组迁移到另一个调控族群。2个进度组的长河能够行使 cgroups 以调控族群为单位分配的能源,同不常间受到 cgroups 以调控族群为单位设定的限定。
层级(hierarchy)。控制族群可以团体成 hierarchical 的花样,既1颗调节族群树。调控族群树上的子节点调控族群是父节点调整族群的儿女,承袭父调节族群的特定的质量。
子系统(subsytem)。三个子种类正是2个能源调控器,比如 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 中生成的数据包。

CGroup 作用及组成

CGroup 是将轻便进度张开分组化管理的 Linux 内核功用。CGroup 本人是提供将经过打开分组化管理的意义和接口的基础结构,I/O 或内部存款和储蓄器的分红调整等切实的能源管理功效是由此那个职能来贯彻的。这个实际的能源管理职能称为 CGroup 子系统或调整器。CGroup 子系统有决定内存的 Memory 调节器、调整过程调节的 CPU 调节器等。运维中的内核可以选拔的 Cgroup 子系统由/proc/cgroup 来确认。

CGroup 提供了三个 CGroup 虚拟文件系统,作为开始展览分组管理和各子系统装置的用户接口。要动用 CGroup,必须挂载 CGroup 文件系统。那时通过挂载选项钦赐使用哪个子系统。

Cgroups提供了以下职能:
    一.限制进度组能够选取的财富数量(Resource limiting )。比方:memory子系统可以为进程组织设立定二个memory使用上限,壹旦过程组使用的内部存款和储蓄器达到限额再提请内部存款和储蓄器,就能够出发OOM(out of memory)。
    二.经过组的事先级调控(Prioritization )。比方:能够采取cpu子系统为有个别进度组分配一定cpu share。
    三.笔录进程组使用的能源数量(Accounting )。例如:能够使用cpuacct子系统记录有个别进度组使用的cpu时间
    肆.进度组隔开(Isolation)。举个例子:使用ns子系统能够使区别的进程组使用分歧的namespace,以高达隔开的目标,不一致的进度组有各自的进程、互连网、文件系统挂载空间。
    5.进度组调整(Control)。比如:使用freezer子系统能够将经过组挂起和还原。

众多时候要求测试程序在能源受限意况下的表现,普通的做法大概是连连对系统加压使能够分配给目的程序的能源减少,换另三个思路考虑,能够品味限制分配给目的程序的财富总量,使得机器状态不奇怪的情景下让程序财富利用到达饱和。

 

最主要介绍Linux下, 如若对经过的CPU和内部存款和储蓄器财富的施用情形举行支配的方式。

图 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 接济的文本系列

用作三个正值做着容器项目标人,知道容器本领是借助Cgroup和Namespace来完成的。在容器中,cpu和内部存款和储蓄器能源是应用Cgroup来调节,PID、IPC、互联网等能源是经过Namespace来划分。在先后尚未配置在容器的事态下,大家仍是可以够选择Cgoup和Namespace来布局场景完毕都部队分极其测试,如使用Cgroup的财富支配效用做能源满载的测试;利用Namespace的能源隔断性子做一些网络特别测试而不影响其余程序的周转。

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

 

补充:

  1. chrt 也足以直接钦定一条命令, 并设置那条命令的事先级的调解攻略, 具体查看 chrt --help
  2. 查看三个进度的调整攻略, 除了采取 chrt 命令之外, 还是能够 cat /proc/<PID>/sched

 

 

一.安顿对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"     }   }

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

cpu.cfs_period_us和cpu.cfs_quota_us来界定该组中的全部进度在单位时间里能够动用的cpu时间。这里的cfs是全然公平级调动度器的缩写。cpu.cfs_period_us就是光阴周期(微秒),默以为一千00,即百阿秒。cpu.cfs_quota_us正是在那之间内可选拔的cpu时间(皮秒),私下认可-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就能够限定在双核上完全接纳)。
cpuset:cpu绑定
小编们限制该组只幸亏0一共二个超线程上运营。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=25陆M。而设置swappiness为0是为了让操作系统不会将MySQL的内部存款和储蓄器无名页沟通出去。
blkio:BLOCK IO限额
blkio.throttle.read_bps_device="8:0 524288"; #每秒读数据上限
blkio.throttle.write_bps_device="8:0 524288"; #每秒写多少上限
里面八: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都以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 
注:共分为二个部分,分别为索要限制的实例,限制的剧情(如cpu,memory),挂载目的。

表 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介绍

Cgroup是开始展览分组化管理的Linux内核功效,具体的能源管理是通过子系统来成功的。能够清楚为子系统就是财富调节器,各样子系统正是贰个财富的分配器,举个例子cpu子系统是决定cpu时间分配的,使用办法如下

实时进程的CPU调控

所谓的实时进度, 约等于那1个对响应时间须要比较高的进度.

那类进程须要在界定的年月内部管理理用户的呼吁, 由此, 在限制的这段时光内, 必要占用全体CPU财富, 并且不可能被别的进度打断.

在这种状态下, 尽管实时进度中出现了近似死循环之类的气象, 就能招致整个系列无响应.

因为实时进程的CPU优先级高, 并且未管理完以前是不会放出CPU财富的.

 

由此, 内核中需求有1种办法来界定实时进程的CPU财富占用.

 

CPU资源支配

各类进程能够攻陷CPU多久, 哪一天能够攻克CPU是和连串的调整密切相关的.

Linux系统中有二种调整战术, 各样调治战略有其适用的光景, 也很难说哪个种类调解计谋是最优的.

Linux的调整战略能够参见代码: include/linux/sched.h

澳门新萄京官方网站 1

/*
 * 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

澳门新萄京官方网站 2

 

Linux 系统也提供了修改调治攻略的指令和系列调用接口.

调用接口请查询相关文书档案, 这里关键介绍一下退换调整计谋的一声令下 - chrt.

澳门新萄京官方网站 3

# 在一个终端中执行
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

澳门新萄京官方网站 4

 

补充:

  1. chrt 也得以直接钦命一条命令, 并设置那条命令的优先级的调整计谋, 具体查看 chrt --help
  2. 翻看八个历程的调节攻略, 除了运用 chrt 命令之外, 还能 cat /proc/<PID>/sched

 

二 使配置生效

[[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 ,更换配置文件后两个服务供给重启,且顺序无法错。

CGroup 相关概念解释

  1. 任务(task)。在 cgroups 中,职务就是系统的七个进度;

  2. 调控族群(control group)。调节族群正是一组根据某种标准划分的历程。Cgroups 中的财富支配都以以调整族群为单位完成。三个进程能够参加到有些调节族群,也从三个进度组迁移到另3个调控族群。3个经过组的进度能够选取cgroups 以调整族群为单位分配的能源,同临时间面前境遇 cgroups 以调控族群为单位设定的范围;

  3. 层级(hierarchy)。调节族群能够团体成 hierarchical 的款型,既一颗调节族群树。调整族群树上的子节点调整族群是父节点调控族群的男女,承接父调整族群的特定的习性;

  4. 子系统(subsystem)。二个子类别正是二个能源调节器,举个例子 cpu 子系统就是决定 cpu 时间分配的3个调节器。子系统必须附加(attach)到多少个层级上才具起效果,三个子体系附加到某些层级今后,这一个层级上的装有控制族群都受到那几个子系统的主宰。

相互关系

  1. 历次在系统中创制新层级时,该体系中的全体职务都以十三分层级的暗许cgroup(大家誉为 root cgroup,此 cgroup 在创建层级时自动创造,前面在该层级中开创的 cgroup 都以此 cgroup 的后裔)的启幕成员;

  2. 贰个子系统最多只可以叠合到一个层级;

  3. 二个层级能够附加多个子系统;

  4. 1个任务可以是几个 cgroup 的分子,然而那个 cgroup 必须在分化的层级;

  5. 系统中的进度(任务)成立子进度(任务)时,该子任务自动造成其父进度所在 cgroup 的分子。然后可依照需求将该子职责移动到分歧的 cgroup 中,但初阶时它总是承接其父任务的 cgroup。

安装(ubuntu)

#apt-get install cgroup-bin

系统总体安装

  1. 拿到当前系统的设置

    sysctl -n kernel.sched_rt_period_us # 实时经过调治的单位CPU时间 一 秒 一千000 sysctl -n kernel.sched_rt_runtime_us # 实时经过在 一 秒中其实占用的CPU时间, 0.九伍秒 950000

以此装置验证实时进程在运转时并不是全然占用CPU的, 每1秒中有0.05秒的时刻足以给别的进度运维.

那样既不会对实时进程的响应时间形成太大的震慑, 也制止了实时进度卡住时产生整个连串无响应.

 

  1. 设置实时进度占用CPU时间

地点的暗中同意设置中, 实时经过占用 玖伍% 的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

 

实时进度的CPU调控

所谓的实时进程, 约等于那一个对响应时间供给相比较高的进度.

那类进度供给在限制的日子内部管理理用户的呼吁, 由此, 在限定的近来内, 供给占用全部CPU能源, 并且不能够被其余进程打断.

在这种状态下, 即使实时进程中出现了类似死循环之类的情状, 就能招致整个种类无响应.

因为实时进程的CPU优先级高, 并且未管理完以前是不会释放CPU财富的.

 

于是, 内核中要求有一种办法来界定实时进程的CPU财富占用.

 

三 运维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

图 1. CGroup 层级图

主干命令

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 命令列出含有钦命子系统的层级

cgroup 中的设置

总体安装是指向全部系统的, 我们也足以经过 cgroup 来对1组经过的CPU能源实行调节.

要是想在 cgroup 中对 sched_rt_period_us 和 sched_rt_runtime_us 实行支配, 必要内核编译选项 CONFIG_RT_GROUP_SCHED=y

查看当前系统的基本编写翻译选项方法如下: (debian 7.陆 系统)

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.陆 暗许未有运行那一个选项, 所以挂载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 文件系统, 开掘多了一个布局文件, 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使用时间的调节.

 

系统一整合体安装

  1. 取妥善前系统的装置

    sysctl -n kernel.sched_rt_period_us # 实时经过调整的单位CPU时间 一 秒 一千000 sysctl -n kernel.sched_rt_runtime_us # 实时经过在 一 秒中实际占用的CPU时间, 0.95秒 960000

以此设置验证实时进程在运作时并不是完全占用CPU的, 每1秒中有0.05秒的年华足以给其余进度运转.

诸如此类既不会对实时进程的响应时间变成太大的影响, 也防止了实时过程卡住时产生整个种类无响应.

 

  1. 设置实时进程占用CPU时间

上边的私下认可设置中, 实时经过占用 玖五% 的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

 

4 财富限制验证

采纳mysqlslap对mysql进行压力测试,看mysql使用财富是不是超过限定

四.一 在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.二 在shell窗口二查看mysql对cpu,内部存储器的利用

看得出:cpu限制在了第捌个为主上,且对第四个中央的行使限制在5/拾。

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

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

澳门新萄京官方网站 5

图 一 所示的 CGroup 层级关系显得,CPU 和 Memory 多个子系统有投机单身的层级连串,而又经过 Task Group 取得关联关系。

子系统验证

能够运用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
    涵盖2个标记(0或一)来拉开只怕关闭cgroup的OOM killer。假设翻开(1),任务固然尝试申请内部存款和储蓄器当先允许,就会被系统OOM killer终止。OOM killer在各类使用cgroup内部存款和储蓄器子系统中都是暗许开启的。倘诺必要关闭,则足以向memory.oom_control文件写入一:

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

  • memory.mem.usage_in_bytes 当前历程内部存款和储蓄器用量,因为以后还未有经过加到组里,就是0了
  • memory.mem.failcnt呈现内存达到限制值的次数

财富支配实例

地方根本介绍资源的部分辩解基础, 上边通过一些实例演示借使因而 cgroup 来支配进度所选择的 CPU和内部存款和储蓄器 财富.

Linux对CPU 和 内部存款和储蓄器的支配有照顾的 cgroup 子系统 cpuset 和 memory

 

cgroup 中的设置

完整安装是对准任何种类的, 我们也能够通过 cgroup 来对一组经过的CPU能源开始展览调节.

1经想在 cgroup 中对 sched_rt_period_us 和 sched_rt_runtime_us 举办调节, 必要内核编写翻译选项 CONFIG_RT_GROUP_SCHED=y

查阅当前系统的基石编写翻译选项方法如下: (debian 柒.陆 系统)

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 七.陆 暗中认可未有运维这一个选项, 所以挂载cgroup之后, 未有设置 sched_rt_period_us 和 sched_rt_runtime_us 的文件

澳门新萄京官方网站 6

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

澳门新萄京官方网站 7

 

果然, 只有cpu.share, 没有 cpu.sched_rt_period_us 和 cpu.sched_rt_runtime_us

不能, 重新编写翻译内核, 编写翻译内核的具体方法参见:  编译Linux内核

为了节约时间, 大家用 make localmodconfig 来创立 .config 文件, 然后修改个中的 CONFIG_RT_GROUP_SCHED=y

下载源码等等参见: 编译Linux内核, 首要步骤如下:

澳门新萄京官方网站 8

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 中, 默认启动的是不是新安装的内核

澳门新萄京官方网站 9

 

开发银行到新水源, 再度翻开内核选项 CONFIG_RT_GROUP_SCHED 是还是不是启用

cat /boot/config-`uname -r` | grep -i rt_group
CONFIG_RT_GROUP_SCHED=y       # 已启用

 

再一次挂载 cgroup 文件系统, 开采多了3个布局文件, cpu.rt_period_us 和 cpu.rt_runtime_us

澳门新萄京官方网站 10

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

澳门新萄京官方网站 11

 

通过配备 cpu.rt_period_us 和 cpu.rt_runtime_us 就可以对 cgroup 中的进度组中的实时进程张开 CPU使用时间的调整.

 

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查看资源消耗。

CGroup 特点

在 cgroups 中,职责就是系统的1个进程。

调整族群(control group)。调整族群正是一组依据某种规范划分的进度。Cgroups 中的能源支配都是以调整族群为单位贯彻。2个进程可以参预到某些调整族群,也从3个进度组迁移到另一个调控族群。多少个经过组的长河可以接纳cgroups 以调控族群为单位分配的财富,相同的时间遭到 cgroups 以调节族群为单位设定的限量。

层级(hierarchy)。调节族群能够组织成 hierarchical 的花样,既1颗调控族群树。调整族群树上的子节点调整族群是父节点调控族群的男女,承接父调节族群的一定的质量。

子系统(subsytem)。3个子种类正是贰个财富调整器,举个例子 cpu 子系统正是决定 cpu 时间分配的3个调节器。子系统必须叠合(attach)到3个层级上工夫起成效,三个子系统附加到某些层级以往,这几个层级上的全数调节族群都受到这几个子系统的操纵。

Cgroup文档

Cgroup的应用细节,子系统和参数设置都能够能够在中找到,承继等特点由于篇幅所限,能够看下文书档案

实例: cgroup 中对内部 *子cgroup* 的CPU能源支配

对各个 *子cgroup* 的CPU占用率实行调控重大注重每种 *子cgroup* 的 cpu.shares 文件

直接用试验进度来讲话, 当中加入了某个注释.

# 安装需要的软件
apt-get install stress     # 让CPU达到 100% 的压力工具
apt-get install sysstat    # 查看系统CPU, 内存, 磁盘, 网络等资源使用情况的工具

 

财富支配实例

上边根本介绍财富的片段争论功底, 上面通过一些实例演示若是因此 cgroup 来调整进度所运用的 CPU和内部存款和储蓄器 能源.

Linux对CPU 和 内存的主宰有相应的 cgroup 子系统 cpuset 和 memory

 

壹)cpu限制实例

范围mysql使用2个核,如第三个核,且对该核的使用不超过百分之五十
[[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

其间:2881九为mysqld的进度号。

子系统的介绍

blkio   -- 这几个子系统为块设备设定输入/输出限制,比方物理设备(磁盘,机械硬盘,USB 等等)。
cpu     -- 那个子系统采用调治程序提供对 CPU 的 cgroup 任务访问。
cpuacct -- 这些子系统自动生成 cgroup 中职分所运用的 CPU 报告。
cpuset  -- 那么些子系统为 cgroup 中的职责分配独立 CPU(在多核系统)和内存节点。
devices -- 这么些子系统可允许也许拒绝 cgroup 中的任务访问设备。

freezer -- 这么些子系统挂起或然复苏 cgroup 中的义务。
memory  -- 这一个子系统设定 cgroup 中职务接纳的内部存款和储蓄器限制,并自动生成由那么些任务使用的内部存款和储蓄器能源报告。
net_cls -- 这一个子系统运用阶段识别符(classid)标识互连网数据包,可允许 Linux 流量调整造进度序(tc)识别从实际 cgroup 中变化的数据包。

CGroup 应用架构

Cgroup实战

实例一 - 暗中认可情形, A 和 B 各占CPU总财富的 二分一
  1. 挂载 cgroup 文件系统 (注意加上 -o cpu 的选料)
  2. 在 cgroup中创建 2个子cgroup A 和 B
  3. 暗中认可处境下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都是 拾2四
  4. 在 A 和 B 中用 stress 工具使其 CPU占用率达到 百分之百
  5. top 命令查看 A 和 B 中经过分别占有的 CPU (应该都是 5/十)

 

# 挂载 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使用率达到 100%
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个核上都产生 100% 的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组中的 3个stress 进程的CPU使用率相加都以 百分百,

鉴于自家测试的计算机是双核, top所看到的CPU最大使用率是 200%, 所以和预期一致, A和B组各占CPU总财富的 四分之二

 

实例: cgroup 中对内部 *子cgroup* 的CPU能源支配

对各个 *子cgroup* 的CPU占用率进行支配器重借助种种 *子cgroup* 的 cpu.shares 文件

一贯用试验进度来发话, 当中插手了有的注释.

# 安装需要的软件
apt-get install stress     # 让CPU达到 100% 的压力工具
apt-get install sysstat    # 查看系统CPU, 内存, 磁盘, 网络等资源使用情况的工具

 

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

范围mysql使用内部存款和储蓄器为不超过51二M
跑三个消耗内部存款和储蓄器脚本

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

内部存款和储蓄器使用获得了有效调控。

图 二. CGroup 标准应用架构图

内部存款和储蓄器限制测试

用调整组限制指标程序内存使用为一千000 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

实例二 - A group 占用全体CPU能源的 2/三, B group 占用全部CPU财富的 1/三
  1. 条件同 实例一, 不再重复挂载 cgroup 文件系统, 也不在重建 A 和 B
  2. A group 的 cpu.shares 文件不改变, 值为 十贰4
  3. B group 的 cpu.shares 文件中的值改为 51二, 那样, 也便是B占用CPU总财富的 1/三 (因为 51二 / (51贰 10二4) = 1/三)
  4. 同实例一, 通过二个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

# 在第3个 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 组中的3个进程占用了CPU总数的 2/三 左右, B组中的二个进度占用了CPU总的数量的 1/三 左右.

 

实例1 - 暗中同意景况, A 和 B 各占CPU总财富的 2/肆
  1. 挂载 cgroup 文件系统 (注意加上 -o cpu 的选项)
  2. 在 cgroup中创建 2个子cgroup A 和 B
  3. 暗许处境下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都是 拾二4
  4. 在 A 和 B 中用 stress 工具使其 CPU占用率达到 百分百
  5. top 命令查看 A 和 B 中经过分别攻陷的 CPU (应该都是 四分之二)

 

澳门新萄京官方网站 12

# 挂载 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使用率达到 100%
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个核上都产生 100% 的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 进程

澳门新萄京官方网站 13

能够看到, A和B组中的 1个stress 进度的CPU使用率相加都以 百分百,

由于本人测试的电脑是双核, top所见到的CPU最大使用率是 200%, 所以和预期一致, A和B组各占CPU总财富的 十三分之伍

 

三)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 
注一:4503三为dd的进程号
注②:八:0对应主设备号和副设备号,能够经过ls -l /dev/sda查看
[[email protected] ~]# ls -l /dev/sda 
brw-rw----. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

澳门新萄京官方网站 14

如图 二 所示,CGroup 能力能够被用来在操作系统底层限制物理能源,起到 Container 的成效。图中每二个 JVM 进度对应多个 Container Cgroup 层级,通过 CGroup 提供的各种子系统,能够对每三个 JVM 进度对应的线程品级进行物理限制,这几个限制包涵CPU、内存等等多数门类的财富。下一部分会切实对应用程序进行 CPU 能源隔开分离进行出现说法。

CPU限制测试

作者的机器上有3个核

%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使用,有贰种做法
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

-一代表无界定,这里改为五千0,即相对于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上,本次希望只用Cpu一来跑这么些小程序
于是把调控组也加到cpuset

# cgcreate -g cpuset:/hzmali_test

看一下现行反革命应用的cpu的设置

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

0-1

改为只用Cpu壹,输入以下命令

# 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到CPU一了

%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

实例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 都钦赐到一个CPU上后的图景

  1. 卸载当前的 cgroup
  2. 双重挂载 cgroup 文件系统, 并钦命 -o cpuset
  3. 钦点 A 的概略CPU为 0 (双核CPU的种种核编号分别是 CPU0, CPU1)
  4. 指定 B 的物理CPU也为 0
  5. 再也 实例壹 中的步骤, 观望产生的变动

 

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

# 再打开第3个 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 二(意思是在二个CPU上运行), 可是出于A和B都只绑定了CPU0,

就此就算是双核的机械, 它们所占用的CPU总的数量却唯有 百分之百, 而不是实例壹 中的 200%.

 

1旦将B组的情理CPU绑定到CPU1, 那么相应具备 stress 的长河都挤占 5/10, CPU财富的总数变为 200%.

下边将B组的情理CPU绑定为CPU一, 看看结果是还是不是和大家的意料同样.

# 在 B组的 shell 窗口中执行以下命令
echo 1 > /mnt/cgroup/B/cpuset.cpus
cat /mnt/cgroup/B/cpuset.cpus
1
stress -c 2

# 在 A组的 shell 窗口中执行以下命令
stress -c 2

# 在第3个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使用率.

 

实例二 - A group 占用全体CPU财富的 2/叁, B group 占用全体CPU能源的 1/三
  1. 境遇同 实例1, 不再另行挂载 cgroup 文件系统, 也不在重建 A 和 B
  2. A group 的 cpu.shares 文件不改变, 值为 十贰肆
  3. B group 的 cpu.shares 文件中的值改为 512, 那样, 相当于B占用CPU总财富的 1/三 (因为 512 / (51二 拾24) = 1/三)
  4. 同实例1, 通过三个shell窗口, 分别是 A 和 B 的CPU使用率高达 百分百, 然后经过 top 查看CPU使用处境

 

澳门新萄京官方网站 15

# 在 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

# 在第3个 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 进程

澳门新萄京官方网站 16

很了解, A 组中的三个进程占用了CPU总数的 2/三 左右, B组中的2个经过占用了CPU总数的 1/3 左右.

 

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
# 展开另3个极限
ps -ef | grep sleep  # 寻找 sleep 1000 的pid, 这里若是是 123肆
chrt -p 1234         # 能够查阅 pid=123四 的进度的 调整计策, 输入如下:
      pid 1234's current scheduling policy: SCHED_OTHER
      pid 1234's current scheduling priority: 0
chrt -p -f 10 1234   # 修改调解计策为 SCHED_FIFO, 并且优先级为十
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能源的.
 
因此, 内核中需求有1种方法来限制实时进度的CPU能源占用.
 
系统完整安装

  1. 赢稳妥前系统的安装
    sysctl -n kernel.sched_rt_period_us   # 实时经过调节的单位CPU时间 1秒
    1000000
    sysctl -n kernel.sched_rt_runtime_us  # 实时经过在 一秒中实际上据有的CPU时间, 0.九五秒
    950000
    以此装置验证实时进度在运维时并不是截然占用CPU的, 每一秒中有0.0伍秒的小运能够给别的进程运转.
    那般既不会对实时进程的响应时间变成太大的熏陶, 也防止了实时进程卡住时变成整个种类无响应.  
  2. 设置实时进程占用CPU时间
    上边的暗中同意设置中, 实时经过占用 9⑤% 的CPU时间. 假若以为占用的太多或太少, 都是能够调动的.举个例子:
    sysctl -w kernel.sched_rt_runtime_us=900000    # 设置实时进程每壹秒中只占0.九秒的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 七.陆 系统)
    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.六 暗中认可未有运维那些选项, 所以挂载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 文件系统, 发掘多了二个布局文件, 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, 内部存款和储蓄器, 磁盘, 网络等能源选择状态的工具
     
    实例一 - 默许情况, A 和 B 各占CPU总财富的 二分一
        挂载 cgroup 文件系统 (注意加上 -o cpu 的选拔)
        在 cgroup中创建 2个子cgroup A 和 B
        默许景况下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都是 十二四
        在 A 和 B 中用 stress 工具使其 CPU占用率到达 百分百
        top 命令查看 A 和 B 中经过分别占有的 CPU (应该都以 2/4)
     
    # 挂载 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 二 是因为测试机器是双核, 要在1个核上都产生 百分之百的CPU 占用率
    # 此外展开一个 shell 窗口, 并将以此shell 参加到 cgroup B中
    echo ¥¥ > B/tasks  # 将近日的 SHELL 参与到 cgroup B中
    stress -c 2    # 在二个核上都发生 百分之百 的CPU 占用率
    # 再展开2个 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                    
    # 查看那 四 个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组中的 1个stress 进程的CPU使用率相加都以 百分之百,
    由于自个儿测试的计算机是双核, top所见到的CPU最大使用率是 200%, 所以和预期一致, A和B组各占CPU总资源的 10分之5
     
    实例二 - A group 占用全体CPU能源的 2/三, B group 占用全体CPU财富的 1/叁
        情况同 实例壹, 不再重复挂载 cgroup 文件系统, 也不在重建 A 和 B
        A group 的 cpu.shares 文件不改变, 值为 拾二四
        B group 的 cpu.shares 文件中的值改为 51二, 那样, 也就是B占用CPU总财富的 1/三 (因为 51二 / (51二 102肆) = 1/3)
        同实例一, 通过一个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
    # 在第3个 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               
    # 查看那 四 个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 组中的三个进度占用了CPU总数的 2/三 左右, B组中的3个经过占用了CPU总的数量的 1/三 左右.
     
    实例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 都钦定到3个CPU上后的图景
        卸载当前的 cgroup
        再一次挂载 cgroup 文件系统, 并内定 -o cpuset
        钦命 A 的物理CPU为 0 (双核CPU的每种核编号分别是 CPU0, CPU一)
        指定 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-- 一 root root 0 Aug 2八 14:3九 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
    # 再张开第3个 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 二(意思是在三个CPU上运转), 不过由于A和B都只绑定了CPU0,
    于是即使是双核的机器, 它们所占有的CPU总的数量却唯有 百分百, 而不是实例1 中的 200%.
     
    设若将B组的大意CPU绑定到CPU一, 那么应该负有 stress 的长河都据有 四分之二, CPU财富的总数变为 200%.
    上边将B组的物理CPU绑定为CPU一, 看看结果是或不是和大家的意料同样.
    # 在 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
    果不其然, 和预期1致. A组中的 stress 和 B组中的 stress 在各自的情理CPU上都据有了 百分之百 左右的CPU使用率.
     
    实例四 - 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的内存, 压缩内核源码包, 并旁观压缩前后内存的转换
        重复步骤 一 ~ 4
        限制组A的内部存款和储蓄器为 十MB, 再一次减少内核源码包, 并观望压缩前后内部存款和储蓄器的变迁
     
    # 重启系统
    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 的内部存款和储蓄器使用量最大为 十MB
    echo 10M > /mnt/cgroup/A/memory.limit_in_bytes
    # 测试限制内部存款和储蓄器为 拾MB 时, 内部存款和储蓄器的选择情况.
    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 四三MB) ==> (贰陆MB 161四MB)  增大了 158八MB
    界定内部存款和储蓄器后, tar 压缩前后 buffer cache 内部存款和储蓄器从 (10MB 四叁MB) ==> (1四MB 4捌MB)  增大了 9MB
     
    总结
    简单的试验就意识 cgroup 如此庞大的调控技艺(而且配置也很简短), 那也就难怪LXC等容器技能能如此有力, 如此流行.
    cgroup 的布署文件过多, 上面包车型客车实例中只简轻便单利用了当中的多少个布局文件, 借使想深入领悟 cgroup, 更加好的运用cgroup的话,
    还得找个介绍cgroup配置文件的文书档案来钻探一下, 那篇博客提供的剧情还缺少.

查阅商议

留存 from: and CGroup...

cgroup的安装

骨子里安装很轻便,最好实行就是yum间接设置(centos下)

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 对应用的内部存储器的决定

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

 

起来尝试:

  1. 重启系统 (为了保险内部存储器的一尘不染)
  2. 挂载 memcg
  3. 在挂载的 /mnt/cgroup 中开创 组A
  4. 将当前shell 加入到 组A
  5. 不限定组A的内部存款和储蓄器, 压缩内核源码包, 并观看压缩前后内部存款和储蓄器的变动
  6. 再一次步骤 1 ~ 4
  7. 范围组A的内部存款和储蓄器为 10MB, 再度回落内核源码包, 并观察压缩前后内部存款和储蓄器的扭转

澳门新萄京官方网站:Cgroup和Namespace在测试中的使用,Linux资源控制。 

# 重启系统
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 内部存款和储蓄器从 (九MB 四3MB) ==> (26MB 161四MB)  增大了 158捌MB

界定内部存款和储蓄器后, tar 压缩前后 buffer cache 内部存款和储蓄器从 (10MB 四3MB) ==> (14MB 4八MB)  增大了 玖MB

 

实例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 都钦命到2个CPU上后的场合

  1. 卸载当前的 cgroup
  2. 双重挂载 cgroup 文件系统, 并钦定 -o cpuset
  3. 内定 A 的大意CPU为 0 (双核CPU的各种核编号分别是 CPU0, CPU一)
  4. 指定 B 的物理CPU也为 0
  5. 再也 实例一 中的步骤, 观察产生的更动

 

澳门新萄京官方网站 17

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

澳门新萄京官方网站 18

 

如若现身上述失实, 只需求再设置 /mnt/cgroup/A/cpuset.mems 就能够. (参照他事他说加以考察: )

澳门新萄京官方网站 19

# 同时设置 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

# 再打开第3个 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

澳门新萄京官方网站 20

从地方的结果能够见见, 即便 stress 命令内定了 -c 2(意思是在二个CPU上运转), 可是出于A和B都只绑定了CPU0,

故此即使是双核的机械, 它们所攻陷的CPU总数却唯有 百分之百, 而不是实例一 中的 200%.

 

假若将B组的情理CPU绑定到CPU一, 那么相应具备 stress 的经过都攻下 2/四, CPU能源的总的数量变为 200%.

上边将B组的物理CPU绑定为CPU1, 看看结果是或不是和大家的意料一样.

澳门新萄京官方网站 21

# 在 B组的 shell 窗口中执行以下命令
echo 1 > /mnt/cgroup/B/cpuset.cpus
cat /mnt/cgroup/B/cpuset.cpus
1
stress -c 2

# 在 A组的 shell 窗口中执行以下命令
stress -c 2

# 在第3个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

澳门新萄京官方网站 22

果然, 和预期一致. A组中的 stress 和 B组中的 stress 在分别的大要CPU上都据有了 百分百 左右的CPU使用率.

 

布局文件

/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 如此强硬的调控本事(而且配置也很粗略), 那也就难怪LXC等容器技巧能那样强硬, 如此流行.

cgroup 的配备文件过多, 上边的实例中只简简单单利用了其中的多少个布局文件, 如若想深远精通 cgroup, 更加好的利用cgroup的话,

还得找个介绍cgroup配置文件的文书档案来探究一下, 那篇博客提供的剧情还相当不足.

实例四 - 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子系统. 能够由此以下方法鲜明:

澳门新萄京官方网站 23

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

澳门新萄京官方网站 24

 

为了私下认可启用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了

澳门新萄京官方网站 25

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

澳门新萄京官方网站 26

 

初始试验:

  1. 重启系统 (为了保险内部存储器的一干二净)
  2. 挂载 memcg
  3. 在挂载的 /mnt/cgroup 中开创 组A
  4. 将当前shell 加入到 组A
  5. 不限制组A的内部存款和储蓄器, 压缩内核源码包, 并观看压缩前后内部存款和储蓄器的成形
  6. 再也步骤 一 ~ 4
  7. 界定组A的内部存款和储蓄器为 10MB, 再度减弱内核源码包, 并观望压缩前后内部存款和储蓄器的转移

 

澳门新萄京官方网站 27

# 重启系统
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

澳门新萄京官方网站 28

从上边的结果可以看看限制内部存款和储蓄器是起了功能的.

不限定内部存款和储蓄器时, tar 压缩前后 buffer cache 内部存款和储蓄器从 (玖MB 肆三MB) ==> (二6MB 161四MB)  增大了 158捌MB

限定内部存款和储蓄器后, tar 压缩前后 buffer cache 内部存储器从 (10MB 四三MB) ==> (1肆MB 4八MB)  增大了 九MB

 

cgroup section的语法格式如下

  1. group <name> {  
  2.     [<permissions>]  
  3.     <controller> {  
  4.         <param name> = <param value>;  
  5.         …  
  6.     }  
  7.     …}  

name: 指定cgroup的名称
permissions:可挑选,钦赐cgroup对应的挂载点文件系统的权能,root用户具备具有权限。
controller:子系统的名称
param name 和 param value:子系统的属性及其属性值

总结

粗略的实行就意识 cgroup 如此强硬的调整技艺(而且配置也相当粗略), 那也就难怪LXC等容器技能能那样庞大, 如此流行.

cgroup 的布局文件过多, 下面的实例中只简单利用了内部的多少个布局文件, 如若想深刻摸底 cgroup, 更加好的运用cgroup的话,

还得找个介绍cgroup配置文件的文书档案来研商一下, 那篇博客提供的剧情还远远不足.

七.1 配置对mysql实例的财富限制

    前提:MySQL数据库已在机械上设置

    7.1.1 修改cgconfig.conf文件

[plain] view plain copy

  1. mount {  
  2.     cpuset  = /cgroup/cpuset;  
  3.     cpu = /cgroup/cpu;  
  4.     cpuacct = /cgroup/cpuacct;  
  5.     memory  = /cgroup/memory;  
  6.         blkio   = /cgroup/blkio;  
  7. }  
  8.   
  9. group mysql_g1 {    
  10.     cpu {  
  11.             cpu.cfs_quota_us = 50000;  
  12.             cpu.cfs_period_us = 100000;  
  13.     }  
  14.     cpuset {    
  15.             cpuset.cpus = "3";    
  16.             cpuset.mems = "0";    
  17.     }    
  18.     cpuacct{  
  19.   
  20.     }  
  21.     memory {    
  22.             memory.limit_in_bytes=104857600;  
  23.             memory.swappiness=0;  
  24.             # memory.max_usage_in_bytes=104857600;  
  25.             # memory.oom_control=0;  
  26.     }   
  27.     blkio  {  
  28.            blkio.throttle.read_bps_device="8:0 524288";  
  29.            blkio.throttle.write_bps_device="8:0 524288";  
  30.     }   
  31. }   

    七.一.二 配置文件的有个别解释。

    cpu:cpu使用时间限额。

    cpu.cfs_period_us和cpu.cfs_quota_us来限制该组中的全部进程在单位时间里可以运用的cpu时间。这里的cfs是一心公平级调动度器的缩写。cpu.cfs_period_us正是光阴周期(阿秒),默以为一千00,即百微秒。cpu.cfs_quota_us正是在那时期内可应用的cpu时间(皮秒),私下认可-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就可以限定在双核上完全采纳)。

    cpuset:cpu绑定

    大家限制该组只幸好0壹共二个超线程上运转。cpuset.mems是用来安装内部存款和储蓄器节点的。

    本例限制使用超线程0上的第多个cpu线程。

    其实cgconfig也便是帮您把安插文件中的配置整理到/cgroup/cpuset那一个目录里面,比如您供给动态设置mysql_group1/ cpuset.cpus的CPU超线程号,能够使用如下的主意。

[plain] view plain copy

  1. [root@localhost ~]# echo "0" > mysql_group1/ cpuset.cpus  

    cpuacct:cpu财富报告

    memory:内部存款和储蓄器限制 

    内部存储器限制我们最重要范围了MySQL能够运用的内部存款和储蓄器最大尺寸memory.limit_in_bytes=25六M。而设置swappiness为0是为着让操作系统不会将MySQL的内部存款和储蓄器无名氏页沟通出去。

    blkio:BLOCK IO限额

    blkio.throttle.read_bps_device="8:0 524288"; #每秒读数据上限
    blkio.throttle.write_bps_device="8:0 524288"; #每秒写多少上限

    当中八:0对应主设备号和副设备号,能够透过ls -l /dev/sda查看

[plain] view plain copy

  1. [root@localhost /]# ls -l /dev/sda  
  2. brw-rw----. 1 root disk 8, 0 Sep 15 04:19 /dev/sda  

    七.壹.三 拓展文化

    今后较新的服务器CPU都以numa结构<非同等内部存款和储蓄器访问结构(NUMA:Non-Uniform Memory Access)>,使用numactl --hardware能够见见numa种种节点的CPU超线程号,以及相应的节点号。

    本例结果如下:

[plain] view plain copy

  1. [root@localhost /]# numactl --hardware   
  2. available: 1 nodes (0)  
  3. node 0 cpus: 0 1 2 3  
  4. node 0 size: 1023 MB  
  5. node 0 free: 68 MB  
  6. node distances:  
  7. node   0   
  8.   0:  10   

    以下是较高等服务器的numa消息,仅作参照他事他说加以调查。

[plain] view plain copy

  1. [root@localhost ~]# numactl --hardware     
  2. available: 4 nodes (0-3)  
  3. node 0 cpus: 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60  
  4. node 0 size: 16338 MB  
  5. node 0 free: 391 MB  
  6. node 1 cpus: 1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61  
  7. node 1 size: 16384 MB  
  8. node 1 free: 133 MB  
  9. node 2 cpus: 2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62  
  10. node 2 size: 16384 MB  
  11. node 2 free: 137 MB  
  12. node 3 cpus: 3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63  
  13. node 3 size: 16384 MB  
  14. node 3 free: 186 MB  
  15. node distances:  
  16. node   0   1   2   3   
  17.   0:  10  20  30  20   
  18.   1:  20  10  20  30   
  19.   2:  30  20  10  20   
  20.   3:  20  30  20  10  

    7.1.4 修改cgrules.conf文件

[plain] view plain copy

  1. [root@localhost ~]# vi /etc/cgrules.conf  
  2. # /etc/cgrules.conf  
  3. #The format of this file is described in cgrules.conf(5)  
  4. #manual page.  
  5. #  
  6. # Example:  
  7. #<user>         <controllers>   <destination>  
  8. #@student       cpu,memory      usergroup/student/  
  9. #peter          cpu             test1/  
  10. #%              memory          test2/  
  11. *:/usr/local/mysql/bin/mysqld * mysql_g1  

    注:共分为三个部分,分别为供给限制的实例,限制的剧情(如cpu,memory),挂载指标。

    7.贰 使配置生效

[plain] view plain copy

  1. [root@localhost ~]# /etc/init.d/cgconfig restart  
  2. Stopping cgconfig service:                                 [  OK  ]  
  3. Starting cgconfig service:                                 [  OK  ]  
  4. [root@localhost ~]# /etc/init.d/cgred restart  
  5. Stopping CGroup Rules Engine Daemon...                     [  OK  ]  
  6. Starting CGroup Rules Engine Daemon:                       [  OK  ]  

    注:重启顺序为cgconfig -> cgred ,更换配置文件后七个服务须求重启,且顺序不能够错。

    七.三 运营MySQL,查看MySQL是还是不是处于cgroup的限制中

[plain] view plain copy

  1. [root@localhost ~]# ps -eo pid,cgroup,cmd | grep -i mysqld  
  2. 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/  
  3. 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  
  4. 30311 blkio:/;net_cls:/;freezer:/;devices:/;memory:/;cpuacct:/;cpu:/;cpuset:/ grep -i mysqld  

    7.四 财富限制验证

    使用mysqlslap对mysql实行压力测试,看mysql使用资源是还是不是当先限制。

    七.4.一 在shell窗口1用mysqlslap对mysql实行压力测试。

[plain] view plain copy

  1. [root@localhost /]# /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  

    七.肆.二 在shell窗口二查看mysql对cpu,内部存储器的选拔
澳门新萄京官方网站 29

    可知:cpu限制在了第多个主旨上,且对第四个基本的运用范围在四分之二。

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

澳门新萄京官方网站 30

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

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

    还原配置文件/etc/cgconfig.conf及/etc/cgrules.conf 为暗中同意配置。测试实例依旧为mysql,测试工具为mysqlslap。

    开启cgconfig及cgrules 服务。

[plain] view plain copy

  1. [root@localhost /]# /etc/init.d/cgconfig restart  
  2. Stopping cgconfig service:                                 [  OK  ]  
  3. Starting cgconfig service:                                 [  OK  ]  
  4. [root@localhost /]# /etc/init.d/cgred restart  
  5. Stopping CGroup Rules Engine Daemon...                     [  OK  ]  
  6. Starting CGroup Rules Engine Daemon:                       [  OK  ]  

    开启mysqlslap压力测试程序。

[plain] view plain copy

  1. [root@localhost /]# /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查看能源消耗。

澳门新萄京官方网站 31

    8.壹 cpu限制实例

    限制mysql使用贰个核,如第三个核,且对该核的行使不超过半数

[plain] view plain copy

  1. [root@localhost /]# mkdir -p /cgroup/cpu/foo/  
  2. [root@localhost /]# mkdir -p /cgroup/cpuset/foo/  
  3. [root@localhost /]# echo 50000 > /cgroup/cpu/foo/cpu.cfs_quota_us  
  4. [root@localhost /]# echo 100000 > /cgroup/cpu/foo/cpu.cfs_period_us  
  5. [root@localhost /]# echo "0" > /cgroup/cpuset/foo/cpuset.mems  
  6. [root@localhost /]# echo "1" > /cgroup/cpuset/foo/cpuset.cpus  
  7. [root@localhost /]# echo 28819 > /cgroup/cpu/foo/tasks   

    在那之中:2881玖为mysqld的进程号。

澳门新萄京官方网站 32

    捌.二 内部存款和储蓄器限制实例

    限制mysql使用内部存款和储蓄器为不当先512M

    跑一个消耗内部存款和储蓄器脚本

[plain] view plain copy

  1. x='a'  
  2. while [ True ];do  
  3.     x=$x$x  
  4. done;  

澳门新萄京官方网站 33

    内存的开支在持续增加,对其实行限定,使其行使内设有500M以内

[plain] view plain copy

  1. [root@localhost /]# mkdir -p /cgroup/memory/foo  
  2. [root@localhost /]# echo 524288000 >  /cgroup/memory/foo/memory.limit_in_bytes  
  3. [root@localhost /]# echo 44476 > /cgroup/memory/foo/tasks   

澳门新萄京官方网站 34
    内部存款和储蓄器使用获得了实惠调整。

    八.三 IO限制实例

    跑2个消耗IO的测试

[plain] view plain copy

  1. [root@localhost ~]# dd if=/dev/sda of=/dev/null   

    通过iotop看io占用情形,磁盘读取速度到了50M/s

澳门新萄京官方网站 35 
    限制读取速度为10M/S

[plain] view plain copy

  1. [root@localhost ~]# mkdir -p /cgroup/blkio/foo  
  2. [root@localhost ~]# echo '8:0   10485760' >  /cgroup/blkio/foo/blkio.throttle.read_bps_device  
  3. [root@localhost ~]# echo 45033 > /cgroup/blkio/foo/tasks  

    注1:4503叁为dd的进度号

    注二:八:0对应主设备号和副设备号,能够因此ls -l /dev/sda查看

[plain] view plain copy

  1. [root@localhost ~]# ls -l /dev/sda  
  2. brw-rw----. 1 root disk 8, 0 Sep 15 04:19 /dev/sda  

9 cgroup小结

    使用cgroup有的时候对经过打开调度,直接通过命令就可以,如若要持久化对经过展成本配,即重启后依旧有效,须要写进配置文件/etc/cgconfig.conf及/etc/cgrules.conf 

   

****************************************************************************************
    最初的文章地址:
    博客主页:

出自为知笔记(Wiz)

本文由澳门新萄京官方网站发布于服务器运维,转载请注明出处:澳门新萄京官方网站:Cgroup和Namespace在测试中的

关键词: