您的位置:时时app平台注册网站 > 彩世界网址 > Linux下CGroup进行CPU、内存等资源控制,linuxcgroup彩

Linux下CGroup进行CPU、内存等资源控制,linuxcgroup彩

2019-09-14 01:31

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的进程号。

图 1. CGroup 层级图

IO限制测验

用dd对硬盘进行写操作

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

打开iotop看下IO速度

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

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

TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND

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

为了调整IO速度,在blkio上创办调节组

# cgcreate -g blkio:/hzmali_test

查阅下硬盘号

# ls -l /dev/sda

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

安装硬盘号和呼应的读取速度限制,然后施行同一的下令

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

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

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

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

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

TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND

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

cgroup小结

行使cgroup一时对经过展开调解,直接通过命令就能够,如果要悠久化对经过打开调控,即重启后依然有效,要求写进配置文件/etc/cgconfig.conf及/etc/cgrules.conf 

***************当您开掘本人的才华撑不起野心时,就请安静下来学习啊***************

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

¥¥='$$'

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

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

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

翻开商议

留存 from: and CGroup...

彩世界网址 1

如图 2 所示,CGroup 技艺能够被用来在操作系统底层限制物理财富,起到 Container 的功能。图中每贰个 JVM 进程对应三个 Container Cgroup 层级,通过 CGroup 提供的种种子系统,能够对每七个 JVM 进度对应的线程等级实行物理限制,这几个限制包涵CPU、内部存储器等等多数门类的能源。下一部分会切实对应用程序实行 CPU 财富隔开分离举办亲自过问。

作为二个正在做着容器项指标人,知道容器本事是依靠Cgroup和Namespace来完毕的。在容器中,cpu和内存能源是接纳Cgroup来决定,PID、IPC、网络等能源是经过Namespace来划分。在程序未有配备在容器的图景下,大家还能够接纳Cgoup和Namespace来协开会地点景完毕都部队分非常测量检验,如选拔Cgroup的能源支配成效做能源满载的测验;利用Namespace的能源隔绝天性做一些网络非常测验而不影响其余程序的运营。

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每秒以内。

    7.3 运行MySQL,查看MySQL是或不是处于cgroup的限定中

[plain] view plain copy

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

Cgroup文档

Cgroup的采取细节,子系统和参数设置都足以能够在中找到,传承等特色由于篇幅所限,能够看下文书档案

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 ,更换配置文件后四个劳务须要重启,且顺序不能够错。

    8.3 IO限制实例

    跑贰个消耗IO的测验

[plain] view plain copy

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

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

彩世界网址 2 
    限制读取速度为10M/S

[plain] view plain copy

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

    注1:45033为dd的历程号

    注2:8:0对应主设备号和副设备号,能够经过ls -l /dev/sda查看

[plain] view plain copy

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

有的是时候供给测验程序在能源受限意况下的表现,普通的做法大概是时时四处对系统加压使能够分配给指标程序的能源减少,换另贰个思路思索,能够品味限制分配给指标程序的能源总的数量,使得机器状态平常的气象下让程序能源采用达到饱和。

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

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。

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

用调节组限制指标程序内部存款和储蓄器使用为一千000 byte,当然,必要root实行
echo "1000000" >memory.limit_in_bytes

一般更推荐用cgset来安装数值

cgset -r memory.limit_in_bytes=1000000 hzmali_test

下一场构造贰个吃内部存款和储蓄器的顺序,每运营三遍内部存储器使用就大幅度增加

#vim memtest.sh

x="hahaha"

while [ True ];do

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

sleep 1

done;

接下来运转程序,并将经过pid写入mem上边调控组的tasks中

#./memtest.sh &

[1] 17638

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

应用cgclassify 能够将运营中的进度加到task中,假若调节组有多少个能源的调整,使用命令会比echo方便广大

cgclassify -g mem:hzmali_test 17638

接下来那货就在相连占内部存款和储蓄器,由于并未有设置disable oom killing,所以最终会oom被kill掉

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

966656

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

978944

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

995328

#

[1] Killed ./memtest.sh

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

留存

from:   and 

CGroup 介绍
CGroup 是 Control Groups 的缩写,是 Linux 内核提供的一种能够限制、记录、隔开进度组 (process groups) 所使用的财力能源 (如 cpu memory i/o 等等) 的体制。二〇〇五 年步入 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。

    7.2 使配置生效

[plain] view plain copy

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

    注:重启顺序为cgconfig -> cgred ,改变配置文件后七个劳务须要重启,且顺序不能够错。

 

3)IO限制实例

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

 
范围读取速度为10M/S

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

CGroup 特点

在 cgroups 中,任务正是系统的贰个历程。

调节族群(control group)。调控族群便是一组遵照某种规范划分的进程。Cgroups 中的能源支配都以以调控族群为单位完成。二个历程能够参与到某些调控族群,也从三个进程组迁移到另一个调节族群。四个进度组的历程能够应用 cgroups 以调控族群为单位分配的财富,同临时候面前遭逢 cgroups 以调节族群为单位设定的限制。

层级(hierarchy)。调整族群能够组织成 hierarchical 的格局,既一颗调控族群树。调节族群树上的子节点调整族群是父节点调控族群的男女,承袭父调整族群的一定的属性。

子系统(subsytem)。二个子体系正是贰个能源调整器,例如 cpu 子系统正是决定 cpu 时间分配的二个调控器。子系统必需附加(attach)到一个层级上手艺起效果,一个子种类附加到有个别层级以往,这几个层级上的全部调整族群都受到那么些子系统的支配。

Cgroup实战

图 1. CGroup 层级图

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

CGroup 特点
在 cgroups 中,职务便是系统的四个经过。
调控族群(control group)。调整族群就是一组根据某种规范划分的经过。Cgroups 中的能源支配都以以调节族群为单位贯彻。三个经过能够步入到有个别调节族群,也从贰个进程组迁移到另三个调节族群。三个历程组的进度能够运用 cgroups 以调控族群为单位分配的能源,同期面前遭逢 cgroups 以调控族群为单位设定的范围。
层级(hierarchy)。调控族群可以协会成 hierarchical 的款式,既一颗调控族群树。调节族群树上的子节点调整族群是父节点控制族群的儿女,承继父调控族群的一定的性质。
子系统(subsytem)。二个子种类就是四个财富调控器,举例 cpu 子系统正是决定 cpu 时间分配的三个调整器。子系统必须叠合(attach)到八个层级上技能起效用,三个子系统附加到某些层级今后,那些层级上的有所调整族群都受到那一个子系统的决定。

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

CGroup 介绍

CGroup 是 Control Groups 的缩写,是 Linux 内核提供的一种可以限制、记录、隔断进度组 (process groups) 所使用的财力财富 (如 cpu memory i/o 等等) 的建制。二零零七 年步入 Linux 2.6.24 内核,CGroups 不是斩新创设的,它将经过管理从 cpuset 中剥离出来,作者是 谷歌(Google) 的 Paul Menage。CGroups 也是 LXC 为达成设想化所使用的财富管理花招。

安装(ubuntu)

#apt-get install cgroup-bin

图 2. CGroup 标准应用框架结构图

如图 2 所示,CGroup 技能能够被用来在操作系统底层限制物理财富,起到 Container 的效果与利益。图中每二个 JVM 进度对应三个 Container Cgroup 层级,通过 CGroup 提供的种种子系统,能够对每二个 JVM 进度对应的线程等第举办物理限制,那些限制包蕴CPU、内部存款和储蓄器等等许五类别的能源。下一部分会实际对应用程序进行 CPU 能源隔断实行躬体力行。

cgroup的安装
实质上安装很简单,最棒试行正是yum直接设置(centos下)

配置文件

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

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

其中:
name: 指定cgroup的名称
permissions:可选择,钦点cgroup对应的挂载点文件系统的权能,root顾客全部有着权限。
controller:子系统的称谓
param name 和 param value:子系统的质量及其属性值

CGroup 作用及组成

CGroup 是将随意进度张开分组化管理的 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子系统能够将经过组挂起和回复。

CPU限制测量试验

本身的机器上有2个核

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

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

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

x=a

while [ True ];do

x=$x

done;

举例小编不想把机器跑死,这里想要限制组里的历程的CPU使用,有2种做法
1.在cpu子系统中央调控制cpu调治的分配的定额
先看下当前cpu分配景况

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

-1

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

100000

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

#./cpu_test.sh &

[1] 17709

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

仍旧直接采用命令cgexec实行

cgexec -g cpu:hzmali_test ./cpu_test.sh

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

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

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

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

2.在cpuset调控物理cpu的分配
眼下应用了地方的方式后,大家开采经过的CPU使用都在Cpu0上,此番希望只用Cpu1来跑那么些小程序
故此把调节组也加到cpuset

# cgcreate -g cpuset:/hzmali_test

看一下现行反革命选取的cpu的安装

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

0-1

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

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

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

或用命令

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

# cgclassify -g cpu,cpuset:hzmali_test 17709

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

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

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

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

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

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

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

子系统的介绍

blkio   -- 那个子系统为块设备设定输入/输出限制,譬喻物理设备(磁盘,机械硬盘,USB 等等)。
cpu     -- 那一个子系统使用调整程序提供对 CPU 的 cgroup 职分访谈。
cpuacct -- 那一个子系统自动生成 cgroup 中职分所运用的 CPU 报告。
cpuset  -- 那些子系统为 cgroup 中的职分分配独立 CPU(在多核系统)和内部存储器节点。
devices -- 那些子系统可允许恐怕拒绝 cgroup 中的职分访谈设备。

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

CGroup 应用架构

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_quota_us正是在那之间内可应用的cpu时间(微秒),暗中同意-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就可以限定在双核上完全选择)。
cpuset:cpu绑定
大家限制该组只可以在0一共1个超线程上运维。cpuset.mems是用来设置内部存储器节点的。
本例限制使用超线程0上的第几个cpu线程。
实质上cgconfig也正是帮您把铺排文件中的配置整理到/cgroup/cpuset这几个目录里面,比方您须要动态设置mysql_group1/ cpuset.cpus的CPU超线程号,能够利用如下的点子。
[[email protected] ~]# echo "0" > mysql_group1/ cpuset.cpus
cpuacct:cpu能源报告
memory:内存限制
 
内部存款和储蓄器限制我们首要范围了MySQL能够应用的内部存款和储蓄器最大尺寸memory.limit_in_bytes=256M。而设置swappiness为0是为了让操作系统不会将MySQL的内存无名氏页交流出去。
blkio:BLOCK IO限额
blkio.throttle.read_bps_device="8:0 524288"; #每秒读数据上限
blkio.throttle.write_bps_device="8:0 524288"; #每秒写多少上限
内部8:0对应主设备号和副设备号,能够透过ls -l /dev/sda查看
[[email protected] ~]# ls -l /dev/sda 
brw-rw----. 1 root disk 8, 0 Sep 15 04:19 /dev/sda

1.3 扩充文化
近日较新的服务器CPU都以numa结构<非同等内存访谈结构(NUMA:Non-Uniform Memory Access)>,使用numactl --hardware能够见见numa各种节点的CPU超线程号,以及相应的节点号。

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

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

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

CGroup 补助的公文体系

Cgroup介绍

Cgroup是举办分组化管理的Linux内核功效,具体的财富管理是通过子系统来成功的。能够精晓为子系统正是能源调节器,每个子系统正是一个财富的分配器,譬喻cpu子系统是调整cpu时间分配的,使用办法如下

cgroup实例深入分析(手工业动态验证)

复原配置文件/etc/cgconfig.conf及/etc/cgrules.conf 为暗中同意配置。测验实譬照旧为mysql,测验工具为mysqlslap。

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

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

通过htop查看能源消耗。

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

    还原配置文件/etc/cgconfig.conf及/etc/cgrules.conf 为暗许配置。测量检验实例如故为mysql,测量试验工具为mysqlslap。

    开启cgconfig及cgrules 服务。

[plain] view plain copy

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

    开启mysqlslap压力测验程序。

[plain] view plain copy

  1. [root@localhost /]# /usr/local/mysql/bin/mysqlslap --defaults-file=/etc/my.cnf --concurrency=150 --iterations=1 --number-int-cols=8 --auto-generate-sql --auto-generate-sql-load-type=mixed --engine=innodb --number-of-queries=100000 -ujesse -pjesse --number-char-cols=35 --auto-generate-sql-add-autoincrement --debug-info -P3306 -h127.0.0.1  

    通过htop查看能源消耗。

彩世界网址 3

子系统验证

能够使用lssubsys -a来列出系统扶助多少种子系统,和:举个例子cpu是决定cpu时间片的,memory是决定内部存款和储蓄器使用的

#lssubsys -a

cpuset

cpu,cpuacct

memory

devices

freezer

net_cls,net_prio

blkio

perf_event

hugetlb

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

blkio 那个子系统设置限定种种块设备的输入输出调控。举个例子:磁盘,光盘以及usb等等。

cpu 这么些子系统应用调解程序为cgroup任务提供cpu的探望。

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

cpuset 就算是多为重的cpu,那么些子系统会为cgroup职责分配单独的cpu和内部存款和储蓄器。

devices 允许或拒绝cgroup任务对设施的会见。

freezer 暂停和回复cgroup职务。

memory 设置每一个cgroup的内部存款和储蓄器限制以及发生内部存款和储蓄器能源报告。

net_cls 标志每一个网络包以供cgroup方便使用。

ns 名称空间子系统

perf_event: 伸张了对每group的监测追踪的技艺,即能够监测属于有个别特定的group的具有线程以及运营在一定CPU上的线程

要为Cgroup分配限制的能源,首先要挂载子系统,然后才有调控组,举例想要对指标程序实行内部存款和储蓄器限制,那就必要挂载memory子系统

选择lssubsys -am来展现已经挂载的子系统

#lssubsys -am

cpuset /sys/fs/cgroup/cpuset

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

memory /sys/fs/cgroup/memory

devices /sys/fs/cgroup/devices

freezer /sys/fs/cgroup/freezer

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

blkio /sys/fs/cgroup/blkio

perf_event /sys/fs/cgroup/perf_event

hugetlb /sys/fs/cgroup/hugetlb

能够手动挂载可能卸载子系统,如进行umount /sys/fs/cgroup/memory,memory子系统就被卸载了,那时候手动施行# mount -t cgroup -o memory memory /sys/fs/cgroup/memory就又挂载上了。
要确定保障必要的子系统都挂上了,不然创立调整组的时候会报错 is not mounted

#cgcreate -g memory,cpu:/hzmali_test

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

哪些创设control group(即要求财富管理的组)呢, 这里用cgcreate命令,当然也会有其余措施, 如cgconfig.conf等

#cgcreate -g memory,cpu:/hzmali_test

那边有个十分重要特征:两个组能够同期做多少个财富的范围,如这里本身还要限制了memory和cpu,然后memory和cpu子系统目录下会自动生成那几个组的目录和些文件,如memory

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-r--r--r-- 1 root root 0 Jul 26 20:56 memory.kmem.usage_Linux下CGroup进行CPU、内存等资源控制,linuxcgroup彩世界网址。in_bytes

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

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

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

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

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

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

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

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

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

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

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

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

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

文本过多,选多少个入眼的讲下:

  • tasks 能够将想要限制财富的经过都加到那个文件中
  • memory.max_usage_in_bytes内部存款和储蓄器的最大使用量,用来限制能源
    -memory.soft_limit_in_bytes 和 memory.limit_in_bytes 的距离是,这一个界定并不会阻碍进度使用超过限额的内部存储器,只是在系统内存不足时,会优先回收当先限额的进度占用的内部存款和储蓄器,使之向限定值靠拢。
  • memory.oom_control
    富含二个标记(0或1)来拉开可能关闭cgroup的OOM killer。倘诺翻开(1),职责借使尝试申请内存当先允许,就能够被系统OOM killer终止。OOM killer在每种使用cgroup内部存款和储蓄器子系统中都是暗中认可开启的。固然须求关闭,则足以向memory.oom_control文件写入1:

# echo 1 > /sys/fs/cgroup/memory.oom_control
万一OOM killer关闭,那么进度尝试申请的内部存款和储蓄器抢先允许,那么它就能够被搁浅,直到额外的内部存储器被放飞

  • memory.mem.usage_in_bytes 当前经过内部存款和储蓄器用量,因为现在还尚无经过加到组里,就是0了
  • memory.mem.failcnt彰显内部存款和储蓄器达到限制值的次数

cgroup的安装

实际安装比极粗略,最棒奉行正是yum直接设置(centos下)

中央命令

cgclassify -- cgclassify命令是用来将运营的天职移动到叁个仍旧七个cgroup。

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

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

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

cgcreate -- cgcreate在层级中开立异cgroup。

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

cgexec -- cgexec命令在内定的cgroup中运作任务。

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

cgred.conf -- cgred.conf是cgred服务的配置文件。

cgrules.conf -- cgrules.conf 包涵用来支配几时职务术语有些 cgroup的准绳。

cgrulesengd -- cgrulesengd 在 cgroup 中公布职务。

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

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

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

表 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

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

    7.4 财富限制验证

    使用mysqlslap对mysql实行压力测验,看mysql使用能源是还是不是超过限制。

    7.4.1 在shell窗口1用mysqlslap对mysql实行压力测量试验。

[plain] view plain copy

  1. [root@localhost /]# /usr/local/mysql/bin/mysqlslap --defaults-file=/etc/my.cnf --concurrency=150 --iterations=1 --number-int-cols=8 --auto-generate-sql --auto-generate-sql-load-type=mixed --engine=innodb --number-of-queries=100000 -ujesse -pjesse --number-char-cols=35 --auto-generate-sql-add-autoincrement --debug-info -P3306 -h127.0.0.1  

    7.4.2 在shell窗口2查看mysql对cpu,内部存储器的使用
彩世界网址 4

    可知:cpu限制在了第五个着力上,且对第五个着力的施用范围在二分一。

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

彩世界网址 5

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

cgroup section的语法格式如下

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

name: 指定cgroup的名称
permissions:可选用,钦点cgroup对应的挂载点文件系统的权柄,root客户具备具备权力。
controller:子系统的称呼
param name 和 param value:子系统的品质及其属性值

9 cgroup小结

    使用cgroup一时对进程展开调节,直接通过命令就能够,如若要长久化对进程展费用配,即重启后照旧有效,需求写进配置文件/etc/cgconfig.conf及/etc/cgrules.conf 

   

****************************************************************************************
    原著地址:
    博客主页:

来自为知笔记(Wiz)

    8.1 cpu限制实例

    限制mysql使用一个核,如第二个核,且对该核的运用不超过百分之五十

[plain] view plain copy

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

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

彩世界网址 6

彩世界网址 7

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

铺排文件

/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;              
                         }  

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

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

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

[plain] view plain copy

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

彩世界网址 8

    内部存款和储蓄器的成本在持续充实,对其开展限定,使其行使内部存款和储蓄器在500M以内

[plain] view plain copy

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

彩世界网址 9
    内部存款和储蓄器使用得到了平价调节。

7.1 配置对mysql实例的财富限制

    前提:MySQL数据库已在机器上安装

    7.1.1 修改cgconfig.conf文件

[plain] view plain copy

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

    7.1.2 配置文件的片段解释。

    cpu:cpu使用时间限额。

    cpu.cfs_period_us和cpu.cfs_quota_us来限制该组中的全部进程在单位时间里能够采取的cpu时间。这里的cfs是全然公平调治器的缩写。cpu.cfs_period_us就是岁月周期(飞秒),默以为一千00,即百微秒。cpu.cfs_quota_us就是在这里面内可选用的cpu时间(微秒),暗许-1,即无界定。(cfs_quota_us是cfs_period_us的两倍就可以限定在双核上完全使用)。

    cpuset:cpu绑定

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

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

    其实cgconfig也正是帮您把计划文件中的配置整理到/cgroup/cpuset那么些目录里面,比方你需求动态设置mysql_group1/ cpuset.cpus的CPU超线程号,能够接纳如下的法子。

[plain] view plain copy

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

    cpuacct:cpu财富报告

    memory:内部存储器限制 

    内部存款和储蓄器限制我们任重(Ren Zhong)而道远范围了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查看

[plain] view plain copy

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

    7.1.3 拓宽文化

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

    本例结果如下:

[plain] view plain copy

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

    以下是较高级服务器的numa新闻,仅作参照。

[plain] view plain copy

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

    7.1.4 修改cgrules.conf文件

[plain] view plain copy

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

    注:共分为3个部分,分别为要求限制的实例,限制的剧情(如cpu,memory),挂载目的。

图 2. CGroup 标准应用架构图

本文由时时app平台注册网站发布于彩世界网址,转载请注明出处:Linux下CGroup进行CPU、内存等资源控制,linuxcgroup彩

关键词: