blk-mq/scsi: tracking device queue depth via sbitmap
Subsystems (9)
v7 cover blk-mq/scsi: tracking device queue depth via sbitmap
Hi,
scsi uses one global atomic variable to track queue depth for each LUN/request queue. This way can't scale well when there is lots of CPU cores and the disk is very fast. Broadcom guys has complained that their high end HBA can't reach top performance because .device_busy is operated in IO path.
Replace the atomic variable sdev->device_busy with sbitmap for tracking scsi device queue depth.
Test on scsi_debug shows this way improve IOPS > 20%. Meantime the IOPS difference is just ~1% compared with bypassing .device_busy on scsi_debug via patches[1]
The 1st 6 patches moves percpu allocation hint into sbitmap, since the improvement by doing percpu allocation hint on sbitmap is observable. Meantime export helpers for SCSI.
Patch 7 and 8 prepares for the conversion by returning budget token from .get_budget callback, meantime passes the budget token to driver via 'struct blk_mq_queue_data' in .queue_rq().
The last four patches changes SCSI for switching to track device queue depth via sbitmap.
The patchset have been tested by Broadcom, and obvious performance boost can be observed on megaraid_sas.
V7:
- fix build failure on drivers/vhost/scsi.c, only patch 2 & 4 are changed
V6:
- rebase on for-5.12/block
V5:
- add comment on sbitmap_weight()
- add patch 'megaraid_sas: v2 replace sdev_busy with local counter' for fixing build failure
V4:
- limit max sdev->queue_depth as max(1024, shost->can_queue)
- simplify code for moving per-cpu allocation hint into sbitmap
V3:
- rebase on both for-5.10/block and 5.10/scsi-queue.
V2:
- fix one build failure
Kashyap Desai (1):
megaraid_sas: v2 replace sdev_busy with local counter
Ming Lei (12):
sbitmap: remove sbitmap_clear_bit_unlock
sbitmap: maintain allocation round_robin in sbitmap
sbitmap: add helpers for updating allocation hint
sbitmap: move allocation hint into sbitmap
sbitmap: export sbitmap_weight
sbitmap: add helper of sbitmap_calculate_shift
blk-mq: add callbacks for storing & retrieving budget token
blk-mq: return budget token from .get_budget callback
scsi: put hot fields of scsi_host_template into one cacheline
scsi: add scsi_device_busy() to read sdev->device_busy
scsi: make sure sdev->queue_depth is <= max(shost->can_queue, 1024)
scsi: replace sdev->device_busy with sbitmap
block/blk-mq-sched.c | 17 +- block/blk-mq.c | 38 ++-- block/blk-mq.h | 25 ++- block/kyber-iosched.c | 3 +- drivers/message/fusion/mptsas.c | 2 +- drivers/scsi/megaraid/megaraid_sas.h | 2 + drivers/scsi/megaraid/megaraid_sas_fusion.c | 48 ++++- drivers/scsi/mpt3sas/mpt3sas_scsih.c | 2 +- drivers/scsi/scsi.c | 13 ++ drivers/scsi/scsi_lib.c | 67 ++++--- drivers/scsi/scsi_priv.h | 3 + drivers/scsi/scsi_scan.c | 23 ++- drivers/scsi/scsi_sysfs.c | 4 +- drivers/scsi/sg.c | 2 +- drivers/vhost/scsi.c | 4 +- include/linux/blk-mq.h | 13 +- include/linux/sbitmap.h | 85 +++++--- include/scsi/scsi_cmnd.h | 2 + include/scsi/scsi_device.h | 8 +- include/scsi/scsi_host.h | 72 ++++--- lib/sbitmap.c | 210 +++++++++++--------- 21 files changed, 428 insertions(+), 215 deletions(-)
Signature · 1 line
2.28.0
PATCH v7 1/13 sbitmap: remove sbitmap_clear_bit_unlock
No one uses this helper any more, so kill it.
--- include/linux/sbitmap.h | 6 ------ 1 file changed, 6 deletions(-)
include/linux/sbitmap.h +0 -6
@@ -315,12 +315,6 @@ static inline void sbitmap_deferred_clear_bit(struct sbitmap *sb, unsigned int bset_bit (SB_NR_TO_BIT (sb, bitnr), addr); } -static inline void sbitmap_clear_bit_unlock (struct sbitmap *sb, -unsigned int bitnr) -{ -clear_bit_unlock (SB_NR_TO_BIT (sb, bitnr),__sbitmap_word (sb, bitnr)); -} -static inline int sbitmap_test_bit (struct sbitmap *sb,unsigned int bitnr) {return test_bit (SB_NR_TO_BIT (sb, bitnr),__sbitmap_word (sb, bitnr));
Signature · 1 line
2.28.0
PATCH v7 2/13 sbitmap: maintain allocation round_robin in sbitmap
In reply to Ming LeiNow allocation round_robin info is maintained by sbitmap_queue.
Actually, bit allocation belongs to sbitmap. Also the following patch will move alloc_hint to sbitmap for users with high depth.
So move round_robin to sbitmap.
--- block/blk-mq.c | 2 +- block/kyber-iosched.c | 3 ++- drivers/vhost/scsi.c | 4 ++-- include/linux/sbitmap.h | 20 ++++++++++---------- lib/sbitmap.c | 28 ++++++++++++++-------------- 5 files changed, 29 insertions(+), 28 deletions(-)
block/blk-mq.c +1 -1
@@ -2676,7 +2676,7 @@ blk_mq_alloc_hctx(struct request_queue *q, struct blk_mq_tag_set *set, goto free_cpumask;if (sbitmap_init_node (&hctx->ctx_map, nr_cpu_ids,ilog2 (8 ), - gfp, node)) + gfp, node, false)) goto free_ctxs; hctx->nr_ctx =0 ;
block/kyber-iosched.c +2 -1
@@ -479,7 +479,8 @@ static int kyber_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int hctx_idx)for (i =0 ; i <KYBER_NUM_DOMAINS ; i++) {if (sbitmap_init_node (&khd->kcq_map[i], hctx->nr_ctx, -ilog2 (8 ),GFP_KERNEL , hctx->numa_node)) { +ilog2 (8 ),GFP_KERNEL , hctx->numa_node, + false)) {while (--i >=0 )sbitmap_free (&khd->kcq_map[i]); goto err_kcqs;
drivers/vhost/scsi.c +2 -2
@@ -614,7 +614,7 @@ vhost_scsi_get_cmd(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,return ERR_PTR (-EIO ); } - tag =sbitmap_get (&svq->scsi_tags,0 , false); + tag =sbitmap_get (&svq->scsi_tags,0 );if (tag <0 ) {pr_err ("Unable to obtain tag for vhost_scsi_cmd\n" );return ERR_PTR (-ENOMEM );
@@ -1512,7 +1512,7 @@ static int vhost_scsi_setup_vq_cmds(struct vhost_virtqueue *vq, int max_cmds)return 0 ;if (sbitmap_init_node (&svq->scsi_tags, max_cmds,-1 ,GFP_KERNEL , -NUMA_NO_NODE )) +NUMA_NO_NODE , false))return -ENOMEM ; svq->max_cmds = max_cmds;
include/linux/sbitmap.h +10 -10
@@ -56,6 +56,11 @@ struct sbitmap {*/ unsigned int map_nr; +/** +* @round_robin: Allocate bits in strict round-robin order. +*/ +bool round_robin; +/** * @map: Allocated bitmap. */
@@ -124,11 +129,6 @@ struct sbitmap_queue {*/ atomic_t ws_active; -/** -* @round_robin: Allocate bits in strict round-robin order. -*/ -bool round_robin; -/** * @min_shallow_depth: The minimum shallow depth which may be passed to * sbitmap_queue_get_shallow() or __sbitmap_queue_get_shallow().
@@ -144,11 +144,14 @@ struct sbitmap_queue {* given, a good default is chosen. * @flags: Allocation flags. * @node: Memory node to allocate on. +* @round_robin: If true, be stricter about allocation order; always allocate +* starting from the last allocated bit. This is less efficient +* than the default behavior (false). * * Return: Zero on success or negative errno on failure. */ int sbitmap_init_node (struct sbitmap *sb,unsigned int depth,int shift, -gfp_t flags,int node); +gfp_t flags,int node,bool round_robin);/** * sbitmap_free() - Free memory used by a &struct sbitmap.
@@ -174,15 +177,12 @@ void sbitmap_resize(struct sbitmap *sb, unsigned int depth);* sbitmap_get() - Try to allocate a free bit from a &struct sbitmap. * @sb: Bitmap to allocate from. * @alloc_hint: Hint for where to start searching for a free bit. -* @round_robin: If true, be stricter about allocation order; always allocate -* starting from the last allocated bit. This is less efficient -* than the default behavior (false). * * This operation provides acquire barrier semantics if it succeeds. * * Return: Non-negative allocated bit number if successful, -1 otherwise. */ -int sbitmap_get (struct sbitmap *sb,unsigned int alloc_hint,bool round_robin); +int sbitmap_get (struct sbitmap *sb,unsigned int alloc_hint);/** * sbitmap_get_shallow() - Try to allocate a free bit from a &struct sbitmap,
lib/sbitmap.c +14 -14
@@ -33,7 +33,7 @@ static inline bool sbitmap_deferred_clear(struct sbitmap_word *map) }int sbitmap_init_node (struct sbitmap *sb,unsigned int depth,int shift, -gfp_t flags,int node) +gfp_t flags,int node,bool round_robin) {unsigned int bits_per_word;unsigned int i;
@@ -58,6 +58,7 @@ int sbitmap_init_node(struct sbitmap *sb, unsigned int depth, int shift, sb->shift = shift; sb->depth = depth; sb->map_nr =DIV_ROUND_UP (sb->depth, bits_per_word); + sb->round_robin = round_robin;if (depth ==0 ) { sb->map =NULL ;
@@ -129,14 +130,14 @@ static int __sbitmap_get_word(unsigned long *word, unsigned long depth, }static int sbitmap_find_bit_in_index (struct sbitmap *sb,int index, -unsigned int alloc_hint,bool round_robin) +unsigned int alloc_hint) {struct sbitmap_word *map = &sb->map[index];int nr; do { nr = __sbitmap_get_word(&map->word, map->depth, alloc_hint, - !round_robin); + !sb->round_robin); if (nr != -1) break; if (!sbitmap_deferred_clear(map))
@@ -146,7 +147,7 @@ static int sbitmap_find_bit_in_index(struct sbitmap *sb, int index,return nr; } -int sbitmap_get (struct sbitmap *sb,unsigned int alloc_hint,bool round_robin) +int sbitmap_get (struct sbitmap *sb,unsigned int alloc_hint) {unsigned int i, index;int nr =-1 ;
@@ -158,14 +159,13 @@ int sbitmap_get(struct sbitmap *sb, unsigned int alloc_hint, bool round_robin)* alloc_hint to find the right word index. No point in looping * twice in find_next_zero_bit() for that case. */ -if (round_robin) +if (sb->round_robin) alloc_hint =SB_NR_TO_BIT (sb, alloc_hint);else alloc_hint =0 ;for (i =0 ; i < sb->map_nr; i++) { - nr =sbitmap_find_bit_in_index (sb, index, alloc_hint, - round_robin); + nr =sbitmap_find_bit_in_index (sb, index, alloc_hint);if (nr !=-1 ) { nr += index << sb->shift;break ;
@@ -350,7 +350,8 @@ int sbitmap_queue_init_node(struct sbitmap_queue *sbq, unsigned int depth,int ret;int i; - ret =sbitmap_init_node (&sbq->sb, depth, shift, flags, node); + ret =sbitmap_init_node (&sbq->sb, depth, shift, flags, node, + round_robin);if (ret)return ret;
@@ -382,7 +383,6 @@ int sbitmap_queue_init_node(struct sbitmap_queue *sbq, unsigned int depth,atomic_set (&sbq->ws[i].wait_cnt, sbq->wake_batch); } - sbq->round_robin = round_robin;return 0 ; }EXPORT_SYMBOL_GPL (sbitmap_queue_init_node);
@@ -424,12 +424,12 @@ int __sbitmap_queue_get(struct sbitmap_queue *sbq) hint = depth ?prandom_u32 () % depth :0 ;this_cpu_write (*sbq->alloc_hint, hint); } - nr =sbitmap_get (&sbq->sb, hint, sbq->round_robin); + nr =sbitmap_get (&sbq->sb, hint);if (nr ==-1 ) {/* If the map is full, a hint won't do us much good. */ this_cpu_write (*sbq->alloc_hint,0 ); - }else if (nr == hint ||unlikely (sbq->round_robin)) { + }else if (nr == hint ||unlikely (sbq->sb.round_robin)) {/* Only update the hint if we used it. */ hint = nr +1 ;if (hint >= depth -1 )
@@ -460,7 +460,7 @@ int __sbitmap_queue_get_shallow(struct sbitmap_queue *sbq,if (nr ==-1 ) {/* If the map is full, a hint won't do us much good. */ this_cpu_write (*sbq->alloc_hint,0 ); - }else if (nr == hint ||unlikely (sbq->round_robin)) { + }else if (nr == hint ||unlikely (sbq->sb.round_robin)) {/* Only update the hint if we used it. */ hint = nr +1 ;if (hint >= depth -1 )
@@ -576,7 +576,7 @@ void sbitmap_queue_clear(struct sbitmap_queue *sbq, unsigned int nr,smp_mb__after_atomic ();sbitmap_queue_wake_up (sbq); -if (likely (!sbq->round_robin && nr < sbq->sb.depth)) +if (likely (!sbq->sb.round_robin && nr < sbq->sb.depth)) *per_cpu_ptr (sbq->alloc_hint, cpu) = nr; }EXPORT_SYMBOL_GPL (sbitmap_queue_clear);
@@ -633,7 +633,7 @@ void sbitmap_queue_show(struct sbitmap_queue *sbq, struct seq_file *m) }seq_puts (m,"}\n" ); -seq_printf (m,"round_robin=%d\n" , sbq->round_robin); +seq_printf (m,"round_robin=%d\n" , sbq->sb.round_robin);seq_printf (m,"min_shallow_depth=%u\n" , sbq->min_shallow_depth); }EXPORT_SYMBOL_GPL (sbitmap_queue_show);
Signature · 6 lines
2.28.0 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
PATCH v7 3/13 sbitmap: add helpers for updating allocation hint
In reply to Ming LeiAdd helpers for updating allocation hint, so that we can avoid to duplicate code.
Prepare for moving allocation hint into sbitmap.
--- lib/sbitmap.c | 93 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 54 insertions(+), 39 deletions(-)
lib/sbitmap.c +54 -39
@@ -9,6 +9,55 @@#include <linux/sbitmap.h> #include <linux/seq_file.h> +static int init_alloc_hint (struct sbitmap_queue *sbq,gfp_t flags) +{ +unsigned depth = sbq->sb.depth; + + sbq->alloc_hint = alloc_percpu_gfp(unsigned int, flags); +if (!sbq->alloc_hint) +return -ENOMEM ; + +if (depth && !sbq->sb.round_robin) { +int i; + +for_each_possible_cpu (i) + *per_cpu_ptr (sbq->alloc_hint, i) =prandom_u32 () % depth; + } + +return 0 ; +} + +static inline unsigned update_alloc_hint_before_get (struct sbitmap_queue *sbq, +unsigned int depth) +{ +unsigned hint; + + hint =this_cpu_read (*sbq->alloc_hint); +if (unlikely (hint >= depth)) { + hint = depth ?prandom_u32 () % depth :0 ; +this_cpu_write (*sbq->alloc_hint, hint); + } + +return hint; +} + +static inline void update_alloc_hint_after_get (struct sbitmap_queue *sbq, +unsigned int depth, +unsigned int hint, +unsigned int nr) +{ +if (nr ==-1 ) { +/* If the map is full, a hint won't do us much good. */ +this_cpu_write (*sbq->alloc_hint,0 ); + }else if (nr == hint ||unlikely (sbq->sb.round_robin)) { +/* Only update the hint if we used it. */ + hint = nr +1 ; +if (hint >= depth -1 ) + hint =0 ; +this_cpu_write (*sbq->alloc_hint, hint); + } +} +/* * See if we have deferred clears that we can batch move */
@@ -355,17 +404,11 @@ int sbitmap_queue_init_node(struct sbitmap_queue *sbq, unsigned int depth,if (ret)return ret; - sbq->alloc_hint = alloc_percpu_gfp(unsigned int, flags); -if (!sbq->alloc_hint) { +if (init_alloc_hint (sbq, flags) !=0 ) {sbitmap_free (&sbq->sb);return -ENOMEM ; } -if (depth && !round_robin) { -for_each_possible_cpu (i) - *per_cpu_ptr (sbq->alloc_hint, i) =prandom_u32 () % depth; - } - sbq->min_shallow_depth =UINT_MAX ; sbq->wake_batch =sbq_calc_wake_batch (sbq, depth);atomic_set (&sbq->wake_index,0 );
@@ -418,24 +461,10 @@ int __sbitmap_queue_get(struct sbitmap_queue *sbq)unsigned int hint, depth;int nr; - hint =this_cpu_read (*sbq->alloc_hint); depth =READ_ONCE (sbq->sb.depth); -if (unlikely (hint >= depth)) { - hint = depth ?prandom_u32 () % depth :0 ; -this_cpu_write (*sbq->alloc_hint, hint); - } + hint =update_alloc_hint_before_get (sbq, depth); nr =sbitmap_get (&sbq->sb, hint); - -if (nr ==-1 ) { -/* If the map is full, a hint won't do us much good. */ -this_cpu_write (*sbq->alloc_hint,0 ); - }else if (nr == hint ||unlikely (sbq->sb.round_robin)) { -/* Only update the hint if we used it. */ - hint = nr +1 ; -if (hint >= depth -1 ) - hint =0 ; -this_cpu_write (*sbq->alloc_hint, hint); - } +update_alloc_hint_after_get (sbq, depth, hint, nr);return nr; }
@@ -449,24 +478,10 @@ int __sbitmap_queue_get_shallow(struct sbitmap_queue *sbq,WARN_ON_ONCE (shallow_depth < sbq->min_shallow_depth); - hint =this_cpu_read (*sbq->alloc_hint); depth =READ_ONCE (sbq->sb.depth); -if (unlikely (hint >= depth)) { - hint = depth ?prandom_u32 () % depth :0 ; -this_cpu_write (*sbq->alloc_hint, hint); - } + hint =update_alloc_hint_before_get (sbq, depth); nr =sbitmap_get_shallow (&sbq->sb, hint, shallow_depth); - -if (nr ==-1 ) { -/* If the map is full, a hint won't do us much good. */ -this_cpu_write (*sbq->alloc_hint,0 ); - }else if (nr == hint ||unlikely (sbq->sb.round_robin)) { -/* Only update the hint if we used it. */ - hint = nr +1 ; -if (hint >= depth -1 ) - hint =0 ; -this_cpu_write (*sbq->alloc_hint, hint); - } +update_alloc_hint_after_get (sbq, depth, hint, nr);return nr; }
Signature · 1 line
2.28.0
PATCH v7 4/13 sbitmap: move allocation hint into sbitmap
In reply to Ming LeiAllocation hint should have belonged to sbitmap, also when sbitmap's depth is high and no need to use mulitple wakeup queues, user can benefit from percpu allocation hint too.
So move allocation hint into sbitmap, then scsi device queue can benefit from allocation hint when converting to plain sbitmap in the following patches.
Meantime convert vhost/scsi.c to use sbitmap allocation with percpu alloc hint, which way is more efficient than previous way.
--- block/blk-mq.c | 2 +- block/kyber-iosched.c | 2 +- drivers/vhost/scsi.c | 4 +- include/linux/sbitmap.h | 41 +++++++++------ lib/sbitmap.c | 112 +++++++++++++++++++++++----------------- 5 files changed, 96 insertions(+), 65 deletions(-)
block/blk-mq.c +1 -1
@@ -2676,7 +2676,7 @@ blk_mq_alloc_hctx(struct request_queue *q, struct blk_mq_tag_set *set, goto free_cpumask;if (sbitmap_init_node (&hctx->ctx_map, nr_cpu_ids,ilog2 (8 ), - gfp, node, false)) + gfp, node, false, false)) goto free_ctxs; hctx->nr_ctx =0 ;
block/kyber-iosched.c +1 -1
@@ -480,7 +480,7 @@ static int kyber_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int hctx_idx)for (i =0 ; i <KYBER_NUM_DOMAINS ; i++) {if (sbitmap_init_node (&khd->kcq_map[i], hctx->nr_ctx,ilog2 (8 ),GFP_KERNEL , hctx->numa_node, - false)) { + false, false)) {while (--i >=0 )sbitmap_free (&khd->kcq_map[i]); goto err_kcqs;
drivers/vhost/scsi.c +2 -2
@@ -614,7 +614,7 @@ vhost_scsi_get_cmd(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,return ERR_PTR (-EIO ); } - tag =sbitmap_get (&svq->scsi_tags,0 ); + tag =sbitmap_get (&svq->scsi_tags);if (tag <0 ) {pr_err ("Unable to obtain tag for vhost_scsi_cmd\n" );return ERR_PTR (-ENOMEM );
@@ -1512,7 +1512,7 @@ static int vhost_scsi_setup_vq_cmds(struct vhost_virtqueue *vq, int max_cmds)return 0 ;if (sbitmap_init_node (&svq->scsi_tags, max_cmds,-1 ,GFP_KERNEL , -NUMA_NO_NODE , false)) +NUMA_NO_NODE , false, true))return -ENOMEM ; svq->max_cmds = max_cmds;
include/linux/sbitmap.h +26 -15
103 lines not on this page · raw message
lib/sbitmap.c +66 -46
225 lines not on this page · raw message
Signature · 6 lines
2.28.0 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
PATCH v7 5/13 sbitmap: export sbitmap_weight
In reply to Ming LeiSCSI's .device_busy will be converted to sbitmap, and sbitmap_weight is needed, so export the helper.
Meantime the only user of sbitmap_weight() is just for getting how many set and not cleared bits, so align sbitmap_weight() meaning with this way because the external user only cares how many busy bits there are in the sbitmap.
--- include/linux/sbitmap.h | 10 ++++++++++ lib/sbitmap.c | 11 ++++++----- 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/sbitmap.h +10 -0
@@ -341,6 +341,16 @@ static inline int sbitmap_test_bit(struct sbitmap *sb, unsigned int bitnr)*/ void sbitmap_show (struct sbitmap *sb,struct seq_file *m); + +/** +* sbitmap_weight() - Return how many set and not cleared bits in a &struct +* sbitmap. +* @sb: Bitmap to check. +* +* Return: How many set and not cleared bits set +*/ +unsigned int sbitmap_weight (const struct sbitmap *sb); +/** * sbitmap_bitmap_show() - Write a hex dump of a &struct sbitmap to a &struct * seq_file.
lib/sbitmap.c +6 -5
@@ -334,20 +334,21 @@ static unsigned int __sbitmap_weight(const struct sbitmap *sb, bool set)return weight; } -static unsigned int sbitmap_weight (const struct sbitmap *sb) +static unsigned int sbitmap_cleared (const struct sbitmap *sb) { -return __sbitmap_weight (sb, true); +return __sbitmap_weight (sb, false); } -static unsigned int sbitmap_cleared (const struct sbitmap *sb) +unsigned int sbitmap_weight (const struct sbitmap *sb) { -return __sbitmap_weight (sb, false); +return __sbitmap_weight (sb, true) -sbitmap_cleared (sb); } +EXPORT_SYMBOL_GPL (sbitmap_weight);void sbitmap_show (struct sbitmap *sb,struct seq_file *m) {seq_printf (m,"depth=%u\n" , sb->depth); -seq_printf (m,"busy=%u\n" ,sbitmap_weight (sb) -sbitmap_cleared (sb)); +seq_printf (m,"busy=%u\n" ,sbitmap_weight (sb));seq_printf (m,"cleared=%u\n" ,sbitmap_cleared (sb));seq_printf (m,"bits_per_word=%u\n" ,1U << sb->shift);seq_printf (m,"map_nr=%u\n" , sb->map_nr);
Signature · 1 line
2.28.0
PATCH v7 6/13 sbitmap: add helper of sbitmap_calculate_shift
In reply to Ming LeiMove code for calculating default shift into one public helper, which can be used for SCSI to calculate shift.
--- include/linux/sbitmap.h | 18 ++++++++++++++++++ lib/sbitmap.c | 16 +++------------- 2 files changed, 21 insertions(+), 13 deletions(-)
include/linux/sbitmap.h +18 -0
@@ -332,6 +332,24 @@ static inline int sbitmap_test_bit(struct sbitmap *sb, unsigned int bitnr)return test_bit (SB_NR_TO_BIT (sb, bitnr),__sbitmap_word (sb, bitnr)); } +static inline int sbitmap_calculate_shift (unsigned int depth) +{ +int shift =ilog2 (BITS_PER_LONG ); + +/* +* If the bitmap is small, shrink the number of bits per word so +* we spread over a few cachelines, at least. If less than 4 +* bits, just forget about it, it's not going to work optimally +* anyway. +*/ +if (depth >=4 ) { +while ((4U << shift) > depth) + shift--; + } + +return shift; +} +/** * sbitmap_show() - Dump &struct sbitmap information to a &struct seq_file. * @sb: Bitmap to show.
lib/sbitmap.c +3 -13
@@ -87,19 +87,9 @@ int sbitmap_init_node(struct sbitmap *sb, unsigned int depth, int shift,unsigned int bits_per_word;unsigned int i; -if (shift <0 ) { - shift =ilog2 (BITS_PER_LONG ); -/* -* If the bitmap is small, shrink the number of bits per word so -* we spread over a few cachelines, at least. If less than 4 -* bits, just forget about it, it's not going to work optimally -* anyway. -*/ -if (depth >=4 ) { -while ((4U << shift) > depth) - shift--; - } - } +if (shift <0 ) + shift =sbitmap_calculate_shift (depth); + bits_per_word =1U << shift;if (bits_per_word >BITS_PER_LONG )return -EINVAL ;
Signature · 1 line
2.28.0
PATCH v7 7/13 blk-mq: add callbacks for storing & retrieving budget token
In reply to Ming LeiSCSI is the only driver which requires dispatch budget, and it isn't fair to add one field into 'struct request' for storing budget token which will be used in the following patches for improving scsi's device busy scalability.
--- drivers/scsi/scsi_lib.c | 18 ++++++++++++++++++ include/linux/blk-mq.h | 9 +++++++++ include/scsi/scsi_cmnd.h | 2 ++ 3 files changed, 29 insertions(+)
drivers/scsi/scsi_lib.c +18 -0
@@ -1641,6 +1641,20 @@ static bool scsi_mq_get_budget(struct request_queue *q)return false; } +static void scsi_mq_set_rq_budget_token (struct request *req,int token) +{ +struct scsi_cmnd *cmd =blk_mq_rq_to_pdu (req); + + cmd->budget_token = token; +} + +static int scsi_mq_get_rq_budget_token (struct request *req) +{ +struct scsi_cmnd *cmd =blk_mq_rq_to_pdu (req); + +return cmd->budget_token; +} +static blk_status_t scsi_queue_rq (struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd) {
@@ -1855,6 +1869,8 @@ static const struct blk_mq_ops scsi_mq_ops_no_commit = { .cleanup_rq = scsi_cleanup_rq, .busy = scsi_mq_lld_busy, .map_queues = scsi_map_queues, + .set_rq_budget_token = scsi_mq_set_rq_budget_token, + .get_rq_budget_token = scsi_mq_get_rq_budget_token, };
@@ -1883,6 +1899,8 @@ static const struct blk_mq_ops scsi_mq_ops = { .cleanup_rq = scsi_cleanup_rq, .busy = scsi_mq_lld_busy, .map_queues = scsi_map_queues, + .set_rq_budget_token = scsi_mq_set_rq_budget_token, + .get_rq_budget_token = scsi_mq_get_rq_budget_token, };struct request_queue *scsi_mq_alloc_queue (struct scsi_device *sdev)
include/linux/blk-mq.h +9 -0
@@ -317,6 +317,15 @@ struct blk_mq_ops {*/ void (*put_budget)(struct request_queue *); +/* +* @set_rq_budget_toekn: store rq's budget token +*/ +void (*set_rq_budget_token)(struct request *,int ); +/* +* @get_rq_budget_toekn: retrieve rq's budget token +*/ +int (*get_rq_budget_token)(struct request *); +/** * @timeout: Called on request timeout. */
include/scsi/scsi_cmnd.h +2 -0
@@ -75,6 +75,8 @@ struct scsi_cmnd {int eh_eflags;/* Used by error handlr */ +int budget_token; +/* * This is set to jiffies as it was when the command was first * allocated. It is used to time how long the command has
Signature · 1 line
2.28.0
PATCH v7 8/13 blk-mq: return budget token from .get_budget callback
In reply to Ming LeiSCSI uses one global atomic variable to track queue depth for each LUN/request queue.
This way doesn't scale well when there is lots of CPU cores and the disk is very fast. It has been observed that IOPS is affected a lot by tracking queue depth via sdev->device_busy in IO path.
Return budget token from .get_budget callback, and the budget token can be passed to driver, so that we can replace the atomic variable with sbitmap_queue, then the scale issue can be fixed.
--- block/blk-mq-sched.c | 17 +++++++++++++---- block/blk-mq.c | 36 +++++++++++++++++++++++++----------- block/blk-mq.h | 25 +++++++++++++++++++++---- drivers/scsi/scsi_lib.c | 16 +++++++++++----- include/linux/blk-mq.h | 4 ++-- 5 files changed, 72 insertions(+), 26 deletions(-)
block/blk-mq-sched.c +13 -4
@@ -131,6 +131,7 @@ static int __blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx) do { struct request *rq; + int budget_token; if (e->type->ops.has_work && !e->type->ops.has_work(hctx)) break;
@@ -140,12 +141,13 @@ static int __blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)break ; } -if (!blk_mq_get_dispatch_budget (q)) + budget_token =blk_mq_get_dispatch_budget (q); +if (budget_token <0 )break ; rq = e->type->ops.dispatch_request (hctx);if (!rq) { -blk_mq_put_dispatch_budget (q); +blk_mq_put_dispatch_budget (q, budget_token);/* * We're releasing without dispatching. Holding the * budget could have blocked any "hctx"s with the
@@ -157,6 +159,8 @@ static int __blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)break ; } +blk_mq_set_rq_budget_token (rq, budget_token); +/* * Now this rq owns the budget which has to be released * if this rq won't be queued to driver via .queue_rq()
@@ -230,6 +234,8 @@ static int blk_mq_do_dispatch_ctx(struct blk_mq_hw_ctx *hctx)struct request *rq; do { + int budget_token; + if (!list_empty_careful(&hctx->dispatch)) { ret = -EAGAIN; break;
@@ -238,12 +244,13 @@ static int blk_mq_do_dispatch_ctx(struct blk_mq_hw_ctx *hctx)if (!sbitmap_any_bit_set (&hctx->ctx_map))break ; -if (!blk_mq_get_dispatch_budget (q)) + budget_token =blk_mq_get_dispatch_budget (q); +if (budget_token <0 )break ; rq =blk_mq_dequeue_from_ctx (hctx, ctx);if (!rq) { -blk_mq_put_dispatch_budget (q); +blk_mq_put_dispatch_budget (q, budget_token);/* * We're releasing without dispatching. Holding the * budget could have blocked any "hctx"s with the
@@ -255,6 +262,8 @@ static int blk_mq_do_dispatch_ctx(struct blk_mq_hw_ctx *hctx)break ; } +blk_mq_set_rq_budget_token (rq, budget_token); +/* * Now this rq owns the budget which has to be released * if this rq won't be queued to driver via .queue_rq()
block/blk-mq.c +25 -11
@@ -1304,10 +1304,15 @@ static enum prep_dispatch blk_mq_prep_dispatch_rq(struct request *rq, bool need_budget) {struct blk_mq_hw_ctx *hctx = rq->mq_hctx; +int budget_token =-1 ; -if (need_budget && !blk_mq_get_dispatch_budget (rq->q)) { -blk_mq_put_driver_tag (rq); -return PREP_DISPATCH_NO_BUDGET ; +if (need_budget) { + budget_token =blk_mq_get_dispatch_budget (rq->q); +if (budget_token <0 ) { +blk_mq_put_driver_tag (rq); +return PREP_DISPATCH_NO_BUDGET ; + } +blk_mq_set_rq_budget_token (rq, budget_token); }if (!blk_mq_get_driver_tag (rq)) {
@@ -1324,7 +1329,7 @@ static enum prep_dispatch blk_mq_prep_dispatch_rq(struct request *rq,* together during handling partial dispatch */ if (need_budget) -blk_mq_put_dispatch_budget (rq->q); +blk_mq_put_dispatch_budget (rq->q, budget_token);return PREP_DISPATCH_NO_TAG ; } }
@@ -1334,12 +1339,16 @@ static enum prep_dispatch blk_mq_prep_dispatch_rq(struct request *rq,/* release all allocated budgets before calling to blk_mq_dispatch_rq_list */ static void blk_mq_release_budgets (struct request_queue *q, -unsigned int nr_budgets) +struct list_head *list) { -int i; +struct request *rq; -for (i =0 ; i < nr_budgets; i++) -blk_mq_put_dispatch_budget (q); +list_for_each_entry (rq, list, queuelist) { +int budget_token =blk_mq_get_rq_budget_token (rq); + +if (budget_token >=0 ) +blk_mq_put_dispatch_budget (q, budget_token); + } }/*
@@ -1437,7 +1446,8 @@ bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *hctx, struct list_head *list, (hctx->flags &BLK_MQ_F_TAG_QUEUE_SHARED );bool no_budget_avail = prep ==PREP_DISPATCH_NO_BUDGET ; -blk_mq_release_budgets (q, nr_budgets); +if (nr_budgets) +blk_mq_release_budgets (q, list);spin_lock (&hctx->lock);list_splice_tail_init (list, &hctx->dispatch);
@@ -1982,6 +1992,7 @@ static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, {struct request_queue *q = rq->q;bool run_queue = true; +int budget_token;/* * RCU or SRCU read lock is needed before checking quiesced flag.
@@ -1999,11 +2010,14 @@ static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,if (q->elevator && !bypass_insert) goto insert; -if (!blk_mq_get_dispatch_budget (q)) + budget_token =blk_mq_get_dispatch_budget (q); +if (budget_token <0 ) goto insert; +blk_mq_set_rq_budget_token (rq, budget_token); +if (!blk_mq_get_driver_tag (rq)) { -blk_mq_put_dispatch_budget (q); +blk_mq_put_dispatch_budget (q, budget_token); goto insert; }
block/blk-mq.h +21 -4
@@ -187,17 +187,34 @@ unsigned int blk_mq_in_flight(struct request_queue *q,void blk_mq_in_flight_rw (struct request_queue *q,struct block_device *part,unsigned int inflight[2 ]); -static inline void blk_mq_put_dispatch_budget (struct request_queue *q) +static inline void blk_mq_put_dispatch_budget (struct request_queue *q, +int budget_token) {if (q->mq_ops->put_budget) - q->mq_ops->put_budget (q); + q->mq_ops->put_budget (q, budget_token); } -static inline bool blk_mq_get_dispatch_budget (struct request_queue *q) +static inline int blk_mq_get_dispatch_budget (struct request_queue *q) {if (q->mq_ops->get_budget)return q->mq_ops->get_budget (q); -return true; +return 0 ; +} + +static inline void blk_mq_set_rq_budget_token (struct request *rq,int token) +{ +if (token <0 ) +return ; + +if (rq->q->mq_ops->set_rq_budget_token) + rq->q->mq_ops->set_rq_budget_token (rq, token); +} + +static inline int blk_mq_get_rq_budget_token (struct request *rq) +{ +if (rq->q->mq_ops->get_rq_budget_token) +return rq->q->mq_ops->get_rq_budget_token (rq); +return -1 ; }static inline void __blk_mq_inc_active_requests (struct blk_mq_hw_ctx *hctx)
drivers/scsi/scsi_lib.c +11 -5
@@ -329,6 +329,7 @@ void scsi_device_unbusy(struct scsi_device *sdev, struct scsi_cmnd *cmd)atomic_dec (&starget->target_busy);atomic_dec (&sdev->device_busy); + cmd->budget_token =-1 ; }static void scsi_kick_queue (struct request_queue *q)
@@ -1142,6 +1143,7 @@ void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd)unsigned long jiffies_at_alloc;int retries, to_clear;bool in_flight; +int budget_token = cmd->budget_token;if (!blk_rq_is_scsi (rq) && !(flags &SCMD_INITIALIZED )) { flags |=SCMD_INITIALIZED ;
@@ -1170,6 +1172,7 @@ void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd) cmd->retries = retries;if (in_flight)__set_bit (SCMD_STATE_INFLIGHT , &cmd->state); + cmd->budget_token = budget_token; }
@@ -1604,19 +1607,19 @@ static void scsi_mq_done(struct scsi_cmnd *cmd)blk_mq_complete_request (cmd->request); } -static void scsi_mq_put_budget (struct request_queue *q) +static void scsi_mq_put_budget (struct request_queue *q,int budget_token) {struct scsi_device *sdev = q->queuedata;atomic_dec (&sdev->device_busy); } -static bool scsi_mq_get_budget (struct request_queue *q) +static int scsi_mq_get_budget (struct request_queue *q) {struct scsi_device *sdev = q->queuedata;if (scsi_dev_queue_ready (q, sdev)) -return true; +return 0 ;atomic_inc (&sdev->restarts);
@@ -1638,7 +1641,7 @@ static bool scsi_mq_get_budget(struct request_queue *q)if (unlikely (atomic_read (&sdev->device_busy) ==0 && !scsi_device_blocked (sdev)))blk_mq_delay_run_hw_queues (sdev->request_queue,SCSI_QUEUE_DELAY ); -return false; +return -1 ; }static void scsi_mq_set_rq_budget_token (struct request *req,int token)
@@ -1666,6 +1669,8 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,blk_status_t ret;int reason; +WARN_ON_ONCE (cmd->budget_token <0 ); +/* * If the device is not in running state we will reject some or all * commands.
@@ -1717,7 +1722,8 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,if (scsi_target (sdev)->can_queue >0 )atomic_dec (&scsi_target (sdev)->target_busy); out_put_budget: -scsi_mq_put_budget (q); +scsi_mq_put_budget (q, cmd->budget_token); + cmd->budget_token =-1 ;switch (ret) {case BLK_STS_OK :break ;
include/linux/blk-mq.h +2 -2
@@ -310,12 +310,12 @@ struct blk_mq_ops {* reserved budget. Also we have to handle failure case * of .get_budget for avoiding I/O deadlock. */ -bool (*get_budget)(struct request_queue *); +int (*get_budget)(struct request_queue *);/** * @put_budget: Release the reserved budget. */ -void (*put_budget)(struct request_queue *); +void (*put_budget)(struct request_queue *,int );/* * @set_rq_budget_toekn: store rq's budget token
Signature · 1 line
2.28.0
PATCH v7 9/13 scsi: put hot fields of scsi_host_template into one cacheline
In reply to Ming LeiThe following three fields of scsi_host_template are referenced in scsi IO submission path, so put them together into one cacheline:
- cmd_size
- queuecommand
- commit_rqs
--- include/scsi/scsi_host.h | 72 ++++++++++++++++++++++------------------ 1 file changed, 39 insertions(+), 33 deletions(-)
include/scsi/scsi_host.h +39 -33
@@ -30,40 +30,15 @@ struct scsi_transport_template;#define MODE_TARGET 0x02struct scsi_host_template { -struct module *module; -const char *name; -/* -* The info function will return whatever useful information the -* developer sees fit. If not provided, then the name field will -* be used instead. -* -* Status: OPTIONAL +* Put fields referenced in IO submission path together in +* same cacheline */ -const char *(* info)(struct Scsi_Host *);/* -* Ioctl interface -* -* Status: OPTIONAL -*/ -int (*ioctl)(struct scsi_device *dev,unsigned int cmd, -void __user *arg); - - -#ifdef CONFIG_COMPAT -/* -* Compat handler. Handle 32bit ABI. -* When unknown ioctl is passed return -ENOIOCTLCMD. -* -* Status: OPTIONAL +* Additional per-command data allocated for the driver. */ -int (*compat_ioctl)(struct scsi_device *dev,unsigned int cmd, -void __user *arg); -#endif - -int (*init_cmd_priv)(struct Scsi_Host *shost,struct scsi_cmnd *cmd); -int (*exit_cmd_priv)(struct Scsi_Host *shost,struct scsi_cmnd *cmd); +unsigned int cmd_size;/* * The queuecommand function is used to queue up a scsi
@@ -111,6 +86,41 @@ struct scsi_host_template {*/ void (*commit_rqs)(struct Scsi_Host *,u16 ); +struct module *module; +const char *name; + +/* +* The info function will return whatever useful information the +* developer sees fit. If not provided, then the name field will +* be used instead. +* +* Status: OPTIONAL +*/ +const char *(*info)(struct Scsi_Host *); + +/* +* Ioctl interface +* +* Status: OPTIONAL +*/ +int (*ioctl)(struct scsi_device *dev,unsigned int cmd, +void __user *arg); + + +#ifdef CONFIG_COMPAT +/* +* Compat handler. Handle 32bit ABI. +* When unknown ioctl is passed return -ENOIOCTLCMD. +* +* Status: OPTIONAL +*/ +int (*compat_ioctl)(struct scsi_device *dev,unsigned int cmd, +void __user *arg); +#endif + +int (*init_cmd_priv)(struct Scsi_Host *shost,struct scsi_cmnd *cmd); +int (*exit_cmd_priv)(struct Scsi_Host *shost,struct scsi_cmnd *cmd); +/* * This is an error handling strategy routine. You don't need to * define one of these if you don't want to - there is a default
@@ -478,10 +488,6 @@ struct scsi_host_template {*/ u64 vendor_id; -/* -* Additional per-command data allocated for the driver. -*/ -unsigned int cmd_size;struct scsi_host_cmd_pool *cmd_pool;/* Delay for runtime autosuspend */
Signature · 1 line
2.28.0
PATCH v7 10/13 megaraid_sas: v2 replace sdev_busy with local counter
In reply to Ming LeiFrom: Kashyap Desai <[email protected]>
use local tracking of per sdev outstanding command since sdev_busy in SML is improved for performance reason using sbitmap (earlier it was atomic variable).
Fix checkpatch ERROR and WARNING.
--- drivers/scsi/megaraid/megaraid_sas.h | 2 + drivers/scsi/megaraid/megaraid_sas_fusion.c | 48 +++++++++++++++++---- 2 files changed, 41 insertions(+), 9 deletions(-)
drivers/scsi/megaraid/megaraid_sas.h +2 -0
@@ -2019,10 +2019,12 @@ union megasas_frame {* struct MR_PRIV_DEVICE - sdev private hostdata * @is_tm_capable: firmware managed tm_capable flag * @tm_busy: TM request is in progress +* @sdev_priv_busy: pending command per sdev */ struct MR_PRIV_DEVICE {bool is_tm_capable;bool tm_busy; +atomic_t sdev_priv_busy;atomic_t r1_ldio_hint;u8 interface_type;u8 task_abort_tmo;
drivers/scsi/megaraid/megaraid_sas_fusion.c +39 -9
79 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH v7 11/13 scsi: add scsi_device_busy() to read sdev->device_busy
In reply to Ming LeiAdd scsi_device_busy() for drivers, so that we can prepare for tracking device queue depth via sbitmap_queue.
--- drivers/message/fusion/mptsas.c | 2 +- drivers/scsi/mpt3sas/mpt3sas_scsih.c | 2 +- drivers/scsi/scsi_lib.c | 4 ++-- drivers/scsi/scsi_sysfs.c | 2 +- drivers/scsi/sg.c | 2 +- include/scsi/scsi_device.h | 5 +++++ 6 files changed, 11 insertions(+), 6 deletions(-)
drivers/message/fusion/mptsas.c +1 -1
@@ -3781,7 +3781,7 @@ mptsas_send_link_status_event(struct fw_event_work *fw_event)printk (MYIOC_s_DEBUG_FMT"SDEV OUTSTANDING CMDS" "%d\n" , ioc->name, - atomic_read(&sdev->device_busy))); + scsi_device_busy(sdev))); } }
drivers/scsi/mpt3sas/mpt3sas_scsih.c +1 -1
@@ -3415,7 +3415,7 @@ scsih_dev_reset(struct scsi_cmnd *scmd)MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET ,0 ,0 , tr_timeout, tr_method);/* Check for busy commands after reset */ -if (r ==SUCCESS &&atomic_read (&scmd->device->device_busy)) +if (r ==SUCCESS &&scsi_device_busy (scmd->device)) r =FAILED ; out: sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(0x%p)\n",
drivers/scsi/scsi_lib.c +2 -2
@@ -385,7 +385,7 @@ static void scsi_single_lun_run(struct scsi_device *current_sdev)static inline bool scsi_device_is_busy (struct scsi_device *sdev) { -if (atomic_read (&sdev->device_busy) >= sdev->queue_depth) +if (scsi_device_busy (sdev) >= sdev->queue_depth)return true;if (atomic_read (&sdev->device_blocked) >0 )return true;
@@ -1638,7 +1638,7 @@ static int scsi_mq_get_budget(struct request_queue *q)* the .restarts flag, and the request queue will be run for handling * this request, see scsi_end_request(). */ -if (unlikely (atomic_read (&sdev->device_busy) ==0 && +if (unlikely (scsi_device_busy (sdev) ==0 && !scsi_device_blocked (sdev)))blk_mq_delay_run_hw_queues (sdev->request_queue,SCSI_QUEUE_DELAY );return -1 ;
drivers/scsi/scsi_sysfs.c +1 -1
@@ -670,7 +670,7 @@ sdev_show_device_busy(struct device *dev, struct device_attribute *attr, char *buf) {struct scsi_device *sdev =to_scsi_device (dev); -return snprintf (buf,20 ,"%d\n" ,atomic_read (&sdev->device_busy)); +return snprintf (buf,20 ,"%d\n" ,scsi_device_busy (sdev)); } static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);
drivers/scsi/sg.c +1 -1
@@ -2504,7 +2504,7 @@ static int sg_proc_seq_show_dev(struct seq_file *s, void *v) scsidp->id, scsidp->lun, (int ) scsidp->type,1 , (int ) scsidp->queue_depth, - (int )atomic_read (&scsidp->device_busy), + (int )scsi_device_busy (scsidp), (int) scsi_device_online(scsidp)); }read_unlock_irqrestore (&sg_index_lock, iflags);
include/scsi/scsi_device.h +5 -0
@@ -590,6 +590,11 @@ static inline int scsi_device_supports_vpd(struct scsi_device *sdev)return 0 ; } +static inline int scsi_device_busy (struct scsi_device *sdev) +{ +return atomic_read (&sdev->device_busy); +} +#define MODULE_ALIAS_SCSI_DEVICE (type) \ MODULE_ALIAS("scsi:t-" __stringify(type) "*")#define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
Signature · 1 line
2.28.0
PATCH v7 12/13 scsi: make sure sdev->queue_depth is <= max(shost->can_queue, 1024)
In reply to Ming LeiLimit scsi device's queue depth is less than max(host->can_queue, 1024) in scsi_change_queue_depth(), and 1024 is big enough for saturating current fast SCSI LUN(SSD, or raid volume on multiple SSDs). Also single hw queue depth is usually enough for saturating single LUN because per-core performance is often considered in storage design.
We need this patch for replacing sdev->device_busy with sbitmap which has to be pre-allocated with reasonable max depth.
--- drivers/scsi/scsi.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
drivers/scsi/scsi.c +11 -0
@@ -214,6 +214,15 @@ void scsi_finish_command(struct scsi_cmnd *cmd)scsi_io_completion (cmd, good_bytes); } + +/* +* 1024 is big enough for saturating the fast scsi LUN now +*/ +static int scsi_device_max_queue_depth (struct scsi_device *sdev) +{ +return max_t (int, sdev->host->can_queue,1024 ); +} +/** * scsi_change_queue_depth - change a device's queue depth * @sdev: SCSI Device in question
@@ -223,6 +232,8 @@ void scsi_finish_command(struct scsi_cmnd *cmd)*/ int scsi_change_queue_depth (struct scsi_device *sdev,int depth) { + depth =min_t (int, depth,scsi_device_max_queue_depth (sdev)); +if (depth >0 ) { sdev->queue_depth = depth;wmb ();
Signature · 1 line
2.28.0
PATCH v7 13/13 scsi: replace sdev->device_busy with sbitmap
In reply to Ming Leiscsi requires one global atomic variable to track queue depth for each LUN/ request queue, meantime blk-mq tracks queue depth for each hctx. This SCSI's requirement can't be implemented in blk-mq easily, cause it is a bigger & harder problem to spread the device or request queue's depth among all hw queues.
The current approach by using atomic variable can't scale well when there is lots of CPU cores and the disk is very fast and IO are submitted to this device concurrently. It has been observed that IOPS is affected a lot by tracking queue depth via sdev->device_busy in IO path.
So replace the atomic variable sdev->device_busy with sbitmap for tracking scsi device queue depth.
It is observed that IOPS is improved ~30% by this patchset in the following test:
1) test machine(32 logical CPU cores)
Thread(s) per core: 2 Core(s) per socket: 8 Socket(s): 2 NUMA node(s): 2 Model name: Intel(R) Xeon(R) Silver 4110 CPU @ 2.10GHz
2) setup scsi_debug:
modprobe scsi_debug virtual_gb=128 max_luns=1 submit_queues=32 delay=0 max_queue=256
3) fio script:
fio --rw=randread --size=128G --direct=1 --ioengine=libaio --iodepth=2048 \ --numjobs=32 --bs=4k --group_reporting=1 --group_reporting=1 --runtime=60 \ --loops=10000 --name=job1 --filename=/dev/sdN
[1] https://lore.kernel.org/linux-block/[email protected]/
--- drivers/scsi/scsi.c | 4 +++- drivers/scsi/scsi_lib.c | 31 ++++++++++++++----------------- drivers/scsi/scsi_priv.h | 3 +++ drivers/scsi/scsi_scan.c | 23 +++++++++++++++++++++-- drivers/scsi/scsi_sysfs.c | 2 ++ include/scsi/scsi_device.h | 5 +++-- 6 files changed, 46 insertions(+), 22 deletions(-)
drivers/scsi/scsi.c +3 -1
@@ -218,7 +218,7 @@ void scsi_finish_command(struct scsi_cmnd *cmd)/* * 1024 is big enough for saturating the fast scsi LUN now */ -static int scsi_device_max_queue_depth (struct scsi_device *sdev) +int scsi_device_max_queue_depth (struct scsi_device *sdev) {return max_t (int, sdev->host->can_queue,1024 ); }
@@ -242,6 +242,8 @@ int scsi_change_queue_depth(struct scsi_device *sdev, int depth)if (sdev->request_queue)blk_set_queue_depth (sdev->request_queue, depth); +sbitmap_resize (&sdev->budget_map, sdev->queue_depth); +return sdev->queue_depth; }EXPORT_SYMBOL (scsi_change_queue_depth);
drivers/scsi/scsi_lib.c +14 -17
@@ -328,7 +328,7 @@ void scsi_device_unbusy(struct scsi_device *sdev, struct scsi_cmnd *cmd)if (starget->can_queue >0 )atomic_dec (&starget->target_busy); -atomic_dec (&sdev->device_busy); +sbitmap_put (&sdev->budget_map, cmd->budget_token); cmd->budget_token =-1 ; }
@@ -1256,19 +1256,17 @@ scsi_device_state_check(struct scsi_device *sdev, struct request *req) }/* -* scsi_dev_queue_ready: if we can send requests to sdev, return 1 else -* return 0. -* -* Called with the queue_lock held. +* scsi_dev_queue_ready: if we can send requests to sdev, assign one token +* and return the token else return -1. */ static inline int scsi_dev_queue_ready (struct request_queue *q,struct scsi_device *sdev) { -unsigned int busy; +int token; - busy =atomic_inc_return (&sdev->device_busy) -1 ; + token =sbitmap_get (&sdev->budget_map);if (atomic_read (&sdev->device_blocked)) { -if (busy) +if (token >=0 ) goto out_dec;/*
@@ -1280,13 +1278,11 @@ static inline int scsi_dev_queue_ready(struct request_queue *q, "unblocking device at zero depth\n")); } -if (busy >= sdev->queue_depth) - goto out_dec; - -return 1 ; +return token; out_dec: -atomic_dec (&sdev->device_busy); -return 0 ; +if (token >=0 ) +sbitmap_put (&sdev->budget_map, token); +return -1 ; }/*
@@ -1611,15 +1607,16 @@ static void scsi_mq_put_budget(struct request_queue *q, int budget_token) {struct scsi_device *sdev = q->queuedata; -atomic_dec (&sdev->device_busy); +sbitmap_put (&sdev->budget_map, budget_token); }static int scsi_mq_get_budget (struct request_queue *q) {struct scsi_device *sdev = q->queuedata; +int token =scsi_dev_queue_ready (q, sdev); -if (scsi_dev_queue_ready (q, sdev)) -return 0 ; +if (token >=0 ) +return token;atomic_inc (&sdev->restarts);
drivers/scsi/scsi_priv.h +3 -0
@@ -5,6 +5,7 @@#include <linux/device.h> #include <linux/async.h> #include <scsi/scsi_device.h> +#include <linux/sbitmap.h> struct request_queue ;struct request ;
@@ -182,6 +183,8 @@ static inline void scsi_dh_add_device(struct scsi_device *sdev) { }static inline void scsi_dh_release_device (struct scsi_device *sdev) { }#endif +extern int scsi_device_max_queue_depth (struct scsi_device *sdev); +/* * internal scsi timeout functions: for use by mid-layer and transport * classes.
drivers/scsi/scsi_scan.c +21 -2
@@ -215,6 +215,7 @@ static void scsi_unlock_floptical(struct scsi_device *sdev,static struct scsi_device *scsi_alloc_sdev (struct scsi_target *starget,u64 lun,void *hostdata) { +unsigned int depth;struct scsi_device *sdev;int display_failure_msg =1 , ret;struct Scsi_Host *shost =dev_to_shost (starget->dev.parent);
@@ -276,8 +277,25 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,WARN_ON_ONCE (!blk_get_queue (sdev->request_queue)); sdev->request_queue->queuedata = sdev; -scsi_change_queue_depth (sdev, sdev->host->cmd_per_lun ? - sdev->host->cmd_per_lun :1 ); + depth = sdev->host->cmd_per_lun ?:1 ; + +/* +* Use .can_queue as budget map's depth because we have to +* support adjusting queue depth from sysfs. Meantime use +* default device queue depth to figure out sbitmap shift +* since we use this queue depth most of times. +*/ +if (sbitmap_init_node (&sdev->budget_map, +scsi_device_max_queue_depth (sdev), +sbitmap_calculate_shift (depth), +GFP_KERNEL , sdev->request_queue->node, + false, true)) { +put_device (&starget->dev); +kfree (sdev); + goto out; + } + +scsi_change_queue_depth (sdev, depth);scsi_sysfs_device_initialize (sdev);
@@ -979,6 +997,7 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,scsi_attach_vpd (sdev); sdev->max_queue_depth = sdev->queue_depth; +WARN_ON_ONCE (sdev->max_queue_depth > sdev->budget_map.depth); sdev->sdev_bflags = *bflags;/*
drivers/scsi/scsi_sysfs.c +2 -0
@@ -477,6 +477,8 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)/* NULL queue means the device can't be used */ sdev->request_queue =NULL ; +sbitmap_free (&sdev->budget_map); +mutex_lock (&sdev->inquiry_mutex); vpd_pg0 =rcu_replace_pointer (sdev->vpd_pg0, vpd_pg0,lockdep_is_held (&sdev->inquiry_mutex));
include/scsi/scsi_device.h +3 -2
@@ -8,6 +8,7 @@#include <linux/blkdev.h> #include <scsi/scsi.h> #include <linux/atomic.h> +#include <linux/sbitmap.h> struct device ;struct request_queue ;
@@ -106,7 +107,7 @@ struct scsi_device {struct list_head siblings;/* list of all devices on this host */ struct list_head same_target_siblings;/* just the devices sharing same target id */ -atomic_t device_busy;/* commands actually active on LLDD */ +struct sbitmap budget_map;atomic_t device_blocked;/* Device returned QUEUE_FULL. */ atomic_t restarts;
@@ -592,7 +593,7 @@ static inline int scsi_device_supports_vpd(struct scsi_device *sdev)static inline int scsi_device_busy (struct scsi_device *sdev) { -return atomic_read (&sdev->device_busy); +return sbitmap_weight (&sdev->budget_map); }#define MODULE_ALIAS_SCSI_DEVICE (type) \
Signature · 1 line
2.28.0
Ming,
Quoted 5 lines
The last four patches changes SCSI for switching to track device queue depth via sbitmap.
The patchset have been tested by Broadcom, and obvious performance boost can be observed on
megaraid_sas.
This series deadlocks SCSI scanning for me on every system I have in my test setup (mpt2sas, mpt3sas, megaraid_sas, qla2xxx, lpfc).
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
A message that is not in the archive (sent off-list or not yet received): 20210131115245.GA1979183@T590
Ming,
Quoted 1 line
BTW, which tree are you based for applying this patchset?
5.12/scsi-queue
Quoted 3 lines
I apply the patchset against for-5.12/block, and run it on kvm with 'megasas' device(LSI MegaRAID SAS 1078), looks it works well, and not see the hang issue.
I tried with for-5.12/block and it still breaks for me. Things work fine up until:
scsi: core: Replace sdev->device_busy with sbitmap
After that patch is applied no disks are discovered on my SAS/FC hosts.
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
Hi Martin,
Quoted 11 lines · Martin K. Petersen
Ming,
Quoted 1 line
BTW, which tree are you based for applying this patchset?
5.12/scsi-queue
Quoted 3 lines
I apply the patchset against for-5.12/block, and run it on kvm with 'megasas' device(LSI MegaRAID SAS 1078), looks it works well, and not see the hang issue.
Quoted 6 lines
I tried with for-5.12/block and it still breaks for me. Things work fine up until:
scsi: core: Replace
sdev->device_busywith sbitmapAfter that patch is applied no disks are discovered on my SAS/FC hosts.
I think the following patch should fix the issue, care to give a test?
drivers/scsi/scsi_lib.c +5 -1
@@ -1266,7 +1266,10 @@ static inline int scsi_dev_queue_ready(struct request_queue *q, token =sbitmap_get (&sdev->budget_map);if (atomic_read (&sdev->device_blocked)) { -if (token >=0 ) +if (token <0 ) + goto out; + +if (scsi_device_busy (sdev) >1 ) goto out_dec;/*
@@ -1282,6 +1285,7 @@ static inline int scsi_dev_queue_ready(struct request_queue *q, out_dec:if (token >=0 )sbitmap_put (&sdev->budget_map, token); +out:return -1 ; }
Signature · 1 line
Ming
Hi Ming,
Quoted 1 line
I think the following patch should fix the issue, care to give a test?
It appears to work my main system. Will try the rest of my test setup tomorrow.
Thanks!
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering