[IO系统]16 IO调度器-NOOP

最新推荐文章于 2024-06-24 10:12:54 发布

YoungerChina

最新推荐文章于 2024-06-24 10:12:54 发布

阅读量3.1k

点赞数 2

分类专栏：数据存储 # 深入理解ext4 文章标签： IO系统调度器 NOOP

本文链接：https://blog.csdn.net/younger_china/article/details/62438691

版权

数据存储同时被 2 个专栏收录

121 篇文章 27 订阅

订阅专栏

深入理解ext4

39 篇文章 171 订阅

订阅专栏

Noop调度算法是内核中最简单的IO调度算法。

1.1 原理

Noop调度算法也叫作电梯调度算法，它将IO请求放入到一个FIFO队列中，然后逐个执行这些IO请求，当然对于一些在磁盘上连续的IO请求，Noop算法会适当做一些合并。这个调度算法特别适合那些不希望调度器重新组织IO请求顺序的应用。

1.2 优势

这种调度算法在以下场景中优势比较明显：

1）在IO调度器下方有更加智能的IO调度设备。如果您的Block Device Drivers是Raid，或者SAN，NAS等存储设备，这些设备会更好地组织IO请求，不用IO调度器去做额外的调度工作；

2）上层的应用程序比IO调度器更懂底层设备。或者说上层应用程序到达IO调度器的IO请求已经是它经过精心优化的，那么IO调度器就不需要画蛇添足，只需要按序执行上层传达下来的IO请求即可。

3）对于一些非旋转磁头氏的存储设备，使用Noop的效果更好。因为对于旋转磁头式的磁盘来说，IO调度器的请求重组要花费一定的CPU时间，但是对于SSD磁盘来说，这些重组IO请求的CPU时间可以节省下来，因为SSD提供了更智能的请求调度算法，不需要内核去画蛇添足。

1.3 调度器源码分析

首先要了解描述elevator的数据结构。和elevator相关的数据结构有个，一个是elevator_type,一个是elevator_queue，前者对应一个调度器类型，后者对应一个调度器实例，也就说如果内核中只有上述四种类型的调度器，则只有四个elevator_type，但是多个块设备(分区)可拥有多个相应分配器的实例，也就是elevator_queue。两个数据结构中最关键的元素都是struct elevator_ops，该结构定义了一组操作函数，用来描述请求队列的相关算法，实现对请求的处理

struct elevator_type
{
    structlist_head list;
    structelevator_ops ops;
    structelv_fs_entry *elevator_attrs;
    charelevator_name[ELV_NAME_MAX];
    structmodule *elevator_owner;
};

及：

struct elevator_queue
{
    structelevator_ops *ops;
    void*elevator_data;
    structkobject kobj;
    structelevator_type *elevator_type;
    structmutex sysfs_lock;
    structhlist_head *hash;
};

函数elevator_init()用来为请求队列分配一个I/O调度器的实例

int elevator_init(struct request_queue *q, char*name)
{
    structelevator_type *e = NULL;
    structelevator_queue *eq;
    int ret =0;
    void*data;
 
   
    /*初始化请求队列的相关元素*/
    INIT_LIST_HEAD(&q->queue_head);
    q->last_merge= NULL;
    q->end_sector= 0;
    q->boundary_rq= NULL;
 
    /*下面根据情况在elevator全局链表中来寻找适合的调度器分配给请求队列*/
 
    if (name){//如果指定了name,则寻找与name匹配的调度器
        e =elevator_get(name);
        if(!e)
            return-EINVAL;
    }
 
    //如果没有指定io调度器，并且chosen_elevator存在，则寻找其指定的调度器
    if (!e&& *chosen_elevator) {
        e =elevator_get(chosen_elevator);
        if(!e)
            printk(KERN_ERR"I/O scheduler %s not found\n",
                            chosen_elevator);
    }
   
    //依然没获取到调度器的话则使用默认配置的调度器
    if (!e) {
        e =elevator_get(CONFIG_DEFAULT_IOSCHED);
        if(!e) {//获取失败则使用最简单的noop调度器
            printk(KERN_ERR
                "DefaultI/O scheduler not found. " \
                "Usingnoop.\n");
            e= elevator_get("noop");
        }
    }
 
    //分配并初始化elevator_queue
    eq =elevator_alloc(q, e);
    if (!eq)
        return-ENOMEM;
 
    //调用ops中的elevator_init_fn函数，针对调度器的队列进行初始化
    data =elevator_init_queue(q, eq);
    if (!data){
        kobject_put(&eq->kobj);
        return-ENOMEM;
    }
 
    //建立数据结构的关系
    elevator_attach(q,eq, data);
    returnret;
}

所有的I/O调度器类型都会通过链表链接起来(通过struct elevator_type中的list元素)，elevator_get()函数便是通过给定的name，在链表中寻找与name匹配的调度器类型。当确定了I/O调度器的类型后，便要通过elevator_alloc()为等待队列分配一个调度器的实例--struct elevator_queue,并进行初始化；其后，由于每个调度器根据自身算法的不同，都会拥有不同的队列结构，在elevator_init_queue()中会调用特定于调度器的初始化函数针对这些队列进行初始化，并且返回特定于调度器的数据结构，最后再elevator_attach()中建立相关结构的关系。

static struct elevator_queue *elevator_alloc(structrequest_queue *q,
                  struct elevator_type *e)
{
    structelevator_queue *eq;
    int i;
 
    //为eq分配内存
    eq =kmalloc_node(sizeof(*eq), GFP_KERNEL | __GFP_ZERO, q->node);
    if(unlikely(!eq))
        gotoerr;
 
    //根据之前确定的elevator_type初始化eq
    eq->ops= &e->ops;
    eq->elevator_type= e;
    kobject_init(&eq->kobj,&elv_ktype);
    mutex_init(&eq->sysfs_lock);
 
    //分配elevator的哈希表内存
    eq->hash= kmalloc_node(sizeof(struct hlist_head) * ELV_HASH_ENTRIES,
                    GFP_KERNEL,q->node);
    if(!eq->hash)
        gotoerr;
 
    //初始化哈希表
    for (i =0; i < ELV_HASH_ENTRIES; i++)
        INIT_HLIST_HEAD(&eq->hash[i]);
 
    return eq;
err:
    kfree(eq);
    elevator_put(e);
    returnNULL;
}

及

static void *elevator_init_queue(structrequest_queue *q,
                 struct elevator_queue *eq)
{
    returneq->ops->elevator_init_fn(q);
}

再：

static void elevator_attach(struct request_queue*q, struct elevator_queue *eq,
               void *data)
{
    q->elevator= eq;
    eq->elevator_data= data;
}

下面就来看一下elevator_ops中定义了哪些操作：

struct elevator_ops
{
    elevator_merge_fn *elevator_merge_fn;
    elevator_merged_fn *elevator_merged_fn;
    elevator_merge_req_fn *elevator_merge_req_fn;
    elevator_allow_merge_fn *elevator_allow_merge_fn;
 
    elevator_dispatch_fn *elevator_dispatch_fn;
    elevator_add_req_fn *elevator_add_req_fn;
    elevator_activate_req_fn *elevator_activate_req_fn;
    elevator_deactivate_req_fn *elevator_deactivate_req_fn;
 
    elevator_queue_empty_fn *elevator_queue_empty_fn;
    elevator_completed_req_fn *elevator_completed_req_fn;
 
    elevator_request_list_fn *elevator_former_req_fn;
    elevator_request_list_fn *elevator_latter_req_fn;
 
    elevator_set_req_fn *elevator_set_req_fn;
    elevator_put_req_fn *elevator_put_req_fn;
 
    elevator_may_queue_fn *elevator_may_queue_fn;
 
    elevator_init_fn *elevator_init_fn;
    elevator_exit_fn *elevator_exit_fn;
    void(*trim)(struct io_context *);
};

这里只关注几个主要的操作函数，其中前面加了*号的表示这些函数是每个调度器都必须实现的

elevator_merge_fn查询一个request，用于将bio并入

elevator_merge_req_fn将两个合并后的请求中多余的那个给删除

*elevator_dispatch_fn将调度器的队列最前面的元素取出，分派给request_queue中的请求队列以等候响应*

*elevator_add_req_fn将一个新的request添加进调度器的队列

elevator_queue_empty_fn检查调度器的队列是否为空

elevator_set_req_fn和elevator_put_req_fn分别在创建新请求和将请求所占的空间释放到内存时调用

*elevator_init_fn用于初始化调度器实例

一个请求在创建到销毁的过程遵循下面三种流程

set_req_fn->

i. add_req_fn -> (merged_fn ->)* -> dispatch_fn -> activate_req_fn-> (deactivate_req_fn -> activate_req_fn ->)* -> completed_req_fn

ii. add_req_fn-> (merged_fn ->)* -> merge_req_fn iii. [none] ->put_req_fn

在分析调度器的实现时，不妨也以此为依据，选择i或者ii来作为分析的流程。

1.4 NOOP源码分析

Noop调度器的实现非常简单，其主要完成了一个elevator request queue，这个request queue没有进行任何的分类处理，只是对输入的request进行简单的队列操作。但是，需要注意的是，虽然Noop没有做什么事情，但是elevator还是对bio进行了后向合并，从而最大限度的保证相邻的bio得到合并处理。Noop调度器实现了elevator的基本接口函数，并将这些函数注册到linux系统的elevator子系统中。

需要注册到elevator子系统中的基本接口函数声明如下：

static struct elevator_type elevator_noop = {
.ops = {
/* 合并两个request */
.elevator_merge_req_fn      = noop_merged_requests,
/* 调度一个合适的request进行发送处理 */
.elevator_dispatch_fn       = noop_dispatch,
/* 将request放入调度器的queue中*/
.elevator_add_req_fn        = noop_add_request,
/* 获取前一个request */
.elevator_former_req_fn     = noop_former_request,
/* 获取后一个request */
.elevator_latter_req_fn     = noop_latter_request,
.elevator_init_fn       = noop_init_queue,
.elevator_exit_fn       = noop_exit_queue,
},
.elevator_name = "noop",
.elevator_owner = THIS_MODULE,
};

Noop调度器使用的管理数据：

struct noop_data {
    structlist_head queue;
};

noop_init_queue如下：

static void *noop_init_queue(struct request_queue*q)
{
    structnoop_data *nd;
 
    //为noop调度器使用的数据结构分配内存
    nd = kmalloc_node(sizeof(*nd),GFP_KERNEL, q->node);
    if (!nd)
        returnNULL;
    //初始化noop调度器使用的队列
    INIT_LIST_HEAD(&nd->queue);
    return nd;
}

由于 Noop 调度器没有对 request 进行任何的分类处理、调度，因此上述这些函数的实现都很简单。例如，当调度器需要发送 request 时，会调用 noop_dispatch 。该函数会直接从调度器所管理的 request queue 中获取一个 request ，然后调用 elv_dispatch_sort 函数将请求加入到设备所在的request queue 中。 Noop dispatch 函数实现如下：

static int noop_dispatch(struct request_queue *q,int force)
{
    struct noop_data *nd =q->elevator->elevator_data;
    if (!list_empty(&nd->queue)) {
        struct request *rq;
        /* 从调度器的队列头中获取一个request */
        rq = list_entry(nd->queue.next, struct request,queuelist);
        list_del_init(&rq->queuelist);
        /* 将获取的request放入到设备所属的request queue中 */
        elv_dispatch_sort(q, rq);
        return 1;
    }
    return 0;
}

当需要往 noop 调度器中放入 request 时，可以调用 noop_add_request ，该函数的实现及其简单，就是将 request 挂入调度器所维护的 request queue 中。 Noop_add_request 函数实现如下：

static void noop_add_request(struct request_queue*q, struct request *rq)
{
    struct noop_data *nd =q->elevator->elevator_data;
    /* 将request挂入noop调度器的request queue */
    list_add_tail(&rq->queuelist,&nd->queue);
}

由此可见， noop 调度器的实现是很简单的，仅仅实现了一个调度器的框架，用一条链表把所有输入的 request 管理起来。

1.5 简单调度器实现

通过 noop 调度器的例子，我们可以了解到实现一个调度器所需要的基本结构：

/* 包含基本的头文件 */
#include <linux/blkdev.h>
#include <linux/elevator.h>
#include <linux/bio.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
/* 定义调度器所需要的数据结构，一条管理request的队列是必须的 */
struct noop_data {
    structlist_head queue;
};
/* 实现调度器的接口函数 */
static struct elevator_type elevator_noop = {
    .ops = {
        /* 调度器的功能函数 */
        .elevator_merge_req_fn      = noop_merged_requests,
         ……
        /* 初始化/注销调度器，通常在下面这些函数初始化调度器内部的一些数据结构，例如noop_data */
        .elevator_init_fn       = noop_init_queue,
        .elevator_exit_fn       = noop_exit_queue,
    },
    .elevator_name = "noop",
    .elevator_owner = THIS_MODULE,
};
/* 注册调度器 */
static int __init noop_init(void)
{
    elv_register(&elevator_noop);
    return 0;
}
/* 销毁调度器 */
static void __exit noop_exit(void)
{
    elv_unregister(&elevator_noop);
}
/* 模块加载时调用noop_init */
module_init(noop_init);
/* 模块退出时调用noop_exit */
module_exit(noop_exit);