内部存款和储蓄器等财富支配,Linux能源支配

作者: 计算机网络  发布:2019-10-16

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

留存

from:   and 

CGroup 介绍
CGroup 是 Control Groups 的缩写,是 Linux 内核提供的一种能够限制、记录、隔开进度组 (process groups) 所使用的财力财富 (如 cpu memory i/o 等等) 的机制。2005 年走入 Linux 2.6.24 内核,CGroups 不是全新创建的,它将经过管理从 cpuset 中脱离出来,我是 Google 的 Paul Menage。CGroups 也是 LXC 为兑现设想化所利用的财富管理花招。

CGroup 成效及组成
CGroup 是将轻巧进度展开分组化管理的 Linux 内核作用。CGroup 自个儿是提供将经过打开分组化管理的效力和接口的底蕴结构,I/O 或内部存款和储蓄器的分红调节等切实的财富管理效果是因此这一个职能来完结的。那几个实际的财富管理职能称为 CGroup 子系统或调节器。CGroup 子系统有调控内部存储器的 Memory 调整器、调控进程调整的 CPU 调节器等。运维中的内核能够利用的 Cgroup 子系统由/proc/cgroup 来确认。
CGroup 提供了三个 CGroup 设想文件系统,作为举办分组处理和各子系统安装的客户接口。要运用 CGroup,必需挂载 CGroup 文件系统。那时通过挂载选项内定使用哪个子系统。

Cgroups提供了以下功能:
1)限制进程组能够采纳的能源数量(Resource limiting )。比方:memory子系统可感到进程组织设立定三个memory使用上限,一旦进度组使用的内部存款和储蓄器达到限额再提请内部存款和储蓄器,就能够出发OOM(out of memory)。
2)进度组的先行级调节(Prioritization )。举个例子:可以行使cpu子系统为有些进度组分配一定cpu share。
3)记录进程组使用的能源数量(Accounting )。比方:可以动用cpuacct子系统记录某些进度组使用的cpu时间
4)进度组隔断(Isolation)。举个例子:使用ns子系统能够使分化的进度组使用分化的namespace,以高达隔离的目标,分歧的进程组有各自的进度、网络、文件系统挂载空间。
5)进程组决定(Control)。譬喻:使用freezer子系统能够将经过组挂起和还原。

CGroup 帮助的文书体系
表 1. CGroup 协理的文本种类

文件名 R/W 用途

Release_agent

RW

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

Notify_on_release

RW

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

Tasks

RW

属于分组的线程 TID 列表

Cgroup.procs

R

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

Cgroup.event_control

RW

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

CGroup 相关概念解释
1)职分(task)。在 cgroups 中,职务正是系统的叁个历程;
2)调控族群(control group)。调整族群正是一组依据某种标准划分的进度。Cgroups 中的财富支配都是以调整族群为单位完结。贰个进程可以插手到某些调控族群,也从贰个进度组迁移到另一个调控族群。四个经过组的进程能够选取cgroups 以调整族群为单位分配的财富,同期遭到 cgroups 以调节族群为单位设定的范围;
3)层级(hierarchy)。调整族群能够团体成 hierarchical 的款式,既一颗控制族群树。调节族群树上的子节点调节族群是父节点调节族群的孩子,传承父调整族群的一定的习性;
4)子系统(subsystem)。三个子种类正是一个财富调控器,比如 cpu 子系统就是调控 cpu 时间分配的三个调节器。子系统必得叠合(attach)到叁个层级上才干起效用,一个子系统附加到有个别层级以后,这些层级上的具有调整族群都受到这一个子系统的操纵。

互相关系
1)每一回在系统中开创新层级时,该系统中的全部职分都以相当层级的默认cgroup(我们称为 root cgroup,此 cgroup 在创造层级时自动创制,后边在该层级中开创的 cgroup 都以此 cgroup 的儿孙)的开头成员;
2)贰个子连串最五只好叠合到叁个层级;
3)二个层级能够增大八个子系统;
4)多少个职责能够是多少个 cgroup 的积极分子,然则那一个 cgroup 必得在差异的层级;
5)系统中的进度(任务)成立子进度(任务)时,该子职分自动形成其父进度所在 cgroup 的分子。然后可依据必要将该子职分移动到分化的 cgroup 中,但开端时它连接承袭其父任务的 cgroup。

数据库系统的财富是指内部存款和储蓄器和CPU(管理器)能源,具有能源的数目,决定了数据查询的性质。当二个SQL Server实例上,具有多少个独立的职业负荷(workload)时,使用财富管理器(Resource Governor),能够完成系统能源在逻辑上的割裂,化解在一台SQL Server实例上,管理多顾客工作负荷的急需。资源管理器允许数据库管理员(DBA)通过编制程序设置财富池,配置资源池具有能源的上限,能源池是每叁个伸手能够采用的能源,那样设置之后,强制系统在拍卖顾客发送的央浼(Requsts)时所花费的CPU 和 Memory能源的数额无法赶过限制,在明确程度上,限制客商可以利用的财富数量,隔开了失控(runaway)的询问对系统的震慑。对于SQL Server 二零一二的话,客户能够基于职业负荷,实现CPU能源的一丝一毫隔断,并能设置CPU财富使用量的硬上限(CAP Usage,Hard Limit)。在三个多客户、高并发的SQL Server实例上,管理员使用Resource Governor,调控分化专门的工作负荷对内部存款和储蓄器和CPU财富的使用量,使差别的应用程序在财富的使用上相互隔开分离,使系统本性获得可预测性的垄断和保管。

要害介绍Linux下, 假如对经过的CPU和内部存款和储蓄器能源的利用状态展开调控的法子。

图 1. CGroup 层级图

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

CGroup 特点
在 cgroups 中,职责就是系统的三个进度。
调整族群(control group)。调节族群正是一组依据某种规范划分的长河。Cgroups 中的财富支配都以以调整族群为单位完结。二个经过能够步向到某些调整族群,也从八个进度组迁移到另叁个调整族群。三个进度组的长河能够行使 cgroups 以调控族群为单位分配的财富,同一时间遭到 cgroups 以调控族群为单位设定的限定。
层级(hierarchy)。调节族群能够团体成 hierarchical 的花样,既一颗调整族群树。调整族群树上的子节点调控族群是父节点调整族群的男女,承接父调整族群的一定的性质。
子系统(subsytem)。二个子种类正是七个财富调整器,比如 cpu 子系统正是调节 cpu 时间分配的三个调控器。子系统必得叠合(attach)到四个层级上能力起效果,五个子体系附加到有个别层级现在,这些层级上的有着调整族群都受到这些子系统的调控。

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

一,能源管理器的主干构成

 

图 2. CGroup 标准应用架构图

如图 2 所示,CGroup 技能能够被用来在操作系统底层限制物理财富,起到 Container 的功效。图中每叁个 JVM 进度对应一个 Container Cgroup 层级,通过 CGroup 提供的种种子系统,能够对每三个 JVM 进度对应的线程等级举办物理限制,那些限制包括CPU、内部存款和储蓄器等等大多类别的能源。下一部分会实际对应用程序举办 CPU 能源隔绝举办自己要作为表率遵从规则。

cgroup的安装
骨子里安装很简单,最棒实践正是yum直接设置(centos下)

布署文件

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

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

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

Resource Governor的可编制程序部分由三部分构成:Resource Pool,Workload Group 和 Classifier Function,每种部分达成分裂的成效。

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

 

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

1.1 修改cgconfig.conf文件

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

1.2 配置文件的某些解释
cpu:cpu使用时间限额

cpu.cfs_period_us和cpu.cfs_quota_us来限制该组中的全部进度在单位时间里能够选择的cpu时间。这里的cfs是一丝一毫公平级调动度器的缩写。cpu.cfs_period_us正是时间周期(阿秒),默感到一千00,即百飞秒。cpu.cfs_内部存款和储蓄器等财富支配,Linux能源支配。quota_us正是在这里期间内可应用的cpu时间(阿秒),暗中同意-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就能够限定在双核上完全采取)。
cpuset:cpu绑定
大家限制该组只好在0一共1个超线程上运营。cpuset.mems是用来设置内存节点的。
本例限制使用超线程0上的第两个cpu线程。
事实上cgconfig也正是帮你把铺排文件中的配置整理到/cgroup/cpuset那些目录里面,譬喻您要求动态设置mysql_group1/ cpuset.cpus的CPU超线程号,能够运用如下的措施。
[[email protected] ~]# echo "0" > mysql_group1/ cpuset.cpus
cpuacct:cpu能源报告
memory:内部存款和储蓄器限制
 
内部存款和储蓄器限制大家第一范围了MySQL能够运用的内部存款和储蓄器最大尺寸memory.limit_in_bytes=256M。而设置swappiness为0是为着让操作系统不会将MySQL的内部存款和储蓄器无名页交流出去。
blkio:BLOCK IO限额
blkio.throttle.read_bps_device="8:0 524288"; #每秒读数据上限
blkio.throttle.write_bps_device="8:0 524288"; #每秒写多少上限
个中8:0对应主设备号和副设备号,能够通过ls -l /dev/sda查看
[[email protected] ~]# ls -l /dev/sda 
brw-rw----. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

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

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

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

# Example: 
#<user> <controllers> <destination> 
#@student cpu,memory usergroup/student/ 
#peter cpu test1/ 
#% memory test2/ 
*:/usr/local/mysql/bin/mysqld * mysql_g1 
注:共分为3个部分,分别为急需限制的实例,限制的从头到尾的经过(如cpu,memory),挂载指标。

1,资源池(Resource Pool)

实时进程的CPU调整

所谓的实时进度, 也正是这几个对响应时间供给相比较高的进度.

这类进度须求在限定的时间内管理顾客的恳求, 由此, 在界定的目前内, 要求占用所有CPU能源, 并且无法被其余进度打断.

在此种状态下, 要是实时进度中出现了相近死循环之类的情景, 就能够招致整个种类无响应.

因为实时进程的CPU优先级高, 並且未处理完此前是不会自由CPU财富的.

 

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

 

2 使配置生效

[[email protected] ~]# /etc/init.d/cgconfig restart 
Stopping cgconfig service: [ OK ] 
Starting cgconfig service: [ OK ] 
[[email protected] ~]# /etc/init.d/cgred restart 
Stopping CGroup Rules Engine Daemon... [ OK ] 
Starting CGroup Rules Engine Daemon: [ OK ] 
注:重启顺序为cgconfig -> cgred ,改造配置文件后多少个服必得要重启,且顺序无法错。

在SQL Server实例中,能源隔开的核心单位是Resource Pool,正如其名,该指标是财富池,在创造Resource Pool时,钦点该Pool具备的CPU和Memory财富的多少限制。在SQL Server 二零一三本子中,最多能够创立陆10个顾客自定义的Resource Pool。SQL Server内置了四个Resource Pools:internal用以系统Task,顾客不能配备;default是暗中同意的Resource Pool,用于此外未有一些名Resource Pool的Request;
2,负载分组(Workload Group)

系统完整安装

  1. 取伏贴前系统的装置

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

本条设置验证实时进程在运营时实际不是一心占用CPU的, 每1秒中有0.05秒的时光能够给别的进度运营.

那般既不会对实时进程的响应时间产生太大的熏陶, 也防止了实时进度卡住时变成整个系统无响应.

 

  1. 安装实时进度占用CPU时间

上边的暗中认可设置中, 实时经过占用 95% 的CPU时间. 假使感到占用的太多或太少, 都以能够调动的.举个例子:

sysctl -w kernel.sched_rt_runtime_us=900000    # 设置实时进程每1秒中只占0.9秒的CPU时间
kernel.sched_rt_runtime_us = 900000
sysctl -n kernel.sched_rt_runtime_us 
900000

 

3 运营MySQL,查看MySQL是或不是处于cgroup的界定中

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

Workload Group是逻辑上的实体,用于表示三个或多少个职业负荷。实际上,一个做事负荷是SQL Server实例接收到的一个查询央求(Request),通过Classifier Function将多个拥有协同天性的Requests划分到平等的Workload Group中。每贰个Resource Pool服务于一个或多少个办事负荷分组,那正是说,这一个职业负荷分组能够共享同贰个Resource Pool中有着的能源。

cgroup 中的设置

一体化安装是指向全数系统的, 大家也足以经过 cgroup 来对一组经过的CPU财富进行调节.

万一想在 cgroup 中对 sched_rt_period_us 和 sched_rt_runtime_us 进行支配, 需求内核编写翻译选项 CONFIG_RT_GROUP_SCHED=y

翻看当前系统的基业编写翻译选项方法如下: (debian 7.6 系统)

cat /boot/config-`uname -r`

查看 CONFIG_RT_GROUP_SCHED 是不是启用

cat /boot/config-`uname -r` | grep -i rt_group
# CONFIG_RT_GROUP_SCHED is not set

debian 7.6 暗中认可未有运维那几个选项, 所以挂载cgroup之后, 未有安装 sched_rt_period_us 和 sched_rt_runtime_us 的文件

mkdir /mnt/cgroup
mount -t cgroup cgroup /mnt/cgroup/
cd /mnt/cgroup/
ls -l
total 0
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_merged
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_queued
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_service_bytes
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_serviced
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_service_time
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.io_wait_time
--w------- 1 root root 0 Aug 28 09:06 blkio.reset_stats
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.sectors
-r--r--r-- 1 root root 0 Aug 28 09:06 blkio.time
-rw-r--r-- 1 root root 0 Aug 28 09:06 blkio.weight
-rw-r--r-- 1 root root 0 Aug 28 09:06 blkio.weight_device
-rw-r--r-- 1 root root 0 Aug 28 09:06 cgroup.clone_children
--w--w--w- 1 root root 0 Aug 28 09:06 cgroup.event_control
-rw-r--r-- 1 root root 0 Aug 28 09:06 cgroup.procs
-r--r--r-- 1 root root 0 Aug 28 09:06 cpuacct.stat
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuacct.usage
-r--r--r-- 1 root root 0 Aug 28 09:06 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.cpu_exclusive
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.cpus
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.mem_exclusive
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.mem_hardwall
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.memory_migrate
-r--r--r-- 1 root root 0 Aug 28 09:06 cpuset.memory_pressure
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.memory_pressure_enabled
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.memory_spread_page
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.memory_spread_slab
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.mems
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.sched_load_balance
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpuset.sched_relax_domain_level
-rw-r--r-- 1 root root 0 Aug 28 09:06 cpu.shares
--w------- 1 root root 0 Aug 28 09:06 devices.allow
--w------- 1 root root 0 Aug 28 09:06 devices.deny
-r--r--r-- 1 root root 0 Aug 28 09:06 devices.list
-rw-r--r-- 1 root root 0 Aug 28 09:06 net_cls.classid
-rw-r--r-- 1 root root 0 Aug 28 09:06 notify_on_release
-rw-r--r-- 1 root root 0 Aug 28 09:06 release_agent
-rw-r--r-- 1 root root 0 Aug 28 09:06 tasks

 

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

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

为了省去时间, 我们用 make localmodconfig 来创制 .config 文件, 然后修改当中的 CONFIG_RT_GROUP_SCHED=y

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

cd /path/to/linux-source-3.2
make localmodconfig
vim .config   # 设置 CONFIG_RT_GROUP_SCHED=y 并保存
make
make modules_install
make install
reboot      # 重启之前看看 /boot/grub/grub.cfg 中, 默认启动的是不是新安装的内核

 

开始到新水源, 再一次查看内核选项 CONFIG_RT_GROUP_SCHED 是或不是启用

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

 

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

mount -t cgroup cgroup /mnt/cgroup/
cd /mnt/cgroup/
ls -l
total 0
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_merged
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_queued
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_service_bytes
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_serviced
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_service_time
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.io_wait_time
--w------- 1 root root 0 Aug 28 09:53 blkio.reset_stats
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.sectors
-r--r--r-- 1 root root 0 Aug 28 09:53 blkio.time
-rw-r--r-- 1 root root 0 Aug 28 09:53 blkio.weight
-rw-r--r-- 1 root root 0 Aug 28 09:53 blkio.weight_device
-rw-r--r-- 1 root root 0 Aug 28 09:53 cgroup.clone_children
--w--w--w- 1 root root 0 Aug 28 09:53 cgroup.event_control
-rw-r--r-- 1 root root 0 Aug 28 09:53 cgroup.procs
-r--r--r-- 1 root root 0 Aug 28 09:53 cpuacct.stat
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuacct.usage
-r--r--r-- 1 root root 0 Aug 28 09:53 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpu.rt_period_us
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpu.rt_runtime_us
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.cpu_exclusive
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.cpus
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.mem_exclusive
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.mem_hardwall
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.memory_migrate
-r--r--r-- 1 root root 0 Aug 28 09:53 cpuset.memory_pressure
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.memory_pressure_enabled
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.memory_spread_page
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.memory_spread_slab
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.mems
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.sched_load_balance
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpuset.sched_relax_domain_level
-rw-r--r-- 1 root root 0 Aug 28 09:53 cpu.shares
--w------- 1 root root 0 Aug 28 09:53 devices.allow
--w------- 1 root root 0 Aug 28 09:53 devices.deny
-r--r--r-- 1 root root 0 Aug 28 09:53 devices.list
-rw-r--r-- 1 root root 0 Aug 28 09:53 net_cls.classid
-rw-r--r-- 1 root root 0 Aug 28 09:53 notify_on_release
-rw-r--r-- 1 root root 0 Aug 28 09:53 release_agent
-rw-r--r-- 1 root root 0 Aug 28 09:53 tasks

cat cpu.rt_period_us 
1000000
cat cpu.rt_runtime_us 
950000

 

经过安顿 cpu.rt_period_us 和 cpu.rt_runtime_us 就足以对 cgroup 中的进程组中的实时进程张开 CPU使用时间的调整.

 

4 财富限制验证

应用mysqlslap对mysql进行压力测量试验,看mysql使用财富是不是抢先限制

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

4.2 在shell窗口2查看mysql对cpu,内部存储器的使用

足见:cpu限制在了第七个基本上,且对第1个着力的施用限制在八分之四。

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

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

SQL Server内置八个负载分组:internal和default,关联到相应的internal和default财富池,internal负载分组用于系统Task,SQL Server将从未被归类函数字展现式钦定负载分组的Request划分到default 分组中。

财富支配实例

上边根本介绍财富的一部分驳斥功底, 上边通过有个别实例演示假如经过 cgroup 来决定进程所运用的 CPU和内部存款和储蓄器 资源.

Linux对CPU 和 内部存款和储蓄器的决定有对应的 cgroup 子系统 cpuset 和 memory

 

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查看财富消耗。

3,分类函数(Classifier Function)

实例: cgroup 中对里面 *子cgroup* 的CPU财富支配

对各个 *子cgroup* 的CPU占用率实行支配珍视依赖各类 *子cgroup* 的 cpu.shares 文件

一向用试验进程来发话, 当中参预了部分注释.

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

 

1)cpu限制实例

界定mysql使用七个核,如第3个核,且对该核的使用不超过四分之二
[[email protected] ~]# mkdir -p /cgroup/cpu/foo/ 
[[email protected] ~]# mkdir -p /cgroup/cpuset/foo/ 
[[email protected] ~]# echo 50000 > /cgroup/cpu/foo/cpu.cfs_quota_us 
[[email protected] ~]# echo 100000 > /cgroup/cpu/foo/cpu.cfs_period_us 
[[email protected] ~]# echo "0" > /cgroup/cpuset/foo/cpuset.mems 
[[email protected] ~]# echo "1" > /cgroup/cpuset/foo/cpuset.cpus 
[[email protected] ~]# echo 28819 > /cgroup/cpu/foo/tasks

里面:28819为mysqld的过程号。

分类函数依照钦赐的法规(Rule),举例,根据Login,应用程序名称,数据库名字等属性,将收取的Request分配(路由)到不一致的负载分组中,能够钦点客商定义的载荷分组或default负载分组。

实例1 - 私下认可情状, A 和 B 各占CPU总财富的 三分一
  1. 挂载 cgroup 文件系统 (注意加上 -o cpu 的取舍)
  2. 在 cgroup中创建 2个子cgroup A 和 B
  3. 暗中认可情况下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都以 1024
  4. 在 A 和 B 中用 stress 工具使其 CPU占用率达到 百分百
  5. top 命令查看 A 和 B 中经过分别攻陷的 CPU (应该都以 百分之五十)

 

# 挂载 cgroup 文件系统
mount -t cgroup -o cpu cgroup /mnt/cgroup/
cd /mnt/cgroup
ls -l
total 0
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_merged
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_queued
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_service_bytes
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_serviced
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_service_time
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.io_wait_time
--w------- 1 root root 0 Aug 28 11:29 blkio.reset_stats
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.sectors
-r--r--r-- 1 root root 0 Aug 28 11:29 blkio.time
-rw-r--r-- 1 root root 0 Aug 28 11:29 blkio.weight
-rw-r--r-- 1 root root 0 Aug 28 11:29 blkio.weight_device
-rw-r--r-- 1 root root 0 Aug 28 11:29 cgroup.clone_children
--w--w--w- 1 root root 0 Aug 28 11:29 cgroup.event_control
-rw-r--r-- 1 root root 0 Aug 28 11:29 cgroup.procs
-r--r--r-- 1 root root 0 Aug 28 11:29 cpuacct.stat
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuacct.usage
-r--r--r-- 1 root root 0 Aug 28 11:29 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.cpu_exclusive
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.cpus
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.mem_exclusive
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.mem_hardwall
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.memory_migrate
-r--r--r-- 1 root root 0 Aug 28 11:29 cpuset.memory_pressure
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.memory_pressure_enabled
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.memory_spread_page
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.memory_spread_slab
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.mems
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.sched_load_balance
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpuset.sched_relax_domain_level
-rw-r--r-- 1 root root 0 Aug 28 11:29 cpu.shares
--w------- 1 root root 0 Aug 28 11:29 devices.allow
--w------- 1 root root 0 Aug 28 11:29 devices.deny
-r--r--r-- 1 root root 0 Aug 28 11:29 devices.list
-rw-r--r-- 1 root root 0 Aug 28 11:29 net_cls.classid
-rw-r--r-- 1 root root 0 Aug 28 11:29 notify_on_release
-rw-r--r-- 1 root root 0 Aug 28 11:29 release_agent
-rw-r--r-- 1 root root 0 Aug 28 11:29 tasks

# 创建 子cgroup A 和 B
mkdir {A,B}
cat A/cpu.shares 
1024
cat B/cpu.shares 
1024

# 在 A 和 B 中分别通过 stress 工具使其CPU使用率达到 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组中的 2个stress 进度的CPU使用率相加都以 百分百,

由于自个儿测验的微机是双核, top所寓指标CPU最大使用率是 200%, 所以和预期一致, A和B组各占CPU总能源的 57%

 

2) 内存限制实例

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

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

内部存款和储蓄器的损耗在反复追加,对其进行限制,使其选拔内设有500M以内
[[email protected] ~]# mkdir -p /cgroup/memory/foo 
[[email protected] ~]# echo 524288000 > /cgroup/memory/foo/memory.limit_in_bytes 
[[email protected] ~]# echo 44476 > /cgroup/memory/foo/tasks

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

4,管理流程

实例2 - A group 占用全体CPU能源的 2/3, B group 占用全体CPU能源的 53%
  1. 境遇同 实例1, 不再重复挂载 cgroup 文件系统, 也不在重新建设构造 A 和 B
  2. A group 的 cpu.shares 文件不改变, 值为 1024
  3. B group 的 cpu.shares 文件中的值改为 512, 那样, 约等于B占用CPU总能源的 十分四 (因为 512 / (512 1024) = 约得其半)
  4. 同实例1, 通过2个shell窗口, 分别是 A 和 B 的CPU使用率高达 百分百, 然后透过 top 查看CPU使用意况

 

# 在 B 中shell 窗口执行以下命令
cat B/cpu.shares 
1024
echo 512 > B/cpu.shares 
cat B/cpu.shares 
512
stress -c 2

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

# 在第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 组中的2个经过占用了CPU总量的 2/3 左右, B组中的2个经过占用了CPU总量的 二分之一 左右.

 

3)IO限制实例

跑一个消耗IO的测验
[[email protected] ~]# dd if=/dev/sda of=/dev/null 
因而iotop看io占用情状,磁盘读取速度到了50M/s

 
范围读取速度为10M/S

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

Resource Governor各类部分互相合作,调节内部存款和储蓄器和CPU财富的行使:Classification将SQL Server实例接收到的Requests进行归类,划分到区别的负载组中,负载组与之提到的Resource Pool中富含的CPU和内部存款和储蓄器能源来拍卖Request,Resource Governor的管理流程如下图: 

实例3 - 物理CPU的控制

地方的实例中, 即便能够决定每一个组的CPU的完全占用率, 但是无法说了算有个别组的历程固定在有个别物理CPU上运营.

要想将 cgroup 绑定到某些固定的CPU上, 须求动用 cpuset 子系统.

先是, 查看系统是不是扶助 cpuset 子系统, 也正是看基础编写翻译选项 CONFIG_CPUSETS 是不是设为y

cat /boot/config-`uname -r` | grep -i cpusets
CONFIG_CPUSETS=y

自家的测量试验系统是支撑的, 假如你的系统不辅助, 就必要再度编写翻译内核了.......

 

下一场, 用上边的例子演示将 A 和 B中的 stress 都钦点到1个CPU上后的情景

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

 

umount /mnt/cgroup
mount -t cgroup -o cpuset cgroup /mnt/cgroup/
cd /mnt/cgroup
ls -l
total 0
-rw-r--r-- 1 root root 0 Aug 28 14:39 cgroup.clone_children
--w--w--w- 1 root root 0 Aug 28 14:39 cgroup.event_control
-rw-r--r-- 1 root root 0 Aug 28 14:39 cgroup.procs
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.cpu_exclusive
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.cpus    <-- 这个就是设置关联物理CPU的文件
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.mem_exclusive
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.mem_hardwall
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.memory_migrate
-r--r--r-- 1 root root 0 Aug 28 14:39 cpuset.memory_pressure
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.memory_pressure_enabled
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.memory_spread_page
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.memory_spread_slab
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.mems
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.sched_load_balance
-rw-r--r-- 1 root root 0 Aug 28 14:39 cpuset.sched_relax_domain_level
-rw-r--r-- 1 root root 0 Aug 28 14:39 notify_on_release
-rw-r--r-- 1 root root 0 Aug 28 14:39 release_agent
-rw-r--r-- 1 root root 0 Aug 28 14:39 tasks

# 创建子cgroup A 和 B
mkdir {A,B}
cat A/cpuset.cpus   
         <--  默认是空的
echo 0 > A/cpuset.cpus
cat A/cpuset.cpus 
0
echo 0 > B/cpuset.cpus   # 同样, 设置B组也绑定到CPU0
# 当前Shell加入到 A组
echo $$ > /mnt/cgroup/A/tasks 
-bash: echo: write error: No space left on device

 

假如出现上述失实, 只须求再设置 /mnt/cgroup/A/cpuset.mems 就可以. (参谋: )

# 同时设置 A 的 cpuset.cpus 和 cpuset.mems
echo 0 > A/cpuset.cpus
echo 0 > A/cpuset.mems
# B组也同样设置
echo 0 > B/cpuset.cpus
echo 0 > B/cpuset.mems

# 将当前 shell 加入到 A组
echo $$ > /mnt/cgroup/A/tasks   <-- 设置过 cpuset.mems 后, 就没有出错了
stress -c 2

# 再打开一个Shell窗口, 并加入到 B组
echo $$ > /mnt/cgroup/B/tasks
stress -c 2

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

从而就算是双核的机械, 它们所占领的CPU总数却独有 百分之百, 实际不是实例1 中的 200%.

 

倘诺将B组的大意CPU绑定到CPU1, 那么相应具备 stress 的长河都侵占 一半, CPU财富的总的数量变为 200%.

上边将B组的概略CPU绑定为CPU1, 看看结果是或不是和大家的预料同样.

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

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

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

 

cgroup小结

利用cgroup有时对进度张开调度,直接通过命令就可以,假使要悠久化对进程展费用配,即重启后依然有效,须求写进配置文件/etc/cgconfig.conf及/etc/cgrules.conf 

***************当你开采自身的才华撑不起野心时,就存候静下来学习吧***************

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

¥¥='$$'

 Linux能源支配-CPU和内部存储器

重在介绍Linux下, 若是对经过的CPU和内部存款和储蓄器财富的使用状态展费用配的措施。
 
CPU财富支配
各种进程能够攻克CPU多久, 何时能够私吞CPU是和系统的调整紧凑相关的.
Linux系统中有三种调节战略, 种种调解战术有其适用的现象, 也很难说哪类调解战略是最优的.
Linux的调整攻略能够参见代码: include/linux/sched.h
/*
 * Scheduling policies
 */
#define SCHED_NORMAL        0
#define SCHED_FIFO        1
#define SCHED_RR        2
#define SCHED_BATCH        3
/* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE        5
/* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */
#define SCHED_RESET_ON_FORK     0x40000000
 
Linux 系统也提供了修改调解战略的通令和种类调用接口.
调用接口请查询相关文书档案, 这里关键介绍一下改换调整战略的下令 - chrt.
# 在三个巅峰中推行
sleep 1000
# 张开另二个极端
ps -ef | grep sleep  # 寻找 sleep 一千 的pid, 这里如若是 1234
chrt -p 1234         # 能够查阅 pid=1234 的经过的 调整战略, 输入如下:
      pid 1234's current scheduling policy: SCHED_OTHER
      pid 1234's current scheduling priority: 0
chrt -p -f 10 1234   # 修改调整战略为 SCHED_FIFO, 而且优先级为10
chrt -p 1234         # 再度翻开调治计策
      pid 1234's current scheduling policy: SCHED_FIFO
      pid 1234's current scheduling priority: 10
 
补充:
    chrt 也得以直接钦定一条命令, 并设置这条命令的事先级的调节战略, 具体查看 chrt --help
    查看一个进度的调节战术, 除了行使 chrt 命令之外, 还足以 cat /proc/<PID>/sched
 
实时进度的CPU调节
所谓的实时过程, 也正是这个对响合时间须要相比较高的进度.
那类进程须求在限制的时日内管理客商的央浼, 因而, 在限定的这段时光内, 要求占用全体CPU能源, 况兼不可能被别的进度打断.
在这里种情景下, 假若实时进程中出现了看似死循环之类的气象, 就能够招致整个系统无响应.
因为实时进程的CPU优先级高, 而且未管理完在此以前是不会自由CPU能源的.
 
于是, 内核中需求有一种艺术来限制实时进程的CPU财富占用.
 
系统一体化安装

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

查阅斟酌

留存 from: and CGroup...

 图片 1

实例4 - cgroup 对运用的内部存储器的垄断(monopoly)

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, 再度收缩内核源码包, 并观望压缩前后内部存款和储蓄器的变动

 

# 重启系统
reboot

# 挂载 memcg
mount -t cgroup -o memory memcg /mnt/cgroup

# 创建 组A
mkdir /mnt/cgroup/A

# 将当前 shell 加入到组A
echo $$ > /mnt/cgroup/A/tasks

# 测试不限制内存时, 内存的使用情况, 这里不用linux源码也可以, 但最好用个大点的文件夹来压缩, 以便更容易看出内存的变化.
free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/ > /dev/null; free -m;
             total       used       free     shared    buffers     cached
Mem:          1843        122       1721          0          9         43
-/  buffers/cache:         68       1774
Swap:         3888          0       3888
             total       used       free     shared    buffers     cached
Mem:          1843       1744         99          0         26       1614
-/  buffers/cache:        104       1739
Swap:         3888          0       3888

# 重启系统
reboot

# 挂载 memcg
mount -t cgroup -o memory memcg /mnt/cgroup

# 创建 组A
mkdir /mnt/cgroup/A

# 将当前 shell 加入到组A
echo $$ > /mnt/cgroup/A/tasks

# 限制 组A 的内存使用量最大为 10MB
echo 10M > /mnt/cgroup/A/memory.limit_in_bytes

# 测试限制内存为 10MB 时, 内存的使用情况.
rm -rf linux-source-3.2.tar.gz
free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/ > /dev/null; free -m;
             total       used       free     shared    buffers     cached
Mem:          1843        122       1721          0         10         43
-/  buffers/cache:         68       1774
Swap:         3888          0       3888
             total       used       free     shared    buffers     cached
Mem:          1843        194       1649          0         14         48
-/  buffers/cache:        131       1712
Swap:         3888          0       3888

从地点的结果能够观望限制内部存款和储蓄器是起了效果的.

不限量内部存款和储蓄器时, tar 压缩前后 buffer cache 内部存款和储蓄器从 (9MB 43MB) ==> (26MB 1614MB)  增大了 1588MB

限定内部存款和储蓄器后, tar 压缩前后 buffer cache 内部存款和储蓄器从 (10MB 43MB) ==> (14MB 48MB)  增大了 9MB

 

Resource Pool 是SQL Server实例中物理财富的子集,由于位于同三个实例上的有所数据库分享该实例的有着能源,因此,最佳将Resource Pool的多少个结合对象创造在master 数据库中。

总结

简单的说的尝试就意识 cgroup 如此强大的调控技术(而且配置也很简短), 那也就难怪LXC等容器手艺能如此有力, 如此流行.

cgroup 的配置文件过多, 上边的实例中只简单利用了里面包车型大巴多少个布局文件, 假设想浓郁精通 cgroup, 更加好的施用cgroup的话,

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

二,创建和平运动用能源管理器

财富管理器暗中认可是停业的,在使用在此之前,必得启用。客商能够经过SSMS启用能源管理器,张开Management,采用Resource Governor,右击弹出高效菜单,点击“Enable”,启用财富管理器:

图片 2

依旧,使用TSQL命令,  重新配置,启用财富管理器:

ALTER RESOURCE GOVERNOR RECONFIGURE;
GO

1, 成立自定义的能源池(Resource Pool)

SQL Server 内置五个能源池:internal和default,internal是系统之中使用的,default是默许的财富池,当三个查询央浼未有一些名财富池时,使用暗中同意的能源池。为了管住客户区别的职业负荷,DBA供给依靠作业必要创制自定义的财富池。在创设能源池时,须求注意,财富池的选项都以比例关系,全部财富的下限(MIN_MEMORY_PERCENT或MIN_CPU_PERCENT)的加和无法超越系统的概略能源总的数量,即无法超越100。

CREATE RESOURCE POOL rp_20Percent
WITH 
(
     MIN_CPU_PERCENT = 0,
     MAX_CPU_PERCENT = 40,
     CAP_CPU_PERCENT = 40,
     AFFINITY SCHEDULER = auto,
     MIN_MEMORY_PERCENT = 0,
     MAX_MEMORY_PERCENT = 20
);

CAP_CPU_PERCENT挑选:设置能源池具有CPU能源的硬上限,任何Workload Group使用的CPU数量不容许当先该上限,而财富池使用的CPU能源有希望超过 MAX_CPU_PERCENT 选项钦赐的比例。

2,成立专门的工作负载组(Workload Group)

本文由韦德国际1946发布于计算机网络,转载请注明出处:内部存款和储蓄器等财富支配,Linux能源支配

关键词: 伟德国际官网 数据库管理 Resource Gov linux-kernel

上一篇:通讯线路的学问,通信线路
下一篇:没有了