瀚海书香

瀚海书香

关注
发信
python学习-斐波那契（黄金比例）
浅谈PHP代码设计结构
Windows RT充满坎坷的一生
第一家倒下的无人车公司：死于内讧，终结于投资方逼宫
Linux MTD介绍
python学习以及使用
Java私塾：Hadoop实战-初级部分 之 Hadoop IO
设计模式的C实现(3)——工厂模式
记一次生产事故：30万单就这样没了！
低代码平台+RPA+AI，从ERP到数字化转型
Photoshop制作简洁漂亮的彩色光晕字
Windows下静态库和动态库的区别
Linux运维的发展前景到底怎么样?Linux学习
intel网卡驱动更新地址
周杰伦深夜弹琴被指扰民 霸气回应：我家没邻居

Why IO bound process increase cpu load

扫码查看

Why IO bond process increase cpu load

Author: Tony  

Date:2013-01-11

About  /proc/loadavg

下面是从网上流行的解释：

前三个数字表示的是1、5、15分钟内的CPU平均处于运行状态的进程个数，后面的两个，一个的分子是正在运行的进程数，分母是进程总数；另一个是最近运行的进程PID

Copy file will increase cpu load

如果在linux系统上运行大文件的copy操作或者大量的读写磁盘操作，系统负载会显著增大。Why？

进行磁盘操作的时候，应该是IO操作，CPU大部分时间应该是等待IO操作完成，不应该占用CPU时间的，为什么load会增大呢？难道linux内核在等待IO的时候，仍然霸占CPU，不能被其他的进程使用？（内核应该不会这么傻，呵呵）

If process can’t get data from disk immediately，what to do?

当进程等待IO数据的时候，最终会到block层的get_request_wait(或类似的函数)

看一下这个函数的实现：(/block/blk-core.c)


点击(此处)折叠或打开

  1. static struct request *get_request_wait(struct request_queue *q, int rw_flags,

  3.                                                struct bio *bio)

  5. {

  7.          const bool is_sync = rw_is_sync(rw_flags) != 0;

  9.          struct request *rq;

  11.          rq = get_request(q, rw_flags, bio, GFP_NOIO);

  13.          while (!rq) {

  15.                    DEFINE_WAIT(wait);

  17.                    struct io_context *ioc;

  19.                    struct request_list *rl = &q->rq;

  21.                    /*修改当前进程的状态为TASK_UNINTERRUPTIBLE*/

  23.                    prepare_to_wait_exclusive(&rl->wait[is_sync], &wait,

  25.                                      TASK_UNINTERRUPTIBLE);

  27.                    trace_block_sleeprq(q, bio, rw_flags & 1);

  29.                    __generic_unplug_device(q);

  31.                    spin_unlock_irq(q->queue_lock);

  33.                   /*调用函数进行调度*/

  35.                    io_schedule();

  37.                    /*

  39.                     * After sleeping, we become a "batching" process and

  41.                     * will be able to allocate at least one request, and

  43.                     * up to a big batch of them for a small period time.

  45.                     * See ioc_batching, ioc_set_batching

  47.                     */

  49.                    ioc = current_io_context(GFP_NOIO, q->node);

  51.                    ioc_set_batching(q, ioc);

  53.                    spin_lock_irq(q->queue_lock);

  55.                    finish_wait(&rl->wait[is_sync], &wait);

  57.                    rq = get_request(q, rw_flags, bio, GFP_NOIO);

  59.          };

  61.          return rq;

  63. }


函数调用了io_schedule（有些会调用io_schedule_timeout，这个函数的不同是，至少sleep多长时间）。我们看一下io_schedule的代码:(kernel/sched.c)


点击(此处)折叠或打开

  1. /*

  3.  * This task is about to go to sleep on IO. Increment rq->nr_iowait so

  5.  * that process accounting knows that this is a task in IO wait state.

  7.  */

  9. void __sched io_schedule(void)

  11. {

  13.          struct rq *rq = raw_rq();

  15.          delayacct_blkio_start();

  17.          atomic_inc(&rq->nr_iowait);

  19.          current->in_iowait = 1;

  21.          /*调用schedule函数，让出的CPU*/

  23.          schedule();

  25.          current->in_iowait = 0;

  27. /*增加当前CPU的等待IO的进程数*/

  29.          atomic_dec(&rq->nr_iowait);

  31.          delayacct_blkio_end();

  33. }


从这个函数可以看出，当进程IO操作的时候，会从当前CPU的running队列移除，并让出CPU。那按照网上的解释，不应该增加load值啊。看来需要看看load的真正含义了。

How the kernel calculate load?

/proc/loadavg对应的代码是fs/proc/loadavg.c


点击(此处)折叠或打开

  1. static int loadavg_proc_show(struct seq_file *m, void *v)

  3. {

  5.          unsigned long avnrun[3];

  7.          get_avenrun(avnrun, FIXED_1/200, 0);

  9.          seq_printf(m, "%lu.%02lu %lu.%02lu %lu.%02lu %ld/%d %d\n",

  11.                    LOAD_INT(avnrun[0]), LOAD_FRAC(avnrun[0]),

  13.                    LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),

  15.                    LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]),

  17.                    nr_running(), nr_threads,

  19.                    task_active_pid_ns(current)->last_pid);

  21.          return 0;

  23. }


这里通过get_avenrun函数获取（kernel/sched.c）


点击(此处)折叠或打开

  1. void get_avenrun(unsigned long *loads, unsigned long offset, int shift)

  3. {

  5.          loads[0] = (avenrun[0] + offset) << shift;

  7.          loads[1] = (avenrun[1] + offset) << shift;

  9.          loads[2] = (avenrun[2] + offset) << shift;

  11. }


这里实际读取的全局变量avenrun。Avenrun的更新在函数calc_global_load


点击(此处)折叠或打开

  1. void calc_global_load(void)

  3. {

  5.          unsigned long upd = calc_load_update + 10;

  7.          long active;

  9.          if (time_before(jiffies, upd))

  11.                    return;

  13.          active = atomic_long_read(&calc_load_tasks);

  15.          active = active > 0 ? active * FIXED_1 : 0;

  17.          avenrun[0] = calc_load(avenrun[0], EXP_1, active);

  19.          avenrun[1] = calc_load(avenrun[1], EXP_5, active);

  21.          avenrun[2] = calc_load(avenrun[2], EXP_15, active);

  23.          calc_load_update += LOAD_FREQ;

  25. }


这里实际读取的calc_load_tasks变量，这个变量在函数calc_load_account_active中被更新。（这个函数可能在每个tick的时候通过update_cpu_load调用，也可能在cpu选择idle进程的时候调用）


点击(此处)折叠或打开

  1. static void calc_load_account_active(struct rq *this_rq)

  3. {

  5.          long nr_active, delta;

  7.          nr_active = this_rq->nr_running;

  9.          /*这里不仅包含的running的进程，也包含了uninterruptible的进程*/

  11.          nr_active += (long) this_rq->nr_uninterruptible;

  13.          if (nr_active != this_rq->calc_load_active) {

  15.                    delta = nr_active - this_rq->calc_load_active;

  17.                    this_rq->calc_load_active = nr_active;

  19.                    atomic_long_add(delta, &calc_load_tasks);

  21.          }

  23. }


Conclusion

内核统计load的含义的是，所有cpu上的处于running状态和uninterruptible状态的进程，由于IO操作的时候，进程会进入uninterruptible状态，所有会增大系统的负载。这个时候负载虽然高，但是CPU仍然是比较空闲的，也就说IO导致的负载过高，对cpu bound型进程的影响不是太大。

10-12 05:28
查看更多
Powered by LMLPHP ©2025 瀚海书香 0.058523