精华内容
下载资源
问答
  • cgroup

    2020-04-12 19:55:35
    比如可以通过cgroup限制特定进程的资源使用,比如使用特定数目的cpu核数和特定大小的内存,如果资源超限的情况下,会被暂停或者杀掉。 关系梳理: 任务(task): 在cgroup中,任务就是一个进程。 控制组(control ...

    cgroups 是Linux内核提供的一种可以限制单个进程或者多个进程所使用资源的机制,可以对 cpu,内存等资源实现精细化的控制

    比如:可以通过cgroup限制特定进程的资源使用,比如使用特定数目的cpu核数和特定大小的内存,如果资源超限的情况下,会被暂停或者杀掉。

    关系梳理:

    • 任务 (task):在cgroup中,任务就是一个进程。
    • 控制组 (control group):cgroup的资源控制是以控制组的方式实现,控制组指明了资源的配额限制。进程可以加入到某个控制组,也可以迁移到另一个控制组。
    • 层级 (hierarchy):控制组有层级关系,类似树的结构,子节点的控制组继承父控制组的属性(资源配额、限制等)
    • 子系统 (subsystem):一个子系统其实就是一种资源的控制器,比如memory子系统可以控制进程内存的使用。子系统需要加入到某个层级,然后该层级的所有控制组,均受到这个子系统的控制。

     

    注意!  任务(进程)  和  层级 是不同的概念,任务可以依赖不同的层级

    • 一个层级可以附加多个子系统
    • 一个任务可以是多个cgroup的成员,但这些cgroup必须位于不同的层级

    某一个进程也可以被加入到不同的 cgroups 层级结构的节点中,因为不同的 cgroups 层级结构可以负责不同的系统资源。

    所以说进程和 cgroup 结构体是一个多对多的关系

    cgroupså±çº§ç»æ示æå¾

     

    实现细节:

    Linux把CGroup实现成了一个file system,在vfs下挂载文件系统,目录下方为他进程tasks

    用户态进程使用到cgroups的功能:VFS,VFS将细节隐藏起来,给用户统一的文件系统API接口

    cgroups和VFS之间的链接部分,称之为cgroups文件系统

    子系统:

    1. cgroups为每种可以控制的资源定义了一个子系统。典型的子系统介绍如下:
    2. cpu 子系统,主要限制进程的 cpu 使用率。
    3. cpuacct 子系统,可以统计 cgroups 中的进程的 cpu 使用报告。
    4. cpuset 子系统,可以为 cgroups 中的进程分配单独的 cpu 节点或者内存节点。
    5. memory 子系统,可以限制进程的 memory 使用量。
    6. blkio 子系统,可以限制进程的块设备 io。
    7. devices 子系统,可以控制进程能够访问某些设备。
    8. net_cls 子系统,可以标记 cgroups 中进程的网络数据包,然后可以使用 tc 模块(traffic control)对数据包进行控制。
    9. freezer 子系统,可以挂起或者恢复 cgroups 中的进程。
    10. ns 子系统,可以使不同 cgroups 下面的进程使用不同的 namespace。
    • 内核使用 cgroup 结构体来表示一个 control group 对某一个或者某几个 cgroups 子系统的资源限制。
    • cgroups可以attach一个或几个cgroups子系统,对资源进行限制
    • 在每一个cgroups层级结构中,每一个节点可以设置对资源不同的限制权重
    • cgroups 的实现不允许css_set同时关联同一个cgroups层级结构下多个节点。 这是因为 cgroups 对同一种资源不允许有多个限制配置。

     

    cgroup使用:

    云平台都是基于 cgroups 技术搭建的,其实也都是把进程分组,然后把整个进程组添加到同一组 cgroups 节点中,受到同样的资源限制。

    1. 安装:sudo apt install cgroup-bin   安装完会出现/sys/fs/cgroup
    2. 创建cpu资源控制组:
    • cd /sys/fs/cgroup/cpu   
    • mkdir test_cpu     
    • echo '10000' > test_cpu/cpu.cfs_period_us     
    • echo  '5000' >  test_cpu/cpu.cfs_quota_us

     

    •  也可以通过挂载:mount -t cgroup -o remount,cpu,cpuset,memory cpu_and_mem /cgroup/cpu_and_mem

    挂载某一个 cgroups 子系统到挂载点之后,就可以通过在挂载点下面建立文件夹或者使用cgcreate命令的方法创建 cgroups 层级结构中的节点。比如通过命令cgcreate -t sankuai:sankuai -g cpu:test就可以在 cpu 子系统下建立一个名为 test 的节点。

    使用 cgset 命令也可以设置 cgroups 子系统的参数,格式为 cgset -r parameter=value path_to_cgroup

    删除可以用cgdelete

     

          3. 限制程序cpu

         cgexec  -g   cpu: test_cpu   ./程序

     

    把进程加入到 cgroups 子节点也有多种方法,可以直接把 pid 写入到子节点下面的 task 文件中。也可以通过 cgclassify 添加进程,格式为 cgclassify -g subsystems:path_to_cgroup pidlist,也可以直接使用 cgexec 在某一个 cgroups 下启动进程,格式为:gexec -g subsystems:path_to_cgroup command arguments

     

    参考:

    https://tech.meituan.com/2015/03/31/cgroups.html
    https://coolshell.cn/articles/17049.html
    https://zhuanlan.zhihu.com/p/81668069

    展开全文
  • Cgroup

    2021-04-05 15:34:20
    文章目录前言一、Cgroup资源配置四、测试CPU和内存五、CPU周期限制六、CPU Core控制七、CPU配额控制参数的混合使用八、内存限额九、Block IO的限制十、bps和iops的限制 前言 cgroups,其名称源自控制组群(control...


    前言

    cgroups,其名称源自控制组群(control groups)的简写,是Linux内核的一个功能,用来限制、控制与分离一个进程组的资源(如CPU、内存、磁盘输入输出等)。

    一、Cgroup资源配置

    Cgroup是Control Groups的缩写,是Linux内核提供的一种可以限制、记录、隔离进程组所使用的物理资源(如CPU、内存、磁盘l0等等)的机制,被LXC、docker 等很多项目用于实现进程资源控制。Cgroup 本身是提供将进程进行分组化管理的功能和接口的基础结构,I/O或内存的分配控制等具体的资源管理是通过该功能来实现的,这些具体的资源管理功能称为Cgroup子系统,有以下几大子系统实现:

    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的功能
    cgroups的一个设计目标是为不同的应用情况提供统一的接口,从控制单一进程(像nice)到操作系统层虚拟化(像OpenVZ,Linux-VServer,LXC)。cgroups提供:
    资源限制:组可以被设置不超过设定的内存限制;这也包括虚拟内存。
    优先级:一些组可能会得到大量的CPU或磁盘IO吞吐量。
    结算:用来衡量系统确实把多少资源用到适合的目的上。
    控制:冻结组或检查点和重启动。
    三、Cgroup的作用
    Cgroups最初的目标是为资源管理提供的一个统一的框架,既整合现有的cpuset等子系统,也为未来开发新的子系统提供接口。现在的cgroups适用于多种应用场景,从单个进程的资源控制,到实现操作系统层次的虚拟化(OS Level Virtualization)。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和内存

    使用Dockerfile来创建一个基于centos的stress工具镜像

    mkdir /opt/stress
    cd /opt/stress
    
    vim Dockerfile
    FROM centos:7
    MAINTAINER HZH<397615552@qq.com>
    RUN yum install -y wget
    RUN wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
    RUN yum install -y stress
    
    docker build -t centos:stress .
    

    使用下面命令创建容器,命令中–cpu-shares参数值不能保证可以获得1个vcpu或者多少GHz的CPU资源,它仅仅是一个弹性的加权值

    docker run -itd --cpu-shares 100 centos:stress
    

    说明:默认情况下,每个Docker容器的CPU份额都是1024。 单独一个容器的份额是没有意义的。只有在同时运行多个容器时,容器的CPU加权的效果才能体现出来。
    例如:启动2个容器及允许查看CPU的使用百分比

    docker run -itd --name cpu512 --cpu-shares 512 centos:stress stress -c 10  #容器产生10个子函数进程
    docker exec -it xxxxxxxx bash  		#进入容器使用top查看cpu使用情况
    
    再开一个容器做比较
    docker run -itd ---name cpu1024 --cpu-shares 1024 centos:stress stress -c 10
    docker exec -it xxxxxxxxx bash      #进入容器使用top对比两个容器的%CPU,比例是1:2
    

    五、CPU周期限制

    1、Docker提供了–cpu-period、–cpu-quota两个参数控制容器可以分配到的CPU时钟周期

    –cpu-period:是用来指定容器CPU的使用要在多长时间内做一次重新分配
    –cpu-quota:是用来指定在这个周期内,最多可以有多少时间用来跑这个容器
    与–cpu-share不同的是,这种配置是指定的一个绝对值,容器对CPU资源的使用绝对不会超过配置的值
    2、–cpu-period、–cpu-quota的单位为微秒
    –cpu-period的最小值为1000微秒,最大值为1秒,默认为0.1秒
    –cpu-quota的值默认为-1,表示不做控制,–cpu-period、–cpu-quota参数一般都是联合使用
    例如:容器进程需要每1秒使用单个CPU的0.2秒时间,可以将cpu-period设置为100000(即0.1秒),cpu-quota设置为200000(0.2秒),当然,在多核情况下,如果允许容器进程完全占用两个CPU,则可以将cpu-period设置为100000(即0.1秒),cpu-quota设置为200000(0.2秒)

    docker run -itd --cpu-period 100000 --cpu-quota 200000 centos:stress
    docker exec -it xxxxxxxxxx
    cat /sys/fs/cgroup/cpu/cpu.cfs_period_us
    cat /sys/fs/cgroup/cpu/cpu.cfs_quota_us
    

    六、CPU Core控制

    对多核CPU的服务器,Docker还可以控制容器允许使用哪些CPU内核,即使用–cpuset-cpus参数
    这对具有多CPU的服务器尤其有用,可以对需要高性能计算的容器进行性能最优的配置

    docker run -itd --name cpu1 --cpuset-cpus 2-3 centos:stress			#2-3表示创建容器只能使用第2、3这两个内核,
    docker exec -it xxxxxxxxxxx bash
    cat /sys/fs/cgroup/cpuset/cpuset.cpus
    
    docker exec xxxxxx taskset -c -p 1
    pid 1's current affinity list: 2,3
    
    

    七、CPU配额控制参数的混合使用

    通过cpuset-cpus参数指定容器A使用CPU内核0,容器B只使用CPU内核3
    在主机上只有这两个容器使用对应的CPU内核情况,他们各自占用全部的内核资源,cpu-shares没有明显效果
    cpuset-cpus、cpuset-mems参数只在多核、多内存节点上的服务器上有效,并且必须与实际的物理配置匹配,否则也无法达到资源控制的目的
    在系统具有多个CPU内核的情况下,需要通过cpuset-cpus参数为设置容器CPU内核才能方便进行测试

    docker run -itd --name cpu3 --cpuset-cpus 1 --cpu-shares 512 centos:stress stress -c 1 
    docker exec -it xxxxxxxxxxx bash
    exit 
    top #按1查看每个核心的占用
    
    docker run -itd --name cpu4 --cpuset-cpus 3 --cpu-shares 1024 centos:stress stress -c 1 
    docker exec -it xxxxxxx bash    
    

    总结:上面的centos:stress镜像安装了stress工具,用来测试CPU和内存的负载,通过在两个容器上分别执行stress -c 1命令,将会给系统一个随机负载,产生1个进程,这个进程都会反复不停的计算由rand()产生随机数的平方根,直到资源耗尽,观察到宿主机上CPU使用率,第三个内核的使用率接近100%,并且一批进程的CPU使用率明显存在2:1 的使用比例的对比

    八、内存限额

    与操作系统类似,容器可以使用的内存包括两个部分:物理内存和Swap
    docker通过以下两组参数来控制容器内存的使用量

    -m或者–memory:设置内存使用限额
    –memory-swap:设置内存+swap 的使用限额
    –vm 1 :启动1个内存工作线程
    –vm-bytes 280M:每个线程分配280M内存,这里的值要小于–memory-swap,否则报错
    docker run -it -m 200M --memory-swap=300M progrium/stress --vm 1 --vm-bytes 280M
    
    docker run -it -m 200M --memory-swap=300M progrium/stress --vm 1 --vm-bytes 310M			#工作线程分配的内存超过300M或者等于300M,分配的内存超过限额,stress线程会报错,容器退出
    
    –vm-bytes等于–memory-swap值,结果报错了
    

    九、Block IO的限制

    默认情况下,所有容器能平等地读写磁盘,可以通过–blkio-weight参数来改变容器block IO的优先级
    –blkio-weight与–cpu-shares类似,设置的是相对权重值,默认为500
    例如:容器A读写磁盘的带宽是容器B的两倍

    docker run -it --name container_A --blkio-weight 600 centos:stress
    cat /sys/fs/cgroup/blkio/blkio.weight
    
    docker run -it --name container_B --blkio-weight 300 centos:stress
    cat /sys/fs/cgroup/blkio/blkio.weight
    

    十、bps和iops的限制

    bps是byte per second:每秒读写的数据量
    iops是io per second:每秒IO的次数
    可通过以下参数控制容器的bps和iops

    –device-read-bps:限制读某个设备的bps
    –device-write-bps:限制写某个设备的bps
    –device-read-iops:限制读某个设备的iops
    –device-write-iops:限制写某个设备的iops
    
    展开全文
  • linux cgroup

    2020-09-13 10:42:03
    了解cgroup 1.描述   Linux CGroup全称Linux Control Group, 是Linux内核的一个功能,用来限制,控制与分离一个进程组群的资源(如CPU、内存、磁盘输入输出等)。这个项目最早是由Google的工程师在2006年发起...
    • 了解cgroup

    1.cgroup描述

    官方描述:

       DESCRIPTION   
           Control groups, usually referred to as cgroups, are a Linux kernel
           feature which allow processes to be organized into hierarchical
           groups whose usage of various types of resources can then be limited
           and monitored.  The kernel's cgroup interface is provided through a
           pseudo-filesystem called cgroupfs.  Grouping is implemented in the
           core cgroup kernel code, while resource tracking and limits are
           implemented in a set of per-resource-type subsystems (memory, CPU,
           and so on).
       
       Terminology
           A cgroup is a collection of processes that are bound to a set of
           limits or parameters defined via the cgroup filesystem.
    
           A subsystem is a kernel component that modifies the behavior of the
           processes in a cgroup.  Various subsystems have been implemented,
           making it possible to do things such as limiting the amount of CPU
           time and memory available to a cgroup, accounting for the CPU time
           used by a cgroup, and freezing and resuming execution of the
           processes in a cgroup.  Subsystems are sometimes also known as
           resource controllers (or simply, controllers).
    
           The cgroups for a controller are arranged in a hierarchy.  This
           hierarchy is defined by creating, removing, and renaming
           subdirectories within the cgroup filesystem.  At each level of the
           hierarchy, attributes (e.g., limits) can be defined.  The limits,
           control, and accounting provided by cgroups generally have effect
           throughout the subhierarchy underneath the cgroup where the
           attributes are defined.  Thus, for example, the limits placed on a
           cgroup at a higher level in the hierarchy cannot be exceeded by
           descendant cgroups
    

      Linux CGroup全称Linux Control Group, 是Linux内核的一个功能,用来限制,控制与分离一个进程组群的资源(如CPU、内存、磁盘输入输出等)。这个项目最早是由Google的工程师在2006年发起(主要是Paul Menage和Rohit Seth),最早的名称为进程容器(process containers)。在2007年时,因为在Linux内核中,容器(container)这个名词太过广泛,为避免混乱,被重命名为cgroup,并且被合并到2.6.24版的内核中去。

      Linux Cgroup ​​​系​​​统​​​中​​​所​​​运​​​行​​​任​​​务​​​(进​​​程​​​)的​​​用​​​户​​​定​​​义​​​组​​​群​​​分​​​配​​​资​​​源​​​ — 比​​​如​​​ CPU 时​​​间​​​、​​​系​​​统​​​内​​​存​​​、​​​网​​​络​​​带​​​宽​​​或​​​者​​​这​​​些​​​资​​​源​​​的​​​组​​​合​​​。​​​可​​​以​​​监​​​控​​​配​​​置​​​的​​​ cgroup,拒​​​绝​​​ cgroup 访​​​问​​​某​​​些​​​资​​​源​​​,甚​​​至​​​在​​​运​​​行​​​的​​​系​​​统​​​中​​​动​​​态​​​配​​​置​​​cgroup。

      cgroup 是 Linux 下的一种将进程按组进行管理的机制,在用户层看来,cgroup 技术就是把系统中的所有进程组织成一颗一颗独立的树,每棵树都包含系统的所有进程,树的每个节点是一个进程组,而每颗树又和一个或者多个 subsystem 关联,树的作用是将进程分组,而 subsystem 的作用就是对这些组进行操作。cgroup 主要包括下面两部分:

    • subsystem : 一个 subsystem 就是一个内核模块,它被关联到一颗 cgroup 树之后,就会在树的每个节点(进程组)上做具体的操作。subsystem 经常被称作 resource controller,因为它主要被用来调度或者限制每个进程组的资源,但是这个说法不完全准确,因为有时我们将进程分组只是为了做一些监控,观察一下他们的状态,比如 perf_event subsystem。到目前为止,Linux 支持 12 种 subsystem,比如限制 CPU 的使用时间,限制使用的内存,统计 CPU 的使用情况,冻结和恢复一组进程等。

    • hierarchy : 一个 hierarchy 可以理解为一棵 cgroup 树,树的每个节点就是一个进程组,每棵树都会与零到多个 subsystem 关联。在一颗树里面,会包含 Linux 系统中的所有进程,但每个进程只能属于一个节点(进程组)。系统中可以有很多颗 cgroup 树,每棵树都和不同的 subsystem 关联,一个进程可以属于多颗树,即一个进程可以属于多个进程组,只是这些进程组和不同的 subsystem 关联。目前 Linux 支持 12 种 subsystem,如果不考虑不与任何 subsystem 关联的情况(systemd 就属于这种情况),Linux 里面最多可以建 12 颗 cgroup 树,每棵树关联一个 subsystem,当然也可以只建一棵树,然后让这棵树关联所有的 subsystem。当一颗 cgroup 树不和任何 subsystem 关联的时候,意味着这棵树只是将进程进行分组,至于要在分组的基础上做些什么,将由应用程序自己决定,systemd 就是一个这样的例子。

    2.原理

      cgroups的实现本质上是给系统进程挂上钩子(hooks),当task运行的过程中涉及到某个资源时就会触发钩子上所附带的subsystem进行检测,最终根据资源类别的不同使用对应的技术进行资源限制和优先级分配。

      cgroups的目的是将任意进程进行分组化管理。

      cgroups本身提供将进程进行分组化管理的功能,而IO或内存的分配等具体的资源管理功能则是通过subsystem来实现的。可以通过/proc/cgroup查看可以使用的subsystem。

      cgroups提供了一个名为cgroup的虚拟文件系统,作为进行分组管理和各子系统设置的用户接口.要使用cgroups,必须挂载cgroup文件系统,此时可以通过挂载参数指定使用的subsystem。

      在linux中,cgroups默认挂载在/sys/fs/cgroup目录,其中包含了所有的子系统以及每个子系统的层级。

    3.cgroups相关概念

      cgroups主要由task,cgroup,subsystem以及hierarchy组成.

    • Task(任务) : 在 linux 系统中,内核本身的调度和管理并不对进程和线程进行区分,只是根据 clone 时传入的参数的不同来从概念上区分进程和线程。这里使用 task 来表示系统的一个进程或线程。
    • cgroup(控制族群): 控制族群是一组按照某种标准划分的进程.cgroups中的资源控制都是以控制族群为单位实现的.一个进程可以加入某个控制族群,也可以迁移至另一个控制族群。
    • Hierarchy(层级) :层级有一系列 cgroup 以一个树状结构排列而成,每个层级通过绑定对应的子系统进行资源控制。层级中的 cgroup 节点可以包含零个或多个子节点,子节点继承父节点挂载的子系统。一个操作系统中可以有多个层级。
    • subsystem(子系统): 通常是一个资源控制器.例如CPU子系统可以控制CPU时间分配.一个子系统必须附加到控制族群树上才能起作用,该树上的所有控制族群都受到该子系统的控制

    3.1.子系统简介

      subsystem实际上就是cgroups的资源控制系统,每种subsystem独立地控制一种资源

    • blkio (since Linux 2.6.33; CONFIG_BLK_CGROUP): 这个subsystem可以为块设备设定输入/输出限制,比如物理驱动设备(包括磁盘,固态硬盘,USB等),限制cgroup访问块设备的IO速度。
    • cpu (since Linux 2.6.24; CONFIG_CGROUP_SCHED): 这个subsystem使用调度程序控制task对CPU的使用,用来限制cgroup的CPU使用率。
    • cpuacct (since Linux 2.6.24; CONFIG_CGROUP_CPUACCT): 这个subsystem自动生成cgroup中task对CPU资源使用情况的报告,统计cgroup的CPU的使用率
    • cpuset (since Linux 2.6.24; CONFIG_CPUSETS): 这个subsystem可以为cgroup中的task分配独立的CPU(此处针对多处理器系统)和内存,绑定cgroup到指定CPUs和NUMA节点。
    • devices (since Linux 2.6.26; CONFIG_CGROUP_DEVICE) : 这个subsystem可以开启或关闭cgroup中task对设备的访问,限制cgroup创建(mknod)和访问设备的权限。
    • freezer (since Linux 2.6.28; CONFIG_CGROUP_FREEZER): 这个subsystem可以挂起或恢复cgroup中的task,suspend和restore一个cgroup中的所有进程。
    • memory (since Linux 2.6.25; CONFIG_MEMCG): 这个subsystem可以设定cgroup中task对内存使用量的限定,并且自动生成这些task对内存资源使用情况的报告,统计和限制cgroup的内存的使用率,包括process memory, kernel memory, 和swap。
    • perf_event (since Linux 2.6.39; CONFIG_CGROUP_PERF): 这个subsystem使用后使得cgroup中的task可以进行统一的性能测试,对cgroup进行性能监控。
    • net_cls (since Linux 2.6.29; CONFIG_CGROUP_NET_CLASSID) : 将一个cgroup中进程创建的所有网络包加上一个classid标记,用于tc和iptables。 只对发出去的网络包生效,对收到的网络包不起作用。
    • net_prio (since Linux 3.3; CONFIG_CGROUP_NET_PRIO) : 针对每个网络接口设置cgroup的访问优先级。
    • hugetlb (since Linux 3.5; CONFIG_CGROUP_HUGETLB) : 限制cgroup的huge pages的使用量。
    • pids (since Linux 4.3; CONFIG_CGROUP_PIDS) : 限制一个cgroup及其子孙cgroup中的总进程数。

      上面这些subsystem,有些需要做资源统计,有些需要做资源控制,有些即不统计也不控制。对于cgroup树来说,有些subsystem严重依赖继承关系,有些subsystem完全用不到继承关系,而有些对继承关系没有严格要求。

    xxx:$ cat /proc/cgroups
    #subsys_name    hierarchy       num_cgroups     enabled
    cpuset  3       1       1
    cpu     2       70      1
    cpuacct 2       70      1
    blkio   9       70      1
    memory  7       127     1
    devices 8       70      1
    freezer 10      1       1
    net_cls 6       1       1
    perf_event      4       1       1
    net_prio        6       1       1
    hugetlb 11      1       1
    pids    5       71      1
    

    3.2.cgroups规则

      在任务,控制族群,层级,子系统间有着一些规则:

    • 同一个hierarchy能够附加一个或多个subsystem
    • 一个subsystem只能附加到一个hierarchy上
    • 每次在系统中创建新层级时,该系统中的所有任务都是那个层级的默认cgroup(我们称之为root cgroup,此cgroup在创建层级时自动创建,后面在该层级中创建的cgroup都是此cgroup的后代)的初始成员
    • 一个任务可以是多个cgroup的成员,但是这些cgroup必须在不同的层级
    • 进程创建子进程时,该子进程自动成为其父进程所在的cgroup的成员.可根据需要将其移至其它cgroup中

    3.3.cgroups 的主要作用

      实现 cgroups 的主要目的是为不同用户层面的资源管理提供一个统一化的接口。从单个任务的资源控制到操作系统层面的虚拟化,cgroups 提供了四大功能:

    • 资源限制:cgroups 可以对任务是要的资源总额进行限制。比如设定任务运行时使用的内存上限,一旦超出就发 OOM。
    • 优先级分配:通过分配的 CPU 时间片数量和磁盘 IO 带宽,实际上就等同于控制了任务运行的优先级。
    • 资源统计:cgoups 可以统计系统的资源使用量,比如 CPU 使用时长、内存用量等。这个功能非常适合当前云端产品按使用量计费的方式。
    • 任务控制:cgroups 可以对任务执行挂起、恢复等操作。

    3.4.cgroups 的文件系统接口

      cgroups 以文件的方式提供应用接口,我们可以通过 mount 命令来查看 cgroups 默认的挂载点:

    $ mount | grep cgroup
    >tmpfs on /sys/fs/cgroup type tmpfs (rw,mode=755)
    cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/lib/systemd/systemd-cgroups-agent,name=systemd)
    cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)
    cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset,clone_children)
    cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event,release_agent=/run/cgmanager/agents/cgm-release-agent.perf_event)
    cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids,release_agent=/run/cgmanager/agents/cgm-release-agent.pids)
    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/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
    cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
    cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
    cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
    cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb,release_agent=/run/cgmanager/agents/cgm-release-agent.hugetlb)
    
    • 第一行的 tmpfs 说明 /sys/fs/cgroup 目录下的文件都是存在于内存中的临时文件。
    • 第二行的挂载点 /sys/fs/cgroup/systemd 用于 systemd 系统对 cgroups 的支持。
    • 其余的挂载点则是内核支持的各个子系统的根级层级结构。

    Note: 在使用 systemd 系统的操作系统中,/sys/fs/cgroup 目录都是由 systemd 在系统启动的过程中挂载的,并且挂载为只读的类型。换句话说,系统是不建议在 /sys/fs/cgroup 目录下创建新的目录并挂载其它子系统的。

    4.如何查看当前进程属于哪些cgroup

      可以通过查看/proc/[pid]/cgroup知道指定进程属于哪些cgroup。

    dev@ubuntu:~$ cat /proc/777/cgroup
    11:cpuset:/
    10:freezer:/
    9:memory:/system.slice/cron.service
    8:blkio:/system.slice/cron.service
    7:perf_event:/
    6:net_cls,net_prio:/
    5:devices:/system.slice/cron.service
    4:hugetlb:/
    3:cpu,cpuacct:/system.slice/cron.service
    2:pids:/system.slice/cron.service
    1:name=systemd:/system.slice/cron.service
    

    每一行包含用冒号隔开的三列:

    • cgroup树的ID, 和/proc/cgroups文件中的ID一一对应。

    • 和cgroup树绑定的所有subsystem,多个subsystem之间用逗号隔开。这里name=systemd表示没有和任何subsystem绑定,只是给他起了个名字叫systemd。

    • 进程在cgroup树中的路径,即进程所属的cgroup,这个路径是相对于挂载点的相对路径。

    以 memory 子系统为例

    xxx:/sys/fs/cgroup/memory$ ls
    cgroup.clone_children           memory.kmem.tcp.failcnt             memory.soft_limit_in_bytes
    cgroup.event_control            memory.kmem.tcp.limit_in_bytes      memory.stat
    cgroup.procs                    memory.kmem.tcp.max_usage_in_bytes  memory.swappiness
    cgroup.sane_behavior            memory.kmem.tcp.usage_in_bytes      memory.usage_in_bytes
    init.scope                      memory.kmem.usage_in_bytes          memory.use_hierarchy
    memory.failcnt                  memory.limit_in_bytes               notify_on_release
    memory.force_empty              memory.max_usage_in_bytes           release_agent
    memory.kmem.failcnt             memory.move_charge_at_immigrate     system.slice
    memory.kmem.limit_in_bytes      memory.numa_stat                    tasks
    memory.kmem.max_usage_in_bytes  memory.oom_control                  user.slice
    memory.kmem.slabinfo            memory.pressure_level
    

    Brief summary of control files.

    
     tasks				 # attach a task(thread) and show list of threads
     cgroup.procs			 # show list of processes
     cgroup.event_control		 # an interface for event_fd()
     memory.usage_in_bytes		 # show current usage for memory
    				 (See 5.5 for details)
     memory.memsw.usage_in_bytes	 # show current usage for memory+Swap
    				 (See 5.5 for details)
     memory.limit_in_bytes		 # set/show limit of memory usage
     memory.memsw.limit_in_bytes	 # set/show limit of memory+Swap usage
     memory.failcnt			 # show the number of memory usage hits limits
     memory.memsw.failcnt		 # show the number of memory+Swap hits limits
     memory.max_usage_in_bytes	 # show max memory usage recorded
     memory.memsw.max_usage_in_bytes # show max memory+Swap usage recorded
     memory.soft_limit_in_bytes	 # set/show soft limit of memory usage
     memory.stat			 # show various statistics
     memory.use_hierarchy		 # set/show hierarchical account enabled
     memory.force_empty		 # trigger forced page reclaim
     memory.pressure_level		 # set memory pressure notifications
     memory.swappiness		 # set/show swappiness parameter of vmscan
    				 (See sysctl's vm.swappiness)
     memory.move_charge_at_immigrate # set/show controls of moving charges
     memory.oom_control		 # set/show oom controls.
     memory.numa_stat		 # show the number of memory usage per numa node
    
     memory.kmem.limit_in_bytes      # set/show hard limit for kernel memory
     memory.kmem.usage_in_bytes      # show current kernel memory allocation
     memory.kmem.failcnt             # show the number of kernel memory usage hits limits
     memory.kmem.max_usage_in_bytes  # show max kernel memory usage recorded
    
     memory.kmem.tcp.limit_in_bytes  # set/show hard limit for tcp buf memory
     memory.kmem.tcp.usage_in_bytes  # show current tcp buf memory allocation
     memory.kmem.tcp.failcnt            # show the number of tcp buf memory usage hits limits
     memory.kmem.tcp.max_usage_in_bytes # show max tcp buf memory usage recorded
    
    

    refer to

    • https://lwn.net/Articles/604609/
    • https://www.cnblogs.com/sparkdev/p/8296063.html
    • Documentation/admin-guide/cgroup-v2.rst
    • https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/cgroup-v1/cgroups.txt?h=v4.18-rc1
    • https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt
    • https://man7.org/linux/man-pages/man7/cgroups.7.html
    展开全文
  • CGroup V11. CGroup 概念Task: 任务,也就是进程,但这里的进程和我们通常意义上的 OS 进程有些区别,在后面会提到。CGroup: 控制组,一个 CGroup 就是一组按照某种标准划分的Tasks。这里的标准就是 Subsystem 配置...

    CGroup V1

    1. CGroup 概念Task: 任务,也就是进程,但这里的进程和我们通常意义上的 OS 进程有些区别,在后面会提到。

    CGroup: 控制组,一个 CGroup 就是一组按照某种标准划分的Tasks。这里的标准就是 Subsystem 配置。换句话说,同一个CGroup 的 Tasks 在一个或多个 Subsystem 上使用同样的配置。

    Hierarchy: 树形结构的 CGroup 层级,每个子 CGroup 节点会继承父 CGroup 节点的子系统配置,每个 Hierarchy 在初始化时会有默认的 CGroup(Root CGroup)。

    Subsystem: 子系统,具体的物理资源配置,比如 CPU 使用率,内存占用,磁盘 IO 速率等。一个 Subsystem 只能附加在一个 Hierarchy 上,一个 Hierarchy 可以附加多个 Subsystem。

    a8860a201b39238fb434052a5fe69cf8.png

    2. CGroup 文件系统

    在具体实现中,CGroup 通过虚拟文件系统实现,一个 CGroup 就是一个文件夹,Hierarchy 层级结构通过文件夹结构实现,而每个 CGroup 的 Subsystem 配置和 Tasks 则通过文件来配置。在 Ubuntu 下,可通过lssubsys -m(需要安装cgroup-tools包),查看已有的 Subsystem:

    root# lssubsys -m

    cpuset /sys/fs/cgroup/cpuset

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

    blkio /sys/fs/cgroup/blkio

    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

    perf_event /sys/fs/cgroup/perf_event

    hugetlb /sys/fs/cgroup/hugetlb

    pids /sys/fs/cgroup/pids

    这些是 Ubuntu16.04 上已实现的 Subsystem 和对应 Hierarchy。各个Subsystem 的作用可参考 RedHat CGroup Doc。在其它系统,你可以需要手动挂载虚拟文件系统并建立 Subsystem 和 Hierarchy 的关系:

    root# mount -t tmpfs cgroup_root /sys/fs/cgroup

    root# mkdir /sys/fs/cgroup/cpu

    root# mount -t cgroup cpu -ocpu /sys/fs/cgroup/cpu

    /sys/fs/cgroup/cpu 即成为附加(attach)了 CPU Subsystem 的 Hierarchy 的根目录,即 Root CGroup,我们可以在该 CGroup 下创建一个 Child CGroup:

    root# mkdir /sys/fs/cgroup/cpu/demo

    root# ls /sys/fs/cgroup/cpu/demo

    cgroup.clone_children cgroup.procs cpuacct.stat cpuacct.usage cpuacct.usage_percpu cpu.cfs_period_us cpu.cfs_quota_us cpu.shares cpu.stat notify_on_release tasks

    在创建 CGroup 时,就已经生成了一堆文件,一个 CGroup 目录中的内容大概可以分为四类:

    Subsystem Conf: 如附加了 CPU Subsystem 的 CGroup 目录下的 cpu* 文件均为 CPU Subsystem 配置

    Tasks: 在该 CGroup 下的 Tasks,分为两个文件,tasks 和 cgroup.procs,两者记录的都是在该进程 PID 列表,但是有所区别。

    CGroup Conf: CGroup 的一些通用配置,比如 notify_on_release 用于在 CGroup 结构变更时执行 release_agent 中的命令,cgroup.clone_children 用于在 Child CGroup 创建时,自动继承父 Child CGroup 的配置,目前只有 cpuset SubSystem 支持

    Child CGroups: 除以上三种文件外的子目录,如Ubuntu16.04中,每个 Root CGroup 下都有个 docker 目录,它由 Docker 创建,用于管理Docker容器的资源配置

    关于 tasks 和 cgroup.procs,网上很多文章将 cgroup 的 Task 简单解释为 OS 进程,这其实不够准确,更精确地说,cgroup.procs 文件中的 PID 列表才是我们通常意义上的进程列表,而 tasks 文件中包含的 PID 实际上可以是 Linux 轻量级进程(LWP) 的 PID,而由于 Linux pthread 库的线程实际上轻量级进程实现的(Linux 内核不支持真正的线程,可通过getconf GNU_LIBPTHREAD_VERSION查看使用的 pthread 线程库版本,Ubuntu16.04上是NPTL2.23(Native Posix Thread Lib),简单来说,Linux 进程主线程 PID = 进程 PID,而其它线程的 PID (LWP PID)则是独立分配的,可通过syscall(SYS_gettid)得到。LWP 在 ps 命令中默认是被隐藏的,在/proc/目录下可以看到。为了区分方便,我们将以 Proc 来表示传统意义上的进程,以 Thread 表示 LWP 进程。

    我们可以通过 ps 命令的 -T 参数将 LWP 在 SPID 列显示出来:

    root# ps -ef | wc -l

    218

    root# ps -efT | wc -l

    816

    root# ps -p 28051 -lfT

    F S UID PID SPID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME CMD

    0 Z root 28051 28051 26889 0 80 0 - 0 exit 10:30 pts/10 00:00:00 [a.out]

    1 R root 28051 28054 26889 99 80 0 - 12409 - 10:30 pts/10 00:00:10 [a.out]

    1 R root 28051 28055 26889 99 80 0 - 12409 - 10:30 pts/10 00:00:10 [a.out]

    以上示例中,Proc 28051 下有两个 Thread (28054,28055),即开了两个子线程。总的来说,Linux 下这种通过 LWP 来实现线程的方式,在一些时候会给用户一些困惑,比如如果我 kill -9 28055(默认在 ps 下看不到),按照 POSIX 标准,28055 “线程”所在的进程会被 Kill掉,因此28051,28054,28055三个进程都会被杀掉,感觉就很诡异。感兴趣的可以看看这篇文章)。

    当要向某个 CGroup 加入 Thread 时,将Thread PID 写入 tasks 或 cgroup.procs 即可,cgroup.procs 会自动变更为该 Task 所属的 Proc PID。如果要加入 Proc 时,则只能写入到 cgroup.procs 文件(未解),tasks 文件会自动更新为该 Proc 下所有的 Thread PID。可以通过cat /proc/PID/cgroup查看某个 Proc/Thread 的 CGroup 信息,

    3. 一个实例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

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50#define _GNU_SOURCE /* See feature_test_macros(7) */

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    const int NUM_THREADS = 5;

    void *thread_main(void *threadid)

    {

    long tid;

    tid = (long)threadid;

    printf("sub thread#%ld, pid #%ld!\n", tid, syscall(SYS_gettid));

    int a=0;

    while(1) {

    a++;

    }

    pthread_exit(NULL);

    }

    int main (int argc, char *argv[])

    {

    printf("main thread, pid #%ld!\n", syscall(SYS_gettid));

    int num_threads;

    if (argc > 1){

    num_threads = atoi(argv[1]);

    }

    if (num_threads<=0 || num_threads>=100){

    num_threads = NUM_THREADS;

    }

    pthread_t* threads = (pthread_t*) malloc (sizeof(pthread_t)*num_threads);

    int rc;

    long t;

    for(t=0; t

    rc = pthread_create(&threads[t], NULL, thread_main, (void *)t);

    if (rc){

    printf("ERROR; return code from pthread_create() is %d\n", rc);

    exit(-1);

    }

    }

    pthread_exit(NULL);

    free(threads);

    }

    这段代码简单创建了四个死循环线程,运行:

    1

    2

    3

    4

    5

    6root# gcc -pthread t.c && ./a.out

    main thread, pid #30354

    sub thread#0, pid #30355

    sub thread#2, pid #30357

    sub thread#3, pid #30358

    sub thread#1, pid #30356

    通过 htop/top(top 默认不会显示 LWP) 看到现在四个 CPU 会被吃满,为了限制资源,我们创建一个 CGroup:

    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

    30root# mkdir /sys/fs/cgroup/cpu/wdj

    # 创建 CGroup 之后,会自动生成相关文件

    root# ls /sys/fs/cgroup/cpu/wdj/

    cgroup.clone_children cgroup.procs cpuacct.stat cpuacct.usage cpuacct.usage_percpu cpu.cfs_period_us cpu.cfs_quota_us cpu.shares cpu.stat notify_on_release tasks

    # 配置该 CGroup,CPU 使用率不能超过 50%

    root# echo 50000 > /sys/fs/cgroup/cpu/wdj/cpu.cfs_quota_us

    # 将 Proc PID 写入 procs

    root# echo 30354 > /sys/fs/cgroup/cpu/wdj/cgroup.procs

    # tasks 已经自动更新, # 此时 CPU 占用率会立即下降到 50%

    root# cat /sys/fs/cgroup/cpu/wdj/tasks

    30355

    30356

    30357

    30358

    # 同样的方式,再来限制下 CPU 核的使用

    root# mkdir /sys/fs/cgroup/cpuset/wdj

    # 限制只能使用 CPU 2,3 两个核

    # 在使用前需要先执行,参考https://stackoverflow.com/questions/28348627/echo-tasks-gives-no-space-left-on-device-when-trying-to-use-cpuset

    #root echo 0 > cpuset/wdj/cpuset.mems

    #root echo 0 > cpuset/wdj/cpuset.cpus

    echo 2,3 > /sys/fs/cgroup/cpuset/wdj/cpuset.cpu

    # 这次我们将 Thread PID 写入 cgroup.procs

    root# echo 30355 > /sys/fs/cgroup/cpu/wdj/cgroup.procs

    # tasks 会自动更新为该 Proc下所有的 Thread PID

    root# cat /sys/fs/cgroup/cpu/wdj/tasks

    30355

    30356

    30357

    30358

    最终我们通过 htop 得到的效果如下:

    399bff5033f19cd8777b1913695f9b2c.png

    如果我们只将 Thread PID 如30356写入 /sys/fs/cgroup/cpu/wdj/tasks,则只会限制thread#1的CPU使用率。总结一下:

    将 Thread PID 写入 tasks: 仅对该”线程”(LWP) 生效

    将 Thread PID 写入 cgroup.procs: 会加入整个 Proc PID

    将 Proc PID 写入 tasks: 没有效果,写不进去

    将 Proc PID 写入 cgroup.procs: 会加入整个 Proc PID

    表现有点怪异,还没找到具体原因,总的来说,目前的 CGroup 还有点乱:

    Subsystem, Hierarchy, CGroup 三者的结构有点乱,将对进程的分组和对资源的控制混在了一起

    由于 Linux 通过 LWP 实现 Thread,导致 CGroup 看起来可以对线程实现控制,但这方面机制不够健全,比如前面提到的加入机制

    CGroup V2

    CGroup V2 在 Linux Kernel 4.5中被引入,并且考虑到其它已有程序的依赖,V2 会和 V1 并存几年。针对于 CGroup V1 中 Subsystem, Herarchy, CGroup 的关系混乱,CGroup V2 中,引入 unified hierarchy 的概念,即只有一个 Hierarchy,仍然通过 mount 来挂载 CGroup V2:

    mount -t cgroup2 none $MOUNT_POINT

    挂载完成之后,目录下会有三个 CGroup 核心文件:

    cgroup.controllers: 该文件列出当前 CGroup 支持的所有 Controller,如: cpu io memory

    cgroup.procs: 在刚挂载时,Root CGroup 目录下的 cgroup.procs 文件中会包含系统当前所有的Proc PID(除了僵尸进程)。同样,可以通过将 Proc PID 写入 cgroup.procs 来将 Proc 加入到 CGroup

    cgroup.subtree_control: 用于控制该 CGroup 下 Controller 开关,只有列在 cgroup.controllers 中的 Controller 才可以被开启,默认情况下所有的 Controller 都是关闭的。

    这三个文件在所有的 CGroup 中都会生成,除此之外,在非 Root CGroup 下,还会有一个 cgroup.events 文件,该文件的 populated 字段会指出当前 CGroup 下的所有存活的 Proc PID,为1则表示其下存活的 Proc PID 数量>1,否则populated为0。这用于 CGroup V1的 release_agent 等事件通知,因为当最后一个进程退出 CGroup 时,cgroup.events 文件会被修改,从而触发事件。

    # 查看当前 CGroup 支持的所有 Controllers

    root# cat cgroup.controllers

    cpu io memory

    # 开启和关闭 Controller

    root# echo "+cpu +memory -io" > cgroup.subtree_control

    在 CGroup V2 中,A CGroup 开启了某个 Controller,则其直接子 CGroup B会生成对应的 Controller 接口文件(如 cpu.cfs_quota_us),并且B CGroup 的 cgroup.controllers 会更新。B也可以选择开启或关闭该 Controller,但影响的是 B 的直接子 CGroup。并且只有没有 Tasks 的 CGroup 即中间节点可以开关 Controller,只有叶子节点(和根节点)可以执行资源配置。这样每个节点要么控制子 CGroup 的 Controller 开关(中间节点),要么控制其下 Tasks 的资源配置(叶子节点),结构更清晰。

    另外,CGroup V2 去掉了 Tasks 文件,增加了 cgroup.threads 文件,用于管理 LWP(仍然没有放弃对”线程”的支持),但语义上会清晰一些。

    站在进程的角度来说,在挂载 CGroup V2时,所有已有Live Proc PID 都会加入到 Root CGroup,之后所有新创建的进程都会自动加入到父进程所属的 CGroup,由于 V2 只有一个 Hierarchy,因此一个进程同一时间只会属于一个 CGroup:

    root# cat /proc/842/cgroup

    ...

    0::/test-cgroup/test-cgroup-nested

    总的来说,CGroup V2去掉了多个 Hierarchy 结构,使用 unified Hierarchy,对 Hierarchy 内部层级结构作出一些限制以保证层级逻辑清晰,并且优化了 CGroup 的文件组织(如 cgroup.events, cgroup.threads)。由于目前手头暂时没有 Kernel 4.5,只能通过文档大概了解下,还是要找机会实际体验一下。

    Reference:

    展开全文
  • CGroup文档

    2020-09-25 21:39:00
    文章目录一、CGroup简述1、定义2、组成与基础概念2.1 control group 控制族群2.2 task 任务2.3 hierarchy 层级树2.4 subsystem 子系统2.5 CGroup 虚拟文件系统:进行分组管理和各子系统设置的用户接口2.6 层级图二、...
  • docker cgroup

    2021-04-06 19:44:03
    文章目录一、Cgroup概念二、stress测试工具1.权重(--cpu-shares)2.cpu core控制 (--cpuset-spus)3.CPU周期限制 (--cpu-period、--cpu-quota)三、CPU配额控制参数四、Block IO限制1.bps和iops的限制五、内存...
  • cgroup
  • cgroup详解

    2021-05-05 22:04:54
    最近想做一个简单的类似docker的东西,其实大概也知道cgroup做些啥(给别人吹不就是做隔离嘛,这么简单的)但是具体能做啥隔离还真不知道,暂时也没有找到专业的总结,还好有一个五一劳动节,所以就想整理一下自己学...
  • 一个MySQL UDF来设置当前线程的cgroup。 这对于将资源控制放在OS的线程上很有用。 安装 $ gcc -o udf_cgroup.so udf_cgroup.c `/mysql_config --include` -shared -fPIC -lcgroup mysql> CREATE FUNCTION set_...
  • CGROUP 配置

    2021-06-29 15:43:07
    Linux内核配置cgroup General setup —>[*] Control Group support —>
  • Docker cgroup 信息 不赞成这样做。 用于检查 docker 容器的最小工具 用法 usage: docker_info.py [-h] [--cgroup_name CGROUP_NAME] [--verbose VERBOSE] [--list LIST] [--url URL] 一般安装 virtualenv env . ...
  • cgroup 简介

    千次阅读 2017-12-19 22:21:04
    cgroup 的功能在于将一台计算机上的资源(CPU,memory,network)进行分片,来防止进程间不利的资源抢占。 术语cgroup:关联一组 task 和一组 subsystem 的配置参数。 一个 task 对应一个进程,cgroup 是资源分片的...
  • cgroup CPUSET

    2019-09-14 14:30:38
    cpuset子系统可以为 cgroup 分配独立 CPU 和内存节点。可根据以下参数来设定 cpuset,每个参数都在 cgroup 虚拟文件系统的一个单独“伪文件”里: 重要 一些子系统有强制参数,在您将任务移至使用这些子系统的 ...
  • Linux下cgroup

    2016-04-07 22:46:20
    Linux下cgroup以及namespces相关知识,包括资源隔离与限制等
  • 容器之 CGroup

    2018-08-08 17:04:17
    转载自:https://jin-yang.github.io/post/linux-container-cgroup-introduce.html 在 CentOS 7 中,已经通过 systemd 替换了之前的 cgroup-tools 工具,为了防止两者冲突,建议只使用 systemd ,只有对于一些不...
  • cgroup--cgroup 测试

    2017-07-04 10:54:00
    cgroups全称control groups,在RHEL6的2.6.32内核中已经包括了cgroup的patch。这里强烈建议安装RHEL6(CentOS6)来使用cgroups,如果没有的话,  只能升级内核了 ( > 2.6.26版本)  安装cgroups  apt-get install...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,781
精华内容 19,512
关键字:

cgroup