| Message ID | 20230811213604.548235-3-bvanassche@acm.org (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Improve performance for zoned UFS devices | expand |
On 8/12/23 06:35, Bart Van Assche wrote: > Measurements have shown that limiting the queue depth to one per zone for > zoned writes has a significant negative performance impact on zoned UFS > devices. Hence this patch that disables zone locking by the mq-deadline > scheduler if the storage controller preserves the command order. This > patch is based on the following assumptions: > - It happens infrequently that zoned write requests are reordered by the > block layer. > - The I/O priority of all write requests is the same per zone. > - Either no I/O scheduler is used or an I/O scheduler is used that > serializes write requests per zone. > > Cc: Damien Le Moal <dlemoal@kernel.org> > Cc: Christoph Hellwig <hch@lst.de> > Cc: Ming Lei <ming.lei@redhat.com> > Signed-off-by: Bart Van Assche <bvanassche@acm.org> > --- > block/mq-deadline.c | 14 ++++++++------ > 1 file changed, 8 insertions(+), 6 deletions(-) > > diff --git a/block/mq-deadline.c b/block/mq-deadline.c > index f958e79277b8..5c2fc4003bc0 100644 > --- a/block/mq-deadline.c > +++ b/block/mq-deadline.c > @@ -353,7 +353,7 @@ deadline_fifo_request(struct deadline_data *dd, struct dd_per_prio *per_prio, > return NULL; > > rq = rq_entry_fifo(per_prio->fifo_list[data_dir].next); > - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) > + if (data_dir == DD_READ || !rq->q->limits.use_zone_write_lock) > return rq; > > /* > @@ -398,7 +398,7 @@ deadline_next_request(struct deadline_data *dd, struct dd_per_prio *per_prio, > if (!rq) > return NULL; > > - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) > + if (data_dir == DD_READ || !rq->q->limits.use_zone_write_lock) > return rq; > > /* > @@ -526,8 +526,9 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, > } > > /* > - * For a zoned block device, if we only have writes queued and none of > - * them can be dispatched, rq will be NULL. > + * For a zoned block device that requires write serialization, if we > + * only have writes queued and none of them can be dispatched, rq will > + * be NULL. > */ > if (!rq) > return NULL; > @@ -552,7 +553,8 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, > /* > * If the request needs its target zone locked, do it. > */ > - blk_req_zone_write_lock(rq); > + if (rq->q->limits.use_zone_write_lock) > + blk_req_zone_write_lock(rq); > rq->rq_flags |= RQF_STARTED; > return rq; > } > @@ -934,7 +936,7 @@ static void dd_finish_request(struct request *rq) > > atomic_inc(&per_prio->stats.completed); > > - if (blk_queue_is_zoned(q)) { > + if (rq->q->limits.use_zone_write_lock) { This is all nice and simple ! However, an inline helper to check rq->q->limits.use_zone_write_lock would be nice. E.g. blk_queue_use_zone_write_lock() ? > unsigned long flags; > > spin_lock_irqsave(&dd->zone_lock, flags);
On 8/14/23 05:33, Damien Le Moal wrote: > On 8/12/23 06:35, Bart Van Assche wrote: >> @@ -934,7 +936,7 @@ static void dd_finish_request(struct request *rq) >> >> atomic_inc(&per_prio->stats.completed); >> >> - if (blk_queue_is_zoned(q)) { >> + if (rq->q->limits.use_zone_write_lock) { > > This is all nice and simple ! However, an inline helper to check > rq->q->limits.use_zone_write_lock would be nice. E.g. > blk_queue_use_zone_write_lock() ? Hi Damien, Do you perhaps want me to introduce a function that does nothing else than returning the value of q->limits.use_zone_write_lock? I'm asking this because recently I have seen a fair number of patches that remove functions that do nothing else than returning the value of a single member variable. Thanks, Bart.
On 8/15/23 02:00, Bart Van Assche wrote: > On 8/14/23 05:33, Damien Le Moal wrote: >> On 8/12/23 06:35, Bart Van Assche wrote: >>> @@ -934,7 +936,7 @@ static void dd_finish_request(struct request *rq) >>> >>> atomic_inc(&per_prio->stats.completed); >>> >>> - if (blk_queue_is_zoned(q)) { >>> + if (rq->q->limits.use_zone_write_lock) { >> >> This is all nice and simple ! However, an inline helper to check >> rq->q->limits.use_zone_write_lock would be nice. E.g. >> blk_queue_use_zone_write_lock() ? > > Hi Damien, > > Do you perhaps want me to introduce a function that does nothing else than > returning the value of q->limits.use_zone_write_lock? I'm asking this because > recently I have seen a fair number of patches that remove functions that do > nothing else than returning the value of a single member variable. I think that what you proposed in your other email (modify blk_req_needs_zone_write_lock) is better when you need to test use_zone_write_lock using a request. Not sure about the cases where we need to test that limit using the queue only. I personally like helpers that avoid hardcoding accesses to the queue limits, but if such helpers are not OK, that is fine. No strong opinion. > > Thanks, > > Bart. >
diff --git a/block/mq-deadline.c b/block/mq-deadline.c index f958e79277b8..5c2fc4003bc0 100644 --- a/block/mq-deadline.c +++ b/block/mq-deadline.c @@ -353,7 +353,7 @@ deadline_fifo_request(struct deadline_data *dd, struct dd_per_prio *per_prio, return NULL; rq = rq_entry_fifo(per_prio->fifo_list[data_dir].next); - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) + if (data_dir == DD_READ || !rq->q->limits.use_zone_write_lock) return rq; /* @@ -398,7 +398,7 @@ deadline_next_request(struct deadline_data *dd, struct dd_per_prio *per_prio, if (!rq) return NULL; - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) + if (data_dir == DD_READ || !rq->q->limits.use_zone_write_lock) return rq; /* @@ -526,8 +526,9 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, } /* - * For a zoned block device, if we only have writes queued and none of - * them can be dispatched, rq will be NULL. + * For a zoned block device that requires write serialization, if we + * only have writes queued and none of them can be dispatched, rq will + * be NULL. */ if (!rq) return NULL; @@ -552,7 +553,8 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, /* * If the request needs its target zone locked, do it. */ - blk_req_zone_write_lock(rq); + if (rq->q->limits.use_zone_write_lock) + blk_req_zone_write_lock(rq); rq->rq_flags |= RQF_STARTED; return rq; } @@ -934,7 +936,7 @@ static void dd_finish_request(struct request *rq) atomic_inc(&per_prio->stats.completed); - if (blk_queue_is_zoned(q)) { + if (rq->q->limits.use_zone_write_lock) { unsigned long flags; spin_lock_irqsave(&dd->zone_lock, flags);
Measurements have shown that limiting the queue depth to one per zone for zoned writes has a significant negative performance impact on zoned UFS devices. Hence this patch that disables zone locking by the mq-deadline scheduler if the storage controller preserves the command order. This patch is based on the following assumptions: - It happens infrequently that zoned write requests are reordered by the block layer. - The I/O priority of all write requests is the same per zone. - Either no I/O scheduler is used or an I/O scheduler is used that serializes write requests per zone. Cc: Damien Le Moal <dlemoal@kernel.org> Cc: Christoph Hellwig <hch@lst.de> Cc: Ming Lei <ming.lei@redhat.com> Signed-off-by: Bart Van Assche <bvanassche@acm.org> --- block/mq-deadline.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)