奥门威尼斯网址:Linux下CGroup进行CPU、内存等资源控制,linuxcgroup

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卡塔 尔(英语:State of Qatar)节制进程组能够利用的财富数量(Resource limiting
卡塔 尔(阿拉伯语:قطر‎。比如:memory子系统可认为进程组织设立定三个memory使用上限,意气风发旦进度组使用的内部存款和储蓄器达到限额再提请内部存款和储蓄器,就能够出发OOM(out
of memory卡塔 尔(阿拉伯语:قطر‎。
2卡塔尔进度组的事先级调节(Prioritization
卡塔尔国。举例:能够采用cpu子系统为有个别进度组分配一定cpu share。
3卡塔 尔(英语:State of Qatar)记录进度组使用的能源数量(Accounting
卡塔 尔(阿拉伯语:قطر‎。比如:能够使用cpuacct子系统记录有个别进度组使用的cpu时间
4卡塔尔进度组隔断(Isolation卡塔尔。举个例子:使用ns子系统能够使差别的进度组使用分裂的namespace,以完结隔开分离的指标,区别的经过组有各自的经过、互连网、文件系统挂载空间。
5卡塔尔国进度组决定(Control卡塔尔。举例:使用freezer子系统能够将经过组挂起和还原。

CGroup 帮助的文件种类
表 1. CGroup 帮忙的文本体系

文件名 R/W 用途

Release_agent

RW

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

Notify_on_release

RW

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

Tasks

RW

属于分组的线程 TID 列表

Cgroup.procs

R

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

Cgroup.event_control

RW

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

CGroup 相关概念解释
1卡塔 尔(阿拉伯语:قطر‎职务(task卡塔尔。在 cgroups 中,义务就是系统的一个进度;
2卡塔 尔(阿拉伯语:قطر‎调控族群(control
group卡塔 尔(英语:State of Qatar)。调节族群就是风姿浪漫组依照某种标准划分的进度。Cgroups
中的财富支配都以以调整族群为单位落实。一个进度能够参加到有个别调整族群,也从一个进度组迁移到另八个调整族群。一个经过组的历程能够利用
cgroups 以调整族群为单位分配的资源,同有时间受到 cgroups
以调控族群为单位设定的节制;
3卡塔尔层级(hierarchy卡塔 尔(英语:State of Qatar)。调节族群能够团体成 hierarchical
的花样,既生龙活虎颗调控族群树。调整族群树上的子节点调节族群是父节点调整族群的子女,世袭父调节族群的特定的质量;
4卡塔 尔(阿拉伯语:قطر‎子系统(subsystem卡塔尔。多个子类别正是三个能源调控器,例如 cpu
子系统便是决定 cpu
时间分配的叁个调控器。子系统必得叠合(attach卡塔 尔(英语:State of Qatar)到二个层级上技能起功效,一个子系统附加到某个层级未来,这一个层级上的持有调整族群都受到那个子系统的支配。

相互关系
1卡塔尔每便在系统中创立新层级时,该系统中的全体任务都以不行层级的暗中同意cgroup(大家誉为 root cgroup,此 cgroup
在开立层级时自动创制,前面在该层级中开创的 cgroup 都以此 cgroup
的遗族卡塔 尔(阿拉伯语:قطر‎的初阶成员;
2卡塔尔一个子种类最七只好叠合到四个层级;
3卡塔尔一个层级能够增大七个子系统;
4卡塔 尔(英语:State of Qatar)叁个职分能够是三个 cgroup 的成员,可是那些 cgroup
必得在不一致的层级;
5卡塔 尔(阿拉伯语:قطر‎系统中的进程(任务卡塔尔国创造子进程(职务卡塔 尔(英语:State of Qatar)时,该子职分自动形成其父进度所在
cgroup 的分子。然后可依据要求将该子职务移动到不一致的 cgroup
中,但早先时它总是世襲其父任务的 cgroup。

数据库系统的能源是指内部存款和储蓄器和CPU(微型机卡塔 尔(阿拉伯语:قطر‎财富,具有能源的数量,决定了数额查询的属性。当二个SQL
Server实例上,拥有多少个单身的办事负荷(workload卡塔 尔(阿拉伯语:قطر‎时,使用能源管理器(Resource
Governor卡塔 尔(英语:State of Qatar),能够完成系统财富在逻辑上的隔开分离,解决在乎气风发台SQL
Server实例上,管理多客商职业负荷的供给。财富微电脑允许数据库管理员(DBA卡塔 尔(阿拉伯语:قطر‎通过编制程序设置财富池,配置财富池具备能源的上限,财富池是每多个伸手能够运用的能源,这样设置之后,强制系统在拍卖客商发送的哀求(Requsts卡塔 尔(英语:State of Qatar)时所消耗的CPU

Memory能源的数额不能够超越约束,在必然水平上,约束客商能够选择的财富数量,隔开分离了失控(runaway卡塔尔国的查询对系统的震慑。对于SQL
Server
2011以来,顾客能够基于工作负荷,达成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卡塔 尔(英语:State of Qatar)。调整族群可以协会成 hierarchical
的方式,既生龙活虎颗调整族群树。调节族群树上的子节点调节族群是父节点调节族群的男女,世袭父调节族群的一定的属性。
子系统(subsytem卡塔 尔(阿拉伯语:قطر‎。二个子连串正是贰个财富调控器,比方 cpu
子系统正是决定 cpu
时间分配的多少个调节器。子系统必得附加(attach卡塔 尔(英语:State of Qatar)到三个层级上技术起效果,三个子种类附加到某些层级现在,这几个层级上的具有调整族群都受到这一个子系统的垄断。

子系统的介绍
blkio —
这一个子系统为块设备设定输入/输出节制,举例物理设备(磁盘,机械硬盘,USB
等等卡塔 尔(英语:State of Qatar)。
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就是岁月周期(飞秒),默感觉100000,即百飞秒。cpu.cfs_quota_us便是在那面内可选用的cpu时间(阿秒),暗中认可-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就可以限制在双核上完全使用)。
cpuset:cpu绑定
咱俩节制该组只好在0后生可畏共1个超线程上运转。cpuset.mems是用来安装内部存款和储蓄器节点的。
本例限定使用超线程0上的第两个cpu线程。
骨子里cgconfig也等于帮您把陈设文件中的配置整理到/cgroup/cpuset那几个目录里面,举例你需求动态设置mysql_group1/
cpuset.cpus的CPU超线程号,能够选用如下的法子。
[[email protected]
~]# echo “0” > mysql_group1/ cpuset.cpus
cpuacct:cpu财富报告
memory:内存节制
 
内部存款和储蓄器限定大家根本范围了MySQL能够选用的内部存款和储蓄器最大尺寸memory.limit_in_bytes=256M。而设置swappiness为0是为了让操作系统不会将MySQL的内部存储器佚名页交流出去。
blkio:BLOCK IO限额
blkio.throttle.read_bps_device=”8:0 524288″; #每秒读数据上限
blkio.throttle.write_bps_device=”8:0 524288″; #每秒写多少上限
其间8:0对应主设备号和副设备号,可以通过ls -l /dev/sda查看
[[email protected]
~]# ls -l /dev/sda 
brw-rw—-. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

1.3 扩充文化
近些日子较新的服务器CPU都是numa结构<非同等内部存储器访问结构(NUMA:Non-Uniform
Memory Access卡塔尔>,使用numactl
–hardware可以见到numa各种节点的CPU超线程号,以致相应的节点号。

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

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

# Example: 
#<user> <controllers> <destination> 
#@student cpu,memory usergroup/student/ 
#peter cpu test1/ 
#% memory test2/ 
*:/usr/local/mysql/bin/mysqld * mysql_g1 
注:共分为3个部分,分别为急需节制的实例,约束的原委(如cpu,memory卡塔尔,挂载指标。

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
二〇一一本子中,最多能够创立64个顾客自定义的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 秒
    1000000
    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限定在了第多个为主上,且对第八个大旨的使用约束在百分之二十。

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使用多少个核,如第一个核,且对该核的运用不超越八分之四
[[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总财富的 60%
  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总能源的 四分之二

 

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财富的 49%
  1. 条件同 实例1, 不再另行挂载 cgroup 文件系统, 也不在重新建立 A 和 B
  2. A group 的 cpu.shares 文件不变, 值为 1024
  3. B group 的 cpu.shares 文件中的值改为 512, 那样,
    相当于B占用CPU总能源的 53% (因为 512 / (512+1024) = 1/2)
  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总数的 1/2 左右.

 

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 1000 的pid, 这里假使是 1234
chrt -p 1234         # 能够查阅 pid=1234 的进度的 调治攻略, 输入如下:
      pid 1234’s current scheduling policy: SCHED_OTHER
      pid 1234’s current scheduling priority: 0
chrt -p -f 10 1234   # 改正调节战术为 SCHED_FIFO, 并且优先级为10
chrt -p 1234         # 再一次翻开调整攻略
      pid 1234’s current scheduling policy: SCHED_FIFO
      pid 1234’s current scheduling priority: 10
 
补充:
    chrt 也能够直接钦点一条命令, 并设置那条命令的先行级的调整攻略,
具体查看 chrt –help
    查看一个历程的调节计谋, 除了使用 chrt 命令之外, 还是能够 cat
/proc/<PID>/sched
 
实时进程的CPU调整
所谓的实时过程, 相当于那多个对响适那个时候候间供给相比较高的进度.
那类进程供给在界定的小时内部管理理客商的号令, 因而, 在约束的方今内,
需求占用全部CPU能源, 而且不可能被此外进度打断.
在这种地方下, 假设实时进程中现身了相似死循环之类的情景,
就可以产生整个系列无响应.
因为实时进程的CPU优先级高, 并且未管理完在此之前是不会放出CPU能源的.
 
故此, 内核中须要有大器晚成种方式来界定实时进度的CPU能源占用.
 
系统一整合体安装

  1. 取伏贴前系统的安装
    sysctl -n kernel.sched_rt_period_us   # 实时经过调治的单位CPU时间 1

    1000000
    sysctl -n kernel.sched_rt_runtime_us  # 实时经过在 1
    秒中实际上据有的CPU时间, 0.95秒
    950000
    其生机勃勃装置验证实时进程在运行时并非一心占用CPU的,
    每1秒中有0.05秒的岁月能够给其余进度运转.
    那般既不会对实时进程的响合时间产生太大的熏陶,
    也制止了实时进度卡住时产生整个系统无响应.
     
  2. 设置实时进程占用CPU时间
    上边的默许设置中, 实时经过占用 95% 的CPU时间. 假使认为占用的太多或太少,
    都是能够调动的.比方:
    sysctl -w kernel.sched_rt_runtime_us=900000    #
    设置实时进度每1秒中只占0.9秒的CPU时间
    kernel.sched_rt_runtime_us = 900000
    sysctl -n kernel.sched_rt_runtime_us 
    900000
     
    cgroup 中的设置
    总体安装是指向任何体系的, 大家也得以通过 cgroup
    来对意气风发组经过的CPU能源扩充调节.
    若果想在 cgroup 中对 sched_rt_period_us 和 sched_rt_runtime_us
    进行调控, 必要内核编译选项 CONFIG_RT_GROUP_SCHED=y
    查阅当前系统的基本编写翻译选项方法如下: (debian 7.6 系统)
    cat /boot/config-`uname -r`
    查看 CONFIG_RT_GROUP_SCHED 是还是不是启用
    cat /boot/config-`uname -r` | grep -i rt_group
    # CONFIG_RT_GROUP_SCHED is not set
    debian 7.6 暗许未有运行那几个选项, 所以挂载cgroup之后, 未有设置
    sched_rt_period_us 和 sched_rt_runtime_us 的文件
    mkdir /mnt/cgroup
    mount -t cgroup cgroup /mnt/cgroup/
    cd /mnt/cgroup/
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 09:06 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 09:06 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 09:06 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 09:06 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 09:06 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 09:06 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 09:06 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 09:06
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 09:06 cpu.shares
    –w——- 1 root root 0 Aug 28 09:06 devices.allow
    –w——- 1 root root 0 Aug 28 09:06 devices.deny
    -r–r–r– 1 root root 0 Aug 28 09:06 devices.list
    -rw-r–r– 1 root root 0 Aug 28 09:06 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 09:06 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 09:06 release_agent
    -rw-r–r– 1 root root 0 Aug 28 09:06 tasks
     
    果然, 只有cpu.share, 没有 cpu.sched_rt_period_us 和
    cpu.sched_rt_runtime_us
    无法, 重新编译内核, 编译内核的具体方法参见:  编写翻译Linux内核
    为了节省时间, 我们用 make localmodconfig 来创立 .config 文件,
    然后改正在那之中的 CONFIG_RT_GROUP_SCHED=y
    下载源码等等参见: 编写翻译Linux内核, 主要步骤如下:
    cd /path/to/linux-source-3.2
    make localmodconfig
    vim .config   # 设置 CONFIG_RT_GROUP_SCHED=y 并保存
    make
    make modules_install
    make install
    reboot      # 重启在此之前看看 /boot/grub/grub.cfg 中,
    暗中同意运营的是否新装置的内核
     
    运营到新水源, 再一次查看内核选项 CONFIG_RT_GROUP_SCHED 是不是启用
    cat /boot/config-`uname -r` | grep -i rt_group
    CONFIG_RT_GROUP_SCHED=y       # 已启用
     
    双重挂载 cgroup 文件系统, 开掘多了2个布局文件, cpu.rt_period_us 和
    cpu.rt_runtime_us
    mount -t cgroup cgroup /mnt/cgroup/
    cd /mnt/cgroup/
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 09:53 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 09:53 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 09:53 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 09:53 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 09:53 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 09:53 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 09:53 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.rt_period_us
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.rt_runtime_us
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 09:53
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 09:53 cpu.shares
    –w——- 1 root root 0 Aug 28 09:53 devices.allow
    –w——- 1 root root 0 Aug 28 09:53 devices.deny
    -r–r–r– 1 root root 0 Aug 28 09:53 devices.list
    -rw-r–r– 1 root root 0 Aug 28 09:53 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 09:53 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 09:53 release_agent
    -rw-r–r– 1 root root 0 Aug 28 09:53 tasks
    cat cpu.rt_period_us 
    1000000
    cat cpu.rt_runtime_us 
    950000
     
    经过配备 cpu.rt_period_us 和 cpu.rt_runtime_us 就足以对 cgroup
    中的进度组中的实时进度展开 CPU使用时间的调整.
     
    财富支配实例
    地点根本介绍资源的有的辩解基本功, 上面通过一些实例演示即使因此 cgroup
    来支配进程所接受的 CPU和内部存款和储蓄器 财富.
    Linux对CPU 和 内存的决定有关照的 cgroup 子系统 cpuset 和 memory
     
    实例: cgroup 中对内部 *子cgroup* 的CPU能源支配
    对各个 *子cgroup* 的CPU占用率进行调整首要依附各种 *子cgroup* 的
    cpu.shares 文件
    直白用试验进程来说话, 在那之中参预了有的注释.
    # 安装须要的软件
    apt-get install stress     # 让CPU到达 百分之百 的下压力工具
    apt-get install sysstat    # 查看系统CPU, 内部存款和储蓄器, 磁盘,
    互连网等财富使用意况的工具
     
    实例1 – 暗许情形, A 和 B 各占CPU总能源的 二分之一
        挂载 cgroup 文件系统 (注意加上 -o cpu 的接受)
        在 cgroup中创建 2个子cgroup A 和 B
        暗中同意景况下, cgroup A 和 cgroup B 中的 cpu.shares 中的数值都以 1024
        在 A 和 B 中用 stress 工具使其 CPU占用率到达 百分之百
        top 命令查看 A 和 B 中经过分别攻克的 CPU (应该都以 一半)
     
    # 挂载 cgroup 文件系统
    mount -t cgroup -o cpu cgroup /mnt/cgroup/
    cd /mnt/cgroup
    ls -l
    total 0
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_merged
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_queued
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_service_bytes
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_serviced
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_service_time
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.io_wait_time
    –w——- 1 root root 0 Aug 28 11:29 blkio.reset_stats
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.sectors
    -r–r–r– 1 root root 0 Aug 28 11:29 blkio.time
    -rw-r–r– 1 root root 0 Aug 28 11:29 blkio.weight
    -rw-r–r– 1 root root 0 Aug 28 11:29 blkio.weight_device
    -rw-r–r– 1 root root 0 Aug 28 11:29 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 11:29 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 11:29 cgroup.procs
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuacct.stat
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuacct.usage
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuacct.usage_percpu
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.cpu_exclusive
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.cpus
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mem_exclusive
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mem_hardwall
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_migrate
    -r–r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_pressure
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_pressure_enabled
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_spread_page
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.memory_spread_slab
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.mems
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpuset.sched_load_balance
    -rw-r–r– 1 root root 0 Aug 28 11:29
    cpuset.sched_relax_domain_level
    -rw-r–r– 1 root root 0 Aug 28 11:29 cpu.shares
    –w——- 1 root root 0 Aug 28 11:29 devices.allow
    –w——- 1 root root 0 Aug 28 11:29 devices.deny
    -r–r–r– 1 root root 0 Aug 28 11:29 devices.list
    -rw-r–r– 1 root root 0 Aug 28 11:29 net_cls.classid
    -rw-r–r– 1 root root 0 Aug 28 11:29 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 11:29 release_agent
    -rw-r–r– 1 root root 0 Aug 28 11:29 tasks
    # 创建 子cgroup A 和 B
    mkdir {A,B}
    cat A/cpu.shares 
    1024
    cat B/cpu.shares 
    1024
    # 在 A 和 B 中分别通过 stress 工具使其CPU使用率达到 百分之百
    echo ¥¥ > A/tasks  # 将近期的 SHELL 参预到 cgroup A中
    stress -c 2    # 这里-c 2 是因为测量试验机器是双核, 要在2个核上都发生 百分百的CPU 占用率
    # 别的打开叁个 shell 窗口, 并将以此shell 参与到 cgroup B中
    echo ¥¥ > B/tasks  # 将前段时间的 SHELL 参加到 cgroup B中
    stress -c 2    # 在2个核上都发出 百分百 的CPU 占用率
    # 再打开叁个 shell 窗口, 用top命令查看 CPU占用意况
    top
    top – 14:10:32 up 43 min,  3 users,  load average: 2.31, 1.24, 0.62
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   114744 used,  1773128 free,    10472
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    45068
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3350 root      20   0  6524   92    0 R  49.9  0.0   0:08.73
    stress                                                                                                                     
     
    3351 root      20   0  6524   92    0 R  49.9  0.0   0:08.67
    stress                                                                                                                     
     
    3353 root      20   0  6524   92    0 R  49.9  0.0   0:07.35
    stress                                                                                                                     
     
    3354 root      20   0  6524   92    0 R  49.9  0.0   0:07.36
    stress                    
    # 查看那 4 个stress 进度是或不是分别归于 A 和 B
    cat /mnt/cgroup/A/tasks 
    2945
    3349
    3350   <– stress 进程
    3351   <– stress 进程
    cat /mnt/cgroup/B/tasks 
    2996
    3352
    3353   <– stress 进程
    3354   <– stress 进程
    能够见到, A和B组中的 2个stress 进度的CPU使用率相加都是 百分百,
    是因为我测量检验的Computer是双核, top所见到的CPU最大使用率是 200%, 所以和预期生机勃勃致,
    A和B组各占CPU总财富的 1/4
     
    实例2 – A group 占用全体CPU能源的 2/3, B group 占用全体CPU能源的 59%
        情形同 实例1, 不再另行挂载 cgroup 文件系统, 也不在重新创立 A 和 B
        A group 的 cpu.shares 文件不改变, 值为 1024
        B group 的 cpu.shares 文件中的值改为 512, 那样,
    相当于B占用CPU总财富的 二分之一 (因为 512 / (512+1024) = 三分之二)
        同实例1, 通过2个shell窗口, 分别是 A 和 B 的CPU使用率高达 百分之百,
    然后通过 top 查看CPU使用景况
     
    # 在 B 中shell 窗口进行以下命令
    cat B/cpu.shares 
    1024
    echo 512 > B/cpu.shares 
    cat B/cpu.shares 
    512
    stress -c 2
    # 在 A 中 shell 窗口进行以下命令
    stress -c 2
    # 在第一个 shell 窗口, 也便是 非A, 非B 的十分 shell 窗口, 用 top
    查看cpu使用状态
    top
    top – 14:13:18 up 46 min,  3 users,  load average: 2.24, 1.92, 1.01
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   114744 used,  1773128 free,    10488
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    45068
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3376 root      20   0  6524   88    0 R  66.6  0.0   0:06.29
    stress                                                                                                                     
     
    3377 root      20   0  6524   88    0 R  66.6  0.0   0:06.30
    stress                                                                                                                     
     
    3373 root      20   0  6524   88    0 R  33.3  0.0   0:04.33
    stress                                                                                                                     
     
    3374 root      20   0  6524   88    0 R  33.3  0.0   0:04.32
    stress               
    # 查看那 4 个stress 进度是不是分别归于 A 和 B
    cat /mnt/cgroup/A/tasks 
    2945
    3375
    3376    <– stress 进程
    3377    <– stress 进程
    cat /mnt/cgroup/B/tasks 
    2996
    3372
    3373    <– stress 进程
    3374    <– stress 进程
    很刚毅, A 组中的2个经过占用了CPU总的数量的 2/3 左右,
    B组中的2个进程占用了CPU总数的 1/4 左右.
     
    实例3 – 物理CPU的控制
    地方的实例中, 固然能够支配每一个组的CPU的完好占用率,
    可是无法垄断(monopoly卡塔 尔(英语:State of Qatar)有个别组的历程固定在有些物理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
    # 再张开第1个 shell 窗口, 用top命令查看CPU使用情状
    top
    top – 15:13:29 up  1:46,  3 users,  load average: 1.01, 0.24, 0.12
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s): 50.0 us,  0.0 sy,  0.0 ni, 50.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   117216 used,  1770656 free,    11144
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    47088
    cached
     PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
    3830 root      20   0  6524   92    0 R  25.0  0.0   0:04.96
    stress                                                                                                                     
     
    3831 root      20   0  6524   92    0 R  25.0  0.0   0:04.97
    stress                                                                                                                     
     
    3834 root      20   0  6524   92    0 R  25.0  0.0   0:03.56
    stress                                                                                                                     
     
    3833 root      20   0  6524   92    0 R  24.6  0.0   0:03.56 stress
    从地点的结果能够看看, 即便 stress 命令钦赐了 -c 2(意思是在2个CPU上运转),
    不过出于A和B都只绑定了CPU0,
    因此纵然是双核的机器, 它们所攻陷的CPU总的数量却唯有 百分之百, 并不是实例1 中的
    200%.
     
    只要将B组的情理CPU绑定到CPU1, 那么应该负有 stress 的进程都攻陷 二分一,
    CPU能源的总的数量变为 200%.
    下边将B组的情理CPU绑定为CPU1, 看看结果是还是不是和大家的料想同样.
    # 在 B组的 shell 窗口中实践以下命令
    echo 1 > /mnt/cgroup/B/cpuset.cpus
    cat /mnt/cgroup/B/cpuset.cpus
    1
    stress -c 2
    # 在 A组的 shell 窗口中实行以下命令
    stress -c 2
    # 在首个shell窗口中用top命令查看试行结果
    top
    top – 15:20:07 up  1:53,  3 users,  load average: 0.38, 0.83, 0.56
    Tasks:  78 total,   5 running,  73 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si, 
    0.0 st
    KiB Mem:   1887872 total,   117340 used,  1770532 free,    11168
    buffers
    KiB Swap:  3982332 total,        0 used,  3982332 free,    47088
    cached
      PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+ 
    COMMAND                                                                                                                    
     
     3854 root      20   0  6524   88    0 R  49.9  0.0   0:03.76
    stress                                                                                                                     
     
     3857 root      20   0  6524   92    0 R  49.9  0.0   0:02.29
    stress                                                                                                                     
     
     3858 root      20   0  6524   92    0 R  49.9  0.0   0:02.29
    stress                                                                                                                     
     
     3855 root      20   0  6524   88    0 R  49.6  0.0   0:03.76 stress
    果真, 和预期后生可畏致. A组中的 stress 和 B组中的 stress
    在分级的大意CPU上都占领了 百分百 左右的CPU使用率.
     
    实例4 – cgroup 对选拔的内部存款和储蓄器的垄断
    cgroup 对内部存款和储蓄器的决定也特别不难, 只要挂载cgroup时, 钦定 -o memory
    # 首先从前挂载的 cpuset 子系统
    umount /mnt/cgroup
    # 挂载cgroup 文件系统, 钦赐 -o memeory
    mount -o memory -t cgroup memcg /mnt/cgroup/
    mount: special device memcg does not exist
     
    并发上述错误的案由大概是因为debian系统中, 暗中认可未有运转 cgroup
    的memory子系统. 能够经过以下办法断定:
    cat /proc/cgroups 
    #subsys_name    hierarchy    num_cgroups    enabled
    cpuset    0    1    1
    cpu    0    1    1
    cpuacct    0    1    1
    memory    1    1    0              <– 这里的 enabled 是 0
    devices    0    1    1
    freezer    0    1    1
    net_cls    0    1    1
    blkio    0    1    1
    perf_event    0    1    1
     
    为了暗许启用memory子系统, 能够设置 grub选项
    vim /etc/default/grub
    # 修改 GRUB_CMDLINE_LINUX=””  ==>
    GRUB_CMDLINE_LINUX=”cgroup_enable=memory”
    # 保存后, 更新grub.cfg
    update-grub
    reboot
     
    重启之后, 开采 /proc/cgroups 中的memory已经 enabled, 并且也能够挂载
    memcg了
    cat /proc/cgroups 
    #subsys_name    hierarchy    num_cgroups    enabled
    cpuset    0    1    1
    cpu    0    1    1
    cpuacct    0    1    1
    memory    1    1    1
    devices    0    1    1
    freezer    0    1    1
    net_cls    0    1    1
    blkio    0    1    1
    perf_event    0    1    1
    # 挂载cgroup 的memory子系统
    mount -t cgroup -o memory memcg /mnt/cgroup
    ls -l /mnt/cgroup/   <– 能够见到有多数 memory 相关的配备
    total 0
    -rw-r–r– 1 root root 0 Aug 28 15:54 cgroup.clone_children
    –w–w–w- 1 root root 0 Aug 28 15:54 cgroup.event_control
    -rw-r–r– 1 root root 0 Aug 28 15:54 cgroup.procs
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.failcnt
    –w——- 1 root root 0 Aug 28 15:54 memory.force_empty
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.limit_in_bytes   <–
    限定内部存款和储蓄器使用的布局文件
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.max_usage_in_bytes
    -rw-r–r– 1 root root 0 Aug 28 15:54
    memory.move_charge_at_immigrate
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.numa_stat
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.oom_control
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.soft_limit_in_bytes
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.stat
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.swappiness
    -r–r–r– 1 root root 0 Aug 28 15:54 memory.usage_in_bytes
    -rw-r–r– 1 root root 0 Aug 28 15:54 memory.use_hierarchy
    -rw-r–r– 1 root root 0 Aug 28 15:54 notify_on_release
    -rw-r–r– 1 root root 0 Aug 28 15:54 release_agent
    -rw-r–r– 1 root root 0 Aug 28 15:54 tasks
     
    起来试验:
        重启系统 (为了确定保障内部存款和储蓄器的通透到底)
        挂载 memcg
        在挂载的 /mnt/cgroup 中开创 组A
        将当前shell 加入到 组A
        不限制组A的内部存款和储蓄器, 压缩内核源码包, 并阅览压缩前后内部存储器的变动
        重复步骤 1 ~ 4
        节制组A的内部存款和储蓄器为 10MB, 再一次减弱内核源码包, 并观看压缩前后内部存款和储蓄器的转移
     
    # 重启系统
    reboot
    # 挂载 memcg
    mount -t cgroup -o memory memcg /mnt/cgroup
    # 创建 组A
    mkdir /mnt/cgroup/A
    # 将日前 shell 参与到组A
    echo ¥¥ > /mnt/cgroup/A/tasks
    # 测量检验不约束内部存款和储蓄器时, 内部存款和储蓄器的应用情状, 这里不用linux源码也得以,
    但最棒用个大点的文本夹来裁减, 以便更便于见到内部存款和储蓄器的变化.
    free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/
    > /dev/null; free -m;
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        122       1721          0          9        
    43
    -/+ buffers/cache:         68       1774
    Swap:         3888          0       3888
                 total       used       free     shared    buffers    
    cached
    Mem:          1843       1744         99          0         26      
    1614
    -/+ buffers/cache:        104       1739
    Swap:         3888          0       3888
    # 重启系统
    reboot
    # 挂载 memcg
    mount -t cgroup -o memory memcg /mnt/cgroup
    # 创建 组A
    mkdir /mnt/cgroup/A
    # 将最近 shell 出席到组A
    echo ¥¥> /mnt/cgroup/A/tasks
    # 限定 组A 的内部存款和储蓄器使用量最大为 10MB
    echo 10M > /mnt/cgroup/A/memory.limit_in_bytes
    # 测量试验节制内部存款和储蓄器为 10MB 时, 内部存款和储蓄器的行使情形.
    rm -rf linux-source-3.2.tar.gz
    free -m; tar czvf linux-source-3.2.tar.gz /path/to/linux-source-3.2/
    > /dev/null; free -m;
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        122       1721          0         10        
    43
    -/+ buffers/cache:         68       1774
    Swap:         3888          0       3888
                 total       used       free     shared    buffers    
    cached
    Mem:          1843        194       1649          0         14        
    48
    -/+ buffers/cache:        131       1712
    Swap:         3888          0       3888
    从地方的结果能够看看限定内部存款和储蓄器是起了职能的.
    不约束内部存款和储蓄器时, tar 压缩前后 buffer + cache 内部存款和储蓄器从 (9MB + 43MB) ==>
    (26MB + 1614MB)  增大了 1588MB
    范围内部存款和储蓄器后, tar 压缩前后 buffer + cache 内部存款和储蓄器从 (10MB + 43MB) ==>
    (14MB + 48MB)  增大了 9MB
     
    总结
    轻松易行的试验就发掘 cgroup 如此强硬的调节技艺(何况配置也不会细小略),
    那也就难怪LXC等容器技艺能那样强大, 如此流行.
    cgroup 的配备文件过多, 上边的实例中只简轻巧单利用了内部的多少个布局文件,
    假若想深切摸底 cgroup, 更加好的应用cgroup的话,
    还得找个介绍cgroup配置文件的文书档案来研究一下,
    那篇博客提供的内容还远远不足.

查阅商议

留存 from: and
CGroup…

 奥门威尼斯网址 1

实例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

 

开端尝试:

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

创设工作负荷分组,通过using子句关联该分组能够使用的能源池,叁个干活负荷分组只好关联三个财富池,一个财富池能够服务二个或多个干活负荷分组。

CREATE WORKLOAD GROUP wg_20Percent
WITH
(
    IMPORTANCE = MEDIUM,
    REQUEST_MAX_MEMORY_GRANT_PERCENT=20,
    REQUEST_MAX_CPU_TIME_SEC=0,
    REQUEST_MEMORY_GRANT_TIMEOUT_SEC=0,
    MAX_DOP=0,
    GROUP_MAX_REQUESTS=0
)
USING rp_20Percent;

IMPORTANCE选项:有四个可选值:Low,Medium和High,私下认可值是Medium,该选用用于钦点该Workload
Group在事关的能源池(Resource
Pool卡塔尔国中绝没有错首要,由于同多个能够Resource Pool关联八个Workload
Group,当三个做事负载组(Workload
Group卡塔尔国的Importance数值高于其余干活负载组(Workload
Group卡塔尔时,在竞争Resource
Pool中的财富时,更便于胜球。当前职业负载组的IMPORTANCE的选项不会选用别的财富池,也不会影响其余财富组中的职业负荷。

REQUEST_MAX_MEMORY_GRANT_PERCENT:暗许值是25,用于钦点专业负载组能够从能源组中申请到的最大付与内部存款和储蓄器(GrantMemory卡塔 尔(阿拉伯语:قطر‎财富,由于付与内部存款和储蓄器跟实施的SORT和HASH
JOIN操作有关,假设设置REQUEST_MAX_MEMORY_GRANT_PERCENT为0,那象征,SQL
Server引擎将不允许施行排序和哈希链接操作。

MAX_DOP:用于钦命并发查询的最大并发度(Degree of
Parallelism卡塔尔国,暗许值是0,表示使用全局配置(Global Setting卡塔尔。

3,创设分类函数(Classifier Function卡塔尔国

分类函数根据特定的平整(Rule卡塔尔国把收到的request路由到差异的能源池中,客户应该把分类函数创建在master数据库中,那样,函数的效用域正是总体SQL
Server实例,分类函数的实践上下文是master
数据库;就算分类函数再次来到NULL,default或不设有的职业负载组的名称,那么查询被路由导default资源池:

  • If the user-defined function returns NULL, default, or the name of
    non-existent group the session is given the default workload group
    context. The session is also given the default context if the
    function fails for any reason.

  • The function should be defined with server scope (master database).

举个例子说,依据客户名称,将Request划分到wg_20Percent负载分组。默许情况下,任何未有一些名Workload
Group的Request,都散发到Default能源池。在骨子里付加物情状中,也得以选择应用程式_NAME()获取应用程序名字,也许SUSERAV4_NAME()获取顾客的登入(Login卡塔尔国名称,依据料用程序或登录名称划分负载分组。

CREATE FUNCTION dbo.rgClassifierFunction_20Percent() 
RETURNS sysname
WITH SCHEMABINDING
AS
BEGIN
    DECLARE @Workload_Group_Name AS sysname
      IF (SUSER_NAME() = 'USER_READONLY')
          SET @workload_group_name = 'wg_20Percent'
    RETURN @workload_group_name
END;

常用来分类函数(Classifier
Function卡塔尔国中的函数如下,那些函数的实施上下文是成套Server:

  • APP_NAME():重临当前Session所在的应用程序的名号
  • HOST_NAME():重回主机名称;
  • SUSER_NAME():重回登录名;
  • IS_SVROLEMEMBE奥迪Q5():当客户是一定的服务器剧中人物时,重回True;

在乎:列表中等学园函授数实践的上下文和归类函数的上下文相符,如若分类函数被创立在master数据库,那么分类函数的询问的节制是在master数据库。

实行上下文是单个数据库的函数是:

  • IS_MEMBER(‘role | group’)
  •  IS_ROLEMEMBER ( ‘role’ [ , ‘database_principal’ ] )

函数:IS_MEMBEEscort(‘role |
group’),用于检验当前的顾客(User卡塔尔是或不是归于当前数据库的role或windows
group。平时状态下,大家把分类函数成立在master系统数据库中,那会产生函数的进行上下文是master数据库,并非客商数据库,而master数据库中恐怕子虚乌有windows
group(数据库客户User卡塔尔国,那会招致函数不或然起到分类的效率:

IS_MEMBER doesn’t work here as it’ll be firing in the context of
the master db, not the user database you’re interested in.

为了然决这么些标题,必需在master数据库中创设相应的windows
group(数据库客户User卡塔 尔(英语:State of Qatar)。

4,运维能源微处理器(Resource Governor卡塔 尔(英语:State of Qatar)

为了运营资源微处理器(Resource
Governor),首先配置能源微型机使用的分类函数,把财富微电脑和分类函数关联起来;然后,重新配置财富微处理机,运营Resource
Governor。运行今后,SQL Server引擎使用分类函数对把SQL
Server实例选择的询问乞请(Requests卡塔 尔(阿拉伯语:قطر‎,分配到分歧的负荷分组中。

ALTER RESOURCE GOVERNOR 
WITH (CLASSIFIER_FUNCTION=dbo.rgClassifierFunction_20Percent);
GO
ALTER RESOURCE GOVERNOR
RECONFIGURE;
GO

5,改进分类函数

改进分类函数,供给先禁止使用财富管理器,然后去掉分类函数和资源微处理机的涉及关系,然后修正分类函数,把能源微机和归类函数重新绑定:

奥门威尼斯网址 3奥门威尼斯网址 4

ALTER RESOURCE GOVERNOR
DISABLE;
GO
ALTER RESOURCE GOVERNOR 
WITH (CLASSIFIER_FUNCTION=NULL);
GO

ALTER FUNCTION dbo.rgClassifierFunction_20Percent() 
RETURNS sysname
WITH SCHEMABINDING
AS
BEGIN
    ....
END;
GO

ALTER RESOURCE GOVERNOR 
WITH (CLASSIFIER_FUNCTION=dbo.rgClassifierFunction_20Percent);
GO
ALTER RESOURCE GOVERNOR
RECONFIGURE;
GO

View Code

三,查看财富管理器

透过以下三个视图查看能源微处理器的元数据:

sys.resource_governor_configuration
sys.resource_governor_workload_groups
sys.resource_governor_resource_pools

经过以下多少个DMV查看财富微型机的总计数据:

sys.dm_resource_governor_configuration
sys.dm_resource_governor_workload_groups
sys.dm_resource_governor_resource_pools

DMV sys.dm_exec_requests 和 sys.dm_exec_sessions
中包含group_id字段,用于表示方今session或request处于的办事负荷分组。

 

MSDN示例脚本:

奥门威尼斯网址 5奥门威尼斯网址 6

CREATE FUNCTION dbo.rgclassifier_v1() 
RETURNS sysname 
WITH SCHEMABINDING
AS
BEGIN
-- Declare the variable to hold the value returned in sysname.
    DECLARE @grp_name AS sysname
-- If the user login is 'sa', map the connection to the groupAdmin  workload group. 
    IF (SUSER_NAME() = 'sa')
        SET @grp_name = 'groupAdmin'
-- Use application information to map the connection to the groupAdhoc workload group.
    ELSE IF (APP_NAME() LIKE '%MANAGEMENT STUDIO%')
        OR (APP_NAME() LIKE '%QUERY ANALYZER%')
            SET @grp_name = 'groupAdhoc'
-- If the application is for reporting, map the connection to the groupReports workload group.
    ELSE IF (APP_NAME() LIKE '%REPORT SERVER%')
        SET @grp_name = 'groupReports'
-- If the connection does not map to any of the previous groups, put the connection into the default workload group.
    ELSE
        SET @grp_name = 'default'
    RETURN @grp_name
END;
GO

-- Register the classifier user-defined function and update the 
-- the in-memory configuration.
ALTER RESOURCE GOVERNOR 
WITH (CLASSIFIER_FUNCTION=dbo.rgclassifier_v1);
GO
ALTER RESOURCE GOVERNOR RECONFIGURE;
GO

View Code

 

参谋文书档案:

Resource
Governor.aspx)

Resource Governor in SQL Server
2012

选取sql server 二〇〇八能源调节器约束内定客户查询所利用CPU能源

CREATE RESOURCE POOL
(Transact-SQL).aspx)

CREATE WORKLOAD GROUP
(Transact-SQL).aspx)

ALTER RESOURCE GOVERNOR
(Transact-SQL).aspx)

发表评论

电子邮件地址不会被公开。 必填项已用*标注