[IO系统]17 IO调度器-DEADLINE

        Deadline算法的核心在于保证每个IO请求在一定的时间内一定要被服务到，以此来避免某个请求饥饿。 

1.1   原理

        Deadline 这种调度器对读写 request 进行了分类管理，并且在调度处理的过程中读请求具有较高优先级。这主要是因为读请求往往是同步操作，对延迟时间比较敏感，而写操作往往是异步操作，可以尽可能的将相邻访问地址的请求进行合并，但是，合并的效率越高，延迟时间会越长。因此，为了区别对待读写请求类型， deadline 采用两条链表对读写请求进行分类管理。但是，引入分类管理之后，在读优先的情况下，写请求如果长时间得到不到调度，会出现饿死的情况，因此， deadline 算法考虑了写饿死的情况，从而保证在读优先调度的情况下，写请求不会被饿死。

        Deadline 这种调度算法的基本思想可以采用下图进行描述：

        读写请求被分成了两个队列，并且采用两种方式将这些 request 管理起来。一种是采用红黑树（ RB tree ）的方式将所有 request 组织起来，通过 request 的访问地址作为索引；另一种方式是采用队列的方式将 request 管理起来，所有的 request 采用先来后到的方式进行排序，即 FIFO 队列。每个 request 会被分配一个 time stamp ，这样就可以知道这个 request 是否已经长时间没有得到调度，需要优先处理。在请求调度的过程中，读队列是优先得到处理的，除非写队列长时间没有得到调度，存在饿死的状况。

        在请求处理的过程中， deadline 算法会优先处理那些访问地址临近的请求，这样可以最大程度的减少磁盘抖动的可能性。只有在有些 request 即将被饿死的时候，或者没有办法进行磁盘顺序化操作的时候， deadline 才会放弃地址优先策略，转而处理那些即将被饿死的 request 。

        总体来讲， deadline 算法对 request 进行了优先权控制调度，主要表现在如下几个方面：

        1） 读写请求分离，读请求具有高优先调度权，除非写请求即将被饿死的时候，才会去调度处理写请求。这种处理可以保证读请求的延迟时间最小化。

        2） 对请求的顺序批量处理。对那些地址临近的顺序化请求， deadline 给予了高优先级处理权。例如一个写请求得到调度后，其临近的 request 会在紧接着的调度过程中被处理掉。这种顺序批量处理的方法可以最大程度的减少磁盘抖动。

        3） 保证每个请求的延迟时间。每个请求都赋予了一个最大延迟时间，如果达到延迟时间的上限，那么这个请求就会被提前处理掉，此时，会破坏磁盘访问的顺序化特征，回影响性能，但是，保证了每个请求的最大延迟时间。

 

1.2     源码分析

        调度器使用的相关数据结构,Deadline调度器需要处理的核心数据结构是deadline_data，该结构描述如下：

struct deadline_data {
    /*
     * run time data
     */
    /*
     * requests(deadline_rq s) are present on both sort_list and fifo_list
     */
    /* 采用红黑树管理所有的request，请求地址作为索引值 */
    struct rb_rootsort_list[2];
    /* 采用FIFO队列管理所有的request，所有请求按照时间先后次序排列 */
    struct list_headfifo_list[2];
    /*
     * next in sortorder. read, write or both are NULL
     */
    /* 批量处理请求过程中，需要处理的下一个request */
    struct request*next_rq[2];
    /* 计数器：统计当前已经批量处理完成的request */
    unsigned int batching;      /* number ofsequential requests made */
    sector_tlast_sector;       /* head position */
    /* 计数器：统计写队列是否即将饿死 */
    unsigned int starved;       /* timesreads have starved writes */
    /*
     * settings thatchange how the i/o scheduler behaves
     */
    /* 配置信息：读写请求的超时时间值 */
    int fifo_expire[2];
    /* 配置信息：批量处理的request数量 */
    int fifo_batch;
    /* 配置信息：写饥饿值 */
    int writes_starved;
    int front_merges;
};

sort_list:读写请求的红黑树，以请求的起始扇区来排序

fifo_list:读写请求的链表，以请求的响应期限来排序

next_rq:下一个读(写)请求，当确定一个批量传输时，通过该指针直接获取下一个请求

batching:批量传输的当前值

last_sector:处理的rq的末尾扇区号

starved: 标识着当前是第starved批读请求传输

fifo_expire:读写请求的期限值

fifo_batch:批量传输的请求数

writes_starved:写请求的饿死线，传输了writes_starved批读请求后，必须传输写请求

front_merges:是否使能frontmerge的检查

DeadlineScheduler的定义：

static struct elevator_type iosched_deadline = {
    .ops = {
        .elevator_merge_fn=        deadline_merge,
        .elevator_merged_fn=       deadline_merged_request,
        .elevator_merge_req_fn=    deadline_merged_requests,
        .elevator_dispatch_fn=     deadline_dispatch_requests,
        .elevator_add_req_fn=      deadline_add_request,
        .elevator_queue_empty_fn=  deadline_queue_empty,
        .elevator_former_req_fn=   elv_rb_former_request,
        .elevator_latter_req_fn=   elv_rb_latter_request,
        .elevator_init_fn=     deadline_init_queue,
        .elevator_exit_fn=     deadline_exit_queue,
    },
 
    .elevator_attrs= deadline_attrs,
    .elevator_name= "deadline",
    .elevator_owner= THIS_MODULE,
};

        初始化函数deadline_init_queue()用于初始化struct deadline_data中的数据，没有太多好说的，先来看检查一个bio是否能合并到request中的函数deadline_merge()

static int
deadline_merge(struct request_queue *q, structrequest **req, struct bio *bio)
{
    structdeadline_data *dd = q->elevator->elevator_data;
    structrequest *__rq;
    int ret;
 
    /*
     * check for front merge
     */
    if(dd->front_merges) {//在deadline scheduler使能了front_merges的情况下才会进行front merge的检查
        sector_tsector = bio->bi_sector + bio_sectors(bio);//取bio的最后一个扇区
 
        //从红黑树中查找起始扇区号与sector相同的request
        __rq =elv_rb_find(&dd->sort_list[bio_data_dir(bio)], sector);
        if(__rq) {//查找成功
            BUG_ON(sector!= blk_rq_pos(__rq));
 
            if(elv_rq_merge_ok(__rq, bio)) {//各项属性的检查，确定bio可以插入
                ret= ELEVATOR_FRONT_MERGE;//设置状态
                gotoout;
            }
        }
    }
 
    returnELEVATOR_NO_MERGE;
out:
    *req =__rq;
    returnret;//将检查的结果返回给通用层
}

        函数deadline_merged_request进行bio插入的善后工作。。主要是考虑前插入改变了原红黑树节点的值，所以要将节点删除再重新进行插入

static void deadline_merged_request(structrequest_queue *q,
                    struct request *req, int type)
{
    structdeadline_data *dd = q->elevator->elevator_data;
 
    /*
     * if the merge was a front merge, we need toreposition request
     */
    if (type== ELEVATOR_FRONT_MERGE) {//如果是是将bio插入request的bio链表的前面则要进行request的重定位
        elv_rb_del(deadline_rb_root(dd,req), req);//将request从红黑树中删除
        deadline_add_rq_rb(dd,req);//重新添加至红黑树
    }
}

        在通用层进行request的合并后，deadline_merged_requests()函数负责善后，注意合并时都是保留前request，舍弃后request

static void
deadline_merged_requests(struct request_queue *q,struct request *req,
             struct request *next)
{
    /*
     * if next expires before rq, assign its expiretime to rq
     * and move into next position (next will bedeleted) in fifo
     */
     /*首先要保证两个请求的所属的队列不为空，然后根据req和next的响应期限时间长短，来选择保留哪个，如果
        后者比前者的期限时间短，也就是先响应，那就要将next的期限时间赋给req,并且将req放置到next在fifo的
        位置，因为next将要被删除*/
    if(!list_empty(&req->queuelist) && !list_empty(&next->queuelist)){
        //如果next的期限时间小于req
        if(time_before(rq_fifo_time(next), rq_fifo_time(req))) {
            list_move(&req->queuelist,&next->queuelist);//调整req在fifo的位置
            rq_set_fifo_time(req,rq_fifo_time(next));//重置req的期限时间
        }
    }
 
    /*
     * kill knowledge of next, this one is a goner
     */
     //将next从链表和红黑树中删除
    deadline_remove_request(q,next);
}

        deadline_add_request()用于将一个新请求添加至调度器，主要是插入各个数据结构，并设置期限值

static void
deadline_add_request(struct request_queue *q,struct request *rq)
{
    structdeadline_data *dd = q->elevator->elevator_data;
    const intdata_dir = rq_data_dir(rq);//获取request的读写方向
 
    deadline_add_rq_rb(dd,rq);//将rq插入红黑树
 
    /*
     * set expire time and add to fifo list
     */
    //设置期限时间
    rq_set_fifo_time(rq,jiffies + dd->fifo_expire[data_dir]);
    //将rq插入fifo_list
    list_add_tail(&rq->queuelist,&dd->fifo_list[data_dir]);
}

        最后要分析的一个函数，也是最重要的一个--deadline_dispatch_requests  调度器如何选择request，分派给request_queue：

static intdeadline_dispatch_requests(struct request_queue *q, intforce)
{
    struct deadline_data*dd = q->elevator->elevator_data;
    const intreads = !list_empty(&dd->fifo_list[READ]);
    const intwrites = !list_empty(&dd->fifo_list[WRITE]);
    struct request*rq;
    int data_dir;
    /*
    * batches are currently reads XOR writes
    请求批量处理入口
    */
    if (dd->next_rq[WRITE])
        rq = dd->next_rq[WRITE];
    else
        rq =dd->next_rq[READ];
    /* 如果批量请求处理存在，并且还没有达到批量请求处理的上限值，那么继续请求的批量处理 */
    if (rq && dd->batching <dd->fifo_batch)
    /* we have a next request are still entitled to batch */
    gotodispatch_request;
    /*
     * at this point weare not running a batch. select the appropriate
     * data direction(read / write)
     */
    /* 优先处理读请求队列 */
    if (reads) {
        BUG_ON(RB_EMPTY_ROOT(&dd->sort_list[READ]));
        /* 如果写请求队列存在饿死的现象，那么优先处理写请求队列 */
        if (writes && (dd->starved++ >=dd->writes_starved))
            goto dispatch_writes;
        data_dir= READ;
        gotodispatch_find_request;
    }
    /*
     * there are eitherno reads or writes have been starved
     */
     /* 没有读请求需要处理，或者写请求队列存在饿死现象 */
    if (writes) {
dispatch_writes:
        BUG_ON(RB_EMPTY_ROOT(&dd->sort_list[WRITE]));
        dd->starved= 0;
        data_dir= WRITE;
        gotodispatch_find_request;
    }
    return 0;
dispatch_find_request:
    /*
     * we are notrunning a batch, find best request for selected data_dir
     */
    if (deadline_check_fifo(dd, data_dir) ||!dd->next_rq[data_dir]) {
        /* 如果请求队列中存在即将饿死的request，或者不存在需要批量处理的请求，那么从FIFO队列头获取一个request */
        /*
         * A deadline hasexpired, the last request was in the other
         * direction, or wehave run out of higher-sectored requests.
         * Start again fromthe request with the earliest expiry time.
         */
        rq =rq_entry_fifo(dd->fifo_list[data_dir].next);
    } else {
        /* 继续批量处理，获取需要批量处理的下一个request */
        /*
         * The last req wasthe same dir and we have a next request in
         * sort order. Noexpired requests so continue on from here.
         */
        rq =dd->next_rq[data_dir];
    }
    dd->batching= 0;
    dispatch_request:
     /* 将request从调度器中移出，发送至设备 */
    /*
     * rq is theselected appropriate request.
     */
    dd->batching++;
    deadline_move_request(dd,rq);
    return 1;
}

        总体而言,Noop和Deadline算法实现是比较简单的