Linux资源管理-IO优先级 使用cgroub控制进程优先级 cgroup blkio子系统

最新推荐文章于 2024-03-27 21:34:11 发布
最新推荐文章于 2024-03-27 21:34:11 发布
阅读量1.1k 收藏 2
点赞数 2
分类专栏： Linux操作系统 文章标签： linux docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44637703/article/details/107464974
版权

如果想要控制进程IO的优先级，需要内核支持，编译器需要开启以下两个参数

CONFIG_BLK_CGROUP=y
CONFIG_CFQ_GROUP_IOSCHED=y

查看方式

[root@localhost ~]# grep -i 'cfq_group' /boot/config-`uname -r`
CONFIG_CFQ_GROUP_IOSCHED=y
[root@localhost ~]# grep -i 'blk_cgroup' /boot/config-`uname -r`
CONFIG_BLK_CGROUP=y

如果这两项都没开启， 需要重新编译内核再重新打开了

再通过 /proc/cgroups 查看 blkio 是否已经打开

[root@localhost ~]# cat /proc/cgroups
#subsys_name    hierarchy       num_cgroups     enabled
cpuset  7       1       1
cpu     11      1       1
cpuacct 11      1       1
blkio   3       1       1
memory  6       68      1
devices 12      33      1
freezer 5       1       1
net_cls 4       1       1
perf_event      10      1       1
net_prio        4       1       1
hugetlb 9       1       1
pids    2       40      1
rdma    8       1       1

这里enabled=1表示已经打开了，如果blkio没哟启用，可以通过grub设置启动参数来启动它

如何测试io的优先级

1 进入cgroup blkio子系统资源组
2 建立2个cgroup资源组，分为A和B，
3 默认情况下，2 个 group资源组中的dd同时进行文件操作，
4 查看默认情况下，2个dd同时完成需要的时间，
5 设置资源组A的权重为100，资源组B的权重为1000 (权重越大表示进行I/O的优先级越高)
6 同时在2个group资源组中进行dd操作，
7 再次查看比较两个资源组A和B的dd进程完成时间

操作流程
1 查看当前系统关于cgroup文件系统，并进入blkio子系统

[root@localhost ~]# mount| grep cgroup
tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)
cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls,net_prio)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/rdma type cgroup (rw,nosuid,nodev,noexec,relatime,rdma)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /mnt/cgroup type cgroup (rw,relatime,blkio)

blkio子系统资源组，blkio子系统是用于限制块设备I/O操作速率

cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

2 在对应的子系统通过mkdir创建资源组，rmdir可将对应的资源组删除，通过将进程pid加入到资源组目录下的tasks文件的方式把某个模块加入到对应的资源组

注意：关于资源组中一些文件这里做解释一下

[root@localhost blkio]# ll
total 0
drwxr-xr-x 2 root root 0 Jul 20 16:43 A
drwxr-xr-x 2 root root 0 Jul 20 16:43 B
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.bfq.io_service_bytes
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.bfq.io_service_bytes_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.bfq.io_serviced
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.bfq.io_serviced_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_merged
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_merged_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_queued
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_queued_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_service_bytes
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_service_bytes_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_serviced
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_serviced_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_service_time
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_service_time_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_wait_time
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.io_wait_time_recursive
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.leaf_weight
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.leaf_weight_device
--w------- 1 root root 0 Jul 20 16:42 blkio.reset_stats
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.sectors
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.sectors_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.io_service_bytes
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.io_service_bytes_recursive
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.io_serviced
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.io_serviced_recursive
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.read_bps_device
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.read_iops_device
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.write_bps_device
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.throttle.write_iops_device
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.time
-r--r--r-- 1 root root 0 Jul 20 16:42 blkio.time_recursive
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.weight
-rw-r--r-- 1 root root 0 Jul 20 16:42 blkio.weight_device
-rw-r--r-- 1 root root 0 Jul 20 16:42 cgroup.clone_children
-rw-r--r-- 1 root root 0 Jul 20 16:42 cgroup.procs
-r--r--r-- 1 root root 0 Jul 20 16:42 cgroup.sane_behavior
-rw-r--r-- 1 root root 0 Jul 20 16:42 notify_on_release
-rw-r--r-- 1 root root 0 Jul 20 16:42 release_agent
-rw-r--r-- 1 root root 0 Jul 20 16:42 tasks


文件 blkio.weight

资源组中的文件 blkio.weight 表示权重，这个值的范围是 100 ~ 1000，值越大则IO的优先级越高，默认是500，其中新的资源组 A和B的blkio.weight的值都为默认值500

文件 tasks

控制具体使用哪个资源组来进行I/O操作，如果将进程PID写到A资源组，则使用资源组A来实现I/O操作，再通过设置资源组的权重来比较进程调度的优先级

测试文件如下：

#!/bin/bash
####################################################################
# 1. 创造1个测试文件, 大小为1G
# 2. 将当前进程加入到指定 cgroup blkio子系统资源组
# 3. 执行 dd 操作
# 4. 删除 测试文件
# 5. 显示log
####################################################################

function usage()
{
    echo "./blkio-test.sh <group1> <group2>"
    exit 1
}

if [ $# != 2 ]; then
    usage
fi

group_src=~/group.src

group1_log=/tmp/group1.log
group2_log=/tmp/group2.log

group1=$1
group2=$2

echo "生成测试数据 $group_src (大小是1G)"
dd if=/dev/zero of=$group_src count=1024 bs=1M

echo "同时在 $group1 和 $group2 中开始 dd 测试"
echo 3 > /proc/sys/vm/drop_caches
echo $$ >> $group1/tasks
(date; dd if=$group_src of=/dev/null; date;) > $group1_log 2>&1 &

echo $$ >> $group2/tasks
(date; dd if=$group_src of=/dev/null; date;) > $group2_log 2>&1 &

wait
echo "测试完成!"

echo "开始清除测试文件"
rm -rf $group_src
echo "测试文件清除完成"

echo "------------------------------------------"
echo "显示group1 的log"
cat $group1_log

echo "------------------------------------------"
echo "显示group2 的log"
cat $group2_log

echo "------------------------------------------"

实现结果：
1 首先使用默认权重500，查看关于I/O调度优先级，

[root@localhost ~]# ./1.sh /sys/fs/cgroup/blkio/A/ /sys/fs/cgroup/blkio/B
生成测试数据 /root/group.src (大小是1G)
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.35757 s, 320 MB/s
同时在 /sys/fs/cgroup/blkio/A/ 和 /sys/fs/cgroup/blkio/B 中开始 dd 测试
测试完成!
开始清除测试文件
测试文件清除完成
------------------------------------------
显示group1 的log
Tue Jul 21 16:18:10 CST 2020
2097152+0 records in
2097152+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.16103 s, 340 MB/s
Tue Jul 21 16:18:23 CST 2020
------------------------------------------
显示group2 的log
Tue Jul 21 16:18:10 CST 2020
2097152+0 records in
2097152+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.16101 s, 340 MB/s
Tue Jul 21 16:18:23 CST 2020
------------------------------------------,

2 将资源组A的权重设置为100，将资源组B的权重设置为1000，再调用测试文件，查看dd相同大小的块资源组A和B的时间

[root@localhost ~]# vim /sys/fs/cgroup/blkio/A/blkio.weight
[root@localhost ~]# vim /sys/fs/cgroup/blkio/B/blkio.weight
[root@localhost ~]# ./1.sh /sys/fs/cgroup/blkio/A/ /sys/fs/cgroup/blkio/B
生成测试数据 /root/group.src (大小是1G)
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.00457 s, 357 MB/s
同时在 /sys/fs/cgroup/blkio/A/ 和 /sys/fs/cgroup/blkio/B 中开始 dd 测试
测试完成!
开始清除测试文件
测试文件清除完成
------------------------------------------
显示group1 的log
Tue Jul 21 16:23:19 CST 2020
2097152+0 records in
2097152+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.7415 s, 392 MB/s
Tue Jul 21 16:23:31 CST 2020
------------------------------------------
显示group2 的log
Tue Jul 21 16:23:19 CST 2020
2097152+0 records in
2097152+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.69067 s, 399 MB/s
Tue Jul 21 16:23:31 CST 2020
------------------------------------------

由上面结果可以看出来，dd 1G大小的文件时，在不同资源组A和B权重均为默认值500时，所需时间一致，当修改资源组A的权重为100，B的权重为1000时，此时资源组B的耗时比A低，
也就说明系统I/O操作的优先级会根据权重设置的不同而不同

ni_darling
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
cgroup-linux内存资源管理.pdf
07-11
cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管理.pdf cgroup-linux内存资源管
容器核心技术之cgroup
qq_29767087的博客
10-07 405
cgroup概述 Cgroups （Control Groups）是 Linux 下用于对一个或一组进程进行资源控制和监控的机制； 可以对诸如 CPU 使用时间、内存、磁盘 I/O 等进程所需的资源进行限制； 不同资源的具体管理工作由相应的 Cgroup 子系统（Subsystem）来实现 ； 针对不同类型的资源限制，只要将限制策略在不同的的子系统上进行关联即可 ； Cgroups 在不同的系统资源管理子系统中以层级树（Hierarchy）的方式来组织管理：每个Cgroup 都可以包含其他的子 Cgrou
从零自制docker-6-【Linux Cgroups】（Cgroups mount cgroup文件系统中的相关组件 相关演示 ubuntu22.04 docker使用cgroup）
最新发布
llovewuzhengzi的博客
03-27 899
在 Ubuntu 22.04 中，Docker 容器的 cgroup 位于 /sys/fs/cgroup 目录下的 system.slice 目录中。ubuntu22.04对应的cgroup设置的当前的进程的所占内存限制大小在memory.max中，查看显示max代表没有限制。此时当前进程的cgroup层次变化为/，代表在cgroup文件系统的根节点，因为是将其进程ID写到了根cgroup。通过mount命令可以查看当前系统中已挂载的文件系统信息，使用mount命令即可显示当前挂载点和设备的对应关系。
容器底层实现技术Namespace/Cgroup
小胡子
03-30 384
Docker容器实现原理 Docker容器在实现上是通过namespace技术来进行进程隔离，通过cgroup技术实现容器进程可用资源的限制，当docker启动一个容器时，实际是创建了多了namespace参数的进程。 Namespace Namespace：命名空间 作用：资源隔离 原理：namespace将内核的全局资源进行封装，使得每个namespace都有一份独立的资源，因此不同进程在各自namespace内对同一种资源使用不会相互干扰 ...
Linux下CGroup进行CPU内存等资源控制
lbyyy的专栏
01-11 7255
留存 from: http://www.cnblogs.com/kevingrace/p/5685433.html  and  http://www.cnblogs.com/wang_yb/p/3942208.html CGroup 介绍 CGroup 是 Control Groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组 (process groups)
cgroups分析与应用连载(一)
u014358116的专栏
03-25 2296
欢迎转载，转载请参见文章末尾处要求 Cgroups介绍 linux内核提供了cgroups控制组(control groups)的功能，最初由google的工程师提出，后来被整合进Linux内核。Cgroups也是LXC（Linux Container容器是一种内核虚拟化技术，可以提供轻量级的虚拟化，以便隔离进程和资源，而且不需要提供指令解释机制以及全虚拟化的其他复杂性）为实现虚拟化所使用
CGroup 介绍、应用实例及原理描述
diaotuhui6321的博客
07-01 1006
CGroup 介绍CGroup 是 Control Groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组 (process groups) 所使用的物力资源 (如 cpu memory i/o 等等) 的机制。2007 年进入 Linux 2.6.24 内核，CGroups 不是全新创造的，它将进程管理从 cpuset 中剥离出来，作者是 Google 的 Pa...
linux cgroup学习总结
liuyij3430448的博客
12-07 3597
大纲cgroups 是Linux内核提供的一种可以限制，隔离单个进程或者多个进程组 (process groups)所使用物理资源的机制，可以对 cpu，内存，i/o等资源实现精细化的控制，cgroups 全称是Control GroupsDocker 就使用了 cgroups 提供的资源限制能力来完成cpu，内存等部分的资源控制。Cgroups是从Linux内核版本2.6.24开始添加进去的，Cgroups最初是由Google的工程师在2006年开发的，起初的名字叫“process containers”
Linux源码剖析——CGroup 实现原理
白话机器学习
07-22 397
前面我们介绍了CGroup的使用与基本概念，接下来将通过分析源码（本文使用的 Linux2.6.25 版本）来介绍CGroup的实现原理。在分析源码前，我们先介绍几个重要的数据结构，因为CGroup就是通过这几个数据结构来控制进程组对各种资源的使用。cgroup。
Docker之cgroups资源限制
weixin_71429850的博客
10-23 598
cgroups是一个非常强大的linux内核工具，他不仅可以限制被namespace隔离起来的资源，还可以为资源权重、计算使用量，操控进程启停等等，所以cgroups（control groups）实现了对资源的配额和度量。1、资源限制：可以对任务使用的资源总额进行限制2、优先级分配：通过分配CPU时间片数量以及磁盘io带宽大小，实际上相当于控制了任务运行优先级3、资源统计：可以统计系统的资源使用量，如CPU时长，内存用量等4、任务统计：cgroups可以对任务执行挂起，恢复等操作。
Cgroup 资源配置方法
小杨博客 学习交流
10-24 2249
cgroups是一个非常强大的linux内核工具。他不仅可以现在被namespace隔离起来的资源，还可以为资源设置权重，计算使用量，控制进程启停等等，所以cgroups实现了对资源的配额和度量
cgroup-linux内存资源管理1
08-04
1. 我擦，内存用了好多，6个多G，可是我什么都没有运行啊 2. 嗯，根据我专业的眼光看出来，内存才用了1G多点，还有很多剩余内存可用 3. free显示的是这
cgroups-rs:本机Rust库用于在Linux下管理控制组
05-25
本机Rust库用于在Linux下管理控制组 目前，该板条箱仅支持原始的V1层次结构，但是计划支持统一层次结构。 例子 使用构建器模式创建控制组 // Acquire a handle for the V1 cgroup hierarchy. let hier = :: ...
Linux运维-运维课程MP4频-05容器-08Cgroup限制进程对memory使用案例.mp4
05-31
Linux运维-运维课程MP4频-05容器-08Cgroup限制进程对memory使用案例.mp4
Linux Cgroup 技术 与 智能手机系统 IO 优化
09-22
演示了 Docker 虚拟化的基础技术之一：Linux Cgroup 以及 该技术在智能手机 IO 优化方面的潜在应用。 2015/04/26 @ 泰晓沙龙 第二期
如何在Linux上通过cgroup限制一个进程使用CPU和内存
weixin_37871174的博客
04-26 3425
Cgroup 实现了对系统资源的细粒度控制和管理，可以将一组进程放入同一个 Cgroup 中，并对该 Control Group 中的所有进程共享相应的资源配额。这两行代码告诉内核同时运行的程序切换超时参数，即当前可占用 10ms 内核时间，然后必须让出时间，并等待 200ms 内核时间过后再占用，以达到限制CPU使用的目地。2. 创建一个名为 mycg 的控制组，以限制该组中的进程的 CPU 占用率和内存使用量。说明测试程序的CPU使用率已经被成功限制在10%以内，而内存占用不会超过50MB。
关于Linux中控制群组cgroup(资源管理)的一些笔记
山河已无恙
10-13 2075
不加思考地滥读或无休止地读书,所读过的东西无法刻骨铭心,其大部分终将消失殆尽。——叔本华
Linux内核进程管理进程优先级
嵌入式Linux内核的博客
03-22 818
本文的目的是从Linux系统进程的优先级为出发点，通过了解相关的知识点，希望大家对系统的进程调度有个整体的了解。其中我们也对CFS调度算法进行了比较深入的分析。在我的经验来看，这些知识对我们在观察系统的状态和相关优化的时候都是非常有用的。比如在使用top命令的时候，NI和PR值到底是什么意思？类似的地方还有ps命令中的NI和PRI值、ulimit命令-e和-r参数的区别等等。当然，希望看完本文后，能让大家对这些命令显示的了解更加深入。
Cgroup blkio简介和测试（使用fio测试）
weixin_34106122的博客
12-29 431
Cgroup blkio简介和测试（使用fio测试） 因需要对docker镜像内的进程对磁盘读写的速度进行限制，研究了下Cgroup blkio，并使用fio对其iops/bps限速进行测试。 Cgroup blkio简介 Linux Cgroup（Control Groups）是Linux内核提供的用于限制、记录、隔离进程组可以使用的资源（cpu、memory、IO等）的一种机制。 在/boot...
容器的指定cgroup子系统
05-12
在Linux中，Cgroups是一种资源隔离的机制，它可以为进程分配特定的系统资源，并限制它们的使用。容器也可以使用Cgroups来限制容器内的进程对系统资源的访问。 在容器中，可以使用`--cgroup-parent`选项来指定Cgroup子系统。例如，如果要将容器的CPU使用限制为50%，可以使用以下命令： ``` docker run --cgroup-parent=/myapp -it --cpu-quota=50000 myapp ``` 上述命令将容器放置在`/myapp` Cgroup层次结构中，并将容器的CPU使用限制为50%。在这个例子中，`--cpu-quota`选项是用来设置CPU配额的，而`--cgroup-parent`选项用来指定Cgroup子系统。 注意，不同的Cgroup子系统支持不同的参数和选项。在使用`--cgroup-parent`选项时，需要确保所选的Cgroup子系统支持指定的选项。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值