lkml.org 
[lkml]   [2012]   [Jan]   [6]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
From
Date
SubjectRe: [RFC 2/3]block: FIOPS ioscheduler core
2012/1/4 Shaohua Li <shaohua.li@intel.com>:
> FIOPS (Fair IOPS) ioscheduler is IOPS based ioscheduler, so only targets
> for drive without I/O seek. It's quite similar like CFQ, but the dispatch
> decision is made according to IOPS instead of slice.
>
> The algorithm is simple. Drive has a service tree, and each task lives in
> the tree. The key into the tree is called vios (virtual I/O). Every request
> has vios, which is calculated according to its ioprio, request size and so
> on. Task's vios is the sum of vios of all requests it dispatches. FIOPS
> always selects task with minimum vios in the service tree and let the task
> dispatch request. The dispatched request's vios is then added to the task's
> vios and the task is repositioned in the sevice tree.
>
> Unlike CFQ, FIOPS doesn't have separate sync/async queues, because with I/O
> less writeback, usually a task can only dispatch either sync or async requests.
> Bias read or write request can still be done with read/write scale.
>
> One issue is if workload iodepth is lower than drive queue_depth, IOPS
> share of a task might not be strictly according to its priority, request
> size and so on. In this case, the drive is in idle actually. Solving the
> problem need make drive idle, so impact performance. I believe CFQ isn't
> completely fair between tasks in such case too.
>
> Signed-off-by: Shaohua Li <shaohua.li@intel.com>
> ---
>  block/Kconfig.iosched |    8
>  block/Makefile        |    1
>  block/blk-ioc.c       |    2
>  block/blk.h           |    2
>  block/fiops-iosched.c |  659 ++++++++++++++++++++++++++++++++++++++++++++++++++
>  5 files changed, 670 insertions(+), 2 deletions(-)
>
> Index: linux/block/Makefile
> ===================================================================
> --- linux.orig/block/Makefile   2011-12-28 09:42:18.000000000 +0800
> +++ linux/block/Makefile        2011-12-28 09:42:35.000000000 +0800
> @@ -14,6 +14,7 @@ obj-$(CONFIG_BLK_DEV_THROTTLING)      += blk-
>  obj-$(CONFIG_IOSCHED_NOOP)     += noop-iosched.o
>  obj-$(CONFIG_IOSCHED_DEADLINE) += deadline-iosched.o
>  obj-$(CONFIG_IOSCHED_CFQ)      += cfq-iosched.o
> +obj-$(CONFIG_IOSCHED_FIOPS)    += fiops-iosched.o
>
>  obj-$(CONFIG_BLOCK_COMPAT)     += compat_ioctl.o
>  obj-$(CONFIG_BLK_DEV_INTEGRITY)        += blk-integrity.o
> Index: linux/block/fiops-iosched.c
> ===================================================================
> --- /dev/null   1970-01-01 00:00:00.000000000 +0000
> +++ linux/block/fiops-iosched.c 2012-01-04 14:01:26.000000000 +0800
> @@ -0,0 +1,659 @@
> +/*
> + * IOPS based IO scheduler. Based on CFQ.
> + *  Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
> + *  Shaohua Li <shli@kernel.org>
> + */
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/blkdev.h>
> +#include <linux/elevator.h>
> +#include <linux/jiffies.h>
> +#include <linux/rbtree.h>
> +#include <linux/ioprio.h>
> +#include "blk.h"
> +
> +#define VIOS_SCALE_SHIFT 10
> +#define VIOS_SCALE (1 << VIOS_SCALE_SHIFT)
> +
> +struct fiops_rb_root {
> +       struct rb_root rb;
> +       struct rb_node *left;
> +       unsigned count;
> +
> +       u64 min_vios;
> +};
> +#define FIOPS_RB_ROOT  (struct fiops_rb_root) { .rb = RB_ROOT}
> +
> +struct fiops_data {
> +       struct queue_data qdata;
> +
> +       struct fiops_rb_root service_tree;
> +
> +       unsigned int busy_queues;
> +
> +       struct work_struct unplug_work;
> +};
> +
> +struct fiops_ioc {
> +       struct dev_io_context dev_ioc;
> +
> +       unsigned int flags;
> +       struct fiops_data *fiopsd;
> +       struct rb_node rb_node;
> +       u64 vios; /* key in service_tree */
> +       struct fiops_rb_root *service_tree;
> +
> +       struct rb_root sort_list;
> +       struct list_head fifo;
> +
> +       pid_t pid;
> +};
> +
> +static struct kmem_cache *fiops_ioc_pool;
> +static struct ioc_builder ioc_builder;
> +#define queue_data_to_fiopsd(ptr) container_of(ptr, struct fiops_data, qdata)
> +#define dev_ioc_to_fiops_ioc(ptr) container_of(ptr, struct fiops_ioc, dev_ioc)
> +#define ioc_service_tree(ioc) (&((ioc)->fiopsd->service_tree))
> +
> +#define RQ_CIC(rq)             \
> +       ((struct fiops_ioc *) (rq)->elevator_private[0])
> +enum ioc_state_flags {
> +       FIOPS_IOC_FLAG_on_rr = 0,       /* on round-robin busy list */
> +};
> +
> +#define FIOPS_IOC_FNS(name)                                            \
> +static inline void fiops_mark_ioc_##name(struct fiops_ioc *ioc)        \
> +{                                                                      \
> +       ioc->flags |= (1 << FIOPS_IOC_FLAG_##name);                     \
> +}                                                                      \
> +static inline void fiops_clear_ioc_##name(struct fiops_ioc *ioc)       \
> +{                                                                      \
> +       ioc->flags &= ~(1 << FIOPS_IOC_FLAG_##name);                    \
> +}                                                                      \
> +static inline int fiops_ioc_##name(const struct fiops_ioc *ioc)        \
> +{                                                                      \
> +       return ((ioc)->flags & (1 << FIOPS_IOC_FLAG_##name)) != 0;      \
> +}
> +
> +FIOPS_IOC_FNS(on_rr);
> +#undef FIOPS_IOC_FNS
> +
> +/*
> + * The below is leftmost cache rbtree addon
> + */
> +static struct fiops_ioc *fiops_rb_first(struct fiops_rb_root *root)
> +{
> +       /* Service tree is empty */
> +       if (!root->count)
> +               return NULL;
> +
> +       if (!root->left)
> +               root->left = rb_first(&root->rb);
> +
> +       if (root->left)
> +               return rb_entry(root->left, struct fiops_ioc, rb_node);
> +
> +       return NULL;
> +}
> +
> +static void rb_erase_init(struct rb_node *n, struct rb_root *root)
> +{
> +       rb_erase(n, root);
> +       RB_CLEAR_NODE(n);
> +}
> +
> +static void fiops_rb_erase(struct rb_node *n, struct fiops_rb_root *root)
> +{
> +       if (root->left == n)
> +               root->left = NULL;
> +       rb_erase_init(n, &root->rb);
> +       --root->count;
> +}
> +
> +static inline u64 max_vios(u64 min_vios, u64 vios)
> +{
> +       s64 delta = (s64)(vios - min_vios);
> +       if (delta > 0)
> +               min_vios = vios;
> +
> +       return min_vios;
> +}
> +
> +static void fiops_update_min_vios(struct fiops_rb_root *service_tree)
> +{
> +       struct fiops_ioc *ioc;
> +
> +       ioc = fiops_rb_first(service_tree);
> +       if (!ioc)
> +               return;
> +       service_tree->min_vios = max_vios(service_tree->min_vios, ioc->vios);
This is tracking the max vios here, not the min one. Should be min_vios()?
> +}
> +
> +/*
> + * The fiopsd->service_trees holds all pending fiops_ioc's that have
> + * requests waiting to be processed. It is sorted in the order that
> + * we will service the queues.
> + */
> +static void fiops_service_tree_add(struct fiops_data *fiopsd,
> +       struct fiops_ioc *ioc)
> +{
> +       struct rb_node **p, *parent;
> +       struct fiops_ioc *__ioc;
> +       struct fiops_rb_root *service_tree = ioc_service_tree(ioc);
> +       u64 vios;
> +       int left;
> +
> +       /* New added IOC */
> +       if (RB_EMPTY_NODE(&ioc->rb_node))
> +               vios = max_vios(service_tree->min_vios, ioc->vios);
> +       else {
> +               vios = ioc->vios;
> +               /* ioc->service_tree might not equal to service_tree */
> +               fiops_rb_erase(&ioc->rb_node, ioc->service_tree);
> +               ioc->service_tree = NULL;
> +       }
> +
> +       left = 1;
> +       parent = NULL;
> +       ioc->service_tree = service_tree;
> +       p = &service_tree->rb.rb_node;
> +       while (*p) {
> +               struct rb_node **n;
> +
> +               parent = *p;
> +               __ioc = rb_entry(parent, struct fiops_ioc, rb_node);
> +
> +               /*
> +                * sort by key, that represents service time.
> +                */
> +               if (vios <  __ioc->vios)
> +                       n = &(*p)->rb_left;
> +               else {
> +                       n = &(*p)->rb_right;
> +                       left = 0;
> +               }
> +
> +               p = n;
> +       }
> +
> +       if (left)
> +               service_tree->left = &ioc->rb_node;
> +
> +       ioc->vios = vios;
> +       rb_link_node(&ioc->rb_node, parent, p);
> +       rb_insert_color(&ioc->rb_node, &service_tree->rb);
> +       service_tree->count++;
> +
> +       fiops_update_min_vios(service_tree);
> +}
> +
> +/*
> + * Update ioc's position in the service tree.
> + */
> +static void fiops_resort_rr_list(struct fiops_data *fiopsd,
> +       struct fiops_ioc *ioc)
> +{
> +       /*
> +        * Resorting requires the ioc to be on the RR list already.
> +        */
> +       if (fiops_ioc_on_rr(ioc))
> +               fiops_service_tree_add(fiopsd, ioc);
> +}
> +
> +/*
> + * add to busy list of queues for service, trying to be fair in ordering
> + * the pending list according to last request service
> + */
> +static void fiops_add_ioc_rr(struct fiops_data *fiopsd, struct fiops_ioc *ioc)
> +{
> +       BUG_ON(fiops_ioc_on_rr(ioc));
> +       fiops_mark_ioc_on_rr(ioc);
> +
> +       fiopsd->busy_queues++;
> +
> +       fiops_resort_rr_list(fiopsd, ioc);
> +}
> +
> +/*
> + * Called when the ioc no longer has requests pending, remove it from
> + * the service tree.
> + */
> +static void fiops_del_ioc_rr(struct fiops_data *fiopsd, struct fiops_ioc *ioc)
> +{
> +       BUG_ON(!fiops_ioc_on_rr(ioc));
> +       fiops_clear_ioc_on_rr(ioc);
> +
> +       if (!RB_EMPTY_NODE(&ioc->rb_node)) {
> +               fiops_rb_erase(&ioc->rb_node, ioc->service_tree);
> +               ioc->service_tree = NULL;
> +       }
> +
> +       BUG_ON(!fiopsd->busy_queues);
> +       fiopsd->busy_queues--;
> +}
> +
> +/*
> + * rb tree support functions
> + */
> +static void fiops_del_rq_rb(struct request *rq)
> +{
> +       struct fiops_ioc *ioc = RQ_CIC(rq);
> +
> +       elv_rb_del(&ioc->sort_list, rq);
> +}
> +
> +static void fiops_add_rq_rb(struct request *rq)
> +{
> +       struct fiops_ioc *ioc = RQ_CIC(rq);
> +       struct fiops_data *fiopsd = ioc->fiopsd;
> +
> +       elv_rb_add(&ioc->sort_list, rq);
> +
> +       if (!fiops_ioc_on_rr(ioc))
> +               fiops_add_ioc_rr(fiopsd, ioc);
> +}
> +
> +static void fiops_reposition_rq_rb(struct fiops_ioc *ioc, struct request *rq)
> +{
> +       elv_rb_del(&ioc->sort_list, rq);
> +       fiops_add_rq_rb(rq);
> +}
> +
> +static void fiops_remove_request(struct request *rq)
> +{
> +       list_del_init(&rq->queuelist);
> +       fiops_del_rq_rb(rq);
> +}
> +
> +static u64 fiops_scaled_vios(struct fiops_data *fiopsd,
> +       struct fiops_ioc *ioc, struct request *rq)
> +{
> +       return VIOS_SCALE;
> +}
> +
> +/* return vios dispatched */
> +static u64 fiops_dispatch_request(struct fiops_data *fiopsd,
> +       struct fiops_ioc *ioc)
> +{
> +       struct request *rq;
> +       struct request_queue *q = fiopsd->qdata.queue;
> +
> +       rq = rq_entry_fifo(ioc->fifo.next);
> +
> +       fiops_remove_request(rq);
> +       elv_dispatch_sort(q, rq);
> +
> +       return fiops_scaled_vios(fiopsd, ioc, rq);
> +}
> +
> +static int fiops_forced_dispatch(struct fiops_data *fiopsd)
> +{
> +       struct fiops_ioc *ioc;
> +       int dispatched = 0;
> +
> +       while ((ioc = fiops_rb_first(&fiopsd->service_tree)) != NULL) {
> +               while (!list_empty(&ioc->fifo)) {
> +                       fiops_dispatch_request(fiopsd, ioc);
> +                       dispatched++;
> +               }
> +               if (fiops_ioc_on_rr(ioc))
> +                       fiops_del_ioc_rr(fiopsd, ioc);
> +       }
> +       return dispatched;
> +}
> +
> +static struct fiops_ioc *fiops_select_ioc(struct fiops_data *fiopsd)
> +{
> +       struct fiops_ioc *ioc;
> +
> +       if (RB_EMPTY_ROOT(&fiopsd->service_tree.rb))
> +               return NULL;
> +       ioc = fiops_rb_first(&fiopsd->service_tree);
> +       return ioc;
> +}
> +
> +static void fiops_charge_vios(struct fiops_data *fiopsd,
> +       struct fiops_ioc *ioc, u64 vios)
> +{
> +       struct fiops_rb_root *service_tree = ioc->service_tree;
> +       ioc->vios += vios;
> +
> +       if (RB_EMPTY_ROOT(&ioc->sort_list))
> +               fiops_del_ioc_rr(fiopsd, ioc);
> +       else
> +               fiops_resort_rr_list(fiopsd, ioc);
> +
> +       fiops_update_min_vios(service_tree);
> +}
> +
> +static int fiops_dispatch_requests(struct request_queue *q, int force)
> +{
> +       struct fiops_data *fiopsd = q->elevator->elevator_data;
> +       struct fiops_ioc *ioc;
> +       u64 vios;
> +
> +       if (unlikely(force))
> +               return fiops_forced_dispatch(fiopsd);
> +
> +       ioc = fiops_select_ioc(fiopsd);
> +       if (!ioc)
> +               return 0;
> +
> +       vios = fiops_dispatch_request(fiopsd, ioc);
> +
> +       fiops_charge_vios(fiopsd, ioc, vios);
> +       return 1;
> +}
> +
> +static void fiops_insert_request(struct request_queue *q, struct request *rq)
> +{
> +       struct fiops_ioc *ioc = RQ_CIC(rq);
> +
> +       rq_set_fifo_time(rq, jiffies);
> +
> +       list_add_tail(&rq->queuelist, &ioc->fifo);
> +
> +       fiops_add_rq_rb(rq);
> +}
> +
> +/*
> + * scheduler run of queue, if there are requests pending and no one in the
> + * driver that will restart queueing
> + */
> +static inline void fiops_schedule_dispatch(struct fiops_data *fiopsd)
> +{
> +       if (fiopsd->busy_queues)
> +               kblockd_schedule_work(fiopsd->qdata.queue,
> +                                     &fiopsd->unplug_work);
> +}
> +
> +static int
> +fiops_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)
> +{
> +       struct fiops_data *fiopsd = q->elevator->elevator_data;
> +       struct dev_io_context *dev_ioc;
> +       struct fiops_ioc *cic;
> +
> +       might_sleep_if(gfp_mask & __GFP_WAIT);
> +
> +       dev_ioc = queue_data_get_io_context(&ioc_builder, &fiopsd->qdata,
> +               gfp_mask);
> +       if (!dev_ioc)
> +               goto queue_fail;
> +
> +       cic = dev_ioc_to_fiops_ioc(dev_ioc);
> +
> +       /*
> +        * we hold a reference of dev_ioc and nobody else set this request,
> +        * doesn't need locking
> +        */
> +       rq->elevator_private[0] = cic;
> +
> +       return 0;
> +
> +queue_fail:
> +       fiops_schedule_dispatch(fiopsd);
> +       return 1;
> +}
> +
> +static void fiops_put_request(struct request *rq)
> +{
> +       struct fiops_ioc *ioc = RQ_CIC(rq);
> +
> +       if (ioc) {
> +               rq->elevator_private[0] = NULL;
> +               put_io_context(ioc->dev_ioc.ioc);
> +       }
> +}
> +
> +static struct request *
> +fiops_find_rq_fmerge(struct fiops_data *fiopsd, struct bio *bio)
> +{
> +       struct task_struct *tsk = current;
> +       struct dev_io_context *gen_cic;
> +       struct fiops_ioc *cic;
> +
> +       gen_cic = queue_data_cic_lookup(&fiopsd->qdata, tsk->io_context);
> +       if (!gen_cic)
> +               return NULL;
> +       cic = dev_ioc_to_fiops_ioc(gen_cic);
> +
> +       if (cic) {
> +               sector_t sector = bio->bi_sector + bio_sectors(bio);
> +
> +               return elv_rb_find(&cic->sort_list, sector);
> +       }
> +
> +       return NULL;
> +}
> +
> +static int fiops_merge(struct request_queue *q, struct request **req,
> +                    struct bio *bio)
> +{
> +       struct fiops_data *fiopsd = q->elevator->elevator_data;
> +       struct request *__rq;
> +
> +       __rq = fiops_find_rq_fmerge(fiopsd, bio);
> +       if (__rq && elv_rq_merge_ok(__rq, bio)) {
> +               *req = __rq;
> +               return ELEVATOR_FRONT_MERGE;
> +       }
> +
> +       return ELEVATOR_NO_MERGE;
> +}
> +
> +static void fiops_merged_request(struct request_queue *q, struct request *req,
> +                              int type)
> +{
> +       if (type == ELEVATOR_FRONT_MERGE) {
> +               struct fiops_ioc *ioc = RQ_CIC(req);
> +
> +               fiops_reposition_rq_rb(ioc, req);
> +       }
> +}
> +
> +static void
> +fiops_merged_requests(struct request_queue *q, struct request *rq,
> +                   struct request *next)
> +{
> +       struct fiops_ioc *ioc = RQ_CIC(rq);
> +       struct fiops_data *fiopsd = q->elevator->elevator_data;
> +       /*
> +        * reposition in fifo if next is older than rq
> +        */
> +       if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist) &&
> +           time_before(rq_fifo_time(next), rq_fifo_time(rq))) {
> +               list_move(&rq->queuelist, &next->queuelist);
> +               rq_set_fifo_time(rq, rq_fifo_time(next));
> +       }
> +
> +       fiops_remove_request(next);
> +
> +       ioc = RQ_CIC(next);
> +       /*
> +        * all requests of this task are merged to other tasks, delete it
> +        * from the service tree.
> +        */
> +       if (fiops_ioc_on_rr(ioc) && RB_EMPTY_ROOT(&ioc->sort_list))
> +               fiops_del_ioc_rr(fiopsd, ioc);
> +}
> +
> +static int fiops_allow_merge(struct request_queue *q, struct request *rq,
> +                          struct bio *bio)
> +{
> +       struct fiops_data *fiopsd = q->elevator->elevator_data;
> +       struct dev_io_context *gen_cic;
> +       struct fiops_ioc *cic;
> +
> +       /*
> +        * Lookup the ioc that this bio will be queued with. Allow
> +        * merge only if rq is queued there.
> +        */
> +       gen_cic = queue_data_cic_lookup(&fiopsd->qdata, current->io_context);
> +       if (!gen_cic)
> +               return false;
> +       cic = dev_ioc_to_fiops_ioc(gen_cic);
> +
> +       return cic == RQ_CIC(rq);
> +}
> +
> +static void fiops_exit_queue(struct elevator_queue *e)
> +{
> +       struct fiops_data *fiopsd = e->elevator_data;
> +       struct request_queue *q = fiopsd->qdata.queue;
> +
> +       cancel_work_sync(&fiopsd->unplug_work);
> +
> +       spin_lock_irq(q->queue_lock);
> +
> +       ioc_builder_exit_queue(&ioc_builder, &fiopsd->qdata);
> +
> +       spin_unlock_irq(q->queue_lock);
> +       kfree(fiopsd);
> +}
> +
> +static void fiops_kick_queue(struct work_struct *work)
> +{
> +       struct fiops_data *fiopsd =
> +               container_of(work, struct fiops_data, unplug_work);
> +       struct request_queue *q = fiopsd->qdata.queue;
> +
> +       spin_lock_irq(q->queue_lock);
> +       __blk_run_queue(q);
> +       spin_unlock_irq(q->queue_lock);
> +}
> +
> +static void *fiops_init_queue(struct request_queue *q)
> +{
> +       struct fiops_data *fiopsd;
> +
> +       fiopsd = kzalloc_node(sizeof(*fiopsd), GFP_KERNEL, q->node);
> +       if (!fiopsd)
> +               return NULL;
> +
> +       if (ioc_builder_init_queue(&ioc_builder, &fiopsd->qdata, q)) {
> +               kfree(fiopsd);
> +               return NULL;
> +       }
> +
> +       fiopsd->service_tree = FIOPS_RB_ROOT;
> +
> +       INIT_WORK(&fiopsd->unplug_work, fiops_kick_queue);
> +
> +       return fiopsd;
> +}
> +
> +static void fiops_slab_kill(void)
> +{
> +       /*
> +        * Caller already ensured that pending RCU callbacks are completed,
> +        * so we should have no busy allocations at this point.
> +        */
> +       if (fiops_ioc_pool)
> +               kmem_cache_destroy(fiops_ioc_pool);
> +}
> +
> +static int __init fiops_slab_setup(void)
> +{
> +       fiops_ioc_pool = KMEM_CACHE(fiops_ioc, 0);
> +       if (!fiops_ioc_pool)
> +               return -ENOMEM;
> +
> +       return 0;
> +}
> +
> +static struct dev_io_context *
> +fiops_alloc_ioc(struct ioc_builder *builder, struct queue_data *qdata,
> +       gfp_t gfp_mask)
> +{
> +       struct fiops_ioc *ioc = kmem_cache_alloc_node(fiops_ioc_pool,
> +               gfp_mask, qdata->queue->node);
> +       if (ioc)
> +               return &ioc->dev_ioc;
> +       return NULL;
> +}
> +
> +static void fiops_free_ioc(struct ioc_builder *builder,
> +       struct dev_io_context *dev_ioc)
> +{
> +       struct fiops_ioc *ioc = dev_ioc_to_fiops_ioc(dev_ioc);
> +       kmem_cache_free(fiops_ioc_pool, ioc);
> +}
> +
> +static void fiops_init_cic(struct queue_data *qdata,
> +       struct dev_io_context *gen_cic)
> +{
> +       struct fiops_data *fiopsd = queue_data_to_fiopsd(qdata);
> +       struct fiops_ioc *ioc = dev_ioc_to_fiops_ioc(gen_cic);
> +
> +       RB_CLEAR_NODE(&ioc->rb_node);
> +       INIT_LIST_HEAD(&ioc->fifo);
> +       ioc->sort_list = RB_ROOT;
> +
> +       ioc->fiopsd = fiopsd;
> +
> +       ioc->pid = current->pid;
> +}
> +
> +static void fiops_exit_cic(struct queue_data *qdata,
> +       struct dev_io_context *gen_cic)
> +{
> +       struct fiops_ioc *ioc = dev_ioc_to_fiops_ioc(gen_cic);
> +
> +       WARN_ON(fiops_ioc_on_rr(ioc));
> +}
> +
> +static struct ioc_builder ioc_builder = {
> +       .alloc_ioc = fiops_alloc_ioc,
> +       .free_ioc = fiops_free_ioc,
> +       .cic_init = fiops_init_cic,
> +       .cic_exit = fiops_exit_cic,
> +};
> +
> +static struct elevator_type iosched_fiops = {
> +       .ops = {
> +               .elevator_merge_fn =            fiops_merge,
> +               .elevator_merged_fn =           fiops_merged_request,
> +               .elevator_merge_req_fn =        fiops_merged_requests,
> +               .elevator_allow_merge_fn =      fiops_allow_merge,
> +               .elevator_dispatch_fn =         fiops_dispatch_requests,
> +               .elevator_add_req_fn =          fiops_insert_request,
> +               .elevator_former_req_fn =       elv_rb_former_request,
> +               .elevator_latter_req_fn =       elv_rb_latter_request,
> +               .elevator_set_req_fn =          fiops_set_request,
> +               .elevator_put_req_fn =          fiops_put_request,
> +               .elevator_init_fn =             fiops_init_queue,
> +               .elevator_exit_fn =             fiops_exit_queue,
> +               .trim =                         queue_data_free_io_context,
> +       },
> +       .elevator_name =        "fiops",
> +       .elevator_owner =       THIS_MODULE,
> +};
> +
> +static int __init fiops_init(void)
> +{
> +       if (fiops_slab_setup())
> +               return -ENOMEM;
> +       if (ioc_builder_init(&ioc_builder)) {
> +               fiops_slab_kill();
> +               return -ENOMEM;
> +       }
> +
> +       elv_register(&iosched_fiops);
> +
> +       return 0;
> +}
> +
> +static void __exit fiops_exit(void)
> +{
> +       elv_unregister(&iosched_fiops);
> +       io_context_builder_exit(&ioc_builder);
> +       fiops_slab_kill();
> +}
> +
> +module_init(fiops_init);
> +module_exit(fiops_exit);
> +
> +MODULE_AUTHOR("Jens Axboe, Shaohua Li <shli@kernel.org>");
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("IOPS based IO scheduler");
> Index: linux/block/Kconfig.iosched
> ===================================================================
> --- linux.orig/block/Kconfig.iosched    2011-12-28 09:42:18.000000000 +0800
> +++ linux/block/Kconfig.iosched 2012-01-04 13:58:35.000000000 +0800
> @@ -43,6 +43,14 @@ config CFQ_GROUP_IOSCHED
>        ---help---
>          Enable group IO scheduling in CFQ.
>
> +config IOSCHED_FIOPS
> +       tristate "IOPS based I/O scheduler"
> +       default y
> +       ---help---
> +         This is an IOPS based I/O scheduler. It will try to distribute
> +          IOPS equally among all processes in the system. It's mainly for
> +          Flash based storage.
> +
>  choice
>        prompt "Default I/O scheduler"
>        default DEFAULT_CFQ
> Index: linux/block/blk.h
> ===================================================================
> --- linux.orig/block/blk.h      2011-12-28 09:42:18.000000000 +0800
> +++ linux/block/blk.h   2011-12-28 09:42:35.000000000 +0800
> @@ -206,7 +206,7 @@ static inline void blk_throtl_exit(struc
>  static inline void blk_throtl_release(struct request_queue *q) { }
>  #endif /* CONFIG_BLK_DEV_THROTTLING */
>
> -#if IS_ENABLED(CONFIG_IOSCHED_CFQ)
> +#if IS_ENABLED(CONFIG_IOSCHED_CFQ) || IS_ENABLED(CONFIG_IOSCHED_FIOPS)
>  struct queue_data;
>  struct ioc_builder {
>        struct dev_io_context *(*alloc_ioc)(struct ioc_builder *builder,
> Index: linux/block/blk-ioc.c
> ===================================================================
> --- linux.orig/block/blk-ioc.c  2011-12-28 09:42:18.000000000 +0800
> +++ linux/block/blk-ioc.c       2011-12-28 09:42:35.000000000 +0800
> @@ -164,7 +164,7 @@ static int __init blk_ioc_init(void)
>  }
>  subsys_initcall(blk_ioc_init);
>
> -#if IS_ENABLED(CONFIG_IOSCHED_CFQ)
> +#if IS_ENABLED(CONFIG_IOSCHED_CFQ) || IS_ENABLED(CONFIG_IOSCHED_FIOPS)
>  #define CIC_DEAD_INDEX_SHIFT   1
>
>  static inline void *queue_data_dead_key(struct queue_data *qdata)
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

\
 
 \ /
  Last update: 2012-01-07 02:09    [from the cache]
©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site