精华内容
下载资源
问答
  • 服务器程序有时候不知道是什么原因导致CPU异常变高,每次变高都需要手工重启程序或服务,很麻烦,于是我就写了这个程序分享给网友朋友,希望能够帮...使用说明,可自定义CPU负载多少,持续多少秒,执行相关bat或程序。
  • CPU负载和 CPU使用率 这两个从一定程度上都可以反映一台机器的繁忙程度. cpu使用率反映的是当前cpu的繁忙程度,忽高忽低的原因在于占用cpu处理时间的进程可能处于io等待状态但却还未释放进入wait。 平均负载(load ...
  • 这个是修复之后的,解决了已发现的BUG。服务器程序有时候不知道是什么原因导致CPU异常变高,每次变高都需要手工重启程序或服务,很麻烦,于是我就写...使用说明,可自定义CPU负载多少,持续多少秒,执行相关bat或程序。
  • 这个工具运行后会让CPU处于100%的运行状态,主要用于通过负载测试系统的故障问题。有需要的可以下载使用。
  • linux 排查cpu负载过高异常,找到最耗CPU的进程,找到最耗CPU的线程,将线程PID转化为16进制
  • CPU负载

    千次阅读 2017-02-08 16:04:26
    确定cpu的负载的定义,帮助管理员设置cpu负载阀值,推测可能的导致cpu负载过高的原因,进而保证服务器的正常运行。
    以下内容转载于 http://blog.chinaunix.net/uid-12693781-id-368837.html,如有问题,请联系本人删除。

    1.cpu负载的定义
       首先,看看cpu负载的定义。在一般情况下可以将单核心cpu的负载看成是一条单行的桥,数字1代表cpu刚好能够处理过来,即桥上能够顺利通过所有的车辆,
    桥外没有等待的车辆,桥是畅通的。当超过1时表示有等待上桥的车辆,小于1时表示车辆能够快速的通过。单核心cpu就表示该cpu能够处理的事务数是1,在多核
    cpu中cpu能够并行处理的事务的数量应该是cpu个数*cpu核数,而且负载数最好不要超过这个数值。例如一个4核cpu,则cpu_load最大值为4,不能长期超过4,否则会有任务没有得到及时的处理,而使系统的负载累积增高,导致系统运行缓慢。
       大多数的Unix系统中的负载只是记录那些处在运行状态和可运行状态的进程,但是Linux有所不同,它会包含那些不可中断的处于睡眠状态的进程。这时当这些进程由于I/O的阻塞而不能够运行,就可能显著的增加cpu的负载。所以在Unix和Linux下的cpu的负载的计算方法是不一样的,在设定监测值的时候也需要特别考率。
       下面从内核源码中分析cpu负载的计算根源,这里能够给出cpu负载的完整计算方法。下面的代码是是在kernel-2.6.32中的kernel/shed.c中截取的,用来计算cpu的平均负载。
    /* Variables and functions for calc_load */
    static atomic_long_t calc_load_tasks;
    static unsigned long calc_load_update;
    unsigned long avenrun[3];
    EXPORT_SYMBOL(avenrun);

    /**
     * get_avenrun - get the load average array
     * @loads: pointer to dest load array
     * @offset: offset to add
     * @shift: shift count to shift the result left
     *
     * These values are estimates at best, so no need for locking.
     */
    void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
    {
    loads[0] = (avenrun[0] + offset) << shift;
    loads[1] = (avenrun[1] + offset) << shift;
    loads[2] = (avenrun[2] + offset) << shift;
    }

    static unsigned long
    calc_load(unsigned long load, unsigned long exp, unsigned long active)
    {
    load *= exp;
    load += active * (FIXED_1 - exp);
    return load >> FSHIFT;
    }

    /*
     * calc_load - update the avenrun load estimates 10 ticks after the
     * CPUs have updated calc_load_tasks.
     */
    void calc_global_load(void)
    {
    unsigned long upd = calc_load_update + 10;
    long active;

    if (time_before(jiffies, upd))
    return;

    active = atomic_long_read(&calc_load_tasks);
    active = active > 0 ? active * FIXED_1 : 0;

    avenrun[0] = calc_load(avenrun[0], EXP_1, active);
    avenrun[1] = calc_load(avenrun[1], EXP_5, active);
    avenrun[2] = calc_load(avenrun[2], EXP_15, active);

    calc_load_update += LOAD_FREQ;
    }

    /*
     * Either called from update_cpu_load() or from a cpu going idle
     */
    static void calc_load_account_active(struct rq *this_rq)
    {
    long nr_active, delta;

    nr_active = this_rq->nr_running;  //记录在cpu上运行的进程数
    nr_active += (long) this_rq->nr_uninterruptible;  //记录不可中断的进程数

    if (nr_active != this_rq->calc_load_active) {
    delta = nr_active - this_rq->calc_load_active;
    this_rq->calc_load_active = nr_active;
    atomic_long_add(delta, &calc_load_tasks);
    }
    }
       从上面的代码特别是注释的两行可以看出,Linux记录cpu负载的时候是将cpu队列中的运行进程数和不可中断进程数都统计在内的,这样在对cpu负载分析的时候就需要考虑不可中断的进程的情况


    2.影响cpu负载的进程
      从定义可以看出cpu的负载主要来自在cpu运行的进程数,队列中准备就绪的进程数和不可中断进程数。那么当cpu负载过高的时候如果能够知道当前运行的进程的状态那么就能够判断是哪些进程的运行导致了问题。刚好,在Linux中ps可以帮助查找当前在运行的进程的状态,通过对这些进程的状态的了解,就能够很好的查找问题的真正原因。
      #ps aux可以显示进程的运行状态
      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
      当使用ps aux后就可以得知一个进程的11项参数,其中STAT是显示进程的运行状态。
      进程的状态有以下几种。
      =================进程STAT状态==================== 
      D 无法中断的休眠状态(通常 IO 的进程)
      R 正在运行,在可中断队列中; 
      S 处于休眠状态,静止状态; 
      T 停止或被追踪,暂停执行; 
      W 进入内存交换(从内核2.6开始无效); 
      X 死掉的进程; 
      Z 僵尸进程不存在但暂时无法消除;
      W: 没有足够的记忆体分页可分配
      WCHAN 正在等待的进程资源;

      <:高优先级进程
      N: 低优先序进程
      L: 有记忆体分页分配并锁在记忆体内 (即时系统或捱A I/O),即,有些页被锁进内存
      s 进程的领导者(在它之下有子进程);
      l 多进程的(使用 CLONE_THREAD, 类似 NPTL pthreads);
      + 位于后台的进程组;

    3.防止cpu负载过高的方法
      短期来看,可以通过kill和killall来杀死一些影响cpu负载的进程,达到降低cpu负载的目的。
      这些进程的状态是可以利用ps 显示出来的,然后对相关的进程采取一定的措施就能在短时间内降低cpu的负载。
      关于kill和killall的用法,这里不做详细的介绍。

    4.cpu负载过高的进一步分析
      长远来看,要想cpu的负载不高,就要从cpu的利用率和当前的服务来进行分析。
      下面以具体的案例进行分析:
      我们有台服务器,当服务器的链接数过高时,就会导致nfs阻塞(该台服务器和另外一台服务采用nfs共享文件),这时wa为95.8%,负载马上就上升到180.

    server1:~$ est
        467 connections established
    当服务器有大量的链接数时会发生nfs阻塞的问题:
    root      2631  0.2  0.0      0     0 ?        D    Jul20  50:28 [nfsd]
    root      2632  0.2  0.0      0     0 ?        D    Jul20  49:24 [nfsd]
    root      2633  0.2  0.0      0     0 ?        S    Jul20  49:27 [nfsd]
    root      2634  0.2  0.0      0     0 ?        S    Jul20  49:47 [nfsd]
    root      2635  0.2  0.0      0     0 ?        S    Jul20  51:12 [nfsd]
    root      2636  0.2  0.0      0     0 ?        S    Jul20  49:00 [nfsd]
    root      2637  0.2  0.0      0     0 ?        S    Jul20  49:39 [nfsd]
    root      2638  0.2  0.0      0     0 ?        D    Jul20  50:24 [nfsd]

    server1:~$ top

    top - 16:13:12 up 14 days, 21:21,  2 users,  load average: 180.20, 59.85, 22.61
    Tasks: 125 total,   1 running, 124 sleeping,   0 stopped,   0 zombie
    Cpu :  2.3%us,  1.3%sy,  0.0%ni,  0.0%id, 95.8%wa,  0.0%hi,  0.5%si,  0.0%st
    Mem:   2076212k total,  2028752k used,    47460k free,     1804k buffers
    Swap:  2104472k total,  1089140k used,  1015332k free,   244076k cached

    通过这种简单的分析,就基本上可以断定问题处在nfs处,需要调整文件共享的方式。



    以下内容转载于http://www.blogjava.net/cenwenchu/archive/2008/06/30/211712.html,如有问题,请联系本人删除。

    CPU时间片

           为了提高程序执行效率,大家在很多应用中都采用了多线程模式,这样可以将原来的序列化执行变为并行执行,任务的分解以及并行执行能够极大地提高程序的运行效率。但这都是代码级别的表现,而硬件是如何支持的呢?那就要靠CPU的时间片模式来说明这一切。程序的任何指令的执行往往都会要竞争CPU这个最宝贵的资源,不论你的程序分成了多少个线程去执行不同的任务,他们都必须排队等待获取这个资源来计算和处理命令。先看看单CPU的情况。下面两图描述了时间片模式和非时间片模式下的线程执行的情况:


     1 非时间片线程执行情况


     2 非时间片线程执行情况

           在图一中可以看到,任何线程如果都排队等待CPU资源的获取,那么所谓的多线程就没有任何实际意义。图二中的CPU Manager只是我虚拟的一个角色,由它来分配和管理CPU的使用状况,此时多线程将会在运行过程中都有机会得到CPU资源,也真正实现了在单CPU的情况下实现多线程并行处理。

           CPU的情况只是单CPU的扩展,当所有的CPU都满负荷运作的时候,就会对每一个CPU采用时间片的方式来提高效率。

           Linux的内核处理过程中,每一个进程默认会有一个固定的时间片来执行命令(默认为1/100秒),这段时间内进程被分配到CPU,然后独占使用。如果使用完,同时未到时间片的规定时间,那么就主动放弃CPU的占用,如果到时间片尚未完成工作,那么CPU的使用权也会被收回,进程将会被中断挂起等待下一个时间片。

    CPU利用率和Load Average的区别

           压力测试不仅需要对业务场景的并发用户等压力参数作模拟,同时也需要在压力测试过程中随时关注机器的性能情况,来确保压力测试的有效性。当服务器长期处于一种超负荷的情况下运行,所能接收的压力并不是我们所认为的可接受的压力。就好比项目经理在给一个人估工作量的时候,每天都让这个人工作12个小时,那么所制定的项目计划就不是一个合理的计划,那个人迟早会垮掉,而影响整体的项目进度。

    CPU利用率在过去常常被我们这些外行认为是判断机器是否已经到了满负荷的一个标准,看到50%-60%的使用率就认为机器就已经压到了临界了。CPU利用率,顾名思义就是对于CPU的使用状况,这是对一个时间段内CPU使用状况的统计,通过这个指标可以看出在某一个时间段内CPU被占用的情况,如果被占用时间很高,那么就需要考虑CPU是否已经处于超负荷运作,长期超负荷运作对于机器本身来说是一种损害,因此必须将CPU的利用率控制在一定的比例下,以保证机器的正常运作。

    Load AverageCPULoad,它所包含的信息不是CPU的使用率状况,而是在一段时间内CPU正在处理以及等待CPU处理的进程数之和的统计信息,也就是CPU使用队列的长度的统计信息。为什么要统计这个信息,这个信息的对于压力测试的影响究竟是怎么样的,那就通过一个类比来解释CPU利用率和Load Average的区别以及对于压力测试的指导意义。

    我们将CPU就类比为电话亭,每一个进程都是一个需要打电话的人。现在一共有4个电话亭(就好比我们的机器有4核),有10个人需要打电话。现在使用电话的规则是管理员会按照顺序给每一个人轮流分配1分钟的使用电话时间,如果使用者在1分钟内使用完毕,那么可以立刻将电话使用权返还给管理员,如果到了1分钟电话使用者还没有使用完毕,那么需要重新排队,等待再次分配使用。


     3 电话使用场景

           上图中对于使用电话的用户又作了一次分类,1min的代表这些使用者占用电话时间小于等于1min2min表示使用者占用电话时间小于等于2min,以此类推。根据电话使用规则,1min的用户只需要得到一次分配即可完成通话,而其他两类用户需要排队两次到三次。

           电话的利用率 = sum (active use cpu time)/period

    每一个分配到电话的使用者使用电话时间的总和去除以统计的时间段。这里需要注意的是是使用电话的时间总和(sum(active use cpu time)),这与占用时间的总和(sum(occupy cpu time))是有区别的。(例如一个用户得到了一分钟的使用权,在10秒钟内打了电话,然后去查询号码本花了20秒钟,再用剩下的30秒打了另一个电话,那么占用了电话1分钟,实际只是使用了40秒)

    电话的Average Load体现的是在某一统计时间段内,所有使用电话的人加上等待电话分配的人一个平均统计。

    电话利用率的统计能够反映的是电话被使用的情况,当电话长期处于被使用而没有的到足够的时间休息间歇,那么对于电话硬件来说是一种超负荷的运作,需要调整使用频度。而电话Average Load却从另一个角度来展现对于电话使用状态的描述,Average Load越高说明对于电话资源的竞争越激烈,电话资源比较短缺。对于资源的申请和维护其实也是需要很大的成本,所以在这种高Average Load的情况下电话资源的长期“热竞争”也是对于硬件的一种损害。

    低利用率的情况下是否会有高Load Average的情况产生呢?理解占有时间和使用时间就可以知道,当分配时间片以后,是否使用完全取决于使用者,因此完全可能出现低利用率高Load Average的情况。由此来看,仅仅从CPU的使用率来判断CPU是否处于一种超负荷的工作状态还是不够的,必须结合Load Average来全局的看CPU的使用情况和申请情况。

    所以回过头来再看测试部对于Load Average的要求,在我们机器为8CPU的情况下,控制在10 Load左右,也就是每一个CPU正在处理一个请求,同时还有2个在等待处理。看了看网上很多人的介绍一般来说Load简单的计算就是2* CPU个数减去1-2左右(这个只是网上看来的,未必是一个标准)。

    补充几点:

    1.对于CPU利用率和CPU Load Average的结果来判断性能问题。首先低CPU利用率不表明CPU不是瓶颈,竞争CPU的队列长期保持较长也是CPU超负荷的一种表现。对于应用来说可能会去花时间在I/O,Socket等方面,那么可以考虑是否后这些硬件的速度影响了整体的效率。

    这里最好的样板范例就是我在测试中发现的一个现象:SIP当前在处理过程中,为了提高处理效率,将控制策略以及计数信息都放置在Memcached Cache里面,当我将Memcached Cache配置扩容一倍以后,CPU的利用率以及Load都有所下降,其实也就是在处理任务的过程中,等待Socket的返回对于CPU的竞争也产生了影响。

    2.未来多CPU编程的重要性。现在服务器的CPU都是多CPU了,我们的服务器处理能力已经不再按照摩尔定律来发展。就我上面提到的电话亭场景来看,对于三种不同时间需求的用户来说,采用不同的分配顺序,我们可看到的Load Average就会有不同。假设我们统计Load的时间段为2分钟,如果将电话分配的顺序按照:1min的用户,2min的用户,3min的用户来分配,那么我们的Load Average将会最低,采用其他顺序将会有不同的结果。所以未来的多CPU编程可以更好的提高CPU的利用率,让程序跑的更快。




    展开全文
  • CPU负载生成器(Python 2) 该脚本允许在有限的时间段内生成固定的CPU负载。 为此,采用了PI控制器。 该脚本输入所需的CPU负载,实验的持续时间以及必须在其上生成负载的CPU内核。 控制器和CPU监视器在两个不同的...
  • CPU负载均衡

    千次阅读 2019-02-28 19:37:36
    (1)当一个进程要加入runqueue时,选择负载最轻的cpu上的runqueue (2)当前CPU的runqueue为空时,主动拉取其他runqueue上的进程来运行 (3)周期计算各个CPU上的负载情况,在必要的时候迁移进程 具体的场景,CFS...

    如何实现负载均衡

    为了系统负载的均衡,主要通过如下三种手段:
    (1)当一个进程要加入runqueue时,选择负载最轻的cpu上的runqueue
    (2)当前CPU的runqueue为空时,主动拉取其他runqueue上的进程来运行
    (3)周期计算各个CPU上的负载情况,在必要的时候迁移进程

    具体的场景,CFS调度器负载均衡发生在如下的一些路径上:
    1.当前进程离开runqueue,进入睡眠,而对应的runqueue中已无进程可运行时,触发负载均衡,试图从别的run_queue中pull一个进程过来运行。

    static struct task_struct *
    pick_next_task_fair(struct rq *rq, struct task_struct *prev)
    {
    	......
    	if (!cfs_rq->nr_running)
    		goto idle;
    	......
    
    
    
     idle:
         new_tasks = idle_balance(rq);
         /*
          * Because idle_balance() releases (and re-acquires) rq->lock, it is
          * possible for any higher priority task to appear. In that case we
          * must re-start the pick_next_entity() loop.
          */
         if (new_tasks < 0)
             return RETRY_TASK;
     
         if (new_tasks > 0)
             goto again;
     
         return NULL;
     }
    
    }
    

    这条内核路径上的负载均衡主入口为idle_balance函数,我们在后面进行讲解。

    2.周期调度器scheduler_tick在执行时会判断负载情况,如有必要会执行负载均衡操作。

    void scheduler_tick(void)
    {
        int cpu = smp_processor_id();
        struct rq *rq = cpu_rq(cpu);
        struct task_struct *curr = rq->curr;
    
        sched_clock_tick();
    
        raw_spin_lock(&rq->lock);
        update_rq_clock(rq);
        curr->sched_class->task_tick(rq, curr, 0);
        update_cpu_load_active(rq);
        raw_spin_unlock(&rq->lock);
    
        perf_event_task_tick();
    
    #ifdef CONFIG_SMP
        rq->idle_balance = idle_cpu(cpu);
        trigger_load_balance(rq);
    #endif
        rq_last_tick_reset(rq);
    }
    

    这条内核路径上的负载均衡主入口为trigger_load_balance函数,我们同样在后面进行讲解。

    3.fork创建进程时/exec运行进程时
    do_fork–>wake_up_new_task->select_task_rq:

    void wake_up_new_task(struct task_struct *p)
     {
         unsigned long flags;
         struct rq *rq;
     
         raw_spin_lock_irqsave(&p->pi_lock, flags);
     #ifdef CONFIG_SMP
         /*
          * Fork balancing, do it here and not earlier because:
          *  - cpus_allowed can change in the fork path
          *  - any previously selected cpu might disappear through hotplug
          */
         set_task_cpu(p, select_task_rq(p, task_cpu(p), SD_BALANCE_FORK, 0));   //子进程重新选择runqueue和cpu,相当于进行了一次负载均衡处理
     #endif
     
         /* Initialize new task's runnable average */
         init_task_runnable_average(p);                   //依据权重初始化子进程的时间片和负载贡献
         rq = __task_rq_lock(p);
         activate_task(rq, p, 0);                         //把子进程加入到runqueue,这是该函数的关键核心
         p->on_rq = TASK_ON_RQ_QUEUED;
         trace_sched_wakeup_new(p, true);
         check_preempt_curr(rq, p, WF_FORK);
     #ifdef CONFIG_SMP
         if (p->sched_class->task_woken)
             p->sched_class->task_woken(rq, p);
     #endif
         task_rq_unlock(rq, p, &flags);
     }
    

    select_task_rq这条语句就是重新根据负载选择runqueue和CPU的。

    4.try_to_wake_up唤醒进程时

    static int
    try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
    {
    	......
         p->sched_contributes_to_load = !!task_contributes_to_load(p);
         p->state = TASK_WAKING;
     
         if (p->sched_class->task_waking)
             p->sched_class->task_waking(p);
     
         cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
         if (task_cpu(p) != cpu) {
             wake_flags |= WF_MIGRATED;
             set_task_cpu(p, cpu);
         }
    	......
    }
    

    唤醒一个进程时根据select_task_rq来进行选择一个负载最轻的CPU去运行,这也就是进行了负载均衡的处理

    调度域

    对于现代的多核心CPU,如何发挥系统多核心的优势,又能够节省功耗,是一个很关键的问题,为了做到多核心之间的负载均衡而引入调度域的概念。我们知道一个多核心的soc片上系统,内部结构是很复杂的,内核采用CPU拓扑结构来描述一个SOC的架构。内核使用调度域来描述CPU之间的层次关系,对于低级别的调度域来说,CPU之间的负载均衡处理开销比较小,而对于越高级别的调度域,其负载均衡的开销就越大。比如一个4核心的SOC,两个核心是一个cluster,共享L2 cache,那么每个cluster可以认为是一个MC调度域,每个MC调度域中有两个调度组,每个调度组中只有一个CPU。而整个SOC可以认为是高一级别的DIE调度域,其中有两个调度组,cluster0属于一个调度组,cluster1属于另一个调度组。跨cluster的负载均衡是需要清除L2 cache的,开销是很大的,因此SOC级别的DIE调度域
    进行负载均衡的开销会更大一些。

    在这里插入图片描述

    • 低层MC调度域
      在这里插入图片描述
      在这里插入图片描述
    • 高层DIE调度域
      在这里插入图片描述

    负载均衡算法分析

    一个调度域中的负载是否均衡是通过比较各个调度组之间的平均负载来衡量的。调度组平均负载的计算方法:内核中定义单个CPU的最大capacity为1024,针对不同的调度组,可能包含有不同数量和能力的CPU,因此组内的capacity也是不同的。内核计算平均负载公式:

    avg_load = (group_load * SCHED_CAPACITY_SCALE) / group_capacity;
    

    SCHED_CAPACITY_SCALE大小为1024。group_load是调度组内各个CPU的cpu_load之和,cpu_load的计算是基于PELT章节介绍的runqueue中的runnable_load负载来完成的。内核引入了一个加权系数delta。为了防止单个CPU负载曲线的波动过大,内核引用该公式计算CPU负载,加入历史负载来计算,delta值越大,历史负载对当前cpu_load的影响越大,也就越不容易产生波动。计算公式如下:

    cpu_load=(previous_runnable_load * (delta-1) + curr_runnable_load) / delta
    

    各个调度组的平均负载计算和PELT中介绍的负载计算比较,可以看出是多了一个参量的,就是CPU的capacity能力值,PELT仅仅是以调度实体或者进程为考量的,而不会考虑当前CPU的能力。系统在周期调度时更新上面对应的负载值,进而进行负载均衡的处理。
    迁移一个进程的代价是对cache的刷新代价,当进程在cache能够共享的CPU之间进行迁移时,那么付出的代价就会低一些,如果进程在cache独立的CPU之间进行迁移,那么付出的代价就大一些,通过调节上述delta值可以来表示这种迁移的阻力。

    代码详解

    • select_task_rq
      这个函数是选择一个目标rq的过程,其实就是为了负载均衡处理。
    static inline
    int select_task_rq(struct task_struct *p, int cpu, int sd_flags, int wake_flags)
    {
        if (p->nr_cpus_allowed > 1)
            cpu = p->sched_class->select_task_rq(p, cpu, sd_flags, wake_flags);  //如果当前进程允许被在多个CPU上运行,那么就执行对应调度类的select_task_rq回调
    
        /*
         * In order not to call set_task_cpu() on a blocking task we need
         * to rely on ttwu() to place the task on a valid ->cpus_allowed
         * cpu.
         *
         * Since this is common to all placement strategies, this lives here.
         *
         * [ this allows ->select_task() to simply return task_cpu(p) and
         *   not worry about this generic constraint ]
         */
        if (unlikely(!cpumask_test_cpu(cpu, tsk_cpus_allowed(p)) ||
                 !cpu_online(cpu)))
            cpu = select_fallback_rq(task_cpu(p), p);
    
        return cpu;
    }
    
    //CFS调度器对应的select_task_rq回调函数
    static int
    select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags)  //prev_cpu指上次该进程执行的CPU
    {
        struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL;
        int cpu = smp_processor_id();           //当前执行唤醒的CPU
        int new_cpu = cpu;
        int want_affine = 0;
        int sync = wake_flags & WF_SYNC;
    
        if (sd_flag & SD_BALANCE_WAKE)
            want_affine = cpumask_test_cpu(cpu, tsk_cpus_allowed(p)); //判断wakeup CPU是否允许执行该进程
    
        rcu_read_lock();
        for_each_domain(cpu, tmp) {  //自下至上遍历调度域
            if (!(tmp->flags & SD_LOAD_BALANCE))
                continue;
    
            /*
             * If both cpu and prev_cpu are part of this domain,
             * cpu is a valid SD_WAKE_AFFINE target.
             */
            if (want_affine && (tmp->flags & SD_WAKE_AFFINE) &&
                cpumask_test_cpu(prev_cpu, sched_domain_span(tmp))) {  //如果当前执行唤醒的CPU和进程上次运行的CPU在同一个调度域,找到该调度域
                affine_sd = tmp;
                break;
            }
    
            if (tmp->flags & sd_flag)
                sd = tmp;
        }
    
        if (affine_sd && cpu != prev_cpu && wake_affine(affine_sd, p, sync)) //会计算负载,并判断wakeup CPU加上进程负载后与prev CPU的大小
            prev_cpu = cpu;         //如果wakeup CPU + 进程load < prev CPU,优先使用wakeup CPU
    
        if (sd_flag & SD_BALANCE_WAKE) {
            new_cpu = select_idle_sibling(p, prev_cpu);  //自上而下遍历调度域,优先使用找到的idle CPU
            goto unlock;
        }
     
         while (sd) { //处理没有设置SD_BALANCE_WAKE的情况,查找相同sd_flag的最空闲CPU来运行
             struct sched_group *group;
             int weight;
     
             if (!(sd->flags & sd_flag)) {
                 sd = sd->child;
                 continue;
             }
     
             group = find_idlest_group(sd, p, cpu, sd_flag);
             if (!group) {
                 sd = sd->child;
                 continue;
             }
     
             new_cpu = find_idlest_cpu(group, p, cpu);
             if (new_cpu == -1 || new_cpu == cpu) {
                 /* Now try balancing at a lower domain level of cpu */
                 sd = sd->child;
                 continue;
             }
     
             /* Now try balancing at a lower domain level of new_cpu */  //在更低一层调度域执行均衡
             cpu = new_cpu;
             weight = sd->span_weight;
             sd = NULL;
             for_each_domain(cpu, tmp) {
                 if (weight <= tmp->span_weight)
                     break;
                 if (tmp->flags & sd_flag)
                     sd = tmp;
             }
             /* while loop will break here if sd == NULL */
         }
     unlock:
         rcu_read_unlock();
     
         return new_cpu;
     }
    
    

    首先判断唤醒CPU是否允许执行该进程,然后判断唤醒CPU和上次执行CPU是否有在同一个调度域,如果有在同一个调度域,那就找到对应的调度域,在该调度域中更新两个CPU的负载情况,如果唤醒CPU加上进程负载后小于prev CPU,那么优先使用唤醒CPU运行进程。

    • idle_balance->load_balance
      当前CPU没有进程要运行时,进行负载均衡处理。load_balance函数我们在下面讲解。

    • scheduler_tick->trigger_load_balance

    void trigger_load_balance(struct rq *rq)
    {
       /* Don't need to rebalance while attached to NULL domain */
       if (unlikely(on_null_domain(rq)))
           return;
    
       if (time_after_eq(jiffies, rq->next_balance))
           raise_softirq(SCHED_SOFTIRQ);
    #ifdef CONFIG_NO_HZ_COMMON
       if (nohz_kick_needed(rq))
           nohz_balancer_kick();
    #endif
    }  
    

    在时钟中断处理中,当检测到了下一次负载平衡的时间点时,就触发一个软中断,这个软中断是在CFS调度器初始化时就已经注册好了的:

    __init void init_sched_fair_class(void)
    {
    #ifdef CONFIG_SMP
        open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
    
    #ifdef CONFIG_NO_HZ_COMMON
        nohz.next_balance = jiffies;
        zalloc_cpumask_var(&nohz.idle_cpus_mask, GFP_NOWAIT);
        cpu_notifier(sched_ilb_notifier, 0);
    #endif
    #endif /* SMP */
    }
    

    下面看下实际运行的函数处理run_rebalance_domains->rebalance_domains:

    static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle)
    {
        int continue_balancing = 1;
        int cpu = rq->cpu;
        unsigned long interval;
        struct sched_domain *sd;
        /* Earliest time when we have to do rebalance again */
        unsigned long next_balance = jiffies + 60*HZ;
        int update_next_balance = 0;
        int need_serialize, need_decay = 0;
        u64 max_cost = 0;
    
        update_blocked_averages(cpu);
    
        rcu_read_lock();
        for_each_domain(cpu, sd) {    //循环遍历调度域,从低级别的MC调度域到高级别的DIE调度域,进行不同调度域中的负载均衡
            /*
             * Decay the newidle max times here because this is a regular
             * visit to all the domains. Decay ~1% per second.
             */
            if (time_after(jiffies, sd->next_decay_max_lb_cost)) {
                sd->max_newidle_lb_cost =
                    (sd->max_newidle_lb_cost * 253) / 256;
                sd->next_decay_max_lb_cost = jiffies + HZ;
                need_decay = 1;
            }
            max_cost += sd->max_newidle_lb_cost;
    
            if (!(sd->flags & SD_LOAD_BALANCE))
                continue;
    
            /*
             * Stop the load balance at this level. There is another
             * CPU in our sched group which is doing load balancing more
             * actively.
             */
            if (!continue_balancing) {
                if (need_decay)
                    continue;
                break;
            }
    
            interval = get_sd_balance_interval(sd, idle != CPU_IDLE);  //获取调度域负载均衡的间隔
    
            need_serialize = sd->flags & SD_SERIALIZE;
            if (need_serialize) {
                if (!spin_trylock(&balancing))
                    goto out;
            }
     
             if (time_after_eq(jiffies, sd->last_balance + interval)) {  //检测是否到达调度域负载均衡的时间点
                 if (load_balance(cpu, rq, sd, idle, &continue_balancing)) {  //进行调度域中的负载均衡处理
                     /*
                      * The LBF_DST_PINNED logic could have changed
                      * env->dst_cpu, so we can't know our idle
                      * state even if we migrated tasks. Update it.
                      */
                     idle = idle_cpu(cpu) ? CPU_IDLE : CPU_NOT_IDLE;
                 }
                 sd->last_balance = jiffies;  //处理完成后更新上次负载均衡的时间
                 interval = get_sd_balance_interval(sd, idle != CPU_IDLE);  //获取下次执行负载均衡的间隔
             }
             if (need_serialize)
                 spin_unlock(&balancing);
     out:
             if (time_after(next_balance, sd->last_balance + interval)) {  //最少要间隔1分钟时间才能执行下次负载均衡
                 next_balance = sd->last_balance + interval;
                 update_next_balance = 1;
             }
         }
         if (need_decay) {
             /*
              * Ensure the rq-wide value also decays but keep it at a
              * reasonable floor to avoid funnies with rq->avg_idle.
              */
             rq->max_idle_balance_cost =
                 max((u64)sysctl_sched_migration_cost, max_cost);
         }
         rcu_read_unlock();
     
         /*
          * next_balance will be updated only when there is a need.
          * When the cpu is attached to null domain for ex, it will not be
          * updated.
          */
         if (likely(update_next_balance))
             rq->next_balance = next_balance;  //更新下次负载均衡的时间点
     }
     
    

    这个函数主要执行如下的步骤:
    1.按照当前CPU所在的调度域,从低级别到高级别依次进行遍历,优先进行低级别的负载均衡,因为这种级别的cache代价小。
    2.load_balance依次检查当前CPU在调度域内是否已经负载均衡,如果负载不均衡,要执行均衡操作
    3.每个调度域负载均衡结束后,要进行下次负载均衡时间的更新

    load_balance是处理负载均衡的核心函数,它的处理单元是一个调度域,也就是sched domain。其中会包含对调度组的处理,这里不再细节讲述代码,而只文字介绍处理流程:

    1.should_we_balance判断是否要在本CPU上执行负载均衡操作,这里会挑选一个idle CPU或者处于第一个调度组的第一个CPU(调度域中的第一个CPU)来执行负载均衡操作。如果不是对应的CPU,则直接跳出负载均衡的处理。
    2.find_busiest_group找出对应调度域中的最繁忙的调度组,该函数中会调用update_sd_lb_stats更新当前调度域相关的调度状态数据,最繁忙调度组必须是除了本CPU所属的调度组之外的调度组,如果本调度组就是最繁忙的调度组,那么退出负载均衡的处理。
    判断是否要进行负载均衡的评估方法如下:
    (1)当前CPU处于idle,判断最繁忙组中的idle CPU数量多于当前组,说明当前组负载更重,不用做均衡。
    (2)当前CPU不是idle,判断最繁忙组和当前组的avg_load,如果当前组的avg_load * 125% 大于最繁忙组,说明负载差距不大,不用做均衡。
    (3)其余情况都需要做负载均衡处理。
    (4)calculate_imbalance计算要迁移的负载。
    3.find_busiest_queue找出最繁忙调度组中的最繁忙运行队列,也就是对应的CPU。这个最繁忙运行队列一定不能是本队列。
    4.从最繁忙运行队列,迁移对应的imbalance_load到当前CPU运行队列上,完成负载均衡操作。
    最后分享一下计算imbalance负载的方法,这里的imbalance负载实际上就是对应的group_load,按照前面介绍的公式:

    delta_avg_load = (group_load * SCHED_CAPACITY_SCALE) / group_capacity;
    

    我们可以通过delta_avg_load反推出来group_load的,真正迁移也就是通过根据进程的load最大迁移group_load大小的负载量。这里的delta_avg_load会计算最繁忙调度组和调度域的平均负载的差值,也会计算当前调度组和调度域平均负载的差值,两者取小来确定的。

    展开全文
  • 理解CPU负载和CPU使用率

    千次阅读 2019-02-14 10:52:55
    [root@system]# top top - 23:39:41 up 8 days, 6:36, 2 users, load average: 0.00, 0.01, 0.05 Tasks: 71 total, 1 running, 70 sleeping, 0 stopped, 0 zombie %Cpu(s): 0.0 us, 0.0 sy, 0.0 ni...

     

    [root@system]# top
    top - 23:39:41 up 8 days,  6:36,  2 users,  load average: 0.00, 0.01, 0.05
    Tasks:  71 total,   1 running,  70 sleeping,   0 stopped,   0 zombie
    %Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    KiB Mem :  1016168 total,   386208 free,    69620 used,   560340 buff/cache
    KiB Swap:        0 total,        0 free,        0 used.   777376 avail Mem 

    这两个从一定程度上都可以反映一台机器的繁忙程度.

    cpu使用率反映的是当前cpu的繁忙程度,忽高忽低的原因在于占用cpu处理时间的进程可能处于io等待状态但却还未释放进入wait。

    平均负载(load average)是指某段时间内占用cpu时间的进程和等待cpu时间的进程数,这里等待cpu时间的进程是指等待被唤醒的进程,不包括处于wait状态进程。

    以上分析可以看出,一台机器很有可能处于低cpu使用率高负载的情况,因此看机器的繁忙程度应该结合两者,从实际的使用情况观察,自己的一台双核志强2.8GHZ,2G内存的机器在平均负载到50左右,cpu使用率才接近100%(应用有不少io操作),这种情况下应用还算流畅,实际访问延迟不是很高。因此在cpu还空闲的情况下,如何提高io响应是减少负载的关键,很多人认为负载到几十了机器就非常繁忙了,我倒觉得如果这个时候cpu使用率比较低,则负载高可能不能很好说明问题,一旦cpu处理的进程处理完后,那些等待的进程也能立刻得到响应,这种情况下应该优化io读写速度。真到cpu使用率一直90%以上,即使平均负载只有个位数(比如某一个进程一直在运算),那机器其实也已经繁忙了~

    其实,在前面的文章中,也有写到cpu使用率低负载高,原因分析 cpu使用率低,但是load很高,load很高的可能是IO

    CPU负载的一个类比

    判断系统负荷是否过重,必须理解load average的真正含义。下面,我根据"Understanding Linux CPU Load"这篇文章,尝试用最通俗的语言,解释这个问题。
    首先,假设最简单的情况,你的电脑只有一个CPU,所有的运算都必须由这个CPU来完成。
    那么,我们不妨把这个CPU想象成一座大桥,桥上只有一根车道,所有车辆都必须从这根车道上通过。(很显然,这座桥只能单向通行。)
    系统负荷为0,意味着大桥上一辆车也没有。

    系统负荷为0.5,意味着大桥一半的路段有车。

    系统负荷为1.0,意味着大桥的所有路段都有车,也就是说大桥已经"满"了。但是必须注意的是,直到此时大桥还是能顺畅通行的。

    系统负荷为1.7,意味着车辆太多了,大桥已经被占满了(100%),后面等着上桥的车辆为桥面车辆的70%。以此类推,系统负荷2.0,意味着等待上桥的车辆与桥面的车辆一样多;系统负荷3.0,意味着等待上桥的车辆是桥面车辆的2倍。总之,当系统负荷大于1,后面的车辆就必须等待了;系统负荷越大,过桥就必须等得越久。

    CPU的系统负荷,基本上等同于上面的类比。大桥的通行能力,就是CPU的最大工作量;桥梁上的车辆,就是一个个等待CPU处理的进程(process)。
    如果CPU每分钟最多处理100个进程,那么系统负荷0.2,意味着CPU在这1分钟里只处理20个进程;系统负荷1.0,意味着CPU在这1分钟里正好处理100个进程;系统负荷1.7,意味着除了CPU正在处理的100个进程以外,还有70个进程正排队等着CPU处理。
    为了电脑顺畅运行,系统负荷最好不要超过1.0,这样就没有进程需要等待了,所有进程都能第一时间得到处理。很显然,1.0是一个关键值,超过这个值,系统就不在最佳状态了,你要动手干预了。

    CPU负载-多处理器

    上面,我们假设你的电脑只有1个CPU。如果你的电脑装了2个CPU,会发生什么情况呢?
    2个CPU,意味着电脑的处理能力翻了一倍,能够同时处理的进程数量也翻了一倍。
    还是用大桥来类比,两个CPU就意味着大桥有两根车道了,通车能力翻倍了。

    所以,2个CPU表明系统负荷可以达到2.0,此时每个CPU都达到100%的工作量。推广开来,n个CPU的电脑,可接受的系统负荷最大为n.0。

    CPU负载-多核处理器

    芯片厂商往往在一个CPU内部,包含多个CPU核心,这被称为多核CPU。
    在系统负荷方面,多核CPU与多CPU效果类似,所以考虑系统负荷的时候,必须考虑这台电脑有几个CPU、每个CPU有几个核心。然后,把系统负荷除以总的核心数,只要每个核心的负荷不超过1.0,就表明电脑正常运行。
    怎么知道电脑有多少个CPU核心呢?
    "cat /proc/cpuinfo"命令,可以查看CPU信息。"grep -c 'model name' /proc/cpuinfo"命令,直接返回CPU的总核心数。

    系统负荷的经验法则

    1.0是系统负荷的理想值吗?
    不一定,系统管理员往往会留一点余地,当这个值达到0.7,就应当引起注意了。经验法则是这样的:
    当系统负荷持续大于0.7,你必须开始调查了,问题出在哪里,防止情况恶化。
    当系统负荷持续大于1.0,你必须动手寻找解决办法,把这个值降下来。
    当系统负荷达到5.0,就表明你的系统有很严重的问题,长时间没有响应,或者接近死机了。你不应该让系统达到这个值。

    对于我的机器,有24个core,那么,load多少合适呢?

     
    1. [root@jiangyi01.sqa.zmf /home/ahao.mah/ALIOS_QA]

    2. #grep 'model name' /proc/cpuinfo | wc -l

    3. 24

    答案是:

     
    1. [root@jiangyi01.sqa.zmf /home/ahao.mah/ALIOS_QA]

    2. #echo "0.7*24" |bc

    3. 16.8

    最佳观察时长

    最后一个问题,"load average"一共返回三个平均值----1分钟系统负荷、5分钟系统负荷,15分钟系统负荷,----应该参考哪个值?
    如果只有1分钟的系统负荷大于1.0,其他两个时间段都小于1.0,这表明只是暂时现象,问题不大。
    如果15分钟内,平均系统负荷大于1.0(调整CPU核心数之后),表明问题持续存在,不是暂时现象。所以,你应该主要观察"15分钟系统负荷",将它作为电脑正常运行的指标。

    REF

    http://blog.scoutapp.com/articles/2009/07/31/understanding-load-averages

    http://share.blog.51cto.com/278008/495067

    http://www.ruanyifeng.com/blog/2011/07/linux_load_average_explained.html

    muahao@aliyun.com

     

    补充:

     

    系统负荷为0,意味着大桥上一辆车也没有。

    系统负荷为0.5,意味着大桥一半的路段有车。

    系统负荷为1.0,意味着大桥的所有路段都有车,也就是说大桥已经"满"了。但是必须注意的是,直到此时大桥还是能顺畅通行的。

    系统负荷为1.7,意味着车辆太多了,大桥已经被占满了(100%),后面等着上桥的车辆为桥面车辆的70%。以此类推,系统负荷2.0,意味着等待上桥的车辆与桥面的车辆一样多;系统负荷3.0,意味着等待上桥的车辆是桥面车辆的2倍。总之,当系统负荷大于1,后面的车辆就必须等待了;系统负荷越大,过桥就必须等得越久。

    CPU的系统负荷,基本上等同于上面的类比。大桥的通行能力,就是CPU的最大工作量;桥梁上的车辆,就是一个个等待CPU处理的进程(process)。

    展开全文
  • cpu负载判断

    2019-03-14 16:34:50
    实际上网上有很多不错的文章,但是个人还是喜欢用自己的语言简洁的描述一下,下面介绍的就是对于cpu负载的判断方法。 什么是cpu的负载? 我们都知道cpu是服务器的核心处理器。它就像是一条单向的道路,而...

    前言


    关于cpu的负载到底是什么?怎样判断cpu的负载到底是高还是低呢?实际上网上有很多不错的文章,但是个人还是喜欢用自己的语言简洁的描述一下,下面介绍的就是对于cpu负载的判断方法。



    什么是cpu的负载?



    我们都知道cpu是服务器的核心处理器。它就像是一条单向的道路,而系统运行的程序或者说进程就像是奔跑在该道路上的交通工具。

    想象一下,负载就代表着在某一时间段上正在奔跑和准备使用cpu公路的汽车的数量。

    当那些汽车的数量有很多的时候就代表着cpu公路的压力大,负载高,结果就是会造成堵车,大量汽车挤满了公路,得等前面的车跑完了,后面的车才能上,并且移动速度缓慢,这就是系统卡顿。再严重就是公路被压坏了,谁都走不了,这就是死机。而正常情况,应该是那些车辆的数量不高于cpu公路可承担的值,这就是正常的运行。




    如何判断当前系统cpu的负载的高低?



    在这里插入图片描述

    【1】首先,要查看系统的平均负载(load average)。它是某段时间内占用cpu时间的进程和等待cpu时间的进程数,这里等待cpu时间的进程是指等待被唤醒的进程,不包括处于wait状态进程,而后面三个值分别代表系统在1分钟、5分钟和15分钟的负载情况。



    【2】由于我们要查看的当前系统cpu的负载的高低,那么就要考虑cpu的数量及性能问题。这时要遵循两个原则:“有多少核心即为有多少负荷"和"核心的核心”。

    “有多少核心即为有多少负荷”:在多核处理中,你的系统均值不应该高于处理器核心的总数量。

    “核心的核心”: 不论核心分布在哪几颗cpu中,只需要计算核心的总数量即可。例如:两颗四核的cpu: 2*4=8 ,代表八个cpu内核。
    cpu个数 x 核心数 = 总核心数

    查看CPU的总核心数
    grep -c 'model name' /proc/cpuinfo  
    
    更多命令,链接如下:
    https://blog.csdn.net/GX_1_11_real/article/details/81026999
    


    【3】理论上每个核心的负荷不超过1.0,就代表系统在正常运行的范畴内。

    即   平均负载 除以 总核心数 <= 1.0 
    

    但是,实际上当这个值处于在 0.70 左右,为了避免负载持续飙升,怕cpu扛不住,就要开始对问题原因进行调查了;当系统负载时间处于1.00或者以上的时候,那么就应该马上解决这个问题。

    即   平均负载 除以 总核心数 <= 0.7 
    

    我们通常应该观察15分钟系统负载,然后再进行判断。因为如果1分钟的系统负荷大于1.0,而其他两个时间段都小于1.0,那么代表这只是暂时的;而观察15分钟内的系统负载仍大于1.0,则代表这个问题是持续的,需要进行解决。



    备注:

    sar查看cpu操作,请看下列链接:
    https://blog.csdn.net/GX_1_11_real/article/details/81318197

    展开全文
  • Linux系统cpu负载浅析

    2019-10-16 14:09:39
    Linux系统cpu负载分析
  • 做压力测试的时候,我们经常会关注两个指标,CPU利用率和CPU负载 Linux中,进程分为三种状态: 阻塞的进程blocked process 可运行的进程runnable process 正在运行的进程running process 当进程处于不可中断时,...
  • 概述 转载:添加链接描述 1.1 CPU负载和CPU利用率的区别是什么? 首先,我们可以通过uptime,w或者top命令看到CPU的平均负载。 top命令参考:Linux : top命令 Load Average :负载的3个数字,比如上图的4.86,5.28,...
  • CPU负载解决办法

    2019-11-07 16:58:26
    1. 查看CPU负载 使用top 命令 2. 打印出堆栈信息 [root@hadoop ~]# jstack PID > 7669.txt 3.把堆栈信息 [root@hadoop ~]# sz 7669,txt 4.查看线程占用情况 [root@hadoop ~]# top -p 7669 -H PID进制...
  • Linux CPU负载性能监测

    千次阅读 2021-11-02 20:48:52
    Linux CPU性能监测平均负载CPU 使用率压测命令 stress模拟负载场景监测工具topmpstatpidstat补充:自愿上下文切换和非自愿上下文切换 平均负载CPU 使用率 平均负载是指单位时间内的活跃进程数,也就是处于可...
  • CPU负载过高的原因

    2021-08-02 09:57:05
    系统中创建了大量的线程,这些线程并发运行,而且工作负载都很重,过多的线程同时运行就会导致CPU负载过高 二 JVM频繁的Full GC,非常耗费CPU资源 2.1 频繁Full GC的原因 内存分配不合理,导致对象频繁进入老年代,...
  • cpu利用率和cpu负载是什么?

    千次阅读 2018-09-22 18:53:23
    我们经常会听到要好好使用cpu的资源,提高cpu利用率,要学习应对高负载的情况,那这个高负载其实大多数情况指的就是cpu负载。我们还会学习到一个命令是top,这个命令可以得到他们的数值和其他系统指标。那么什么是...
  • CPU负载 没有依赖性。 let cpu = require ( 'cpu-load' ) // track the CPU load over the next 1 second cpu ( 1000 , function ( load ) { load //=> 0.03 (3%) } ) CPU 负载在多核机器上平均。 无需将 CPU ...
  • 记录: 1. cpufreq 使用 2. 加大负载方式 3. 查看负载方式 4. cpufreq 几种governor
  • zabbix cpu负载

    2019-09-11 15:17:49
    标签:zabbix cpu负载值 首先,现在的CPU都是多核的,所以参数里默认显示的一个核心的参数,而不是总和,解决方法。 中文路径:组态--模板,里找个你监控主机使用的模板,我使用的模板是“Template OS Linux” ...
  • CPU负载均衡之loadavg计算

    千次阅读 2020-06-26 10:10:12
    本文主要介绍如下内容: 1. CPU负载概念说明 2. CPU负载数据使用 3. CPU负载计算方式以及过程
  • 本文主要从常用的top命令入手,说明linux下的cpu 负载是怎么回事,以及帮助大家简单判断cpu负载高的原因。 top查看机器负载 我们在linux下使用top指令将会输出如下图所示页面: 这里的load average以及缩写的us、sy...
  • cpu负载过高产生的原因及排查

    千次阅读 2019-12-24 11:11:49
    之前面试被问到,造成CPU load过高的原因有哪些?如何快速排查其原因? 开一贴,总结该相关知识 什么是cpu load 值 to...
  • CPU 负载CPU 使用率 这两个从一定程度上都可以反映一台机器的繁忙程度。 CPU 使用率反映的是当前 CPU 的繁忙程度,忽高忽低的原因在于占用 CPU 处理时间的进程可能处于 IO 等待状态但却还未释放进入wait。 ...
  • 教你如何查看Linux的CPU负载

    千次阅读 2017-11-09 23:43:00
    记得博主以前被问到CPU负载如何才算高的时候,出过一次糗,具体就不记录了。。。在网上找了一篇比较详细的Linux下的CPU负载算法教程,科普一下。不感兴趣,或看不懂的朋友无视即可,不必浪费时间哈。 昨天查看...
  • CentOS 7 下 CPU 负载较高排查记录

    千次阅读 2020-12-31 15:43:12
    文章目录通过 top 查看服务器负载通过 iostat 查看磁盘读写情况iostat 安装iostat 使用找到 I/O 占用高的进程通过 iotop 命令查看通过 pidstat 命令查找参考 通过 top 查看服务器负载 [root@localhost ~]$ top top -...
  • CPU负载监控脚本代码

    2020-09-15 22:52:18
    CPU负载监控脚本代码,需要的朋友可以参考下
  • 才子白:那我考考你,假如你发现测试服务器一个java进程cpu负载占用很高,如何用命令去排查具体是哪行代码引起的呢? 成子怯生生的问了一句:我可以百度吗? 1、首先查看系统资源占用信息,top看一下 top命令下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 269,032
精华内容 107,612
关键字:

CPU负载