cosmoslhf
cosmoslhf

linux io schedule: CFQ

   CFQ，即Completely Fair Queueing绝对公平调度器，力图为竞争块设备使用权的所有进程分配一个等同的时间片，在调度器分配给进程的时间片内，进程可以将其读写请求发送给底层块设备，当进程的时间片消耗完，进程的请求队列将被挂起，等待调度。相对于Noop和Deadline调度器，CFQ要复杂得多，因此可能要分几次才能将其分析完。

 

优先级

      每个进程都会有一个IO优先级，CFQ调度器将会将其作为考虑的因素之一，来确定该进程的请求队列何时可以获取块设备的使用权。IO优先级从高到低可以分为三大类:RT(real time),BE(best try),IDLE(idle),其中RT和BE又可以再划分为8个子优先级。实际上，我们已经知道CFQ调度器的公平是针对于进程而言的，而只有同步请求(read或syn write)才是针对进程而存在的，他们会放入进程自身的请求队列，而所有同优先级的异步请求，无论来自于哪个进程，都会被放入公共的队列，异步请求的队列总共有8(RT)+8(BE)+1(IDLE)=17个。

调度器的结构

      CFQ调度器在整个工作过程中所涉及到的结构比较多，我们可以把这些结构分为两类，一类是用来描述调度器本身相关的结构，由于CFQ将进程作为考虑对象，因此另一类结构就是特定于进程的结构，对于这些结构，我们只选择其内部的重要元素进行分析。和调度器相关的数据结构主要有两个，一个是描述调度器的struct cfq_data，一个是描述队列的struct cfq_queue。

 

struct cfq_data {
	struct request_queue *queue;

	/*
	 * rr list of queues with requests and the count of them
	 */
	struct cfq_rb_root service_tree;

	/*
	 * 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;

	int rq_in_driver[2];
	int sync_flight;

	/*
	 * queue-depth detection
	 */
	int rq_queued;
	int hw_tag;
	int hw_tag_samples;
	int rq_in_driver_peak;

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

	struct cfq_queue *active_queue;
	struct cfq_<strong style="color: black; background-color: rgb(160, 255, 255);">io</strong>_context *active_cic;

	/*
	 * async queue for each priority case
	 */
	struct cfq_queue *async_cfqq[2][IOPRIO_BE_NR];  
	struct cfq_queue *async_idle_cfqq;
	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_latency;

	struct list_head cic_list;

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

	unsigned long last_end_sync_rq;
};

queue:指向块设备对应的request_queue

service_tree:所有待调度的队列都被添加进该红黑树，等待调度获取时间片

prio_trees[CFQ_PRIO_LISTS]：对应8个优先级的红黑树，所有优先级类别为RT或BE的进程的同步请求队列，都会根据优先级添加至相应的红黑树

 busy_queues:用于计算service_tree中有多少个队列在等待调度

active_queue:指向当前占有块设备的队列

async_cfqq[2][IOPRIO_BE_NR]:对应RT和BE优先级类的16个异步请求队列

async_idle_cfqq:对应优先级类别为IDLE的异步请求队列

cfq_quantum：用于计算在一个队列的时间片内，最多发放多少个请求到底层的块设备

cfq_fifo_expire[2]：同步、异步请求的响应期限时间

cfq_slice[2]：同步、异步请求队列的时间片长度

 

struct cfq_queue {
	/* reference count */
	atomic_t ref;
	/* various state flags, see below */
	unsigned int flags;
	/* parent cfq_data */
	struct cfq_data *cfqd;
	/* service_tree member */
	struct rb_node rb_node;
	/* service_tree key */
	unsigned long rb_key;
	/* prio tree member */
	struct rb_node p_node;	
	/* prio tree root we belong to, if any */
	struct rb_root *p_root;
	/* sorted list of pending requests */
	struct rb_root sort_list; 
	/* if fifo isn't expired, next request to serve */
	struct request *next_rq;
	/* requests queued in sort_list */
	int queued[2];
	/* currently allocated requests */
	int allocated[2];
	/* fifo list of requests in sort_list */
	struct list_head fifo;	   

	unsigned long slice_end;
	long slice_resid;
	unsigned int slice_dispatch;

	/* pending metadata requests */
	int meta_pending;
	/* number of requests that are on the dispatch list or inside driver */
	int dispatched;

	/* <strong style="color: black; background-color: rgb(160, 255, 255);">io</strong> prio of this group */
	unsigned short ioprio, org_ioprio;
	unsigned short ioprio_class, org_ioprio_class;

	unsigned int seek_samples;
	u64 seek_total;
	sector_t seek_mean;
	sector_t last_request_pos;
	unsigned long seeky_start;

	pid_t pid;

	struct cfq_queue *new_cfqq;
};

cfqd:指向队列所属的cfq_data

rb_node:用于将队列插入service_tree

rb_key:红黑树节点关键值，用于确定队列在service_tree中的位置，该值要综合jiffies，进程的IO优先级等因素进行计算

p_node:用于将队列插入对应优先级的prio_tree

p_root:对应的prio_tree树根

sort_list:组织队列内的请求用的红黑树，按请求的起始扇区进行排序

fifo:组织队列内的请求用的链表头，按请求的响应期限排序

slice_end:指明时间片何时消耗完

slice_dispatch:在时间片内发送的请求数

ioprio:进程的当前IO优先级

 

相对于进程的结构有struct io_context和struct cfq_io_context。io_context的核心结构是一个基数树，里面组织了进程所访问的所有块设备所对应的cfq_io_context。cfq_io_context中的核心结构是两个队列，也就是进程在一个CFQ调度器所关系到的队列，一个是同步的，一个是异步的，下面是我根据自己的理解画的一张关系图:

linux io schedule: CFQ_第1张图片

 

这一节暂时就分析道这里了，后面再结合代码来分析CFQ调度器的具体实现

 

前文介绍了CFQ调度器的一些概念和结构之间的关系，这里再结合实际的代码，来分析CFQ的工作流程。CFQ调度器的定义如下：

[cpp] view plain copy print ?
  1. static struct elevator_type iosched_cfq = {
  2. .ops = {
  3. .elevator_merge_fn = cfq_merge,
  4. .elevator_merged_fn = cfq_merged_request,
  5. .elevator_merge_req_fn = cfq_merged_requests,
  6. .elevator_allow_merge_fn = cfq_allow_merge,
  7. .elevator_dispatch_fn = cfq_dispatch_requests,
  8. .elevator_add_req_fn = cfq_insert_request,
  9. .elevator_activate_req_fn = cfq_activate_request,
  10. .elevator_deactivate_req_fn = cfq_deactivate_request,
  11. .elevator_queue_empty_fn = cfq_queue_empty,
  12. .elevator_completed_req_fn = cfq_completed_request,
  13. .elevator_former_req_fn = elv_rb_former_request,
  14. .elevator_latter_req_fn = elv_rb_latter_request,
  15. .elevator_set_req_fn = cfq_set_request,
  16. .elevator_put_req_fn = cfq_put_request,
  17. .elevator_may_queue_fn = cfq_may_queue,
  18. .elevator_init_fn = cfq_init_queue,
  19. .elevator_exit_fn = cfq_exit_queue,
  20. .trim = cfq_free_io_context,
  21. },
  22. .elevator_attrs = cfq_attrs,
  23. .elevator_name = "cfq",
  24. .elevator_owner = THIS_MODULE,
  25. };
[cpp] view plain copy print ?
  1. static struct elevator_type iosched_cfq = {  
  2.     .ops = {  
  3.         .elevator_merge_fn =        cfq_merge,  
  4.         .elevator_merged_fn =       cfq_merged_request,  
  5.         .elevator_merge_req_fn =    cfq_merged_requests,  
  6.         .elevator_allow_merge_fn =  cfq_allow_merge,  
  7.         .elevator_dispatch_fn =     cfq_dispatch_requests,  
  8.         .elevator_add_req_fn =      cfq_insert_request,  
  9.         .elevator_activate_req_fn = cfq_activate_request,  
  10.         .elevator_deactivate_req_fn =   cfq_deactivate_request,  
  11.         .elevator_queue_empty_fn =  cfq_queue_empty,  
  12.         .elevator_completed_req_fn =    cfq_completed_request,  
  13.         .elevator_former_req_fn =   elv_rb_former_request,  
  14.         .elevator_latter_req_fn =   elv_rb_latter_request,  
  15.         .elevator_set_req_fn =      cfq_set_request,  
  16.         .elevator_put_req_fn =      cfq_put_request,  
  17.         .elevator_may_queue_fn =    cfq_may_queue,  
  18.         .elevator_init_fn =     cfq_init_queue,  
  19.         .elevator_exit_fn =     cfq_exit_queue,  
  20.         .trim =             cfq_free_io_context,  
  21.     },  
  22.     .elevator_attrs =   cfq_attrs,  
  23.     .elevator_name =    "cfq",  
  24.     .elevator_owner =   THIS_MODULE,  
  25. };  

 

可以看到CFQ调度器涉及到的操作函数还是比较多的，这里我只打算选一些和提交bio以及request相关的函数进行分析。在提交bio的时候，如果在通用层寻找可以合并bio的途径失败，要通过cfq_merge()来判断是否能够将bio插入到某个request的bio链表首部

[cpp] view plain copy print ?
  1. static struct request *
  2. cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)
  3. {
  4. struct task_struct *tsk = current;
  5. struct cfq_io_context *cic;
  6. struct cfq_queue *cfqq;
  8. //在进程的io_context中，找到进程特定于块设备的cfq_io_context
  9. cic = cfq_cic_lookup(cfqd, tsk->io_context);
  10. if (!cic)
  11. return NULL;
  13. //根据同步还是异步，确定cfq_queue
  14. cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));
  15. if (cfqq) {
  16. sector_t sector = bio->bi_sector + bio_sectors(bio);//得到末尾扇区号
  18. //从cfq_queue的红黑树中查找对应的节点
  19. return elv_rb_find(&cfqq->sort_list, sector);
  20. }
  22. return NULL;
  23. }
[cpp] view plain copy print ?
  1. static struct request *  
  2. cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)  
  3. {  
  4.     struct task_struct *tsk = current;  
  5.     struct cfq_io_context *cic;  
  6.     struct cfq_queue *cfqq;  
  7.   
  8.     //在进程的io_context中，找到进程特定于块设备的cfq_io_context  
  9.     cic = cfq_cic_lookup(cfqd, tsk->io_context);  
  10.     if (!cic)  
  11.         return NULL;  
  12.   
  13.     //根据同步还是异步，确定cfq_queue  
  14.     cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));  
  15.     if (cfqq) {  
  16.         sector_t sector = bio->bi_sector + bio_sectors(bio);//得到末尾扇区号  
  17.   
  18.         //从cfq_queue的红黑树中查找对应的节点  
  19.         return elv_rb_find(&cfqq->sort_list, sector);  
  20.     }  
  21.   
  22.     return NULL;  
  23. }  

 

cfq_find_rq_fmerge()进行实际的搜索工作，要确定bio的归属request，必须先确定进程的通信对象是谁(因为一个进程有可能和多个块设备通信)，也就是要找到进程对应的cfq_io_context结构，其中包含了进程的同步请求队列和异步请求队列的地址，只要找到了相应的cfq_io_context，就可以通过bio的同异步性确定对应的cfq_queue了，最后再判断对应的cfq_queue中是否存在可以容纳bio的request。推导cfq_io_context的关键在于以块设备CFQ调度器的描述结构cfq_data的地址为关键值，在进程的io_context的基数树中进行搜索

[html] view plain copy print ?
  1. <SPAN style="FONT-SIZE: 12px">static struct request *
  2. cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)
  3. {
  4. struct task_struct *tsk = current;
  5. struct cfq_io_context *cic;
  6. struct cfq_queue *cfqq;
  8. //在进程的io_context中，找到进程特定于块设备的cfq_io_context
  9. cic = cfq_cic_lookup(cfqd, tsk->io_context);
  10. if (!cic)
  11. return NULL;
  13. //根据同步还是异步，确定cfq_queue
  14. cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));
  15. if (cfqq) {
  16. sector_t sector = bio->bi_sector + bio_sectors(bio);//得到末尾扇区号
  18. //从cfq_queue的红黑树中查找对应的节点
  19. return elv_rb_find(&cfqq->sort_list, sector);
  20. }
  22. return NULL;
  23. }
  24. </SPAN>
[html] view plain copy print ?
  1. <span style="font-size: 12px;">static struct request *  
  2. cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)  
  3. {  
  4.     struct task_struct *tsk = current;  
  5.     struct cfq_io_context *cic;  
  6.     struct cfq_queue *cfqq;  
  7.   
  8.     //在进程的io_context中，找到进程特定于块设备的cfq_io_context  
  9.     cic = cfq_cic_lookup(cfqd, tsk->io_context);  
  10.     if (!cic)  
  11.         return NULL;  
  12.   
  13.     //根据同步还是异步，确定cfq_queue  
  14.     cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));  
  15.     if (cfqq) {  
  16.         sector_t sector = bio->bi_sector + bio_sectors(bio);//得到末尾扇区号  
  17.   
  18.         //从cfq_queue的红黑树中查找对应的节点  
  19.         return elv_rb_find(&cfqq->sort_list, sector);  
  20.     }  
  21.   
  22.     return NULL;  
  23. }  
  24. </span>  

 


通过基数树寻找对应设备的cfq_io_context:

[cpp] view plain copy print ?
  1. <SPAN style="FONT-SIZE: 12px">static struct cfq_io_context *
  2. cfq_cic_lookup(struct cfq_data *cfqd, struct io_context *ioc)
  3. {
  4. struct cfq_io_context *cic;
  5. unsigned long flags;
  6. void *k;
  8. if (unlikely(!ioc))
  9. return NULL;
  11. rcu_read_lock();
  13. /*
  14. * we maintain a last-hit cache, to avoid browsing over the tree
  15. */
  17. //由于进程很有可能连续访问同一块设备，因此先将cic中的关键值直接与cfqd比较
  18. cic = rcu_dereference(ioc->ioc_data);
  19. if (cic && cic->key == cfqd) {
  20. rcu_read_unlock();
  21. return cic;
  22. }
  24. do {//在进程io_context的基数树中寻找对应访问的块设备的cfq_data结构
  25. cic = radix_tree_lookup(&ioc->radix_root, (unsigned long) cfqd);
  26. rcu_read_unlock();
  27. if (!cic)
  28. break;
  29. /* ->key must be copied to avoid race with cfq_exit_queue() */
  30. k = cic->key;
  31. if (unlikely(!k)) {
  32. cfq_drop_dead_cic(cfqd, ioc, cic);
  33. rcu_read_lock();
  34. continue;
  35. }
  37. //保存cic到ioc->ioc_data
  38. spin_lock_irqsave(&ioc->lock, flags);
  39. rcu_assign_pointer(ioc->ioc_data, cic);
  40. spin_unlock_irqrestore(&ioc->lock, flags);
  41. break;
  42. } while (1);
  44. return cic;
  45. }</SPAN>
[cpp] view plain copy print ?
  1. <span style="font-size: 12px;">static struct cfq_io_context *  
  2. cfq_cic_lookup(struct cfq_data *cfqd, struct io_context *ioc)  
  3. {  
  4.     struct cfq_io_context *cic;  
  5.     unsigned long flags;  
  6.     void *k;  
  7.   
  8.     if (unlikely(!ioc))  
  9.         return NULL;  
  10.   
  11.     rcu_read_lock();  
  12.   
  13.     /* 
  14.      * we maintain a last-hit cache, to avoid browsing over the tree 
  15.      */  
  16.   
  17.     //由于进程很有可能连续访问同一块设备，因此先将cic中的关键值直接与cfqd比较  
  18.     cic = rcu_dereference(ioc->ioc_data);  
  19.     if (cic && cic->key == cfqd) {  
  20.         rcu_read_unlock();  
  21.         return cic;  
  22.     }  
  23.   
  24.     do {//在进程io_context的基数树中寻找对应访问的块设备的cfq_data结构  
  25.         cic = radix_tree_lookup(&ioc->radix_root, (unsigned long) cfqd);  
  26.         rcu_read_unlock();  
  27.         if (!cic)  
  28.             break;  
  29.         /* ->key must be copied to avoid race with cfq_exit_queue() */  
  30.         k = cic->key;  
  31.         if (unlikely(!k)) {  
  32.             cfq_drop_dead_cic(cfqd, ioc, cic);  
  33.             rcu_read_lock();  
  34.             continue;  
  35.         }  
  36.   
  37.         //保存cic到ioc->ioc_data  
  38.         spin_lock_irqsave(&ioc->lock, flags);  
  39.         rcu_assign_pointer(ioc->ioc_data, cic);  
  40.         spin_unlock_irqrestore(&ioc->lock, flags);  
  41.         break;  
  42.     } while (1);  
  43.   
  44.     return cic;  
  45. }</span>  

 

在通用层__make_request()函数中，如果bio找不到接收对象，那么就要重新创建一个request来接收它。分配一个request必须进行初始化，需要调用cfq_set_request()函数。和前面的过程比较类似的是，request要先找到接收它的cfq_queue，然后这里出现了一个问题，如果这个request是进程的第一个同步请求或者异步请求，那么就要分配新的cfq_queue来接收request。同步请求和异步请求的处理情况有点区别，因为进程独自拥有自己的同步请求队列，而进程的异步请求都是共享cfq_data中的异步请求队列的，所以只有当request是同步请求时才需要进行cfq_queue的分配

[cpp] view plain copy print ?
  1. static int
  2. cfq_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)
  3. {
  4. struct cfq_data *cfqd = q->elevator->elevator_data;
  5. struct cfq_io_context *cic;
  6. const int rw = rq_data_dir(rq);
  7. const bool is_sync = rq_is_sync(rq);
  8. struct cfq_queue *cfqq;
  9. unsigned long flags;
  11. might_sleep_if(gfp_mask & __GFP_WAIT);
  13. //获取进程特定于块设备的cfq_io_context结构
  14. cic = cfq_get_io_context(cfqd, gfp_mask);
  16. spin_lock_irqsave(q->queue_lock, flags);
  18. if (!cic)
  19. goto queue_fail;
  21. new_queue:
  22. cfqq = cic_to_cfqq(cic, is_sync);//根据同异步情况，获取进程中对应的cfq_queue
  23. if (!cfqq || cfqq == &cfqd->oom_cfqq) {//如果还没有相应的cfqq则进行分配
  24. cfqq = cfq_get_queue(cfqd, is_sync, cic->ioc, gfp_mask);//分配cfq_queue
  25. cic_set_cfqq(cic, cfqq, is_sync);//设置cic->cfqq[is_sync] = cfqq
  26. } else {
  27. /*
  28. * If the queue was seeky for too long, break it apart.
  29. */
  30. if (cfq_cfqq_coop(cfqq) && should_split_cfqq(cfqq)) {
  31. cfq_log_cfqq(cfqd, cfqq, "breaking apart cfqq");
  32. cfqq = split_cfqq(cic, cfqq);
  33. if (!cfqq)
  34. goto new_queue;
  35. }
  37. /*
  38. * Check to see if this queue is scheduled to merge with
  39. * another, closely cooperating queue. The merging of
  40. * queues happens here as it must be done in process context.
  41. * The reference on new_cfqq was taken in merge_cfqqs.
  42. */
  43. if (cfqq->new_cfqq)
  44. cfqq = cfq_merge_cfqqs(cfqd, cic, cfqq);
  45. }
  47. cfqq->allocated[rw]++;
  48. atomic_inc(&cfqq->ref);
  50. spin_unlock_irqrestore(q->queue_lock, flags);
  52. rq->elevator_private = cic;//保存cfq_io_context到request
  53. rq->elevator_private2 = cfqq;//保存cfq_queue到request
  54. return 0;
  56. queue_fail:
  57. if (cic)
  58. put_io_context(cic->ioc);
  60. cfq_schedule_dispatch(cfqd);
  61. spin_unlock_irqrestore(q->queue_lock, flags);
  62. cfq_log(cfqd, "set_request fail");
  63. return 1;
  64. }
[cpp] view plain copy print ?
  1. static int  
  2. cfq_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)  
  3. {  
  4.     struct cfq_data *cfqd = q->elevator->elevator_data;  
  5.     struct cfq_io_context *cic;  
  6.     const int rw = rq_data_dir(rq);  
  7.     const bool is_sync = rq_is_sync(rq);  
  8.     struct cfq_queue *cfqq;  
  9.     unsigned long flags;  
  10.   
  11.     might_sleep_if(gfp_mask & __GFP_WAIT);  
  12.   
  13.     //获取进程特定于块设备的cfq_io_context结构  
  14.     cic = cfq_get_io_context(cfqd, gfp_mask);  
  15.   
  16.     spin_lock_irqsave(q->queue_lock, flags);  
  17.   
  18.     if (!cic)  
  19.         goto queue_fail;  
  20.   
  21. new_queue:  
  22.     cfqq = cic_to_cfqq(cic, is_sync);//根据同异步情况，获取进程中对应的cfq_queue  
  23.     if (!cfqq || cfqq == &cfqd->oom_cfqq) {//如果还没有相应的cfqq则进行分配  
  24.         cfqq = cfq_get_queue(cfqd, is_sync, cic->ioc, gfp_mask);//分配cfq_queue  
  25.         cic_set_cfqq(cic, cfqq, is_sync);//设置cic->cfqq[is_sync] = cfqq  
  26.     } else {  
  27.         /* 
  28.          * If the queue was seeky for too long, break it apart. 
  29.          */  
  30.         if (cfq_cfqq_coop(cfqq) && should_split_cfqq(cfqq)) {  
  31.             cfq_log_cfqq(cfqd, cfqq, "breaking apart cfqq");  
  32.             cfqq = split_cfqq(cic, cfqq);  
  33.             if (!cfqq)  
  34.                 goto new_queue;  
  35.         }  
  36.   
  37.         /* 
  38.          * Check to see if this queue is scheduled to merge with 
  39.          * another, closely cooperating queue.  The merging of 
  40.          * queues happens here as it must be done in process context. 
  41.          * The reference on new_cfqq was taken in merge_cfqqs. 
  42.          */  
  43.         if (cfqq->new_cfqq)  
  44.             cfqq = cfq_merge_cfqqs(cfqd, cic, cfqq);  
  45.     }  
  46.   
  47.     cfqq->allocated[rw]++;  
  48.     atomic_inc(&cfqq->ref);  
  49.   
  50.     spin_unlock_irqrestore(q->queue_lock, flags);  
  51.   
  52.     rq->elevator_private = cic;//保存cfq_io_context到request  
  53.     rq->elevator_private2 = cfqq;//保存cfq_queue到request  
  54.     return 0;  
  55.   
  56. queue_fail:  
  57.     if (cic)  
  58.         put_io_context(cic->ioc);  
  59.   
  60.     cfq_schedule_dispatch(cfqd);  
  61.     spin_unlock_irqrestore(q->queue_lock, flags);  
  62.     cfq_log(cfqd, "set_request fail");  
  63.     return 1;  
  64. }  

 


当一个request创建初始化，就要将其插入到相应的队列中，cfq_insert_request()函数完成这个功能，和deadline调度器相似，request会被放入两个队列里，一个是按照起始扇区号排列的红黑树(sort_list)，一个是按响应期限排列的链表(fifo)

[cpp] view plain copy print ?
  1. static void cfq_insert_request(struct request_queue *q, struct request *rq)
  2. {
  3. struct cfq_data *cfqd = q->elevator->elevator_data;
  4. struct cfq_queue *cfqq = RQ_CFQQ(rq);
  6. cfq_log_cfqq(cfqd, cfqq, "insert_request");
  7. cfq_init_prio_data(cfqq, RQ_CIC(rq)->ioc);//根据ioc设定cfq_queue的优先级类和优先级
  9. cfq_add_rq_rb(rq);//将rq添加到cfq_queue的红黑树
  11. //设置期限值
  12. rq_set_fifo_time(rq, jiffies + cfqd->cfq_fifo_expire[rq_is_sync(rq)]);
  13. list_add_tail(&rq->queuelist, &cfqq->fifo);//添加至fifo
  15. cfq_rq_enqueued(cfqd, cfqq, rq);
  16. }
[cpp] view plain copy print ?
  1. static void cfq_insert_request(struct request_queue *q, struct request *rq)  
  2. {  
  3.     struct cfq_data *cfqd = q->elevator->elevator_data;  
  4.     struct cfq_queue *cfqq = RQ_CFQQ(rq);  
  5.   
  6.     cfq_log_cfqq(cfqd, cfqq, "insert_request");  
  7.     cfq_init_prio_data(cfqq, RQ_CIC(rq)->ioc);//根据ioc设定cfq_queue的优先级类和优先级  
  8.   
  9.     cfq_add_rq_rb(rq);//将rq添加到cfq_queue的红黑树  
  10.   
  11.     //设置期限值  
  12.     rq_set_fifo_time(rq, jiffies + cfqd->cfq_fifo_expire[rq_is_sync(rq)]);  
  13.     list_add_tail(&rq->queuelist, &cfqq->fifo);//添加至fifo  
  14.   
  15.     cfq_rq_enqueued(cfqd, cfqq, rq);  
  16. }  

 


当一个request纳入一个新的bio后，要考虑能否和其他request进行合并，假如是将bio插入到链表的末尾，那么就要在sort_list中获取request后面的一个request(通过函数elv_rb_latter_request()来获取)，然后判断前者的结束扇区和前者的起始扇区是否一样，这些工作都是再通用层代码中完成的，当两个request通过了通用层的审核和，并完成合并操作后，将调用cfq_merged_requests进行一些针对队列的额外工作

[cpp] view plain copy print ?
  1. tatic void
  2. cfq_merged_requests(struct request_queue *q, struct request *rq,
  3. struct request *next)
  4. {
  5. /*
  6. * reposition in fifo if next is older than rq
  7. */
  8. if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist) &&
  9. time_before(rq_fifo_time(next), rq_fifo_time(rq))) {
  10. list_move(&rq->queuelist, &next->queuelist);
  11. rq_set_fifo_time(rq, rq_fifo_time(next));
  12. }
  14. cfq_remove_request(next);
  15. }
[cpp] view plain copy print ?
  1. tatic void  
  2. cfq_merged_requests(struct request_queue *q, struct request *rq,  
  3.             struct request *next)  
  4. {  
  5.     /* 
  6.      * reposition in fifo if next is older than rq 
  7.      */  
  8.     if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist) &&  
  9.         time_before(rq_fifo_time(next), rq_fifo_time(rq))) {  
  10.         list_move(&rq->queuelist, &next->queuelist);  
  11.         rq_set_fifo_time(rq, rq_fifo_time(next));  
  12.     }  
  13.   
  14.     cfq_remove_request(next);  
  15. }  

 

这里主要是考察两个request的期限，因为合并时都是将后者合并入前者，因此当后者的期限时间小于前者时，要进行相应的调整，这一点和deadline调度器是一样的。

最后分析的依然是每个调度器最重要的函数--elevator_dispatch_fn

CFQ调度器在发送request到底层块设备时的流程大致如下：

1.选择一个cfq_queue

2.从cfq_queue中选择一个request进行发送

选择cfq_queue的思路如下：

1.如果当前的cfq_queue的时间片还没用完，则继续当前的cfq_queue

2.如果当前的cfq_queue的时间片消耗完了，则优先在对应的prio_tree中选择一个cfq_queue，该cfq_queue的第一个访问扇区与整个调度器最后处理的扇区之间的差值必须小于一个阈值，如果OK的话就选择这个cfq_queue

3.如果找不到这样的cfq_queue，再从service_tree中调度其他的cfq_queue

[cpp] view plain copy print ?
  1. <SPAN style="FONT-SIZE: 12px">static int cfq_dispatch_requests(struct request_queue *q, int force)
  2. {
  3. struct cfq_data *cfqd = q->elevator->elevator_data;
  4. struct cfq_queue *cfqq;
  6. if (!cfqd->busy_queues)
  7. return 0;
  9. if (unlikely(force))
  10. return cfq_forced_dispatch(cfqd);
  12. //先要选择一个队列
  13. cfqq = cfq_select_queue(cfqd);
  14. if (!cfqq)
  15. return 0;
  17. /*
  18. * Dispatch a request from this cfqq, if it is allowed
  19. */
  20. //从选择的cfq_queue中选择request进行分派
  21. if (!cfq_dispatch_request(cfqd, cfqq))
  22. return 0;
  24. cfqq->slice_dispatch++;
  25. cfq_clear_cfqq_must_dispatch(cfqq);
  27. /*
  28. * expire an async queue immediately if it has used up its slice. idle
  29. * queue always expire after 1 dispatch round.
  30. */
  31. /*如果service_tree中有其他队列等待调度，而刚刚发送请求的
  32. 队列是异步队列并且发送数已经超过了时间片的内最大请求数，
  33. 则将异步队列挂起，如果是idle队列则在发送一个请求后直接将队列挂起
  34. */
  35. if (cfqd->busy_queues > 1 && ((!cfq_cfqq_sync(cfqq) &&
  36. cfqq->slice_dispatch >= cfq_prio_to_maxrq(cfqd, cfqq)) ||
  37. cfq_class_idle(cfqq))) {
  38. cfqq->slice_end = jiffies + 1;
  39. cfq_slice_expired(cfqd, 0);
  40. }
  42. cfq_log_cfqq(cfqd, cfqq, "dispatched a request");
  43. return 1;
  44. }
  45. </SPAN>
[cpp] view plain copy print ?
  1. <span style="font-size: 12px;">static int cfq_dispatch_requests(struct request_queue *q, int force)  
  2. {  
  3.     struct cfq_data *cfqd = q->elevator->elevator_data;  
  4.     struct cfq_queue *cfqq;  
  5.   
  6.     if (!cfqd->busy_queues)  
  7.         return 0;  
  8.   
  9.     if (unlikely(force))  
  10.         return cfq_forced_dispatch(cfqd);  
  11.   
  12.     //先要选择一个队列  
  13.     cfqq = cfq_select_queue(cfqd);  
  14.     if (!cfqq)  
  15.         return 0;  
  16.   
  17.     /* 
  18.      * Dispatch a request from this cfqq, if it is allowed 
  19.      */  
  20.      //从选择的cfq_queue中选择request进行分派  
  21.     if (!cfq_dispatch_request(cfqd, cfqq))  
  22.         return 0;  
  23.   
  24.     cfqq->slice_dispatch++;  
  25.     cfq_clear_cfqq_must_dispatch(cfqq);  
  26.   
  27.     /* 
  28.      * expire an async queue immediately if it has used up its slice. idle 
  29.      * queue always expire after 1 dispatch round. 
  30.      */  
  31.      /*如果service_tree中有其他队列等待调度，而刚刚发送请求的 
  32.        队列是异步队列并且发送数已经超过了时间片的内最大请求数， 
  33.        则将异步队列挂起，如果是idle队列则在发送一个请求后直接将队列挂起 
  34.      */  
  35.     if (cfqd->busy_queues > 1 && ((!cfq_cfqq_sync(cfqq) &&  
  36.         cfqq->slice_dispatch >= cfq_prio_to_maxrq(cfqd, cfqq)) ||  
  37.         cfq_class_idle(cfqq))) {  
  38.         cfqq->slice_end = jiffies + 1;  
  39.         cfq_slice_expired(cfqd, 0);  
  40.     }  
  41.   
  42.     cfq_log_cfqq(cfqd, cfqq, "dispatched a request");  
  43.     return 1;  
  44. }  
  45. </span>  

 


cfq_select_queue()用来选择一个队列，active_queue为当前运行的队列

[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_select_queue(struct cfq_data *cfqd)
  2. {
  3. struct cfq_queue *cfqq, *new_cfqq = NULL;
  5. /*先检查active_queue*/
  6. cfqq = cfqd->active_queue;
  7. if (!cfqq)//没有指定active_queue则跳转到new_queue去选择新的队列
  8. goto new_queue;
  10. /*
  11. * The active queue has run out of time, expire it and select new.
  12. */
  13. //指定了active_queue,这里检查该队列的时间片是否已经过去
  14. if (cfq_slice_used(cfqq) && !cfq_cfqq_must_dispatch(cfqq))
  15. goto expire;
  17. /*
  18. * The active queue has requests and isn't expired, allow it to
  19. * dispatch.
  20. */
  21. /*走到这里表示时间片尚在，这里检查cfq_queue的sort_list是否为空*/
  22. if (!RB_EMPTY_ROOT(&cfqq->sort_list))
  23. goto keep_queue;
  25. /*
  26. * If another queue has a request waiting within our mean seek
  27. * distance, let it run. The expire code will check for close
  28. * cooperators and put the close queue at the front of the service
  29. * tree. If possible, merge the expiring queue with the new cfqq.
  30. */
  31. //走到这里表示active_queue内已经没有请求了，因此要找一个最适合的cfq_queue
  32. new_cfqq = cfq_close_cooperator(cfqd, cfqq);
  33. if (new_cfqq) {
  34. if (!cfqq->new_cfqq)
  35. cfq_setup_merge(cfqq, new_cfqq);
  36. goto expire;
  37. }
  39. /*
  40. * No requests pending. If the active queue still has requests in
  41. * flight or is idling for a new request, allow either of these
  42. * conditions to happen (or time out) before selecting a new queue.
  43. */
  44. if (timer_pending(&cfqd->idle_slice_timer) ||
  45. (cfqq->dispatched && cfq_cfqq_idle_window(cfqq))) {
  46. cfqq = NULL;
  47. goto keep_queue;
  48. }
  50. expire:
  51. cfq_slice_expired(cfqd, 0);//将时间片消耗完的active_queue重新插入service_tree
  52. new_queue:
  53. cfqq = cfq_set_active_queue(cfqd, new_cfqq);//设定new_cfqq为新的active_tree接收时间片
  54. keep_queue:
  55. return cfqq;
  56. }
[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_select_queue(struct cfq_data *cfqd)  
  2. {  
  3.     struct cfq_queue *cfqq, *new_cfqq = NULL;  
  4.   
  5.     /*先检查active_queue*/  
  6.     cfqq = cfqd->active_queue;  
  7.     if (!cfqq)//没有指定active_queue则跳转到new_queue去选择新的队列  
  8.         goto new_queue;  
  9.   
  10.     /* 
  11.      * The active queue has run out of time, expire it and select new. 
  12.      */  
  13.      //指定了active_queue,这里检查该队列的时间片是否已经过去  
  14.     if (cfq_slice_used(cfqq) && !cfq_cfqq_must_dispatch(cfqq))  
  15.         goto expire;  
  16.   
  17.     /* 
  18.      * The active queue has requests and isn't expired, allow it to 
  19.      * dispatch. 
  20.      */  
  21.      /*走到这里表示时间片尚在，这里检查cfq_queue的sort_list是否为空*/  
  22.     if (!RB_EMPTY_ROOT(&cfqq->sort_list))  
  23.         goto keep_queue;  
  24.   
  25.     /* 
  26.      * If another queue has a request waiting within our mean seek 
  27.      * distance, let it run.  The expire code will check for close 
  28.      * cooperators and put the close queue at the front of the service 
  29.      * tree.  If possible, merge the expiring queue with the new cfqq. 
  30.      */  
  31.      //走到这里表示active_queue内已经没有请求了，因此要找一个最适合的cfq_queue  
  32.     new_cfqq = cfq_close_cooperator(cfqd, cfqq);  
  33.     if (new_cfqq) {  
  34.         if (!cfqq->new_cfqq)  
  35.             cfq_setup_merge(cfqq, new_cfqq);  
  36.         goto expire;  
  37.     }  
  38.   
  39.     /* 
  40.      * No requests pending. If the active queue still has requests in 
  41.      * flight or is idling for a new request, allow either of these 
  42.      * conditions to happen (or time out) before selecting a new queue. 
  43.      */  
  44.     if (timer_pending(&cfqd->idle_slice_timer) ||  
  45.         (cfqq->dispatched && cfq_cfqq_idle_window(cfqq))) {  
  46.         cfqq = NULL;  
  47.         goto keep_queue;  
  48.     }  
  49.   
  50. expire:  
  51.     cfq_slice_expired(cfqd, 0);//将时间片消耗完的active_queue重新插入service_tree  
  52. new_queue:  
  53.     cfqq = cfq_set_active_queue(cfqd, new_cfqq);//设定new_cfqq为新的active_tree接收时间片  
  54. keep_queue:  
  55.     return cfqq;  
  56. }  

 

cfq_close_cooperator查找一个在扇区地址上满足要求的队列，这个操作只对同步请求队列有效

[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_close_cooperator(struct cfq_data *cfqd,
  2. struct cfq_queue *cur_cfqq)
  3. {
  4. struct cfq_queue *cfqq;
  6. if (!cfq_cfqq_sync(cur_cfqq))
  7. return NULL;
  8. if (CFQQ_SEEKY(cur_cfqq))
  9. return NULL;
  11. /*
  12. * We should notice if some of the queues are cooperating, eg
  13. * working closely on the same area of the disk. In that case,
  14. * we can group them together and don't waste time idling.
  15. */
  16. //根据扇区的差值，寻找一个最接近的节点
  17. cfqq = cfqq_close(cfqd, cur_cfqq);
  18. if (!cfqq)
  19. return NULL;
  21. /*
  22. * It only makes sense to merge sync queues.
  23. */
  24. if (!cfq_cfqq_sync(cfqq))
  25. return NULL;
  26. if (CFQQ_SEEKY(cfqq))
  27. return NULL;
  29. return cfqq;
  30. }
[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_close_cooperator(struct cfq_data *cfqd,  
  2.                           struct cfq_queue *cur_cfqq)  
  3. {  
  4.     struct cfq_queue *cfqq;  
  5.   
  6.     if (!cfq_cfqq_sync(cur_cfqq))  
  7.         return NULL;  
  8.     if (CFQQ_SEEKY(cur_cfqq))  
  9.         return NULL;  
  10.   
  11.     /* 
  12.      * We should notice if some of the queues are cooperating, eg 
  13.      * working closely on the same area of the disk. In that case, 
  14.      * we can group them together and don't waste time idling. 
  15.      */  
  16.      //根据扇区的差值，寻找一个最接近的节点  
  17.     cfqq = cfqq_close(cfqd, cur_cfqq);  
  18.     if (!cfqq)  
  19.         return NULL;  
  20.   
  21.     /* 
  22.      * It only makes sense to merge sync queues. 
  23.      */  
  24.     if (!cfq_cfqq_sync(cfqq))  
  25.         return NULL;  
  26.     if (CFQQ_SEEKY(cfqq))  
  27.         return NULL;  
  28.   
  29.     return cfqq;  
  30. }  

 

cfqq_close执行实际的工作

[cpp] view plain copy print ?
  1. static struct cfq_queue *cfqq_close(struct cfq_data *cfqd,
  2. struct cfq_queue *cur_cfqq)
  3. {
  4. struct rb_root *root = &cfqd->prio_trees[cur_cfqq->org_ioprio];
  5. struct rb_node *parent, *node;
  6. struct cfq_queue *__cfqq;
  7. sector_t sector = cfqd->last_position;//这里区最后访问的扇区
  9. if (RB_EMPTY_ROOT(root))
  10. return NULL;
  12. /*
  13. * First, if we find a request starting at the end of the last
  14. * request, choose it.
  15. */
  16. //首先试图在同优先级的红黑树中寻找与最近访问的扇区相接的另一个cfq_queue
  17. __cfqq = cfq_prio_tree_lookup(cfqd, root, sector, &parent, NULL);
  18. if (__cfqq)//如果找到了的话则选定该cfq_queue进行调度
  19. return __cfqq;
  21. /*
  22. * If the exact sector wasn't found, the parent of the NULL leaf
  23. * will contain the closest sector.
  24. */
  25. //parent保存了最接近的节点的父节点，如果没找到相邻的cfq_queue，获取父节点对应的cfq_queue
  26. __cfqq = rb_entry(parent, struct cfq_queue, p_node);
  28. /*如果__cfqq的下一个派送请求(next_rq指定)的扇区地址和调度器最后派送的请求的结束扇区之间的间隙满足要求，
  29. 则选定该cfq_queue*/
  30. if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))
  31. return __cfqq;
  33. /* 前面都不成功，则根据next_rq和sector的大小关系，
  34. 来选择最接近的比__cfqq的起始扇区大的节点或者小的节点*/
  35. if (blk_rq_pos(__cfqq->next_rq) < sector)
  36. node = rb_next(&__cfqq->p_node);
  37. else
  38. node = rb_prev(&__cfqq->p_node);
  39. if (!node)
  40. return NULL;
  42. //这里再把选择的节点进行一次间隙的判断，如果间隙小于阈值，则选择该节点，否则返回NULL
  43. __cfqq = rb_entry(node, struct cfq_queue, p_node);
  44. if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))
  45. return __cfqq;
  47. return NULL;
  48. }
[cpp] view plain copy print ?
  1. static struct cfq_queue *cfqq_close(struct cfq_data *cfqd,  
  2.                     struct cfq_queue *cur_cfqq)  
  3. {  
  4.     struct rb_root *root = &cfqd->prio_trees[cur_cfqq->org_ioprio];  
  5.     struct rb_node *parent, *node;  
  6.     struct cfq_queue *__cfqq;  
  7.     sector_t sector = cfqd->last_position;//这里区最后访问的扇区  
  8.   
  9.     if (RB_EMPTY_ROOT(root))  
  10.         return NULL;  
  11.   
  12.     /* 
  13.      * First, if we find a request starting at the end of the last 
  14.      * request, choose it. 
  15.      */  
  16.      //首先试图在同优先级的红黑树中寻找与最近访问的扇区相接的另一个cfq_queue  
  17.     __cfqq = cfq_prio_tree_lookup(cfqd, root, sector, &parent, NULL);  
  18.     if (__cfqq)//如果找到了的话则选定该cfq_queue进行调度  
  19.         return __cfqq;  
  20.   
  21.     /* 
  22.      * If the exact sector wasn't found, the parent of the NULL leaf 
  23.      * will contain the closest sector. 
  24.      */  
  25.      //parent保存了最接近的节点的父节点，如果没找到相邻的cfq_queue，获取父节点对应的cfq_queue  
  26.     __cfqq = rb_entry(parent, struct cfq_queue, p_node);  
  27.       
  28.     /*如果__cfqq的下一个派送请求(next_rq指定)的扇区地址和调度器最后派送的请求的结束扇区之间的间隙满足要求， 
  29.       则选定该cfq_queue*/  
  30.     if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))  
  31.         return __cfqq;  
  32.   
  33.     /* 前面都不成功，则根据next_rq和sector的大小关系， 
  34.        来选择最接近的比__cfqq的起始扇区大的节点或者小的节点*/  
  35.     if (blk_rq_pos(__cfqq->next_rq) < sector)  
  36.         node = rb_next(&__cfqq->p_node);  
  37.     else  
  38.         node = rb_prev(&__cfqq->p_node);  
  39.     if (!node)  
  40.         return NULL;  
  41.   
  42.     //这里再把选择的节点进行一次间隙的判断，如果间隙小于阈值，则选择该节点，否则返回NULL  
  43.     __cfqq = rb_entry(node, struct cfq_queue, p_node);  
  44.     if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))  
  45.         return __cfqq;  
  46.   
  47.     return NULL;  
  48. }  

 

如果找到了这样的队列，则在cfq_set_active_queue()函数中设定该队列为运行队列，否则就从service_tree中调度时间点最邻近的队列

[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_set_active_queue(struct cfq_data *cfqd,
  2. struct cfq_queue *cfqq)
  3. {
  4. if (!cfqq)//假如没指定cfqq，则从service_tree中最前的节点
  5. cfqq = cfq_get_next_queue(cfqd);
  7. __cfq_set_active_queue(cfqd, cfqq);//设定active_queue为cfqq
  8. return cfqq;
  9. }
[cpp] view plain copy print ?
  1. static struct cfq_queue *cfq_set_active_queue(struct cfq_data *cfqd,  
  2.                           struct cfq_queue *cfqq)  
  3. {  
  4.     if (!cfqq)//假如没指定cfqq，则从service_tree中最前的节点  
  5.         cfqq = cfq_get_next_queue(cfqd);  
  6.   
  7.     __cfq_set_active_queue(cfqd, cfqq);//设定active_queue为cfqq  
  8.     return cfqq;  
  9. }  

 

队列选择完毕，下面要通过cfq_dispatch_request()函数在队列中选择合适的request进行发送

[cpp] view plain copy print ?
  1. static bool cfq_dispatch_request(struct cfq_data *cfqd, struct cfq_queue *cfqq)
  2. {
  3. struct request *rq;
  5. BUG_ON(RB_EMPTY_ROOT(&cfqq->sort_list));
  7. //先判断是否确定发放cfqq里的请求
  8. if (!cfq_may_dispatch(cfqd, cfqq))
  9. return false;
  11. /*
  12. * follow expired path, else get first next available
  13. */
  14. /*这里先检查fifo中的请求，如果fifo为空或者fifo中第一个请求的期限还没到，则不会获取到request*/
  15. rq = cfq_check_fifo(cfqq);
  16. if (!rq)//如果fifo中获取rq失败，则考虑备选的next_rq，next_rq总是从扇区的连续性上考虑的
  17. rq = cfqq->next_rq;
  19. /*
  20. * insert request into driver dispatch list
  21. */
  22. cfq_dispatch_insert(cfqd->queue, rq);//将rq插入到设备的请求队列
  24. if (!cfqd->active_cic) {
  25. struct cfq_io_context *cic = RQ_CIC(rq);
  27. atomic_long_inc(&cic->ioc->refcount);
  28. cfqd->active_cic = cic;
  29. }
  31. return true;
  32. }
[cpp] view plain copy print ?
  1. static bool cfq_dispatch_request(struct cfq_data *cfqd, struct cfq_queue *cfqq)  
  2. {  
  3.     struct request *rq;  
  4.   
  5.     BUG_ON(RB_EMPTY_ROOT(&cfqq->sort_list));  
  6.   
  7.     //先判断是否确定发放cfqq里的请求  
  8.     if (!cfq_may_dispatch(cfqd, cfqq))  
  9.         return false;  
  10.   
  11.     /* 
  12.      * follow expired path, else get first next available 
  13.      */  
  14.      /*这里先检查fifo中的请求，如果fifo为空或者fifo中第一个请求的期限还没到，则不会获取到request*/  
  15.     rq = cfq_check_fifo(cfqq);  
  16.     if (!rq)//如果fifo中获取rq失败，则考虑备选的next_rq，next_rq总是从扇区的连续性上考虑的  
  17.         rq = cfqq->next_rq;  
  18.   
  19.     /* 
  20.      * insert request into driver dispatch list 
  21.      */  
  22.     cfq_dispatch_insert(cfqd->queue, rq);//将rq插入到设备的请求队列  
  23.   
  24.     if (!cfqd->active_cic) {  
  25.         struct cfq_io_context *cic = RQ_CIC(rq);  
  26.   
  27.         atomic_long_inc(&cic->ioc->refcount);  
  28.         cfqd->active_cic = cic;  
  29.     }  
  30.   
  31.     return true;  
  32. }  

 

在发送具体的request之前，先要确定是否适合为该队列发放请求，主要是判断队列在时间片内发送的请求数有没有超额

[cpp] view plain copy print ?
  1. static bool cfq_may_dispatch(struct cfq_data *cfqd, struct cfq_queue *cfqq)
  2. {
  3. unsigned int max_dispatch;
  5. /*
  6. * Drain async requests before we start sync IO
  7. */
  8. //如果cfqq可以被idle并且设备有异步请求处理，则不进行新的同步请求的发放
  9. if (cfq_cfqq_idle_window(cfqq) && cfqd->rq_in_driver[BLK_RW_ASYNC])
  10. return false;
  12. /*
  13. * If this is an async queue and we have sync IO in flight, let it wait
  14. */
  15. //如果发放的是异步请求并且request_queue中还有同步请求在等待提交，则不方法
  16. if (cfqd->sync_flight && !cfq_cfqq_sync(cfqq))
  17. return false;
  18. //默认max_dispatch为预定的cfq_quantum,也就是说cfqq在时间片内最多dispatch
  19. //cfq_quantum个请求
  20. max_dispatch = cfqd->cfq_quantum;
  22. //如果cfqq的优先级类为idle，则在时间片内只能dispatch一个请求
  23. if (cfq_class_idle(cfqq))
  24. max_dispatch = 1;
  26. /*
  27. * Does this cfqq already have too much IO in flight?
  28. */
  29. //如果队列发放下去的请求数超额
  30. if (cfqq->dispatched >= max_dispatch) {
  31. /*
  32. * idle queue must always only have a single IO in flight
  33. */
  34. if (cfq_class_idle(cfqq))//如果是idle优先级，则不能进行发放
  35. return false;
  37. /*
  38. * We have other queues, don't allow more IO from this one
  39. */
  40. if (cfqd->busy_queues > 1)//如果有其他的队列在等待发放请求，则不进行发放
  41. return false;
  43. /*
  44. * Sole queue user, allow bigger slice
  45. */
  46. //如果service_tree中只有该队列，且优先级高于idle，则扩宽max_dispatch的限制
  47. max_dispatch *= 4;
  48. }
  50. /*
  51. * Async queues must wait a bit before being allowed dispatch.
  52. * We also ramp up the dispatch depth gradually for async IO,
  53. * based on the last sync IO we serviced
  54. */
  55. /*下面根据最后一次发送的同步请求和现在的时间间隔以及同步请求时间片的值，计算出
  56. depth，根据depth重置max_dispatch，这里的意图应该是在从同步请求的发送转为
  57. 异步请求的发送时，延迟一下异步请求的发送*/
  58. if (!cfq_cfqq_sync(cfqq) && cfqd->cfq_latency) {
  59. unsigned long last_sync = jiffies - cfqd->last_end_sync_rq;
  60. unsigned int depth;
  62. depth = last_sync / cfqd->cfq_slice[1];
  63. if (!depth && !cfqq->dispatched)
  64. depth = 1;
  65. if (depth < max_dispatch)
  66. max_dispatch = depth;
  67. }
  69. /*
  70. * If we're below the current max, allow a dispatch
  71. */
  72. return cfqq->dispatched < max_dispatch;
  73. }
[cpp] view plain copy print ?
  1. static bool cfq_may_dispatch(struct cfq_data *cfqd, struct cfq_queue *cfqq)  
  2. {  
  3.     unsigned int max_dispatch;  
  4.   
  5.     /* 
  6.      * Drain async requests before we start sync IO 
  7.      */  
  8.      //如果cfqq可以被idle并且设备有异步请求处理，则不进行新的同步请求的发放  
  9.     if (cfq_cfqq_idle_window(cfqq) && cfqd->rq_in_driver[BLK_RW_ASYNC])  
  10.         return false;  
  11.   
  12.     /* 
  13.      * If this is an async queue and we have sync IO in flight, let it wait 
  14.      */  
  15.      //如果发放的是异步请求并且request_queue中还有同步请求在等待提交，则不方法  
  16.     if (cfqd->sync_flight && !cfq_cfqq_sync(cfqq))  
  17.         return false;  
  18.     //默认max_dispatch为预定的cfq_quantum,也就是说cfqq在时间片内最多dispatch  
  19.     //cfq_quantum个请求  
  20.     max_dispatch = cfqd->cfq_quantum;  
  21.   
  22.     //如果cfqq的优先级类为idle，则在时间片内只能dispatch一个请求  
  23.     if (cfq_class_idle(cfqq))  
  24.         max_dispatch = 1;  
  25.   
  26.     /* 
  27.      * Does this cfqq already have too much IO in flight? 
  28.      */  
  29.      //如果队列发放下去的请求数超额  
  30.     if (cfqq->dispatched >= max_dispatch) {  
  31.         /* 
  32.          * idle queue must always only have a single IO in flight 
  33.          */  
  34.         if (cfq_class_idle(cfqq))//如果是idle优先级，则不能进行发放  
  35.             return false;  
  36.   
  37.         /* 
  38.          * We have other queues, don't allow more IO from this one 
  39.          */  
  40.         if (cfqd->busy_queues > 1)//如果有其他的队列在等待发放请求，则不进行发放  
  41.             return false;  
  42.   
  43.         /* 
  44.          * Sole queue user, allow bigger slice 
  45.          */  
  46.          //如果service_tree中只有该队列，且优先级高于idle，则扩宽max_dispatch的限制  
  47.         max_dispatch *= 4;  
  48.     }  
  49.   
  50.     /* 
  51.      * Async queues must wait a bit before being allowed dispatch. 
  52.      * We also ramp up the dispatch depth gradually for async IO, 
  53.      * based on the last sync IO we serviced 
  54.      */  
  55.      /*下面根据最后一次发送的同步请求和现在的时间间隔以及同步请求时间片的值，计算出 
  56.        depth，根据depth重置max_dispatch，这里的意图应该是在从同步请求的发送转为 
  57.        异步请求的发送时，延迟一下异步请求的发送*/  
  58.     if (!cfq_cfqq_sync(cfqq) && cfqd->cfq_latency) {  
  59.         unsigned long last_sync = jiffies - cfqd->last_end_sync_rq;  
  60.         unsigned int depth;  
  61.   
  62.         depth = last_sync / cfqd->cfq_slice[1];  
  63.         if (!depth && !cfqq->dispatched)  
  64.             depth = 1;  
  65.         if (depth < max_dispatch)  
  66.             max_dispatch = depth;  
  67.     }  
  68.   
  69.     /* 
  70.      * If we're below the current max, allow a dispatch 
  71.      */  
  72.     return cfqq->dispatched < max_dispatch;  
  73. }  

 


通过检查后，则要正式开始选择request，选择的原则是：如果fifo中的第一个请求期限已到，则选择该请求，否则选择next_rq指针指定的请求，该指针指向的请求总是从物理扇区的连续性上考虑的。最后调用cfq_dispatch_insert()函数将request插入到request_queue中去，等待块设备的响应

[cpp] view plain copy print ?
  1. static void cfq_dispatch_insert(struct request_queue *q, struct request *rq)
  2. {
  3. struct cfq_data *cfqd = q->elevator->elevator_data;
  4. struct cfq_queue *cfqq = RQ_CFQQ(rq);
  6. cfq_log_cfqq(cfqd, cfqq, "dispatch_insert");
  8. cfqq->next_rq = cfq_find_next_rq(cfqd, cfqq, rq);//选择一个扇区间隙最近的请求赋给next_rq作为下一个请求的备选
  9. cfq_remove_request(rq);//将rq从sort_list和fifo中移除
  10. cfqq->dispatched++;
  11. elv_dispatch_sort(q, rq);//将rq分派到request queue的请求队列等候响应
  13. if (cfq_cfqq_sync(cfqq))
  14. cfqd->sync_flight++;
  15. }

 

你可能感兴趣的:(linux io schedule: CFQ)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • EIO国际确定性的交易（3/10）资管 ， 资金委托安全吗？ 古城鹏哥
    大家可能都知道资金托管，账户是自己开，钱在自己的账户上，密码是由自己掌控，别人提不走你账户的资金，每天可以看下到自己的账户，也可以看到交易流水。现金只能提到自己的银行卡中。账户由技术人员或操作人员，或者是机构团队帮你操作账户，产生盈利和收入，以获得的利润来分配盈利，技术强硬和做的时间久了过硬技术团队，会保证你的资金本金，不会让你的本金亏损的按照一定比例分配收入。所以在这个过程当中一定要看清楚技术的
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • jQuery 键盘事件keydown ,keypress ,keyup介绍 107x jsjquerykeydownkeypresskeyup
    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码 $('input').keyup(funciton(){      
  • AngularJS中的Promise bijian1013 JavaScriptAngularJSPromise
    一.Promise         Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。         为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
  • c++ 用数组实现栈类 CrazyMizzz 数据结构C++
    #include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
  • java和c语言的雷同 麦田的设计者 java递归scaner
    软件启动时的初始化代码，加载用户信息2015年5月27号 从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：      a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 不会再继续执行。      b、for循环相比于whi
  • LINUX环境并发服务器的三种实现模型 被触发 linux
    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1  循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
  • Oracle数据库查询指令 肆无忌惮_ oracle数据库
    20140920   单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录   -- 查看emp表   desc emp  
  • ext右下角浮动窗口 知了ing JavaScriptext
    第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
  • 浅谈REDIS数据库的键值设计 矮蛋蛋 redis
    http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
  • maven编译可执行jar包 alleni123 maven
    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
  • 人力资源在现代企业中的作用 百合不是茶 HR 企业管理
    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
  • Linux自启动设置详解 bijian1013 linux
    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 阅读之前建议先看一下附图。 本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
  • Spring Aop Schema实现 bijian1013 javaspringAOP
    本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
  • 【Gson七】Gson预定义类型适配器 bit1129 gson
    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，   DateTypeAdapter   public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。   Spark Streaming的解决方案是累加器，工作原理是，定义
  • linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 幸运的是systemtap的安装包里带了inodewatch.stp，位
  • java-两种方法求第一个最长的可重复子串 bylijinnan java算法
    import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
  • Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan javanetty
    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 文章里面提到的操作，每一步都能在Netty里面找到对应的代码 其中Reactor里面的Acceptor就对应Netty的ServerBo
  • servelt filter listener 的生命周期 cngolon filterlistenerservelt生命周期
    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
  • jmpopups获取input元素值 ctrain JavaScript
    jmpopups 获取弹出层form表单 首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 我们必须到jmpopups生成的代码中去查找这个值，$(
  • vi查找替换命令详解 daizj linux正则表达式替换查找vim
    一、查找 查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串 使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找 字符串匹配 pattern是需要匹配的字符串，例如： 1:  /abc<En
  • 对网站中的js,css文件进行打包 dcj3sjt126com PHP打包
    一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
  • php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
    在开发Yii 时，在程序中定义了如下方式：        if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
  • linux 文件格式（1） sed工具 eksliang linuxlinux sed工具sed工具linux sed详解
    转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介       sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
  • Android应用程序获取系统权限 gqdy365 android
    引用 如何使Android应用程序获取系统权限         第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：         1. 在应用程序的AndroidManifest.xml中的manifest节点
  • HoverTree开发日志之验证码 hvt .netC#asp.nethovertreewebform
    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
  • JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
    译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 基于 JSON API 的客户端还能够充分利用缓存，
  • 数据结构随记_2 lx.asymmetric 数据结构笔记
    第三章 栈与队列 一．简答题 1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  3. 向栈中压入元素的操作是先  移动栈顶指针&n
  • Linux下的监控工具dstat 网络接口 linux
    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
  • C 语言初级入门--二维数组和指针 1140566087 二维数组c/c++指针
    /* 二维数组的定义和二维数组元素的引用 二维数组的定义： 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法： 类型名 数组名[常量表达式1][常量表达式2] 二维数组的引用： 引用二维数组元素时必须带有两个下标，引用形式如下： 例如： int a[3][4];  引用：
  • 10点睛Spring4.1-Application Event wiselyman application
    10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段 应按照如下部分实现bean之间的消息通讯 继承ApplicationEvent类实现自己的事件 实现继承ApplicationListener接口实现监听事件 使用ApplicationContext发布消息
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他