• 大家都熟悉Linux下可以通过top命令来查看所有进程的内存,CPU等信息。除此之外,还有其他一些命令,可以得到更详细的信息,例如 进程相关 [plain] view plaincopy cat /proc/your_...

    转自:http://blog.csdn.net/xh_xpz/article/details/6793056

    大家都熟悉Linux下可以通过top命令来查看所有进程的内存,CPU等信息。除此之外,还有其他一些命令,可以得到更详细的信息,例如

    进程相关

    [plain] view plaincopy
    1. cat /proc/your_PID/status  

    通过top或ps -ef | grep '进程名' 得到进程的PID。该命令可以提供进程状态、文件句柄数、内存使用情况等信息。


    内存相关

    [plain] view plaincopy
    1. vmstat -s -S M  

    该可以查看包含内存每个项目的报告,通过-S M或-S k可以指定查看的单位,默认为kb。结合watch命令就可以看到动态变化的报告了。

    也可用

    [plain] view plaincopy
    1. cat /proc/meminfo  


    CPU相关

    要看cpu的配置信息可用

    [plain] view plaincopy
    1. cat /proc/cpuinfo  

    它能显示诸如CPU核心数,时钟频率、CPU型号等信息。

    要查看cpu波动情况的,尤其是多核机器上,可使用

    [plain] view plaincopy
    1. mpstat -P ALL 10  

    该命令可间隔10秒钟采样一次CPU的使用情况,每个核的情况都会显示出来,例如,每个核的idle情况等。

    只需查看均值的,可用

    [plain] view plaincopy
    1. iostat -c  


    IO相关

    [plain] view plaincopy
    1. iostat -p ALL  

    该命令可查看所有设备使用率、读写字节数等信息。

    展开全文
  • 公司规划将一款游戏移植到某嵌入式平台,Sam做性能分析时发现此平台...1. 在Linux下,如何确认是多核或多CPU: #cat /proc/cpuinfo 如果有多个类似以下的项目,则为多核或多CPU: processor : 0 ...... processor : 1

    公司规划将一款游戏移植到某嵌入式平台,Sam做性能分析时发现此平台CPU是双核。于是思考如何利用双核来提高游戏效果。先从简单的基础知识说起:

     

    1. 在Linux下,如何确认是多核或多CPU:

    #cat /proc/cpuinfo

    如果有多个类似以下的项目,则为多核或多CPU:

    processor       : 0

    ......

    processor       : 1

     

    2. Linux下,如何看每个CPU的使用率:

    #top -d 1

    之后按下1. 则显示多个CPU

    Cpu0  :  1.0%us,  3.0%sy,  0.0%ni, 96.0%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

     

    3. 如何察看某个进程在哪个CPU上运行:

    #top -d 1

    之后按下f.进入top Current Fields设置页面:

    选中:j: P          = Last used cpu (SMP)

    则多了一项:P 显示此进程使用哪个CPU。

     

    Sam经过试验发现:同一个进程,在不同时刻,会使用不同CPU Core.这应该是Linux Kernel SMP处理的。

     

     

    4. 配置Linux Kernel使之支持多Core:

    内核配置期间必须启用 CONFIG_SMP 选项,以使内核感知 SMP。

    Processor type and features  ---> Symmetric multi-processing support

     

    察看当前Linux Kernel是否支持(或者使用)SMP

    #uname -a

     

    5. Kernel 2.6的SMP负载平衡:

    在 SMP 系统中创建任务时,这些任务都被放到一个给定的 CPU 运行队列中。通常来说,我们无法知道一个任务何时是短期存在的,何时需要长期运行。因此,最初任务到 CPU 的分配可能并不理想。

    为了在 CPU 之间维护任务负载的均衡,任务可以重新进行分发:将任务从负载重的 CPU 上移动到负载轻的 CPU 上。Linux 2.6 版本的调度器使用负载均衡(load balancing) 提供了这种功能。每隔 200ms,处理器都会检查 CPU 的负载是否不均衡;如果不均衡,处理器就会在 CPU 之间进行一次任务均衡操作

    这个过程的一点负面影响是新 CPU 的缓存对于迁移过来的任务来说是冷的(需要将数据读入缓存中)。

     

    记住 CPU 缓存是一个本地(片上)内存,提供了比系统内存更快的访问能力。如果一个任务是在某个 CPU 上执行的,与这个任务有关的数据都会被放到这个 CPU 的本地缓存中,这就称为热的。如果对于某个任务来说,CPU 的本地缓存中没有任何数据,那么这个缓存就称为冷的

     

    不幸的是,保持 CPU 繁忙会出现 CPU 缓存对于迁移过来的任务为冷的情况。

     

     

    6. 应用程序如何利用多Core :

    开发人员可将可并行的代码写入线程,而这些线程会被SMP操作系统安排并发运行。

    另外,Sam设想,对于必须顺序执行的代码。可以将其分为多个节点,每个节点为一个thread.并在节点间放置channel.节点间形如流水线。这样也可以大大增强CPU利用率。

     

    例如:

    游戏可以分为3个节点。

    1.接受外部信息,声称数据 (1ms)

    2.利用数据,物理运算(3ms)

    3.将物理运算的结果展示出来。(2ms)

    如果线性编程,整个流程需要6ms.

    但如果将每个节点作为一个thread。但thread间又同步执行。则整个流程只需要3ms.

     

     

     

     

     

    附1:

    多处理的历史

     

     

    多处理起源于 20 世纪 50 年代中期的一些公司,这些公司中有些您可能知道,而另一些您可能就不记得了(IBM、Digital Equipment Corporation、Control Data Corporation)。20 世纪 60 年代早期,Burroughs Corporation 引入了一种对称 MIMD 多处理器,它带有四个 CPU 并通过交叉开关可连接最多十六个内存模块(第一种 SMP 架构)。1964 年引入了 CDC 6600,它的使用比较成功并得到流行,它提供了一个带有十个子处理器(外围处理单元)的 CPU。20 世纪 60 年代末,Honeywell 发布了它的第一个 Multics 系统,这是带八个 CPU 的另一种对称多处理系统。

    在开发多处理系统的同时,各种技术的使用也提高了缩小处理器体积和运行更快的时钟频率的能力。20 世纪 80 年代,Cray Research 等公司引入了多处理器系统和类似 UNIX® 的操作系统(CX-OS),以便利用这些能力。

    20 世纪 80 年代末期,随着单处理器个人计算机系统(如 IBM PC)的流行,多处理系统的使用呈下降趋势。但是到了二十年后的现在,多处理利用对称多处理技术又回到了个人计算机系统中。

    Amdahl 法则

    Gene Amdahl 是一名计算机架构师、IBM 职员,在 IBM、Amdahl Corporation(以他的名字命名的企业)和其他一些公司从事计算机架构开发。但是最著名的是他的法则,该法则用于在改进系统的一部分后预测最大的预期系统改进。它主要用来计算使用多处理器后理论上的最大性能改进(参见图 1)。


    图 1. 处理器并行化的 Amdahl 法则
    处理器并行化的 Amdahl 法则

    使用图 1 所示的等式,可计算系统的最大性能改进,N 表示处理器的数目,而因数 F 指定不能并行化的系统部分(即本质上顺序的系统部分)。结果如图 2 所示。


    图 2. 最多十个 CPU 的 Amdahl 法则
    最多十个 CPU 的 Amdahl 法则

    图 2 中最上面的一条线显示了处理器的数目。理想状态下,添加另外的处理器来解决问题时,希望看到这样的性能增长。不幸的是,并非所有的问题都可以并行化,而且还有管理处理器的开销,所以速度的提高并没有这么大。底部(紫色的线)是一个 90% 的处理属于顺序性的问题例子。在此图中,最佳的情况是棕色的线,它展示了一个 10% 顺序性(因此 90% 可并行化)的问题。即使在这种情况下,十个处理器的执行性能也只比五个稍好一点儿。

     

     

     

     

    附2:

    什么是调度器?

    通常来说,操作系统是应用程序和可用资源之间的媒介。典型的资源有内存和物理设备。但是 CPU 也可以认为是一个资源,调度器可以临时分配一个任务在上面执行(单位是时间片)。调度器使得我们同时执行多个程序成为可能,因此可以与具有各种需求的用户共享 CPU。

    调度器的一个重要目标是有效地分配 CPU 时间片,同时提供很好的用户体验。调度器还需要面对一些互相冲突的目标,例如既要为关键实时任务最小化响应时间,又要最大限度地提高 CPU 的总体利用率。下面我们来看一下 Linux 2.6 调度程序是如何实现这些目标的,并与以前的调度器进行比较。




    回页首


     

    早期 Linux 调度器的问题

     

    O-notation 的重要性
    O-notation 可以告诉我们一个算法会占用多少时间。一个 O(n) 算法所需要的时间依赖于输入的多少(与 n 是线性关系),而 O(n^2) 则是输入数量的平方。O(1) 与输入无关,可以在固定的时间内完成操作。

     

    在 2.6 版本的内核之前,当很多任务都处于活动状态时,调度器有很明显的限制。这是由于调度器是使用一个复杂度为 O(n) 的算法实现的。在这种调度器中,调度任务所花费的时间是一个系统中任务个数的函数。换而言之,活动的任务越多,调度任务所花费的时间越长。在任务负载非常重时,处理器会因调度消耗掉大量的时间,用于任务本身的时间就非常少了。因此,这个算法缺乏可伸缩性。

    在对称多处理系统(SMP)中,2.6 版本之前的调度器对所有的处理器都使用一个运行队列。这意味着一个任务可以在任何处理器上进行调度 —— 这对于负载均衡来说是好事,但是对于内存缓存来说却是个灾难。例如,假设一个任务正在 CPU-1 上执行,其数据在这个处理器的缓存中。如果这个任务被调度到 CPU-2 上执行,那么数据就需要先在 CPU-1 使其无效,并将其放到 CPU-2 的缓存中。

    以前的调度器还使用了一个运行队列锁;因此在 SMP 系统中,选择一个任务执行就会阻碍其他处理器操作这个运行队列。结果是空闲处理器只能等待这个处理器释放出运行队列锁,这样会造成效率的降低。

    最后,在早期的内核中,抢占是不可能的;这意味着如果有一个低优先级的任务在执行,高优先级的任务只能等待它完成。

    展开全文
  • top命令经常用来监控linux的系统状况,比如cpu、内存的使用,程序员基本都知道这个命令,但比较奇怪的是能用好它的人却很少,例如top监控视图中内存数值的含义就有不少的曲解。 本文通过一个运

    查看多核CPU命令

     mpstat -P ALL  和  sar -P ALL 

    说明:sar -P ALL > aaa.txt   重定向输出内容到文件 aaa.txt

     

    top命令经常用来监控linux的系统状况,比如cpu、内存的使用,程序员基本都知道这个命令,但比较奇怪的是能用好它的人却很少,例如top监控视图中内存数值的含义就有不少的曲解。

    本文通过一个运行中的WEB服务器的top监控截图,讲述top视图中的各种数据的含义,还包括视图中各进程(任务)的字段的排序。

    top进入视图

    top视图 01

    【top视图 01】是刚进入top的基本视图,我们来结合这个视图讲解各个数据的含义。


     

    1. 第一行:
    2. 10:01:23 — 当前系统时间
    3. 126 days, 14:29 — 系统已经运行了126天14小时29分钟(在这期间没有重启过)
    4. 2 users — 当前有2个用户登录系统
    5. load average: 1.15, 1.42, 1.44 — load average后面的三个数分别是1分钟、5分钟、15分钟的负载情况。

    load average数据是每隔5秒钟检查一次活跃的进程数,然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量,结果高于5的时候就表明系统在超负荷运转了。

     

    1. 第二行:
    2. Tasks — 任务(进程),系统现在共有183个进程,其中处于运行中的有1个,182个在休眠(sleep),stoped状态的有0个,zombie状态(僵尸)的有0个。


     

    1. 第三行:cpu状态
    2. 6.7% us — 用户空间占用CPU的百分比。
    3. 0.4% sy — 内核空间占用CPU的百分比。
    4. 0.0% ni — 改变过优先级的进程占用CPU的百分比
    5. 92.9% id — 空闲CPU百分比
    6. 0.0% wa — IO等待占用CPU的百分比
    7. 0.0% hi — 硬中断(Hardware IRQ)占用CPU的百分比
    8. 0.0% si — 软中断(Software Interrupts)占用CPU的百分比


     

    在这里CPU的使用比率和windows概念不同,如果你不理解用户空间和内核空间,需要充充电了。


     

    1. 第四行:内存状态
    2. 8306544k total — 物理内存总量(8GB)
    3. 7775876k used — 使用中的内存总量(7.7GB)
    4. 530668k free — 空闲内存总量(530M)
    5. 79236k buffers — 缓存的内存量 (79M)



     

    1. 第五行:swap交换分区
    2. 2031608k total — 交换区总量(2GB)
    3. 2556k used — 使用的交换区总量(2.5M)
    4. 2029052k free — 空闲交换区总量(2GB)
    5. 4231276k cached — 缓冲的交换区总量(4GB)


     

    这里要说明的是不能用windows的内存概念理解这些数据,如果按windows的方式此台服务器“危矣”:8G的内存总量只剩下530M的可用内存。Linux的内存管理有其特殊性,复杂点需要一本书来说明,这里只是简单说点和我们传统概念(windows)的不同。

    第四行中使用中的内存总量(used)指的是现在系统内核控制的内存数,空闲内存总量(free)是内核还未纳入其管控范围的数量。纳入内核管理的内存不见得都在使用中,还包括过去使用过的现在可以被重复利用的内存,内核并不把这些可被重新使用的内存交还到free中去,因此在linux上free内存会越来越少,但不用为此担心。

    如果出于习惯去计算可用内存数,这里有个近似的计算公式:第四行的free + 第四行的buffers + 第五行的cached,按这个公式此台服务器的可用内存:530668+79236+4231276 = 4.7GB。

    对于内存监控,在top里我们要时刻监控第五行swap交换分区的used,如果这个数值在不断的变化,说明内核在不断进行内存和swap的数据交换,这是真正的内存不够用了。

     

    第六行是空行

    第七行以下:各进程(任务)的状态监控
    PID — 进程id
    USER — 进程所有者
    PR — 进程优先级
    NI — nice值。负值表示高优先级,正值表示低优先级
    VIRT — 进程使用的虚拟内存总量,单位kb。VIRT=SWAP+RES
    RES — 进程使用的、未被换出的物理内存大小,单位kb。RES=CODE+DATA
    SHR — 共享内存大小,单位kb
    S — 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
    %CPU — 上次更新到现在的CPU时间占用百分比
    %MEM — 进程使用的物理内存百分比
    TIME+ — 进程使用的CPU时间总计,单位1/100秒
    COMMAND — 进程名称(命令名/命令行)

    多U多核CPU监控

    在top基本视图中,按键盘数字“1”,可监控每个逻辑CPU的状况:

    top视图 02

    观察上图,服务器有16个逻辑CPU,实际上是4个物理CPU。

    如果不按1,则在top视图里面显示的是所有cpu的平均值

    进程字段排序

    默认进入top时,各进程是按照CPU的占用量来排序的,在【top视图 01】中进程ID为14210的java进程排在第一(cpu占用100%),进程ID为14183的java进程排在第二(cpu占用12%)。可通过键盘指令来改变排序字段,比如想监控哪个进程占用MEM最多,我一般的使用方法如下:

    1. 敲击键盘“b”(打开/关闭加亮效果),top的视图变化如下:


    top视图 03

    我们发现进程id为10704的“top”进程被加亮了,top进程就是视图第二行显示的唯一的运行态(runing)的那个进程,可以通过敲击“y”键关闭或打开运行态进程的加亮效果。

    2. 敲击键盘“x”(打开/关闭排序列的加亮效果),top的视图变化如下:

     

    top视图 04

    可以看到,top默认的排序列是“%CPU”。

    3. 通过”shift + >”或”shift + <”可以向右或左改变排序列,下图是按一次”shift + >”的效果图:

    top视图 05

    视图现在已经按照%MEM来排序了。

    改变进程显示字段

    1. 敲击“f”键,top进入另一个视图,在这里可以编排基本视图中的显示字段:

    top视图 06

    这里列出了所有可在top基本视图中显示的进程字段,有”*”并且标注为大写字母的字段是可显示的,没有”*”并且是小写字母的字段是不显示的。如果要在基本视图中显示“CODE”和“DATA”两个字段,可以通过敲击“r”和“s”键:

    top视图 07

    2. “回车”返回基本视图,可以看到多了“CODE”和“DATA”两个字段:

    top视图 08

    top命令的补充

    top命令是Linux上进行系统监控的首选命令,但有时候却达不到我们的要求,比如当前这台服务器,top监控有很大的局限性。这台服务器运行着websphere集群,有两个节点服务,就是【top视图 01】中的老大、老二两个java进程,top命令的监控最小单位是进程,所以看不到我关心的java线程数和客户连接数,而这两个指标是java的web服务非常重要的指标,通常我用ps和netstate两个命令来补充top的不足。

    监控java线程数:
    ps -eLf | grep java | wc -l

    监控网络客户连接数:
    netstat -n | grep tcp | grep 侦听端口 | wc -l

    上面两个命令,可改动grep的参数,来达到更细致的监控要求。

    在Linux系统“一切都是文件”的思想贯彻指导下,所有进程的运行状态都可以用文件来获取。系统根目录/proc中,每一个数字子目录的名字都是运行中的进程的PID,进入任一个进程目录,可通过其中文件或目录来观察进程的各项运行指标,例如task目录就是用来描述进程中线程的,因此也可以通过下面的方法获取某进程中运行中的线程数量(PID指的是进程ID):

    ls /proc/PID/task | wc -l

    在linux中还有一个命令pmap,来输出进程内存的状况,可以用来分析线程堆栈:

    pmap PID


    大家都熟悉Linux下可以通过top命令来查看所有进程的内存,CPU等信息。除此之外,还有其他一些命令,可以得到更详细的信息,例如

    进程相关

    cat /proc/your_PID/status

     

    通过top或ps -ef | grep '进程名' 得到进程的PID。该命令可以提供进程状态、文件句柄数、内存使用情况等信息。

     

    内存相关

    vmstat -s -S M

     

    该可以查看包含内存每个项目的报告,通过-S M或-S k可以指定查看的单位,默认为kb。结合watch命令就可以看到动态变化的报告了。

    也可用

    cat /proc/meminfo

     

    CPU相关

    要看cpu的配置信息可用

    cat /proc/cpuinfo

     

    它能显示诸如CPU核心数,时钟频率、CPU型号等信息。

    要查看cpu波动情况的,尤其是多核机器上,可使用

     

    mpstat -P ALL 10

     

    该命令可间隔10秒钟采样一次CPU的使用情况,每个核的情况都会显示出来,例如,每个核的idle情况等。

    只需查看均值的,可用

    iostat -c

    IO相关

    iostat -P ALL

     

    该命令可查看所有设备使用率、读写字节数等信息。

     

    另外,htop ,有时间可以用一下。

    展开全文
  • 多核的负载均衡

    多核的负载均衡

    Linux 在多线程的情况下,进程是如何调度的呢?我们先来看看下面流程图:

    Linux 多核调度流程图要理解多核首先要理解单核,前面的文章中我已经对单核的调度算法学习了。其实多核的情况下,需要理解负载均衡的概念。所以,

    • 在多核的 CPU 上,每个 core 上面的还是使用FIFO、RR、CFS算法调度进程的
    • 在core与core之间,使用一些算法进行负载均衡。
      • 对于 RT 的进程,core和core之间使用 pull_rt_request 和 push_rt_request 的进行负载均衡。这是一种主动的平衡策略。
      • 对于 normal 的进程,采用的是的跟随 check 的方式,比较被动。

    pull_rt_request:是当一个 core 闲下来的时候,会主动的去忙的 core 里面拉去进程,帮繁忙的 core 来运行进程。

    push_rt_request:是当一个 core 繁忙的时候,它会主动的将它上面的进程推送给闲暇的 core,让闲暇的 core 帮忙来执行。

    普通进程会在三个时机触发 core 负责平衡:

    • 当一个时钟周期结束的时候
    • 当一个 core 进入 IDLE 状态的时候
    • 当一个 core 执行 fork 或者 exec 的时候

    来来,我们来测试一下,请看下面的代码:

    1  #include <stdio.h>
    2  #include <pthread.h>
    3  #include <sys/types.h>
    4
    5  void *thread_fun(void *param)
    6  {
    7          printf("thread pid:%d, tid:%lu\n", getpid(), pthread_self());
    8          while (1) ;
    9          return NULL;
    10  }
    11
    12  int main(void)
    13  {
    14          pthread_t tid1, tid2;
    15          int ret;
    16
    17          printf("main pid:%d, tid:%lu\n", getpid(), pthread_self());
    18
    19          ret = pthread_create(&tid1, NULL, thread_fun, NULL);
    20          if (ret == -1) {
    21                  perror("cannot create new thread");
    22                  return 1;
    23          }
    24
    25          ret = pthread_create(&tid2, NULL, thread_fun, NULL);
    26          if (ret == -1) {
    27                  perror("cannot create new thread");
    28                  return 1;
    29          }
    30
    31          if (pthread_join(tid1, NULL) != 0) {
    32                  perror("call pthread_join function fail");
    33                  return 1;
    34          }
    35
    36          if (pthread_join(tid2, NULL) != 0) {
    37                  perror("call pthread_join function fail");
    38                  return 1;
    39          }
    40
    41          return 0;
    42  }
    
    ~> gcc show_cores.c -pthread
    ~> ./a.out
    

    执行结果如下所示:
    在这里插入图片描述在上图中可以看到,a.out 的进程 cpu 占用率是 200% ,这是因为 Linux 操作系统会帮我们将 a.out 里面两个线程的负载平均到这两个 core 里面。
    使用 time 这个命令,我们也可以看到一些 Linux 做 core 之间负载均衡的痕迹,下图所示,real 是程序真正在 cpu 执行的时间,user 是站在用户的角度执行的时候,user 大概是 real 的两倍,这说明 Linux 将两个线程执行时间平衡到两个 core 里面执行了,因为为我们节省了一半的时间了。
    time

    我们可以使用 taskset这个 shell 命令来设置进程在那个 core 里面跑。例如

    taskset -a -p 01 2000 # 将 2000 进程所有的线程放到 01 这个 core 里面跑
    

    taskset

    taskset -a -p 01 2000 # 将 2000 进程所有的线程放到 01 这个 core 里面跑
    

    taskset

    中断的负载均衡

    我们以网卡的中断来说明,如何做到网络的中断的负载均衡的。
    如何下图所示:

    在这里插入图片描述在上图中,可以发现我的虚拟机上,有两个网卡驱动,我们看看 ens33 的队列的负载均衡是怎么做的。 rps_cpus 里面可以设置中断队列的中断发送给那个 cpu 来处理。这是 linux 的 RPS(Receive Packet Steering) 补丁,这个补丁解决了中断分配不均匀的问题。我们可以做下面的修改:

    ~> echo 'fffe' > /sys/class/net/lo/queues/rx-0/rps_cpus
    

    这样设计就把中断分给了 01、02、03 三个 core 里面了。
    可以使用下面的 shell 语句进行观察:

    watch -d "cat /proc/softirqs | grep 'NET_RX'"
    

    cgroup

    cgroup 是 Linux 提供一种 cpu 资源隔离的机制。它是为了解决用户级的进程调度公平。
    假如有一个用户底下有 1024 个进程,另外一个用户下面有 52 个进程,那A用户很明显会占用更多的资源,因为 CFS 尽量的让每个进程公平得获得 CPU 资源,这样积累下来第一个用户获得比第二个进程获得更多得资源,如果,如果第二个进程是 CPU 消耗型的虽然进程数量少,但是需要的 CPU资源更多。所以CFS可能能会造成用户级的不公平。

    那咋办呢?当然是是有办法了,这就是 cgroup 了。

    先不解释概念,先一波如下一顿操作:

    # 启动三个 a.out 程序
    ~> ./a.out &
    ~> ./a.out &
    ~> ./a.out &
    
    ~> cd /sys/fs/cgroup/cpu
    ~> mkdir A 
    ~> mkdir B
    ~> echo 1834 > A/cgroup.procs
    ~> echo 1837 > A/cgroup.procs
    ~> echo 1840 > B/cgroup.procs
    

    在这一波操作前三个 a.out 的 cpu 占用率如下所示:
    a.out进行完这波操作完,再来看看三个 a.out 的 cpu 占用率:
    在这里插入图片描述在路径 /sys/fs/cgroup/cpu 下面我们我们可以像新建文件夹一样的创建一个 cgroup ,然后我们可以在 cgroup.proc 里面写入进程ID好,这样就把 pid 进程放到了这个 cgroup 里面了。

    可以调整几个参数来调整 cgroup 里面进程的 cpu 占用率。

    先来看看看 pid 和 cgroup 的关系。如下所示:

    pid cgroup
    1840 B
    1834 A
    1837 A

    它们的 cpu 占用率如下所示:
    cpu我们进行如下设置:

    ~> echo 512 > B/cpu.shares
    

    这个命令会将 B 的CPU占用的优先级设置为 512 , A 的 cpu.shares 的值为 1024 。A 是 B的二倍,所以 A 可以分到三个二的 CPU ,B可以分到三分之一的 CPU时间。

    结果如下下图所示:

    在这里插入图片描述
    在来看看其的参数:

    • cpu.rt_period_us: RT型进程一个周期的微秒数
    • cpu.rt_runtime_us:RT型进程能在 cpu.rt_period_us 中跑多长时间
    • cpu.cfs_period_us:normal 型进程一个周期的微秒数
    • cpu.cfs_quota_us:normal 型进程能在 cpu.rt_period_us 中跑多长时间

    来看看 cpu.cfs_quota 是咋用的:

    ~> echo 10000 > A/cpu.cfs_quota_us
    

    在执行之前:

    在这里插入图片描述在执行之后:

    在这里插入图片描述我们知道,1837和1834 是在 A 中执行的,我们把 A 中 normal 类型的进程的运行时间减少后,CPU 资源大多给了 A , 所以 1840 这个进程就获得大部分的 CPU资源。

    这就是cgroup.

    Linux 不是一个实时操作系统

    什么样子的系统称之为实时操作系统呢?真相只有一个,那就是进程从就绪到执行的等待时间是可预期的。

    在这里插入图片描述怎么理解可预期呢?就是一个进程 RT 从唤醒到获得 CPU 资源的时间不会超过一个阈值。如果超过了那这个操作系统就不能称为实时操作系统。

    原因是 RT 进程在好三类 CPU 区间下不能抢到 CPU 资源。

    不能抢的情况是有下面几个:

    • 进程上下切换过程中拿到 spinlock,进程中有 spinlock
    • 中断和软中断
    • 内核进程不能抢

    这三类 CPU区间 CPU 占用时长都是不确定的。所以 Linux 不是硬实时操作系统。

    可以安装 preempt_rt 这补丁来把 Linux 做成一个近似的硬实时操作系统。

    这个补丁实现下面的功能:

    • spinlock 迁移为可调度的 mutex ,其中 mutex 是可以抢的。
    • 实现优先级继承协议,举个例子, A B C 三个进程, 他们优先级是 1 2 3 , A 和 C 两个之间存在锁,C 控制了锁,但是 C 的优先级比较低,C 总是抢不到 CPU,所以 A 有等 C 好长时间。优先级继承协议是将 C 从优先级设置成 1 ,这样的话,C 就能比较快速的干完自己的事情,干完后就可以把锁给 A了
    • 中断和软中断线程化,什么是中断线程化,我也不知道?需要进一步的了解。

    番外知识点

    fork 我已经知道是个什么东西了,exce 不执行,exce 说白了就是挂羊头买狗肉的做法,首先就是用 fork 出来进程的内存、代码端、程序计数器等一个完整的进程;然后使用把这些都擦除掉,然后将我们希望运行的程序放到刚才说的进程结构里面去,酒瓶子就装上了新酒。

    展开全文
  • 1. Linux下,如何看每个CPU的使用率: #top -d 1 之后按下数字1. 则显示多个CPU (top后按1也一样) Cpu0 : 1.0%us, 3.0%sy, 0.0%ni, 96.0%id, 0.0%wa, 0.0%hi, 0.0%si,
     
    

    1. Linux下,如何看每个CPU的使用率:

    #top -d 1

    之后按下数字1. 则显示多个CPU   (top后按1也一样)

    Cpu0  :  1.0%us,  3.0%sy,  0.0%ni, 96.0%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

     

    2. 在Linux下,如何确认是多核或多CPU:

    #cat /proc/cpuinfo

    如果有多个类似以下的项目,则为多核或多CPU:

    processor       : 0

    ......

    processor       : 1

     

     

    3. 如何察看某个进程在哪个CPU上运行:

    #top -d 1

    之后按下f.进入top Current Fields设置页面:

    选中:j: P          = Last used cpu (SMP)

    则多了一项:P 显示此进程使用哪个CPU。

     

    Sam经过试验发现:同一个进程,在不同时刻,会使用不同CPU Core.这应该是Linux Kernel SMP处理的。

     

     

    4. 配置Linux Kernel使之支持多Core:

    内核配置期间必须启用 CONFIG_SMP 选项,以使内核感知 SMP。

    Processor type and features  ---> Symmetric multi-processing support

     

    察看当前Linux Kernel是否支持(或者使用)SMP

    #uname -a

     

    5. Kernel 2.6的SMP负载平衡:

    在 SMP 系统中创建任务时,这些任务都被放到一个给定的 CPU 运行队列中。通常来说,我们无法知道一个任务何时是短期存在的,何时需要长期运行。因此,最初任务到 CPU 的分配可能并不理想。

    为了在 CPU 之间维护任务负载的均衡,任务可以重新进行分发:将任务从负载重的 CPU 上移动到负载轻的 CPU 上。Linux 2.6 版本的调度器使用负载均衡(load balancing) 提供了这种功能。每隔 200ms,处理器都会检查 CPU 的负载是否不均衡;如果不均衡,处理器就会在 CPU 之间进行一次任务均衡操作

    这个过程的一点负面影响是新 CPU 的缓存对于迁移过来的任务来说是冷的(需要将数据读入缓存中)。

     

    记住 CPU 缓存是一个本地(片上)内存,提供了比系统内存更快的访问能力。如果一个任务是在某个 CPU 上执行的,与这个任务有关的数据都会被放到这个 CPU 的本地缓存中,这就称为热的。如果对于某个任务来说,CPU 的本地缓存中没有任何数据,那么这个缓存就称为冷的

     

    不幸的是,保持 CPU 繁忙会出现 CPU 缓存对于迁移过来的任务为冷的情况。

     

     

    6. 应用程序如何利用多Core :

    开发人员可将可并行的代码写入线程,而这些线程会被SMP操作系统安排并发运行。

    另外,Sam设想,对于必须顺序执行的代码。可以将其分为多个节点,每个节点为一个thread.并在节点间放置channel.节点间形如流水线。这样也可以大大增强CPU利用率。

     

    例如:

    游戏可以分为3个节点。

    1.接受外部信息,声称数据 (1ms)

    2.利用数据,物理运算(3ms)

    3.将物理运算的结果展示出来。(2ms)

    如果线性编程,整个流程需要6ms.

    但如果将每个节点作为一个thread。但thread间又同步执行。则整个流程只需要3ms.

    展开全文
  • 一.线程/进程 进程:资源管理的最小单位 线程:执行任务的最小单位 内核线程:内核空间创建,类似用户进程,但运行期间不能被抢断 用户线程:用户空间创建,拥有进程上下文,可调度可睡眠   二....
  • 目前的x86/x64的多核/多处理器系统是SMP结构,共享主存,内存是共享设备,多个处理器/核心要访问内存,首先要获得内存总线的控制权,任何时刻只有一个处理器/核心能获得内存总线的控制权,所以单就内存来说,不会...
  • linux驱动-内存分配

    2018-08-04 10:26:26
    linux地址类型:先看图解: linux地址空间主要分两类:虚拟地址和物理地址。 图中假设虚拟地址和物理地址都是从0x00000000到0xFFFFFFFF(这里只是为了好理解,实际要根据具体情况配置)。当然物理地址要根据实际...
  • Linux多核CPU知识

    2015-07-23 19:29:13
    1. 在Linux下,如何确认是多核或多CPU: #cat /proc/cpuinfo 如果有多个类似以下的项目,则为多核或多CPU: processor : 0 ...... processor : 1 2. Linux下,如何看每个CPU的使用率: #top -d...
  • 本文来自:《被神话的Linux, 一文带你看清Linux多核可扩展性设计上的不足》 我们先来看一段来自猛士王垠的话: 跟有些人聊操作系统是件闹心的事,因为我往往会抛弃一些术语和概念,从零开始讨论。我试图从“计算...
  • 很多工程师碰到一个共性的问题:Linux工程师很多,甚至有很多有多年工作经验,但是对一些Linux内存管理和linux进程管理关键概念的理解非常模糊,比如不理解CPU、内存资源等的真正分布,具体的工作机制,这使得他们对...
  • 本文接着《有关微内核OS史上最透彻一篇 - 写于华为鸿蒙发布一周之际》继续写下去。我其实并不想讨论微内核的概念,也并不擅长去阐述概念,这是百科全书的事,但无奈最近由于鸿...
  • 最近我在几个linux设备上发现整数溢出,以致我开始用kmalloc重写内存分配。 注意: 理解这篇文章需要知道点linux内核。有时候我肯能用熟知的一些函数名。如果你不知道他们的意义,可以快速google。我提到的所有...
  • Linux服务器,tomcat启动参数根据服务器物理内存动态分配内存
  • linux查看多核负载

    2013-06-17 15:39:28
    1. Linux下,如何看每个CPU的使用率: #top -M 之后按下数字1. (或者top之后按1也一样)则显示多个CPU 的信息,和内存信息: [root@testpc ~]# top -M top - 15:38:40 up 2 days, 2:05, 2
  • 本文可以作为《Linux转发性能评估与优化(转发瓶颈分析与解决方案)》的姊妹篇,这两篇文章结合在一起,恰好就是整个Linux内核协议栈的一个优化方案。事实上Linux协议栈本来就是面向两个方向的,一个是转发,更多的是...
  • 转自:...1. 在Linux下,如何确认是多核或多CPU: #cat /proc/cpuinfo 如果有多个类似以下的项目,则为多核或多CPU: processor : 0 ...... processor : 1 2. ...
  • 对于大多数开发者而言,系统的内存分配就是一个黑盒子,就是几个API的调用。有你就给我,没有我就想别的办法。实际深入进去时,才发现这个领域里也是百家争鸣,非常热闹。有操作系统层面的内存分配器(Memory ...
  • 想在C语言程序员之间开始一个激烈的,或者说有争议的讨论很简单,只需要问:“使用动态内存分配安全吗?” 使用动态内存分配安全吗? 在C语言程序开发中,动态内存分配允许程序在运行时向系统申请内存使用,只不过在...
  • (1) 了解在多核cpu环境下,erlang并发进程调度对各个cpu核负载的影响; (2) Erlang虚拟机的内存增加机理; (3) Erlang进程的调度情况; (4) Linux下监控cpu的使用状况 实验环境 联想小型机:操作...
1 2 3 4 5 ... 20
收藏数 16,791
精华内容 6,716