Linux块层多队列之引入内核，


本文转载自微信公众号「相遇Linux」，作者JeffXie。转载本文请联系相遇Linux公众号。 

Linux块设备多队列机制在Linux3.13中引入，刚开始引入多队列时是多队列和单队列并存。

想研究多队列，当然还是以原始patch的方式研究最靠谱了。

patch原始代码:

git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git

分支:linux-block/v3.10-blk-mq

首先过目一下多队列架构:

以读IO为例，单队列和多队列相同的执行路径：

  1. read_pages() 
  2. { 
  3. ... 
  4.   blk_start_plug() /* 进程准备蓄流 */ 
  5.   mapping->a_ops->readpages() /* 蓄流 */ 
  6.   blk_finish_plug() /* 进程开始泄流 */ 
  7.  ... 
  8. } 
  9. io_schedule() 进程蓄流之后等待io完成 
  10. (在blk_mq_make_request()函数中request的数目大于或者等于16 
  11. request_count >= BLK_MAX_REQUEST_COUNT 
  12. 不需要调用io_schedule(),直接泄流到块设备驱动) 

mapping->a_ops->readpages() 会一直调用q->make_request_fn()

  1. generic_make_request（） 
  2.     q->make_request_fn() 调用blk_queue_bio()或者 
  3.     多队列blk_queue_make_request() 
  4.       __elv_add_request() 

为什么引入多队列：多队列相对与单队列来说，每个cpu上都有一个软队列(使用blk_mq_ctx结构表示)避免插入request的时候使用spinlock锁，而且如今的高速存储设备，比如支持nvme的ssd(小弟刚买了一块，速度确实快),访问延迟非常小，而且本身硬件就支持多队列,(引入的多队列使用每个硬件队列hctx->delayed_work替换了request_queue->delay_work) 以前的单队列架构已经不能榨干它的性能，而且成为了它的累赘,单队列在插入request和泄流到块设备驱动时，一直有request_queue上的全局spinlock锁，搞得人们都想直接bypass块层的冲动。

单队列插入request时会使用request_queue上的全局spinlock锁

  1. blk_queue_bio() 
  2. { 
  3.     ... 
  4.     spin_lock_irq(q->queue_lock); 
  5.     elv_merge（） 
  6.     spin_lock_irq(q->queue_lock); 
  7.     ... 
  8. } 

单队列泄流到块设备驱动时也是使用request_queue上的全局spinlock锁:

  1. struct request_queue *blk_alloc_queue_node（） 
  2.   INIT_DELAYED_WORK(&q->delay_work, blk_delay_work); 
  3.  
  4. blk_delay_work() 
  5.   __blk_run_queue() 
  6.     q->request_fn(q); 

__blk_run_queue()函数必须在队列锁中，也就是spin_lock_irq(q->queue_lock);

  1. 281  * __blk_run_queue - run a single device queue 
  2.  282  * @q:  The queue to run 
  3.  283  * 
  4.  284  * Description: 
  5.  285  *    See @blk_run_queue. This variant must be called with the queue lock 
  6.  286  *    held and interrupts disabled. 
  7.  287  */      
  8.  288 void __blk_run_queue(struct request_queue *q) 
  9.  289 {        
  10.  290         if (unlikely(blk_queue_stopped(q))) 
  11.  291                 return; 
  12.  292  
  13.  293         __blk_run_queue_uncond(q); 
  14.  294 } 

多队列插入request时没有使用spinlock锁:

  1. blk_mq_insert_requests() 
  2.   __blk_mq_insert_request() 
  3.     struct blk_mq_ctx *ctx = rq->mq_ctx; (每cpu上的blk_mq_ctx) 
  4.     list_add_tail(&rq->queuelist, &ctx->rq_list) 

多队列泄流到块设备驱动也没有使用spinlock锁：

  1. static int blk_mq_init_hw_queues() 
  2.   INIT_DELAYED_WORK(&hctx->delayed_work, blk_mq_work_fn); 
  3.  
  4.  708 static void blk_mq_work_fn(struct work_struct *work) 
  5.  709 {                
  6.  710         struct blk_mq_hw_ctx *hctx; 
  7.  711                  
  8.  712         hctx = container_of(work, struct blk_mq_hw_ctx, delayed_work.work); 
  9.  713         __blk_mq_run_hw_queue(hctx); 
  10.  714 } 
  11.  
  12. __blk_mq_run_hw_queue()   
  13.     没有spinlock锁 
  14.   q->mq_ops->queue_rq(hctx, rq); 执行多队列上的->queue_rq()回调函数 

从下图可以看出系统使用多队列之后的性能提升:

(我自己没测试过性能，凭客观想象应该与下列图相符:) )

相关内容