linux的IO调度

2011 年 1 月 8 日

IO调度发生在Linux内核的IO调度层。这个层次是针对Linux的整体IO层次体系来说的。从read()或者write()系统调用的角度来说，Linux整体IO体系可以分为七层，它们分别是：

1. VFS层：虚拟文件系统层。由于内核要跟多种文件系统打交道，而每一种文件系统所实现的数据结构和相关方法都可能不尽相同，所以，内核抽象了这一层，专门用来适配各种文件系统，并对外提供统一操作接口。

2. 文件系统层：不同的文件系统实现自己的操作过程，提供自己特有的特征,例如ext3，4，xfs等。

3. 页缓存层：负责针对page的缓存。

4. 通用块层：由于绝大多数情况的io操作是跟块设备打交道，所以Linux在此提供了一个类似vfs层的块设备操作抽象层。下层对接各种不同属性的块设备，对上提供统一的Block IO请求标准。

5. IO调度层：因为绝大多数的块设备都是类似磁盘这样的设备，所以有必要根据这类设备的特点以及应用的不同特点来设置一些不同的调度算法和队列。以便在不同的应用环境下有针对性的提高磁盘的读写效率，这里就是大名鼎鼎的Linux电梯所起作用的地方。针对机械硬盘的各种调度方法就是在这实现的。

6. 块设备驱动层：驱动层对外提供相对比较高级的设备操作接口，往往是C语言的，而下层对接设备本身的操作方法和规范。

7. 块设备层：这层就是具体的物理设备了，定义了各种针对设备操作方法和规范。

常用的查看系统IO的命令

iostat

iostat -x 时间次数，主要关注%util（在统计时间内所有处理IO时间，除以总共统计时间），查看IO是否繁忙。对于raid设备这个指标有参考意义，但不是绝对的。因为对于多磁盘，即使%util是100%，因为磁盘的并发能力，所以磁盘使用未必就到了瓶颈。

avgrq-sz 平均请求长度，长度越短，代表随机读写越高，反之则顺序读写越高

avgqu-sz 内核中平均IO队列长度，而非块设备中

await 平均每次设备I/O操作的等待时间 (毫秒)

svctm: 平均每次设备I/O操作的服务时间 (毫秒)，基本不关注

iotop

通过这个命令可以很直观的看到哪个线程占用IO比较高，同时其中有一列是PRIO，可以像top调整进程优先级一样，调整IO的优先级，命令是ionice

对于一般的程序基本都是BE/4

一共有3中调度类，其中RE和BE类下有0-7,8个优先级，idle下只有一个子优先级，这个可以通过man iotop很直观的查到,realtime优先级最高，代表无论系统中发生了什么其他事情，realtime调度类都能被赋予磁盘的第一个访问权限，所以导致的结果很有可能会’饿死’其他进程。best-effort代表对于没有请求特殊类型的IO，也就是一般IO的进程，他是最有效的一个调度类。Idle是3个调度类中优先级最低的，只有当没有其他进程调用磁盘IO的时候，才会得到磁盘的IO调度权限。

注意ionice调整io优先级，只支持cfq调度器。

其他

类似sar， strace，lsof等等命令都可以查看系统的IO，或者对系统调用进行追踪

IO调度

IO调度这一层。它要解决的核心问题是，如何提高块设备IO的整体性能？这一层也主要是针对机械硬盘结构而设计的。众所周知，机械硬盘的存储介质是磁盘，磁头在盘片上移动进行磁道寻址，行为类似播放一张唱片。这种结构的特点是，顺序访问时吞吐量较高，但是如果一旦对盘片有随机访问，那么大量的时间都会浪费在磁头的移动上，这时候就会导致每次IO的响应时间变长，极大的降低IO的响应速度。磁头在盘片上寻道的操作，类似电梯调度，如果在寻道的过程中，能把顺序路过的相关磁道的数据请求都“顺便”处理掉，那么就可以在比较小影响响应速度的前提下，提高整体IO的吞吐量。这就是我们问什么要设计IO调度算法的原因。在最开始的时期，Linux把这个算法命名为Linux电梯算法。目前在内核中默认开启了三种算法，其实严格算应该是两种，因为第一种叫做noop，就是空操作调度算法，也就是没有任何调度操作，并不对io请求进行排序，仅仅做适当的io合并的一个fifo队列。

目前内核中默认的调度算法应该是cfq，叫做完全公平队列调度。这个调度算法试图给所有进程提供一个完全公平的IO操作环境。它为每个进程创建一个同步IO调度队列，并默认以时间片和请求数限定的方式分配IO资源，以此保证每个进程的IO资源占用是公平的，同时cfq还实现了针对进程级别的优先级调度

查看和修改IO调度算法的方法是：

[root@localhost ~]# echo cfq > /sys/block/sda/queue/scheduler 
[root@localhost ~]# cat !$
cat /sys/block/sda/queue/scheduler
noop deadline [cfq]

cfq是通用服务器比较好的IO调度算法选择，对桌面用户也是比较好的选择。但是对于很多IO压力较大的场景就并不是很适应，尤其是IO压力集中在某些进程上的场景。因为这种场景我们需要更多的满足某个或者某几个进程的IO响应速度，而不是让所有的进程公平的使用IO，比如数据库应用。

deadline调度（最终期限调度）就是更适合上述场景的解决方案。deadline实现了四个队列，其中两个分别处理正常read和write，按扇区号排序，进行正常io的合并处理以提高吞吐量。因为IO请求可能会集中在某些磁盘位置，这样会导致新来的请求一直被合并，可能会有其他磁盘位置的io请求被饿死。因此实现了另外两个处理超时read和write的队列，按请求创建时间排序，如果有超时的请求出现，就放进这两个队列，调度算法保证超时（达到最终期限时间）的队列中的请求会优先被处理，防止请求被饿死。

在高版本的内核上提供的则是针对多队列的优化版本，noop->none，deadline->mq-deadline，cfq->bfq，以及kyber。

CFQ完全公平队列

CFQ是内核默认选择的IO调度队列，它在桌面应用场景以及大多数常见应用场景下都是很好的选择。如何实现一个所谓的完全公平队列（Completely Fair Queueing）？首先我们要理解所谓的公平是对谁的公平？从操作系统的角度来说，产生操作行为的主体都是进程，所以这里的公平是针对每个进程而言的，我们要试图让进程可以公平的占用IO资源。那么如何让进程公平的占用IO资源？我们需要先理解什么是IO资源。当我们衡量一个IO资源的时候，一般喜欢用的是两个单位，一个是数据读写的带宽，另一个是数据读写的IOPS。带宽就是以时间为单位的读写数据量，比如，100Mbyte/s。而IOPS是以时间为单位的读写次数。在不同的读写情境下，这两个单位的表现可能不一样，但是可以确定的是，两个单位的任何一个达到了性能上限，都会成为IO的瓶颈。从机械硬盘的结构考虑，如果读写是顺序读写，那么IO的表现是可以通过比较少的IOPS达到较大的带宽，因为可以合并很多IO，也可以通过预读等方式加速数据读取效率。当IO的表现是偏向于随机读写的时候，那么IOPS就会变得更大，IO的请求的合并可能性下降，当每次io请求数据越少的时候，带宽表现就会越低。从这里我们可以理解，针对进程的IO资源的主要表现形式有两个，进程在单位时间内提交的IO请求个数和进程占用IO的带宽。其实无论哪个，都是跟进程分配的IO处理时间长度紧密相关的。

有时业务可以在较少IOPS的情况下占用较大带宽，另外一些则可能在较大IOPS的情况下占用较少带宽，所以对进程占用IO的时间进行调度才是相对最公平的。即，我不管你是IOPS高还是带宽占用高，到了时间咱就换下一个进程处理。所以，cfq就是试图给所有进程分配等同的块设备使用的时间片，进程在时间片内，可以将产生的IO请求提交给块设备进行处理，时间片结束，进程的请求将排进它自己的队列，等待下次调度的时候进行处理。这就是cfq的基本原理。

当然，现实生活中不可能有真正的“公平”，常见的应用场景下，我们很可能需要人为的对进程的IO占用进行人为指定优先级，这就像对进程的CPU占用设置优先级的概念一样。所以，除了针对时间片进行公平队列调度外，cfq还提供了优先级支持。每个进程都可以设置一个IO优先级，cfq会根据这个优先级的设置情况作为调度时的重要参考因素。优先级首先分成三大类：RT、BE、IDLE，它们分别是实时（Real Time）、最佳效果（Best Effort）和闲置（Idle）三个类别，对每个类别的IO，cfq都使用不同的策略进行处理。另外，RT和BE类别中，分别又再划分了8个子优先级实现更细节的QOS需求，而IDLE只有一个子优先级。

另外，我们都知道内核默认对存储的读写都是经过缓存（buffer/cache）的，在这种情况下，cfq是无法区分当前处理的请求是来自哪一个进程的。只有在进程使用同步方式（sync read或者sync wirte）或者直接IO（Direct IO）方式进行读写的时候，cfq才能区分出IO请求来自哪个进程。所以，除了针对每个进程实现的IO队列以外，还实现了一个公共的队列用来处理异步请求。

CFQ设计原理

首先上源码！在block/cfq_isolated.c下面，基于内核4.4版本

struct cfq_data {
            struct request_queue *queue;
            /* Root service tree for cfq_groups */
            struct cfq_rb_root grp_service_tree;
            struct cfq_group *root_group;

            /*
             * The priority currently being served
             */
            enum wl_class_t serving_wl_class;
            enum wl_type_t serving_wl_type;
            unsigned long workload_expires;
            struct cfq_group *serving_group;

            /*
             * Each priority tree is sorted by next_request position.  These
             * trees are used when determining if two or more queues are
             * interleaving requests (see cfq_close_cooperator).
             */
            struct rb_root prio_trees[CFQ_PRIO_LISTS];

            unsigned int busy_queues;
            unsigned int busy_sync_queues;

            int rq_in_driver;
            int rq_in_flight[2];

            /*
             * queue-depth detection
             */
            int rq_queued;
            int hw_tag;
            /*
             * hw_tag can be
             * -1 => indeterminate, (cfq will behave as if NCQ is present, to allow better detection)
             *  1 => NCQ is present (hw_tag_est_depth is the estimated max depth)
             *  0 => no NCQ
             */
            int hw_tag_est_depth;
            unsigned int hw_tag_samples;

            /*
             * idle window management
             */
            struct timer_list idle_slice_timer;
            struct work_struct unplug_work;

            struct cfq_queue *active_queue;
            struct cfq_io_cq *active_cic;

            sector_t last_position;

            /*
             * tunables, see top of file
             */
            unsigned int cfq_quantum;
            unsigned int cfq_fifo_expire[2];
            unsigned int cfq_back_penalty;
            unsigned int cfq_back_max;
            unsigned int cfq_slice[2];
            unsigned int cfq_slice_async_rq;
            unsigned int cfq_slice_idle;
            unsigned int cfq_group_idle;
            unsigned int cfq_latency;
            unsigned int cfq_target_latency;

            /*
             * Fallback dummy cfqq for extreme OOM conditions
             */
            struct cfq_queue oom_cfqq;

            unsigned long last_delayed_sync;
};

cfq通过一个叫做cfq_data的数据结构维护了整个调度器流程。在一个支持了cgroup功能的cfq中，全部进程被分成了若干个control group进行管理。每个cgroup在cfq中都有一个cfq_group的结构进行描述，所有的cgroup都被作为一个调度对象放进一个红黑树中，并以vdisktime为key进行排序。vdisktime这个时间纪录的是当前cgroup所占用的io时间，每次对cgroup进行调度时，总是通过红黑树选择当前vdisktime时间最少的cgroup进行处理，以保证所有cgroups之间的IO资源占用“公平”。当然我们知道，cgroup是可以对blkio进行资源比例分配的，其作用原理就是，分配比例大的cgroup占用vdisktime时间增长较慢，分配比例小的vdisktime时间增长较快，快慢与分配比例成正比。这样就做到了不同的cgroup分配的IO比例不一样，并且在cfq的角度看来依然是“公平“的。

选择好了需要处理的cgroup（cfq_group）之后，调度器需要决策选择下一步的service_tree。service_tree这个数据结构对应的都是一系列的红黑树，主要目的是用来实现请求优先级分类的，就是RT、BE、IDLE的分类。每一个cfq_group都维护了7个service_trees，其定义如下，在cfq_group结构体下：

struct cfq_rb_root service_trees[2][3];
struct cfq_rb_root service_tree_idle;

其中service_tree_idle就是用来给IDLE类型的请求进行排队用的红黑树。而上面二维数组，首先第一个维度针对RT和BE分别各实现了一个数组，每一个数组中都维护了三个红黑树，分别对应三种不同子类型的请求，分别是：SYNC、SYNC_NOIDLE以及ASYNC。我们可以认为SYNC相当于SYNC_IDLE并与SYNC_NOIDLE对应。idling是cfq在设计上为了尽量合并连续的IO请求以达到提高吞吐量的目的而加入的机制，我们可以理解为是一种“空转”等待机制。空转是指，当一个队列处理一个请求结束后，会在发生调度之前空等一小会时间，如果下一个请求到来，则可以减少磁头寻址，继续处理顺序的IO请求。为了实现这个功能，cfq在service_tree这层数据结构这实现了SYNC队列，如果请求是同步顺序请求，就入队这个service tree，如果请求是同步随机请求，则入队SYNC_NOIDLE队列，以判断下一个请求是否是顺序请求。所有的异步写操作请求将入队ASYNC的service tree，并且针对这个队列没有空转等待机制。此外，cfq还对SSD这样的硬盘有特殊调整，当cfq发现存储设备是一个ssd硬盘这样的队列深度更大的设备时，所有针对单独队列的空转都将不生效，所有的IO请求都将入队SYNC_NOIDLE这个service tree。

同时每一个service tree都对应了若干个cfq_queue队列，每个cfq_queue队列对应一个进程。

cfq_group还维护了一个在cgroup内部所有进程公用的异步IO请求队列，其结构如下：

struct cfq_queue *async_cfqq[2][IOPRIO_BE_NR];
struct cfq_queue *async_idle_cfqq;

异步请求也分成了RT、BE、IDLE这三类进行处理，每一类对应一个cfq_queue进行排队。BE和RT也实现了优先级的支持，每一个类型有IOPRIO_BE_NR这么多个优先级，这个值定义为8，数组下标为0-7。可以看出，从cfq的角度来说，已经可以实现异步IO的cgroup支持了，我们需要定义一下这里所谓异步IO的含义，它仅仅表示从内存的buffer/cache中的数据同步到硬盘的IO请求，而不是aio(man 7 aio)或者linux的native异步io以及libaio机制，实际上这些所谓的“异步”IO机制，在内核中都是同步实现的（本质上冯诺伊曼计算机没有真正的“异步”机制）。

也就是说当IO请求抵达内核就返回给进程了，剩下的将由内核到硬盘之间同步完成。

三种优先级类型的service_tree的选择就是根据类型的优先级来做选择的，RT优先级最高，BE其次，IDLE最低。就是说，RT里有，就会一直处理RT，RT没了再处理BE。每个service_tree对应一个元素为cfq_queue排队的红黑树，而每个cfq_queue就是内核为进程（线程）创建的请求队列。每一个cfq_queue都会维护一个rb_key的变量，这个变量实际上就是这个队列的IO服务时间（service time）。这里还是通过红黑树找到service time时间最短的那个cfq_queue进行服务，以保证“完全公平”。

选择好了cfq_queue之后，就要开始处理这个队列里的IO请求了。这里的调度方式基本跟deadline类似。cfq_queue会对进入队列的每一个请求进行两次入队，一个放进fifo中，另一个放进按访问扇区顺序作为key的红黑树中。默认从红黑树中取请求进行处理，当请求的延时时间达到deadline时，就从红黑树中取等待时间最长的进行处理，以保证请求不被饿死。

CFQ参数调整

所有cfq的可调参数都可以在/sys/class/block/sda/queue/iosched/目录下找到，当然，在你的系统上，请将sda替换为相应的磁盘名称。

[root@localhost ~/linux-4.4.209/block]# echo cfq > /sys/block/sda/queue/scheduler
[root@localhost ~/linux-4.4.209/block]# ls /sys/class/block/sda/queue/iosched/
back_seek_max  back_seek_penalty  fifo_expire_async  fifo_expire_sync  group_idle  low_latency  quantum  slice_async  slice_async_rq  slice_idle  slice_sync  target_latency

back_seek_max: 磁头可以向后寻址的最大范围，默认值为16M。
back_seek_penalty：向后寻址的惩罚系数。这个值是跟向前寻址进行比较的。
以上两个是为了防止磁头寻道发生抖动而导致寻址过慢而设置的。基本思路是这样，一个io请求到来的时候，cfq会根据其寻址位置预估一下其磁头寻道成本。首先设置一个最大值back_seek_max，对于请求所访问的扇区号在磁头后方的请求，只要寻址范围没有超过这个值，cfq会像向前寻址的请求一样处理它。然后再设置一个评估成本的系数back_seek_penalty，相对于磁头向前寻址，向后寻址的距离为1/2(1/back_seek_penalty)时，cfq认为这两个请求寻址的代价是相同。这两个参数实际上是cfq判断请求合并处理的条件限制，凡事复合这个条件的请求，都会尽量在本次请求处理的时候一起合并处理
fifo_expire_async：设置异步请求的超时时间。同步请求和异步请求是区分不同队列处理的，cfq在调度的时候一般情况都会优先处理同步请求，之后再处理异步请求，除非异步请求符合上述合并处理的条件限制范围内。当本进程的队列被调度时，cfq会优先检查是否有异步请求超时，就是超过fifo_expire_async参数的限制。如果有，则优先发送一个超时的请求，其余请求仍然按照优先级以及扇区编号大小来处理。
fifo_expire_sync：与上面的参数类似，是设置同步请求的超时时间
slice_idle：参数设置了一个等待时间。这让cfq在切换cfq_queue或service tree的时候等待一段时间，目的是提高机械硬盘的吞吐量。一般情况下，来自同一个cfq_queue或者service tree的IO请求的寻址局部性更好，所以这样可以减少磁盘的寻址次数。这个值在机械硬盘上默认为非零。当然在固态硬盘或者硬RAID设备上设置这个值为非零会降低存储的效率，因为固态硬盘没有磁头寻址这个概念，所以在这样的设备上应该设置为0，关闭此功能。
group_idle：这个参数也跟上一个参数类似，区别是当cfq要切换cfq_group的时候会等待一段时间。在cgroup的场景下，如果我们沿用slice_idle的方式，那么空转等待可能会在cgroup组内每个进程的cfq_queue切换时发生。这样会如果这个进程一直有请求要处理的话，那么直到这个cgroup的配额被耗尽，同组中的其它进程也可能无法被调度到。这样会导致同组中的其它进程饿死而产生IO性能瓶颈。在这种情况下，我们可以将slice_idle ＝ 0而group_idle ＝ 8。这样空转等待就是以cgroup为单位进行的，而不是以cfq_queue的进程为单位进行，以防止上述问题产生。
low_latency：这个是用来开启或关闭cfq的低延时（low latency）模式的开关。当这个开关打开时，cfq将会根据target_latency的参数设置来对每一个进程的分片时间（slice time）进行重新计算。这将有利于对吞吐量的公平（默认是对时间片分配的公平）。关闭这个参数（设置为0）将忽略target_latency的值。这将使系统中的进程完全按照时间片方式进行IO资源分配。这个开关默认是打开的。
我们已经知道cfq设计上有“空转”（idling）这个概念，目的是为了可以让连续的读写操作尽可能多的合并处理，减少磁头的寻址操作以便增大吞吐量。如果有进程总是很快的进行顺序读写，那么它将因为cfq的空转等待命中率很高而导致其它需要处理IO的进程响应速度下降，如果另一个需要调度的进程不会发出大量顺序IO行为的话，系统中不同进程IO吞吐量的表现就会很不均衡。就比如，系统内存的cache中有很多脏页要写回时，桌面又要打开一个浏览器进行操作，这时脏页写回的后台行为就很可能会大量命中空转时间，而导致浏览器的小量IO一直等待，让用户感觉浏览器运行响应速度变慢。这个low_latency主要是对这种情况进行优化的选项，当其打开时，系统会根据target_latency的配置对因为命中空转而大量占用IO吞吐量的进程进行限制，以达到不同进程IO占用的吞吐量的相对均衡。这个开关比较合适在类似桌面应用的场景下打开。
target_latency：当low_latency的值为开启状态时，cfq将根据这个值重新计算每个进程分配的IO时间片长度。
quantum：这个参数用来设置每次从cfq_queue中处理多少个IO请求。在一个队列处理事件周期中，超过这个数字的IO请求将不会被处理。这个参数只对同步的请求有效。
slice_sync：当一个cfq_queue队列被调度处理时，它可以被分配的处理总时间是通过这个值来作为一个计算参数指定的。公式为：time_slice = slice_sync + (slice_sync/5 * (4 – prio))。这个参数对同步请求有效。
slice_async：这个值跟上一个类似，区别是对异步请求有效。
slice_async_rq：这个参数用来限制在一个slice的时间范围内，一个队列最多可以处理的异步请求个数。请求被处理的最大个数还跟相关进程被设置的io优先级有关。

CFQ iops模式

默认情况下cfq是以时间片方式支持的带优先级的调度来保证IO资源占用的公平。高优先级的进程将得到更多的时间片长度，而低优先级的进程时间片相对较小。当我们的存储是一个高速并且支持NCQ（原生指令队列）的设备的时候，我们最好可以让其可以从多个cfq队列中处理多路的请求，以便提升NCQ的利用率。此时使用时间片的分配方式分配资源就显得不合时宜了，因为基于时间片的分配，同一时刻最多能处理的请求队列只有一个。这时，我们需要切换cfq的模式为IOPS模式。切换方式很简单，就是将slice_idle=0即可。内核会自动检测你的存储设备是否支持NCQ，如果支持的话cfq会自动切换为IOPS模式。

另外，在默认的基于优先级的时间片方式下，我们可以使用ionice命令来调整进程的IO优先级。进程默认分配的IO优先级是根据进程的nice值计算而来的，计算方法可以在man ionice中看到

deadline最终期限调度

deadline调度算法相对cfq要简单很多。其设计目标是，在保证请求按照设备扇区的顺序进行访问的同时，兼顾其它请求不被饿死，要在一个最终期限前被调度到。我们知道磁头对磁盘的寻道是可以进行顺序访问和随机访问的，因为寻道延时时间的关系，顺序访问时IO的吞吐量更大，随机访问的吞吐量小。如果我们想为一个机械硬盘进行吞吐量优化的话，那么就可以让调度器按照尽量复合顺序访问的IO请求进行排序，之后请求以这样的顺序发送给硬盘，就可以使IO的吞吐量更大。但是这样做也有另一个问题，就是如果此时出现了一个请求，它要访问的磁道离目前磁头所在磁道很远，应用的请求又大量集中在目前磁道附近。导致大量请求一直会被合并和插队处理，而那个要访问比较远磁道的请求将因为一直不能被调度而饿死。deadline就是这样一种调度器，能在保证IO最大吞吐量的情况下，尽量使远端请求在一个期限内被调度而不被饿死的调度器。

deadline设计原理

deadline调度器实现了两类队列，一类负责对请求按照访问扇区进行排序。这个队列使用红黑树组织，叫做sort_list。另一类对请求的访问时间进行排序。使用链表组织，叫做fifo_list。

由于读写请求的明显处理差异，在每一类队列中，又按请求的读写类型分别分了两个队列，就是说deadline调度器实际上有4个队列：

按照扇区访问顺序排序的读队列。
按照扇区访问顺序排序的写队列。
按照请求时间排序的读队列。
按照请求时间排序的写队列。

deadline之所以要对读写队列进行分离，是因为要实现读操作比写操作更高的优先级。从应用的角度来看，读操作一般都是同步行为，就是说，读的时候程序一般都要等到数据返回后才能做下一步的处理。而写操作的同步需求并不明显，一般程序都可以将数据写到缓存，之后由内核负责同步到存储上即可。所以，对读操作进行优化可以明显的得到收益。当然，deadline在这样的情况下必然要对写操作会饿死的情况进行考虑，保证其不会被饿死。

deadline的入队很简单：当一个新的IO请求产生并进行了必要的合并操作之后，它在deadline调度器中会分别按照扇区顺序和请求产生时间分别入队sort_list和fifo_list。并再进一步根据请求的读写类型入队到相应的读或者写队列。

deadline的出队处理相对麻烦一点：

1. 首先判断读队列是否为空，如果读队列不为空并且写队列没发生饥饿（starved < writes_starved）则处理读队列，否则处理写队列（第4步）。

2. 进入读队列处理后，首先检查fifo_list中是否有超过最终期限（read_expire）的读请求，如果有则处理该请求以防止被饿死。

3. 如果上一步为假，则处理顺序的读请求以增大吞吐。

4. 如果第1步检查读队列为空或者写队列处于饥饿状态，那么应该处理写队列。其过程和读队列处理类似。

5. 进入写队列处理后，首先检查fifo_list中是否有超过最终期限（write_expire）的写请求，如果有则处理该请求以防止被饿死。

6. 如果上一步为假，则处理顺序的写请求以增大吞吐。

总结来说：读的优先级高于写优先级，如果有将要过deadline的请求，则先处理将要过期的请求。正常情况下保证顺序读写，保证吞吐量，有饥饿的情况下处理饥饿。

deadline参数调整

[root@localhost ~/linux-4.4.209/block]# echo deadline > /sys/block/sdb/queue/scheduler
[root@localhost ~/linux-4.4.209/block]# ls /sys/block/sdb/queue/iosched/
fifo_batch  front_merges  read_expire  write_expire  writes_starved

read_expire：读请求的超时时间设置，单位为ms。当一个读请求入队deadline的时候，其过期时间将被设置为当前时间＋read_expire，并放倒fifo_list中进行排序。
write_expire：写请求的超时时间设置，单位为ms。功能根读请求类似。
fifo_batch：在顺序（sort_list）请求进行处理的时候，deadline将以batch为单位进行处理。每一个batch处理的请求个数为这个参数所限制的个数。在一个batch处理的过程中，不会产生是否超时的检查，也就不会产生额外的磁盘寻道时间。这个参数可以用来平衡顺序处理和饥饿时间的矛盾，当饥饿时间需要尽可能的符合预期的时候，我们可以调小这个值，以便尽可能多的检查是否有饥饿产生并及时处理。增大这个值当然也会增大吞吐量，但是会导致处理饥饿请求的延时变长。
writes_starved：这个值是在上述deadline出队处理第一步时做检查用的。用来判断当读队列不为空时，写队列的饥饿程度是否足够高。当检查存在有写请求的时候，deadline并不会立即对写请求进行处理，而是给相关数据结构中的starved进行累计，如果这是第一次检查到有写请求进行处理，那么这个计数就为1。如果此时writes_starved值为2，则我们认为此时饥饿程度还不足够高，所以继续处理读请求。只有当starved >= writes_starved的时候，deadline才回去处理写请求。可以认为这个值是用来平衡deadline对读写请求处理优先级状态的，这个值越大，则写请求越被滞后处理，越小，写请求就越可以获得趋近于读请求的优先级。
front_merges：当一个新请求进入队列的时候，如果其请求的扇区距离当前扇区很近，那么它就是可以被合并处理的。而这个合并可能有两种情况，一个是向当前位置后合并，另一种是向前合并。在某些场景下，向前合并是不必要的，那么我们就可以通过这个参数关闭向前合并。默认deadline支持向前合并，设置为0关闭。

NOOP空间调度器

noop调度器是最简单的调度器。它本质上就是一个链表实现的fifo队列，并对请求进行简单的合并处理。调度器本身并没有提供任何可疑配置的参数。

根据以上几种io调度算法的分析，我们应该能对各种调度算法的使用场景有一些大致的思路了。从原理上看，cfq是一种比较通用的调度算法，它是一种以进程为出发点考虑的调度算法，保证大家尽量公平。deadline是一种以提高机械硬盘吞吐量为思考出发点的调度算法，尽量保证在有io请求达到最终期限的时候进行调度，非常适合业务比较单一并且IO压力比较重的业务，比如数据库。而noop呢？其实如果我们把我们的思考对象拓展到固态硬盘，那么你就会发现，无论cfq还是deadline，都是针对机械硬盘的结构进行的队列算法调整，而这种调整对于固态硬盘来说，完全没有意义。对于固态硬盘来说，IO调度算法越复杂,额外要处理的逻辑就越多，效率就越低。所以，固态硬盘这种场景下使用noop是最好的，deadline次之，而cfq由于复杂度的原因，无疑效率最低。

Cgroup——针对IO的资源隔离

前面我们说到，通过追踪一个read()系统调用来一窥这些层次的结构，当read()系统调用发生，内核首先会通过汇编指令引发一个软中断，然后根据中断传入的参数查询系统调用影射表，找到read()对应的内核调用方法名，并去执行相关调用，这个系统调用名一般情况下就是sys_read()。从此，便开始了调用在内核中处理的过程的第一步，一共分为7层。

其中6、7都是相关具体设备的，如果在这个层次提供，那就不是内核全局的功能，而是某些设备自己的特点。文件系统层也可以实现，但是如果要全局实现也是不可能的，需要每种文件系统中都实现一遍，成本太高。所以，可以实现限速的地方比较合适的是VFS、缓存层、通用块层和IO调度层。而VFS和page cache这样的机制并不是面向块设备设计的，都是做其他事情用的，虽然也在io体系中，但是并不适合用来做block io的限速。所以这几层中，最适合并且成本最低就可以实现的地方就是IO调度层和通用块层。IO调度层本身已经有队列了，我们只要在队列里面实现一个限速机制即可，但是在IO调度层实现的限速会因为不同调度算法的侧重点不一样而有很多局限性，从通用块层实现的限速，原则上就可以对几乎所有的块设备进行带宽和iops的限制。截止目前（4.3.3内核），IO限速主要实现在这两层中。

根据IO调度层和通用块层的特点，这两层分别实现了两种不同策略的IO控制策略，也是目前blkio子系统提供的两种控制策略，一个是权重比例方式的控制，另一个是针对IO带宽和IOPS的控制。

几种IO

1、一般IO

一个正常的文件io，需要经过vfs -> buffer\page cache -> 文件系统 -> 通用块设备层 -> IO调度层 -> 块设备驱动 -> 硬件设备这所有几个层次。其实这就是一般IO。当然，不同的状态可能会有变化，比如一个进程正好open并read一个已经存在于page cache中的数据。

2、Direct IO

中文也可以叫直接IO操作，其特点是，VFS之后跳过buffer\page cache层，直接从文件系统层进行操作。那么就意味着，无论读还是写，都不会进行cache。我们基本上可以理解这样的io看起来效率要低很多，直接看到的速度就是设备的速度，并且缺少了cache层对数据的缓存之后，文件系统和数据块的操作效率直接暴露给了应用程序，块的大小会直接影响io速度。

3、Sync IO & write-through:

中文叫做同步IO操作，如果是写操作的话也叫write-through，这个操作往往容易跟上面的DIO搞混，因为看起来他们速度上差不多，但是是有本质区别的。这种方式写的数据要等待存储写入返回才能成功返回，所以跟DIO效率差不多，但是，写的数据仍然是要在cache中写入的，这样其他一般IO的程度仍然可以使用cache机制加速IO操作。所以，这里的sync的意思就是，在执行write操作的时候，让cache和存储上的数据一致。那么他跟一般IO其实一样，数据是要经过cache层的。

4、write-back:

将目前在cache中还没写回存储的脏数据写回到存储。这个名词一般指的是一个独立的过程，这个过程不是随着应用的写而发生，这往往是内核自己找个时间来单独操作的。说白了就是，应用写文件，感觉自己很快写完了，其实内核都把数据放倒cache里了，然后内核自己找时间再去写回到存储上。实际上write-back只是在一般IO的情况下，保证数据一致性的一种机制而已。

以是否使用缓冲（缓存）的区别，IO可以分成缓存IO（Buffered IO）和直接IO（Direct io）。其实就是名词上的不同而已。这里面的buffer的含义跟内存中buffer cache有概念上的不同。实际上这里Buffered IO的含义，相当于内存中的buffer cache+page cache，就是IO经过缓存的意思。如果cgroup针对IO的资源限制实现在了通用块设备层，那么将会对哪些IO操作有影响呢？其实原则上说都有影响，因为绝大多数数据都是要经过通用块设备层写入存储的，但是对于应用程序来说感受可能不一样。在一般IO的情况下，应用程序很可能很快的就写完了数据（在数据量小于缓存空间的情况下），然后去做其他事情了。这时应用程序感受不到自己被限速了，而内核在处理write-back的阶段，由于没有相关page cache中的inode是属于那个cgroup的信息记录，所以所有的page cache的回写只能放到cgroup的root组中进行限制，而不能在其他cgroup中进行限制，因为root组的cgroup一般是不做限制的，所以就相当于目前的cgroup的blkio对buffered IO是没有限速支持的。这个功能将在使用了unified-hierarchy体系的cgroup v2中的部分文件系统（ext系列）已经得到得到支持，据说在4.5版本的内核中正式发布。

而在Sync IO和Direct IO的情况下，由于应用程序写的数据是不经过缓存层的，所以能直接感受到速度被限制，一定要等到整个数据按限制好的速度写完或者读完，才能返回。这就是当前cgroup的blkio限制所能起作用的环境限制。

blkio配置方法

会创建两个cgroup组，分别是test1，test2，让这两个组的进程在对/dev/vdb，设备号为252:16的这个磁盘进行读写的时候按权重比例进行io资源的分配。

权重比例分配

首尔确认系统已经挂在相应的cgroup目录

[root@9_134_10_228 ~]# ls /sys/fs/cgroup/blkio/
blkio.avg_queue_size              blkio.io_wait_time                 blkio.time
blkio.dequeue                     blkio.io_wait_time_recursive       blkio.time_recursive
blkio.diskstats                   blkio.leaf_weight                  blkio.unaccounted_time
blkio.empty_time                  blkio.leaf_weight_device           blkio.weight
blkio.group_wait_time             blkio.reset_stats                  blkio.weight_device
blkio.idle_time                   blkio.sectors                      cgroup.clone_children
blkio.io_merged                   blkio.sectors_recursive            cgroup.event_control
blkio.io_merged_recursive         blkio.throttle.buffered_write_bps  cgroup.procs
blkio.io_queued                   blkio.throttle.io_service_bytes    cgroup.sane_behavior
blkio.io_queued_recursive         blkio.throttle.io_serviced         notify_on_release
blkio.io_service_bytes            blkio.throttle.leaf_weight_device  release_agent
blkio.io_service_bytes_recursive  blkio.throttle.read_bps_device     system.slice
blkio.io_serviced                 blkio.throttle.read_iops_device    tasks
blkio.io_serviced_recursive       blkio.throttle.weight_device       user.slice
blkio.io_service_time             blkio.throttle.write_bps_device
blkio.io_service_time_recursive   blkio.throttle.write_iops_device

创建好两个对应的cgroup组，相关目录下会自动产生相关配置项：

[root@9_134_10_228 ~]# mkdir /sys/fs/cgroup/blkio/test1
[root@9_134_10_228 ~]# mkdir /sys/fs/cgroup/blkio/test2
[root@9_134_10_228 ~]# ls /sys/fs/cgroup/blkio/test{1,2}
/sys/fs/cgroup/blkio/test1:
blkio.avg_queue_size              blkio.io_service_time              blkio.throttle.read_iops_device
blkio.dequeue                     blkio.io_service_time_recursive    blkio.throttle.weight_device
blkio.diskstats                   blkio.io_wait_time                 blkio.throttle.write_bps_device
blkio.empty_time                  blkio.io_wait_time_recursive       blkio.throttle.write_iops_device
blkio.group_wait_time             blkio.leaf_weight                  blkio.time
blkio.idle_time                   blkio.leaf_weight_device           blkio.time_recursive
blkio.io_merged                   blkio.reset_stats                  blkio.unaccounted_time
blkio.io_merged_recursive         blkio.sectors                      blkio.weight
blkio.io_queued                   blkio.sectors_recursive            blkio.weight_device
blkio.io_queued_recursive         blkio.throttle.buffered_write_bps  cgroup.clone_children
blkio.io_service_bytes            blkio.throttle.io_service_bytes    cgroup.event_control
blkio.io_service_bytes_recursive  blkio.throttle.io_serviced         cgroup.procs
blkio.io_serviced                 blkio.throttle.leaf_weight_device  notify_on_release
blkio.io_serviced_recursive       blkio.throttle.read_bps_device     tasks

/sys/fs/cgroup/blkio/test2:
blkio.avg_queue_size              blkio.io_service_time              blkio.throttle.read_iops_device
blkio.dequeue                     blkio.io_service_time_recursive    blkio.throttle.weight_device
blkio.diskstats                   blkio.io_wait_time                 blkio.throttle.write_bps_device
blkio.empty_time                  blkio.io_wait_time_recursive       blkio.throttle.write_iops_device
blkio.group_wait_time             blkio.leaf_weight                  blkio.time
blkio.idle_time                   blkio.leaf_weight_device           blkio.time_recursive
blkio.io_merged                   blkio.reset_stats                  blkio.unaccounted_time
blkio.io_merged_recursive         blkio.sectors                      blkio.weight
blkio.io_queued                   blkio.sectors_recursive            blkio.weight_device
blkio.io_queued_recursive         blkio.throttle.buffered_write_bps  cgroup.clone_children
blkio.io_service_bytes            blkio.throttle.io_service_bytes    cgroup.event_control
blkio.io_service_bytes_recursive  blkio.throttle.io_serviced         cgroup.procs
blkio.io_serviced                 blkio.throttle.leaf_weight_device  notify_on_release
blkio.io_serviced_recursive       blkio.throttle.read_bps_device     tasks

针对cgroup进行权重限制的配置有blkio.weight，是单纯针对cgroup进行权重配置的，还有blkio.weight_device可以针对设备单独进行限制，我们都来试试。首先我们想设置test1和test2使用任何设备的io权重比例都是1:2：

# 权重设置范围为10~1000
[root@9_134_10_228 ~]# echo 100 > /sys/fs/cgroup/blkio/test1/blkio.weight
[root@9_134_10_228 ~]# echo 200 > /sys/fs/cgroup/blkio/test2/blkio.weight

测试脚本如下

#!/bin/bash

testfile1=/home/test1
testfile2=/home/test2

if [ -e $testfile1 ]
then
    rm -rf $testfile1
fi

if [ -e $testfile2 ]
then
    rm -rf $testfile2
fi

sync
echo 3 > /proc/sys/vm/drop_caches

cgexec -g blkio:test1 dd if=/dev/zero of=$testfile1 oflag=direct bs=1M count=1024 &

cgexec -g blkio:test2 dd if=/dev/zero of=$testfile2 oflag=direct bs=1M count=1024 &

dd使用的是direct标记，在这使用sync和不加任何标记的话都达不到效果。因为权重限制是基于cfq实现，cfq要标记进程，而buffered IO都是内核同步，无法标记进程。使用iotop查看限制效果：

[root@9_134_10_228 ~]# iotop -b -n1 | grep direct
17305 be/4 root        0.00 B/s  108.91 M/s  0.00 % 99.99 % dd if=/dev/zero of=/home/test1 oflag=direct bs=1M count=1024
17306 be/4 root        0.00 B/s   54.45 M/s  0.00 % 60.05 % dd if=/dev/zero of=/home/test2 oflag=direct bs=1M count=1024

达到了1:2比例限速的效果。此时对于磁盘读取的限制效果也一样。读取的时候要注意，仍然要保证读取的文件不在page cache中，方法就是：echo 3 > /proc/sys/vm/drop_caches。因为在page cache中的数据已经在内存里了，直接修改是直接改内存中的内容，只有write-back的时候才会经过cfq。

[root@9_134_10_228 ~]# echo "252:16 400" > /sys/fs/cgroup/blkio/test1/blkio.weight_device
[root@9_134_10_228 ~]# echo "252:16 200" > /sys/fs/cgroup/blkio/test2/blkio.weight_device

[root@9_134_10_228 ~]# iotop -b -n1|grep direct
 1800 be/4 root        0.00 B/s  102.24 M/s  0.00 % 99.99 % dd if=/dev/zero of=/home/test1 oflag=direct bs=1M count=1024
 1801 be/4 root        0.00 B/s   51.12 M/s  0.00 % 99.99 % dd if=/dev/zero of=/home/test2 oflag=direct bs=1M count=1024

可以看到权重确实是按照最后一次的设置，test1和test2变成了2:1的比例，而不是1:2了。这里要说明的就是，注意blkio.weight_device的设置会覆盖blkio.weight的设置，因为前者的设置精确到了设备，Linux在这里的策略是，越精确越优先。

读写带宽和IOPS限制

针对读写带宽和iops的限制都是绝对值限制，所以我们不用两个cgroup做对比了。我们就设置test1的写带宽速度为1M/s:

[root@9_134_10_228 ~]# echo "252:16 1048576" > /sys/fs/cgroup/blkio/test1/blkio.throttle.write_bps_device
[root@9_134_10_228 ~]# sync
[root@9_134_10_228 ~]# echo 3 > /proc/sys/vm/drop_caches

[root@9_134_10_228 /home]# cgexec -g blkio:test1 dd if=/dev/zero of=/data/bigfile/test oflag=direct count=1024 bs=1M
^C14+0 records in
14+0 records out
14680064 bytes (15 MB) copied, 14.018 s, 1.0 MB/s

[root@9_134_10_228 /home]# cgexec -g blkio:test2 dd if=/dev/zero of=/data/bigfile/test2 oflag=direct count=1024 bs=1M
^C834+0 records in
834+0 records out
874512384 bytes (875 MB) copied, 6.84129 s, 128 MB/s

可以看到这块设备针对test1的cgroup的读写速度确实限制在了1MB/s，对于其他cgroup则没有限制

最后是针对IOPS的限制，直接上命令

[root@9_134_10_228 ~]# echo "252:0  10" > /sys/fs/cgroup/blkio/test1/blkio.throttle.write_iops_device 
[root@9_134_10_228 ~]# rm /home/test 
[root@9_134_10_228 ~]# sync
[root@9_134_10_228 ~]# echo 3 > /proc/sys/vm/drop_caches
[root@9_134_10_228 ~]# cgexec -g blkio:test1 dd if=/dev/zero of=/home/test oflag=direct count=1024 bs=1M
^C121+0 records in
121+0 records out
126877696 bytes (127 MB) copied, 12.0576 s, 10.0 MB/s

限制了每秒的输入输出量(或读写次数)，如果这块磁盘同时还有其他读写，那么速率会进一步的下降，同时速率跟写入的块大小有关。

其他相关限制文件

针对权重比例限制的相关文件

blkio.leaf_weight[_device]

其意义等同于blkio.weight[_device]

主要表示当本cgroup中有子cgroup的时候，本cgroup的进程和子cgroup中的进程所分配的资源比例是怎么样的。举个例子说吧，假设有一组cgroups的关系是这样的：

root
       /    |   \
      A     B    leaf
     400   200   200

leaf就表示root组下的进程所占io资源的比例。

此时A组中的进程可以占用的比例为：400/（400+200+200）＊ 100% ＝ 50%

B为：200/（400+200+200）＊ 100% ＝ 25%

而root下的进程为：200/（400+200+200）＊ 100% ＝ 25%

blkio.time

统计相关设备的分配给本组的io处理时间，单位为ms。权重就是依据此时间比例进行分配的。

blkio.sectors

统计本cgroup对设备的读写扇区个数。

blkio.io_service_bytes

统计本cgroup对设备的读写字节个数。

blkio.io_serviced

统计本cgroup对设备的读写操作个数。

blkio.io_service_time

统计本cgroup对设备的各种操作时间。时间单位是ns。

blkio.io_wait_time

统计本cgroup对设备的各种操作的等待时间。时间单位是ns。

blkio.io_merged

统计本cgroup对设备的各种操作的合并处理次数。

blkio.io_queued

统计本cgroup对设备的各种操作的当前正在排队的请求个数。

blkio.*_recursive

这一堆文件是相对应的不带_recursive的文件的递归显示版本，所谓递归的意思就是，它会显示出包括本cgroup在内的衍生cgroup的所有信息的总和。

针对带宽和iops限制的相关文件

blkio.throttle.io_serviced