From: Yu Kuai <[email protected]>
Changes in v11:
- keep the comments in bfq_weights_tree_remove() and move it to the
caller where bfqq can be freed.
- add two followed up cleanup patches.
Changes in v10:
- Add reviewed-tag for patch 2
Changes in v9:
- also update how many bfqqs have pending_reqs bfq_bfqq_move().
- fix one language in patch 4
- Add reviewed-tag for patch 1,3,4
Changes in v8:
- Instead of using whether bfqq is busy, using whether bfqq has pending
requests. As Paolo pointed out the former way is problematic.
Changes in v7:
- fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
also retest this patchset on v5.18 to make sure functionality is
correct.
- move the updating of 'bfqd->busy_queues' into new apis
Changes in v6:
- add reviewed-by tag for patch 1
Changes in v5:
- rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
- fix wrong definition in patch 1
- fix spelling mistake in patch 2: leaset -> least
- update comments in patch 3
- add reviewed-by tag in patch 2,3
Changes in v4:
- split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
suggested by Jan Kara.
- remove unused 'in_groups_with_pending_reqs',
Changes in v3:
- remove the cleanup patch that is irrelevant now(I'll post it
separately).
- instead of hacking wr queues and using weights tree insertion/removal,
using bfq_add/del_bfqq_busy() to count the number of groups
(suggested by Jan Kara).
Changes in v2:
- Use a different approch to count root group, which is much simple.
Currently, bfq can't handle sync io concurrently as long as they
are not issued from root group. This is because
'bfqd->num_groups_with_pending_reqs > 0' is always true in
bfq_asymmetric_scenario().
The way that bfqg is counted into 'num_groups_with_pending_reqs':
Before this patchset:
1) root group will never be counted.
2) Count if bfqg or it's child bfqgs have pending requests.
3) Don't count if bfqg and it's child bfqgs complete all the requests.
After this patchset:
1) root group is counted.
2) Count if bfqg has pending requests.
3) Don't count if bfqg complete all the requests.
With the above changes, concurrent sync io can be supported if only
one group is activated.
fio test script(startdelay is used to avoid queue merging):
[global]
filename=/dev/sda
allow_mounted_write=0
ioengine=psync
direct=1
ioscheduler=bfq
offset_increment=10g
group_reporting
rw=randwrite
bs=4k
[test1]
numjobs=1
[test2]
startdelay=1
numjobs=1
[test3]
startdelay=2
numjobs=1
[test4]
startdelay=3
numjobs=1
[test5]
startdelay=4
numjobs=1
[test6]
startdelay=5
numjobs=1
[test7]
startdelay=6
numjobs=1
[test8]
startdelay=7
numjobs=1
test result:
running fio on root cgroup
v5.18: 112 Mib/s
v5.18-patched: 112 Mib/s
running fio on non-root cgroup
v5.18: 51.2 Mib/s
v5.18-patched: 112 Mib/s
Note that I also test null_blk with "irqmode=2
completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
that service guarantees are still preserved.
Previous versions:
RFC: https://lore.kernel.org/all/[email protected]/
v1: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/all/[email protected]/
v3: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/all/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/[email protected]/
Yu Kuai (6):
block, bfq: support to track if bfqq has pending requests
block, bfq: record how many queues have pending requests
block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
block, bfq: do not idle if only one group is activated
block, bfq: cleanup bfq_weights_tree add/remove apis
block, bfq: cleanup __bfq_weights_tree_remove()
block/bfq-cgroup.c | 10 +++++++
block/bfq-iosched.c | 71 +++++++--------------------------------------
block/bfq-iosched.h | 30 +++++++++----------
block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
4 files changed, 76 insertions(+), 104 deletions(-)
--
2.31.1
From: Yu Kuai <[email protected]>
Now that root group is counted into 'num_groups_with_pending_reqs',
'num_groups_with_pending_reqs > 0' is always true in
bfq_asymmetric_scenario(). Thus change the condition to '> 1'.
On the other hand, this change can enable concurrent sync io if only
one group is activated.
Signed-off-by: Yu Kuai <[email protected]>
Reviewed-by: Jan Kara <[email protected]>
---
block/bfq-iosched.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index 970b302a7a3e..6d95b0e488a8 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -820,7 +820,7 @@ bfq_pos_tree_add_move(struct bfq_data *bfqd, struct bfq_queue *bfqq)
* much easier to maintain the needed state:
* 1) all active queues have the same weight,
* 2) all active queues belong to the same I/O-priority class,
- * 3) there are no active groups.
+ * 3) there is at most one active group.
* In particular, the last condition is always true if hierarchical
* support or the cgroups interface are not enabled, thus no state
* needs to be maintained in this case.
@@ -852,7 +852,7 @@ static bool bfq_asymmetric_scenario(struct bfq_data *bfqd,
return varied_queue_weights || multiple_classes_busy
#ifdef CONFIG_BFQ_GROUP_IOSCHED
- || bfqd->num_groups_with_pending_reqs > 0
+ || bfqd->num_groups_with_pending_reqs > 1
#endif
;
}
--
2.31.1
From: Yu Kuai <[email protected]>
It's the same with bfq_weights_tree_remove() now.
Signed-off-by: Yu Kuai <[email protected]>
Reviewed-by: Jan Kara <[email protected]>
---
block/bfq-iosched.c | 11 +----------
block/bfq-iosched.h | 1 -
block/bfq-wf2q.c | 2 +-
3 files changed, 2 insertions(+), 12 deletions(-)
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index 4ad4fa0dad4a..c14fb6b2a46d 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -944,7 +944,7 @@ void bfq_weights_tree_add(struct bfq_queue *bfqq)
* See the comments to the function bfq_weights_tree_add() for considerations
* about overhead.
*/
-void __bfq_weights_tree_remove(struct bfq_queue *bfqq)
+void bfq_weights_tree_remove(struct bfq_queue *bfqq)
{
struct rb_root_cached *root;
@@ -964,15 +964,6 @@ void __bfq_weights_tree_remove(struct bfq_queue *bfqq)
bfq_put_queue(bfqq);
}
-/*
- * Invoke __bfq_weights_tree_remove on bfqq and decrement the number
- * of active groups for each queue's inactive parent entity.
- */
-void bfq_weights_tree_remove(struct bfq_queue *bfqq)
-{
- __bfq_weights_tree_remove(bfqq);
-}
-
/*
* Return expired entry, or NULL to just start from scratch in rbtree.
*/
diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index 4bb58ab0c90a..7795aaf4454f 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -974,7 +974,6 @@ void bic_set_bfqq(struct bfq_io_cq *bic, struct bfq_queue *bfqq, bool is_sync);
struct bfq_data *bic_to_bfqd(struct bfq_io_cq *bic);
void bfq_pos_tree_add_move(struct bfq_data *bfqd, struct bfq_queue *bfqq);
void bfq_weights_tree_add(struct bfq_queue *bfqq);
-void __bfq_weights_tree_remove(struct bfq_queue *bfqq);
void bfq_weights_tree_remove(struct bfq_queue *bfqq);
void bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq,
bool compensate, enum bfqq_expiration reason);
diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
index 124aaea6196e..5a02cb94d86e 100644
--- a/block/bfq-wf2q.c
+++ b/block/bfq-wf2q.c
@@ -770,7 +770,7 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
* there is a counter associated with the entity).
*/
if (prev_weight != new_weight && bfqq)
- __bfq_weights_tree_remove(bfqq);
+ bfq_weights_tree_remove(bfqq);
entity->weight = new_weight;
/*
* Add the entity, if it is not a weight-raised queue,
--
2.31.1
From: Yu Kuai <[email protected]>
The 'bfq_data' and 'rb_root_cached' can both be accessed through
'bfq_queue', thus only pass 'bfq_queue' as parameter.
Signed-off-by: Yu Kuai <[email protected]>
---
block/bfq-iosched.c | 19 +++++++++----------
block/bfq-iosched.h | 10 +++-------
block/bfq-wf2q.c | 18 ++++++------------
3 files changed, 18 insertions(+), 29 deletions(-)
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index 6d95b0e488a8..4ad4fa0dad4a 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -870,9 +870,9 @@ static bool bfq_asymmetric_scenario(struct bfq_data *bfqd,
* In most scenarios, the rate at which nodes are created/destroyed
* should be low too.
*/
-void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
- struct rb_root_cached *root)
+void bfq_weights_tree_add(struct bfq_queue *bfqq)
{
+ struct rb_root_cached *root = &bfqq->bfqd->queue_weights_tree;
struct bfq_entity *entity = &bfqq->entity;
struct rb_node **new = &(root->rb_root.rb_node), *parent = NULL;
bool leftmost = true;
@@ -944,13 +944,14 @@ void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
* See the comments to the function bfq_weights_tree_add() for considerations
* about overhead.
*/
-void __bfq_weights_tree_remove(struct bfq_data *bfqd,
- struct bfq_queue *bfqq,
- struct rb_root_cached *root)
+void __bfq_weights_tree_remove(struct bfq_queue *bfqq)
{
+ struct rb_root_cached *root;
+
if (!bfqq->weight_counter)
return;
+ root = &bfqq->bfqd->queue_weights_tree;
bfqq->weight_counter->num_active--;
if (bfqq->weight_counter->num_active > 0)
goto reset_entity_pointer;
@@ -967,11 +968,9 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
* Invoke __bfq_weights_tree_remove on bfqq and decrement the number
* of active groups for each queue's inactive parent entity.
*/
-void bfq_weights_tree_remove(struct bfq_data *bfqd,
- struct bfq_queue *bfqq)
+void bfq_weights_tree_remove(struct bfq_queue *bfqq)
{
- __bfq_weights_tree_remove(bfqd, bfqq,
- &bfqd->queue_weights_tree);
+ __bfq_weights_tree_remove(bfqq);
}
/*
@@ -6220,7 +6219,7 @@ static void bfq_completed_request(struct bfq_queue *bfqq, struct bfq_data *bfqd)
bfqq->budget_timeout = jiffies;
bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
- bfq_weights_tree_remove(bfqd, bfqq);
+ bfq_weights_tree_remove(bfqq);
}
now_ns = ktime_get_ns();
diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index 257acb54c6dc..4bb58ab0c90a 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -973,13 +973,9 @@ struct bfq_queue *bic_to_bfqq(struct bfq_io_cq *bic, bool is_sync);
void bic_set_bfqq(struct bfq_io_cq *bic, struct bfq_queue *bfqq, bool is_sync);
struct bfq_data *bic_to_bfqd(struct bfq_io_cq *bic);
void bfq_pos_tree_add_move(struct bfq_data *bfqd, struct bfq_queue *bfqq);
-void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
- struct rb_root_cached *root);
-void __bfq_weights_tree_remove(struct bfq_data *bfqd,
- struct bfq_queue *bfqq,
- struct rb_root_cached *root);
-void bfq_weights_tree_remove(struct bfq_data *bfqd,
- struct bfq_queue *bfqq);
+void bfq_weights_tree_add(struct bfq_queue *bfqq);
+void __bfq_weights_tree_remove(struct bfq_queue *bfqq);
+void bfq_weights_tree_remove(struct bfq_queue *bfqq);
void bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq,
bool compensate, enum bfqq_expiration reason);
void bfq_put_queue(struct bfq_queue *bfqq);
diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
index 5e8224c96921..124aaea6196e 100644
--- a/block/bfq-wf2q.c
+++ b/block/bfq-wf2q.c
@@ -707,7 +707,6 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
struct bfq_queue *bfqq = bfq_entity_to_bfqq(entity);
unsigned int prev_weight, new_weight;
struct bfq_data *bfqd = NULL;
- struct rb_root_cached *root;
#ifdef CONFIG_BFQ_GROUP_IOSCHED
struct bfq_sched_data *sd;
struct bfq_group *bfqg;
@@ -770,19 +769,15 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
* queue, remove the entity from its old weight counter (if
* there is a counter associated with the entity).
*/
- if (prev_weight != new_weight && bfqq) {
- root = &bfqd->queue_weights_tree;
- __bfq_weights_tree_remove(bfqd, bfqq, root);
- }
+ if (prev_weight != new_weight && bfqq)
+ __bfq_weights_tree_remove(bfqq);
entity->weight = new_weight;
/*
* Add the entity, if it is not a weight-raised queue,
* to the counter associated with its new weight.
*/
- if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1) {
- /* If we get here, root has been initialized. */
- bfq_weights_tree_add(bfqd, bfqq, root);
- }
+ if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1)
+ bfq_weights_tree_add(bfqq);
new_st->wsum += entity->weight;
@@ -1687,7 +1682,7 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
* Next function is invoked last, because it causes bfqq to be
* freed. DO NOT use bfqq after the next function invocation.
*/
- bfq_weights_tree_remove(bfqd, bfqq);
+ bfq_weights_tree_remove(bfqq);
}
}
@@ -1708,8 +1703,7 @@ void bfq_add_bfqq_busy(struct bfq_queue *bfqq)
if (!bfqq->dispatched) {
bfq_add_bfqq_in_groups_with_pending_reqs(bfqq);
if (bfqq->wr_coeff == 1)
- bfq_weights_tree_add(bfqd, bfqq,
- &bfqd->queue_weights_tree);
+ bfq_weights_tree_add(bfqq);
}
if (bfqq->wr_coeff > 1)
--
2.31.1
From: Yu Kuai <[email protected]>
Currently, bfq can't handle sync io concurrently as long as they
are not issued from root group. This is because
'bfqd->num_groups_with_pending_reqs > 0' is always true in
bfq_asymmetric_scenario().
The way that bfqg is counted into 'num_groups_with_pending_reqs':
Before this patch:
1) root group will never be counted.
2) Count if bfqg or it's child bfqgs have pending requests.
3) Don't count if bfqg and it's child bfqgs complete all the requests.
After this patch:
1) root group is counted.
2) Count if bfqg have pending requests.
3) Don't count if bfqg complete all the requests.
With this change, the occasion that only one group is activated can be
detected, and next patch will support concurrent sync io in the
occasion.
Signed-off-by: Yu Kuai <[email protected]>
Reviewed-by: Jan Kara <[email protected]>
---
block/bfq-iosched.c | 42 ------------------------------------------
block/bfq-iosched.h | 18 +++++++++---------
block/bfq-wf2q.c | 23 ++++++++---------------
3 files changed, 17 insertions(+), 66 deletions(-)
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index 0dcae2f52896..970b302a7a3e 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -970,48 +970,6 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
void bfq_weights_tree_remove(struct bfq_data *bfqd,
struct bfq_queue *bfqq)
{
- struct bfq_entity *entity = bfqq->entity.parent;
-
- for_each_entity(entity) {
- struct bfq_sched_data *sd = entity->my_sched_data;
-
- if (sd->next_in_service || sd->in_service_entity) {
- /*
- * entity is still active, because either
- * next_in_service or in_service_entity is not
- * NULL (see the comments on the definition of
- * next_in_service for details on why
- * in_service_entity must be checked too).
- *
- * As a consequence, its parent entities are
- * active as well, and thus this loop must
- * stop here.
- */
- break;
- }
-
- /*
- * The decrement of num_groups_with_pending_reqs is
- * not performed immediately upon the deactivation of
- * entity, but it is delayed to when it also happens
- * that the first leaf descendant bfqq of entity gets
- * all its pending requests completed. The following
- * instructions perform this delayed decrement, if
- * needed. See the comments on
- * num_groups_with_pending_reqs for details.
- */
- if (entity->in_groups_with_pending_reqs) {
- entity->in_groups_with_pending_reqs = false;
- bfqd->num_groups_with_pending_reqs--;
- }
- }
-
- /*
- * Next function is invoked last, because it causes bfqq to be
- * freed if the following holds: bfqq is not in service and
- * has no dispatched request. DO NOT use bfqq after the next
- * function invocation.
- */
__bfq_weights_tree_remove(bfqd, bfqq,
&bfqd->queue_weights_tree);
}
diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index 338ff5418ea8..257acb54c6dc 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -496,27 +496,27 @@ struct bfq_data {
struct rb_root_cached queue_weights_tree;
/*
- * Number of groups with at least one descendant process that
+ * Number of groups with at least one process that
* has at least one request waiting for completion. Note that
* this accounts for also requests already dispatched, but not
* yet completed. Therefore this number of groups may differ
* (be larger) than the number of active groups, as a group is
* considered active only if its corresponding entity has
- * descendant queues with at least one request queued. This
+ * queues with at least one request queued. This
* number is used to decide whether a scenario is symmetric.
* For a detailed explanation see comments on the computation
* of the variable asymmetric_scenario in the function
* bfq_better_to_idle().
*
* However, it is hard to compute this number exactly, for
- * groups with multiple descendant processes. Consider a group
- * that is inactive, i.e., that has no descendant process with
+ * groups with multiple processes. Consider a group
+ * that is inactive, i.e., that has no process with
* pending I/O inside BFQ queues. Then suppose that
* num_groups_with_pending_reqs is still accounting for this
- * group, because the group has descendant processes with some
+ * group, because the group has processes with some
* I/O request still in flight. num_groups_with_pending_reqs
* should be decremented when the in-flight request of the
- * last descendant process is finally completed (assuming that
+ * last process is finally completed (assuming that
* nothing else has changed for the group in the meantime, in
* terms of composition of the group and active/inactive state of child
* groups and processes). To accomplish this, an additional
@@ -525,7 +525,7 @@ struct bfq_data {
* we resort to the following tradeoff between simplicity and
* accuracy: for an inactive group that is still counted in
* num_groups_with_pending_reqs, we decrement
- * num_groups_with_pending_reqs when the first descendant
+ * num_groups_with_pending_reqs when the first
* process of the group remains with no request waiting for
* completion.
*
@@ -533,12 +533,12 @@ struct bfq_data {
* carefulness: to avoid multiple decrements, we flag a group,
* more precisely an entity representing a group, as still
* counted in num_groups_with_pending_reqs when it becomes
- * inactive. Then, when the first descendant queue of the
+ * inactive. Then, when the first queue of the
* entity remains with no request waiting for completion,
* num_groups_with_pending_reqs is decremented, and this flag
* is reset. After this flag is reset for the entity,
* num_groups_with_pending_reqs won't be decremented any
- * longer in case a new descendant queue of the entity remains
+ * longer in case a new queue of the entity remains
* with no request waiting for completion.
*/
unsigned int num_groups_with_pending_reqs;
diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
index 5549ccf09cd2..5e8224c96921 100644
--- a/block/bfq-wf2q.c
+++ b/block/bfq-wf2q.c
@@ -984,19 +984,6 @@ static void __bfq_activate_entity(struct bfq_entity *entity,
entity->on_st_or_in_serv = true;
}
-#ifdef CONFIG_BFQ_GROUP_IOSCHED
- if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */
- struct bfq_group *bfqg =
- container_of(entity, struct bfq_group, entity);
- struct bfq_data *bfqd = bfqg->bfqd;
-
- if (!entity->in_groups_with_pending_reqs) {
- entity->in_groups_with_pending_reqs = true;
- bfqd->num_groups_with_pending_reqs++;
- }
- }
-#endif
-
bfq_update_fin_time_enqueue(entity, st, backshifted);
}
@@ -1653,7 +1640,8 @@ void bfq_add_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
if (!entity->in_groups_with_pending_reqs) {
entity->in_groups_with_pending_reqs = true;
#ifdef CONFIG_BFQ_GROUP_IOSCHED
- bfqq_group(bfqq)->num_queues_with_pending_reqs++;
+ if (!(bfqq_group(bfqq)->num_queues_with_pending_reqs++))
+ bfqq->bfqd->num_groups_with_pending_reqs++;
#endif
}
}
@@ -1665,7 +1653,8 @@ void bfq_del_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
if (entity->in_groups_with_pending_reqs) {
entity->in_groups_with_pending_reqs = false;
#ifdef CONFIG_BFQ_GROUP_IOSCHED
- bfqq_group(bfqq)->num_queues_with_pending_reqs--;
+ if (!(--bfqq_group(bfqq)->num_queues_with_pending_reqs))
+ bfqq->bfqd->num_groups_with_pending_reqs--;
#endif
}
}
@@ -1694,6 +1683,10 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
if (!bfqq->dispatched) {
bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
+ /*
+ * Next function is invoked last, because it causes bfqq to be
+ * freed. DO NOT use bfqq after the next function invocation.
+ */
bfq_weights_tree_remove(bfqd, bfqq);
}
}
--
2.31.1
From: Yu Kuai <[email protected]>
If entity belongs to bfqq, then entity->in_groups_with_pending_reqs
is not used currently. This patch use it to track if bfqq has pending
requests through callers of weights_tree insertion and removal.
Signed-off-by: Yu Kuai <[email protected]>
Reviewed-by: Jan Kara <[email protected]>
---
block/bfq-iosched.c | 1 +
block/bfq-iosched.h | 2 ++
block/bfq-wf2q.c | 24 ++++++++++++++++++++++--
3 files changed, 25 insertions(+), 2 deletions(-)
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index f769c90744fd..0dcae2f52896 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -6261,6 +6261,7 @@ static void bfq_completed_request(struct bfq_queue *bfqq, struct bfq_data *bfqd)
*/
bfqq->budget_timeout = jiffies;
+ bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
bfq_weights_tree_remove(bfqd, bfqq);
}
diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index 64ee618064ba..44e08b194749 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -1082,6 +1082,8 @@ void bfq_requeue_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq,
bool expiration);
void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration);
void bfq_add_bfqq_busy(struct bfq_queue *bfqq);
+void bfq_add_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq);
+void bfq_del_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq);
/* --------------- end of interface of B-WF2Q+ ---------------- */
diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
index 8fc3da4c23bb..bd8f4ed84848 100644
--- a/block/bfq-wf2q.c
+++ b/block/bfq-wf2q.c
@@ -1646,6 +1646,22 @@ void bfq_requeue_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq,
bfqq == bfqd->in_service_queue, expiration);
}
+void bfq_add_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
+{
+ struct bfq_entity *entity = &bfqq->entity;
+
+ if (!entity->in_groups_with_pending_reqs)
+ entity->in_groups_with_pending_reqs = true;
+}
+
+void bfq_del_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
+{
+ struct bfq_entity *entity = &bfqq->entity;
+
+ if (entity->in_groups_with_pending_reqs)
+ entity->in_groups_with_pending_reqs = false;
+}
+
/*
* Called when the bfqq no longer has requests pending, remove it from
* the service tree. As a special case, it can be invoked during an
@@ -1668,8 +1684,10 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
bfq_deactivate_bfqq(bfqd, bfqq, true, expiration);
- if (!bfqq->dispatched)
+ if (!bfqq->dispatched) {
+ bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
bfq_weights_tree_remove(bfqd, bfqq);
+ }
}
/*
@@ -1686,10 +1704,12 @@ void bfq_add_bfqq_busy(struct bfq_queue *bfqq)
bfq_mark_bfqq_busy(bfqq);
bfqd->busy_queues[bfqq->ioprio_class - 1]++;
- if (!bfqq->dispatched)
+ if (!bfqq->dispatched) {
+ bfq_add_bfqq_in_groups_with_pending_reqs(bfqq);
if (bfqq->wr_coeff == 1)
bfq_weights_tree_add(bfqd, bfqq,
&bfqd->queue_weights_tree);
+ }
if (bfqq->wr_coeff > 1)
bfqd->wr_busy_queues++;
--
2.31.1
On Fri 16-09-22 15:19:41, Yu Kuai wrote:
> From: Yu Kuai <[email protected]>
>
> The 'bfq_data' and 'rb_root_cached' can both be accessed through
> 'bfq_queue', thus only pass 'bfq_queue' as parameter.
>
> Signed-off-by: Yu Kuai <[email protected]>
Looks good. Feel free to add:
Reviewed-by: Jan Kara <[email protected]>
Honza
> ---
> block/bfq-iosched.c | 19 +++++++++----------
> block/bfq-iosched.h | 10 +++-------
> block/bfq-wf2q.c | 18 ++++++------------
> 3 files changed, 18 insertions(+), 29 deletions(-)
>
> diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
> index 6d95b0e488a8..4ad4fa0dad4a 100644
> --- a/block/bfq-iosched.c
> +++ b/block/bfq-iosched.c
> @@ -870,9 +870,9 @@ static bool bfq_asymmetric_scenario(struct bfq_data *bfqd,
> * In most scenarios, the rate at which nodes are created/destroyed
> * should be low too.
> */
> -void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
> - struct rb_root_cached *root)
> +void bfq_weights_tree_add(struct bfq_queue *bfqq)
> {
> + struct rb_root_cached *root = &bfqq->bfqd->queue_weights_tree;
> struct bfq_entity *entity = &bfqq->entity;
> struct rb_node **new = &(root->rb_root.rb_node), *parent = NULL;
> bool leftmost = true;
> @@ -944,13 +944,14 @@ void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
> * See the comments to the function bfq_weights_tree_add() for considerations
> * about overhead.
> */
> -void __bfq_weights_tree_remove(struct bfq_data *bfqd,
> - struct bfq_queue *bfqq,
> - struct rb_root_cached *root)
> +void __bfq_weights_tree_remove(struct bfq_queue *bfqq)
> {
> + struct rb_root_cached *root;
> +
> if (!bfqq->weight_counter)
> return;
>
> + root = &bfqq->bfqd->queue_weights_tree;
> bfqq->weight_counter->num_active--;
> if (bfqq->weight_counter->num_active > 0)
> goto reset_entity_pointer;
> @@ -967,11 +968,9 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
> * Invoke __bfq_weights_tree_remove on bfqq and decrement the number
> * of active groups for each queue's inactive parent entity.
> */
> -void bfq_weights_tree_remove(struct bfq_data *bfqd,
> - struct bfq_queue *bfqq)
> +void bfq_weights_tree_remove(struct bfq_queue *bfqq)
> {
> - __bfq_weights_tree_remove(bfqd, bfqq,
> - &bfqd->queue_weights_tree);
> + __bfq_weights_tree_remove(bfqq);
> }
>
> /*
> @@ -6220,7 +6219,7 @@ static void bfq_completed_request(struct bfq_queue *bfqq, struct bfq_data *bfqd)
> bfqq->budget_timeout = jiffies;
>
> bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
> - bfq_weights_tree_remove(bfqd, bfqq);
> + bfq_weights_tree_remove(bfqq);
> }
>
> now_ns = ktime_get_ns();
> diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
> index 257acb54c6dc..4bb58ab0c90a 100644
> --- a/block/bfq-iosched.h
> +++ b/block/bfq-iosched.h
> @@ -973,13 +973,9 @@ struct bfq_queue *bic_to_bfqq(struct bfq_io_cq *bic, bool is_sync);
> void bic_set_bfqq(struct bfq_io_cq *bic, struct bfq_queue *bfqq, bool is_sync);
> struct bfq_data *bic_to_bfqd(struct bfq_io_cq *bic);
> void bfq_pos_tree_add_move(struct bfq_data *bfqd, struct bfq_queue *bfqq);
> -void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
> - struct rb_root_cached *root);
> -void __bfq_weights_tree_remove(struct bfq_data *bfqd,
> - struct bfq_queue *bfqq,
> - struct rb_root_cached *root);
> -void bfq_weights_tree_remove(struct bfq_data *bfqd,
> - struct bfq_queue *bfqq);
> +void bfq_weights_tree_add(struct bfq_queue *bfqq);
> +void __bfq_weights_tree_remove(struct bfq_queue *bfqq);
> +void bfq_weights_tree_remove(struct bfq_queue *bfqq);
> void bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq,
> bool compensate, enum bfqq_expiration reason);
> void bfq_put_queue(struct bfq_queue *bfqq);
> diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
> index 5e8224c96921..124aaea6196e 100644
> --- a/block/bfq-wf2q.c
> +++ b/block/bfq-wf2q.c
> @@ -707,7 +707,6 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
> struct bfq_queue *bfqq = bfq_entity_to_bfqq(entity);
> unsigned int prev_weight, new_weight;
> struct bfq_data *bfqd = NULL;
> - struct rb_root_cached *root;
> #ifdef CONFIG_BFQ_GROUP_IOSCHED
> struct bfq_sched_data *sd;
> struct bfq_group *bfqg;
> @@ -770,19 +769,15 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
> * queue, remove the entity from its old weight counter (if
> * there is a counter associated with the entity).
> */
> - if (prev_weight != new_weight && bfqq) {
> - root = &bfqd->queue_weights_tree;
> - __bfq_weights_tree_remove(bfqd, bfqq, root);
> - }
> + if (prev_weight != new_weight && bfqq)
> + __bfq_weights_tree_remove(bfqq);
> entity->weight = new_weight;
> /*
> * Add the entity, if it is not a weight-raised queue,
> * to the counter associated with its new weight.
> */
> - if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1) {
> - /* If we get here, root has been initialized. */
> - bfq_weights_tree_add(bfqd, bfqq, root);
> - }
> + if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1)
> + bfq_weights_tree_add(bfqq);
>
> new_st->wsum += entity->weight;
>
> @@ -1687,7 +1682,7 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
> * Next function is invoked last, because it causes bfqq to be
> * freed. DO NOT use bfqq after the next function invocation.
> */
> - bfq_weights_tree_remove(bfqd, bfqq);
> + bfq_weights_tree_remove(bfqq);
> }
> }
>
> @@ -1708,8 +1703,7 @@ void bfq_add_bfqq_busy(struct bfq_queue *bfqq)
> if (!bfqq->dispatched) {
> bfq_add_bfqq_in_groups_with_pending_reqs(bfqq);
> if (bfqq->wr_coeff == 1)
> - bfq_weights_tree_add(bfqd, bfqq,
> - &bfqd->queue_weights_tree);
> + bfq_weights_tree_add(bfqq);
> }
>
> if (bfqq->wr_coeff > 1)
> --
> 2.31.1
>
--
Jan Kara <[email protected]>
SUSE Labs, CR
> Il giorno 19 set 2022, alle ore 10:46, Jan Kara <[email protected]> ha scritto:
>
> On Fri 16-09-22 15:19:41, Yu Kuai wrote:
>> From: Yu Kuai <[email protected]>
>>
>> The 'bfq_data' and 'rb_root_cached' can both be accessed through
>> 'bfq_queue', thus only pass 'bfq_queue' as parameter.
>>
>> Signed-off-by: Yu Kuai <[email protected]>
>
Thanks for keeping improving BFQ's code.
Acked-by: Paolo Valente <[email protected]>
> Looks good. Feel free to add:
>
> Reviewed-by: Jan Kara <[email protected]>
>
> Honza
>> ---
>> block/bfq-iosched.c | 19 +++++++++----------
>> block/bfq-iosched.h | 10 +++-------
>> block/bfq-wf2q.c | 18 ++++++------------
>> 3 files changed, 18 insertions(+), 29 deletions(-)
>>
>> diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
>> index 6d95b0e488a8..4ad4fa0dad4a 100644
>> --- a/block/bfq-iosched.c
>> +++ b/block/bfq-iosched.c
>> @@ -870,9 +870,9 @@ static bool bfq_asymmetric_scenario(struct bfq_data *bfqd,
>> * In most scenarios, the rate at which nodes are created/destroyed
>> * should be low too.
>> */
>> -void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
>> - struct rb_root_cached *root)
>> +void bfq_weights_tree_add(struct bfq_queue *bfqq)
>> {
>> + struct rb_root_cached *root = &bfqq->bfqd->queue_weights_tree;
>> struct bfq_entity *entity = &bfqq->entity;
>> struct rb_node **new = &(root->rb_root.rb_node), *parent = NULL;
>> bool leftmost = true;
>> @@ -944,13 +944,14 @@ void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
>> * See the comments to the function bfq_weights_tree_add() for considerations
>> * about overhead.
>> */
>> -void __bfq_weights_tree_remove(struct bfq_data *bfqd,
>> - struct bfq_queue *bfqq,
>> - struct rb_root_cached *root)
>> +void __bfq_weights_tree_remove(struct bfq_queue *bfqq)
>> {
>> + struct rb_root_cached *root;
>> +
>> if (!bfqq->weight_counter)
>> return;
>>
>> + root = &bfqq->bfqd->queue_weights_tree;
>> bfqq->weight_counter->num_active--;
>> if (bfqq->weight_counter->num_active > 0)
>> goto reset_entity_pointer;
>> @@ -967,11 +968,9 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
>> * Invoke __bfq_weights_tree_remove on bfqq and decrement the number
>> * of active groups for each queue's inactive parent entity.
>> */
>> -void bfq_weights_tree_remove(struct bfq_data *bfqd,
>> - struct bfq_queue *bfqq)
>> +void bfq_weights_tree_remove(struct bfq_queue *bfqq)
>> {
>> - __bfq_weights_tree_remove(bfqd, bfqq,
>> - &bfqd->queue_weights_tree);
>> + __bfq_weights_tree_remove(bfqq);
>> }
>>
>> /*
>> @@ -6220,7 +6219,7 @@ static void bfq_completed_request(struct bfq_queue *bfqq, struct bfq_data *bfqd)
>> bfqq->budget_timeout = jiffies;
>>
>> bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
>> - bfq_weights_tree_remove(bfqd, bfqq);
>> + bfq_weights_tree_remove(bfqq);
>> }
>>
>> now_ns = ktime_get_ns();
>> diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
>> index 257acb54c6dc..4bb58ab0c90a 100644
>> --- a/block/bfq-iosched.h
>> +++ b/block/bfq-iosched.h
>> @@ -973,13 +973,9 @@ struct bfq_queue *bic_to_bfqq(struct bfq_io_cq *bic, bool is_sync);
>> void bic_set_bfqq(struct bfq_io_cq *bic, struct bfq_queue *bfqq, bool is_sync);
>> struct bfq_data *bic_to_bfqd(struct bfq_io_cq *bic);
>> void bfq_pos_tree_add_move(struct bfq_data *bfqd, struct bfq_queue *bfqq);
>> -void bfq_weights_tree_add(struct bfq_data *bfqd, struct bfq_queue *bfqq,
>> - struct rb_root_cached *root);
>> -void __bfq_weights_tree_remove(struct bfq_data *bfqd,
>> - struct bfq_queue *bfqq,
>> - struct rb_root_cached *root);
>> -void bfq_weights_tree_remove(struct bfq_data *bfqd,
>> - struct bfq_queue *bfqq);
>> +void bfq_weights_tree_add(struct bfq_queue *bfqq);
>> +void __bfq_weights_tree_remove(struct bfq_queue *bfqq);
>> +void bfq_weights_tree_remove(struct bfq_queue *bfqq);
>> void bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq,
>> bool compensate, enum bfqq_expiration reason);
>> void bfq_put_queue(struct bfq_queue *bfqq);
>> diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
>> index 5e8224c96921..124aaea6196e 100644
>> --- a/block/bfq-wf2q.c
>> +++ b/block/bfq-wf2q.c
>> @@ -707,7 +707,6 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
>> struct bfq_queue *bfqq = bfq_entity_to_bfqq(entity);
>> unsigned int prev_weight, new_weight;
>> struct bfq_data *bfqd = NULL;
>> - struct rb_root_cached *root;
>> #ifdef CONFIG_BFQ_GROUP_IOSCHED
>> struct bfq_sched_data *sd;
>> struct bfq_group *bfqg;
>> @@ -770,19 +769,15 @@ __bfq_entity_update_weight_prio(struct bfq_service_tree *old_st,
>> * queue, remove the entity from its old weight counter (if
>> * there is a counter associated with the entity).
>> */
>> - if (prev_weight != new_weight && bfqq) {
>> - root = &bfqd->queue_weights_tree;
>> - __bfq_weights_tree_remove(bfqd, bfqq, root);
>> - }
>> + if (prev_weight != new_weight && bfqq)
>> + __bfq_weights_tree_remove(bfqq);
>> entity->weight = new_weight;
>> /*
>> * Add the entity, if it is not a weight-raised queue,
>> * to the counter associated with its new weight.
>> */
>> - if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1) {
>> - /* If we get here, root has been initialized. */
>> - bfq_weights_tree_add(bfqd, bfqq, root);
>> - }
>> + if (prev_weight != new_weight && bfqq && bfqq->wr_coeff == 1)
>> + bfq_weights_tree_add(bfqq);
>>
>> new_st->wsum += entity->weight;
>>
>> @@ -1687,7 +1682,7 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
>> * Next function is invoked last, because it causes bfqq to be
>> * freed. DO NOT use bfqq after the next function invocation.
>> */
>> - bfq_weights_tree_remove(bfqd, bfqq);
>> + bfq_weights_tree_remove(bfqq);
>> }
>> }
>>
>> @@ -1708,8 +1703,7 @@ void bfq_add_bfqq_busy(struct bfq_queue *bfqq)
>> if (!bfqq->dispatched) {
>> bfq_add_bfqq_in_groups_with_pending_reqs(bfqq);
>> if (bfqq->wr_coeff == 1)
>> - bfq_weights_tree_add(bfqd, bfqq,
>> - &bfqd->queue_weights_tree);
>> + bfq_weights_tree_add(bfqq);
>> }
>>
>> if (bfqq->wr_coeff > 1)
>> --
>> 2.31.1
>>
> --
> Jan Kara <[email protected]>
> SUSE Labs, CR
> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>
> From: Yu Kuai <[email protected]>
>
> Changes in v11:
> - keep the comments in bfq_weights_tree_remove() and move it to the
> caller where bfqq can be freed.
> - add two followed up cleanup patches.
>
> Changes in v10:
> - Add reviewed-tag for patch 2
>
> Changes in v9:
> - also update how many bfqqs have pending_reqs bfq_bfqq_move().
> - fix one language in patch 4
> - Add reviewed-tag for patch 1,3,4
>
> Changes in v8:
> - Instead of using whether bfqq is busy, using whether bfqq has pending
> requests. As Paolo pointed out the former way is problematic.
>
> Changes in v7:
> - fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
> also retest this patchset on v5.18 to make sure functionality is
> correct.
> - move the updating of 'bfqd->busy_queues' into new apis
>
> Changes in v6:
> - add reviewed-by tag for patch 1
>
> Changes in v5:
> - rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
> - fix wrong definition in patch 1
> - fix spelling mistake in patch 2: leaset -> least
> - update comments in patch 3
> - add reviewed-by tag in patch 2,3
>
> Changes in v4:
> - split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
> suggested by Jan Kara.
> - remove unused 'in_groups_with_pending_reqs',
>
> Changes in v3:
> - remove the cleanup patch that is irrelevant now(I'll post it
> separately).
> - instead of hacking wr queues and using weights tree insertion/removal,
> using bfq_add/del_bfqq_busy() to count the number of groups
> (suggested by Jan Kara).
>
> Changes in v2:
> - Use a different approch to count root group, which is much simple.
>
> Currently, bfq can't handle sync io concurrently as long as they
> are not issued from root group. This is because
> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
> bfq_asymmetric_scenario().
>
> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>
> Before this patchset:
> 1) root group will never be counted.
> 2) Count if bfqg or it's child bfqgs have pending requests.
> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>
> After this patchset:
> 1) root group is counted.
> 2) Count if bfqg has pending requests.
> 3) Don't count if bfqg complete all the requests.
>
> With the above changes, concurrent sync io can be supported if only
> one group is activated.
>
> fio test script(startdelay is used to avoid queue merging):
> [global]
> filename=/dev/sda
> allow_mounted_write=0
> ioengine=psync
> direct=1
> ioscheduler=bfq
> offset_increment=10g
> group_reporting
> rw=randwrite
> bs=4k
>
> [test1]
> numjobs=1
>
> [test2]
> startdelay=1
> numjobs=1
>
> [test3]
> startdelay=2
> numjobs=1
>
> [test4]
> startdelay=3
> numjobs=1
>
> [test5]
> startdelay=4
> numjobs=1
>
> [test6]
> startdelay=5
> numjobs=1
>
> [test7]
> startdelay=6
> numjobs=1
>
> [test8]
> startdelay=7
> numjobs=1
>
> test result:
> running fio on root cgroup
> v5.18: 112 Mib/s
> v5.18-patched: 112 Mib/s
>
> running fio on non-root cgroup
> v5.18: 51.2 Mib/s
> v5.18-patched: 112 Mib/s
>
> Note that I also test null_blk with "irqmode=2
> completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
> that service guarantees are still preserved.
>
Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
Thanks,
Paolo
> Previous versions:
> RFC: https://lore.kernel.org/all/[email protected]/
> v1: https://lore.kernel.org/all/[email protected]/
> v2: https://lore.kernel.org/all/[email protected]/
> v3: https://lore.kernel.org/all/[email protected]/
> v4: https://lore.kernel.org/all/[email protected]/
> v5: https://lore.kernel.org/all/[email protected]/
> v6: https://lore.kernel.org/all/[email protected]/
> v7: https://lore.kernel.org/all/[email protected]/
>
>
> Yu Kuai (6):
> block, bfq: support to track if bfqq has pending requests
> block, bfq: record how many queues have pending requests
> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
> block, bfq: do not idle if only one group is activated
> block, bfq: cleanup bfq_weights_tree add/remove apis
> block, bfq: cleanup __bfq_weights_tree_remove()
>
> block/bfq-cgroup.c | 10 +++++++
> block/bfq-iosched.c | 71 +++++++--------------------------------------
> block/bfq-iosched.h | 30 +++++++++----------
> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
> 4 files changed, 76 insertions(+), 104 deletions(-)
>
> --
> 2.31.1
>
> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>
> From: Yu Kuai <[email protected]>
>
> Currently, bfq can't handle sync io concurrently as long as they
> are not issued from root group. This is because
> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
> bfq_asymmetric_scenario().
>
> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>
> Before this patch:
> 1) root group will never be counted.
> 2) Count if bfqg or it's child bfqgs have pending requests.
> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>
> After this patch:
> 1) root group is counted.
> 2) Count if bfqg have pending requests.
> 3) Don't count if bfqg complete all the requests.
>
> With this change, the occasion that only one group is activated can be
> detected, and next patch will support concurrent sync io in the
> occasion.
>
> Signed-off-by: Yu Kuai <[email protected]>
> Reviewed-by: Jan Kara <[email protected]>
> ---
> block/bfq-iosched.c | 42 ------------------------------------------
> block/bfq-iosched.h | 18 +++++++++---------
> block/bfq-wf2q.c | 23 ++++++++---------------
> 3 files changed, 17 insertions(+), 66 deletions(-)
>
> diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
> index 0dcae2f52896..970b302a7a3e 100644
> --- a/block/bfq-iosched.c
> +++ b/block/bfq-iosched.c
> @@ -970,48 +970,6 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
> void bfq_weights_tree_remove(struct bfq_data *bfqd,
> struct bfq_queue *bfqq)
> {
> - struct bfq_entity *entity = bfqq->entity.parent;
> -
> - for_each_entity(entity) {
> - struct bfq_sched_data *sd = entity->my_sched_data;
> -
> - if (sd->next_in_service || sd->in_service_entity) {
> - /*
> - * entity is still active, because either
> - * next_in_service or in_service_entity is not
> - * NULL (see the comments on the definition of
> - * next_in_service for details on why
> - * in_service_entity must be checked too).
> - *
> - * As a consequence, its parent entities are
> - * active as well, and thus this loop must
> - * stop here.
> - */
> - break;
> - }
> -
> - /*
> - * The decrement of num_groups_with_pending_reqs is
> - * not performed immediately upon the deactivation of
> - * entity, but it is delayed to when it also happens
> - * that the first leaf descendant bfqq of entity gets
> - * all its pending requests completed. The following
> - * instructions perform this delayed decrement, if
> - * needed. See the comments on
> - * num_groups_with_pending_reqs for details.
> - */
> - if (entity->in_groups_with_pending_reqs) {
> - entity->in_groups_with_pending_reqs = false;
> - bfqd->num_groups_with_pending_reqs--;
> - }
> - }
> -
> - /*
> - * Next function is invoked last, because it causes bfqq to be
> - * freed if the following holds: bfqq is not in service and
> - * has no dispatched request. DO NOT use bfqq after the next
> - * function invocation.
> - */
> __bfq_weights_tree_remove(bfqd, bfqq,
> &bfqd->queue_weights_tree);
Why are you keeping the wrapper function bfq_weights_tree_remove() if it contains only the invocation of __bfq_weights_tree_remove()?
> }
> diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
> index 338ff5418ea8..257acb54c6dc 100644
> --- a/block/bfq-iosched.h
> +++ b/block/bfq-iosched.h
> @@ -496,27 +496,27 @@ struct bfq_data {
> struct rb_root_cached queue_weights_tree;
>
> /*
> - * Number of groups with at least one descendant process that
> + * Number of groups with at least one process that
> * has at least one request waiting for completion. Note that
> * this accounts for also requests already dispatched, but not
> * yet completed. Therefore this number of groups may differ
> * (be larger) than the number of active groups, as a group is
> * considered active only if its corresponding entity has
> - * descendant queues with at least one request queued. This
> + * queues with at least one request queued. This
> * number is used to decide whether a scenario is symmetric.
> * For a detailed explanation see comments on the computation
> * of the variable asymmetric_scenario in the function
> * bfq_better_to_idle().
> *
> * However, it is hard to compute this number exactly, for
> - * groups with multiple descendant processes. Consider a group
> - * that is inactive, i.e., that has no descendant process with
> + * groups with multiple processes. Consider a group
> + * that is inactive, i.e., that has no process with
> * pending I/O inside BFQ queues. Then suppose that
> * num_groups_with_pending_reqs is still accounting for this
> - * group, because the group has descendant processes with some
> + * group, because the group has processes with some
> * I/O request still in flight. num_groups_with_pending_reqs
> * should be decremented when the in-flight request of the
> - * last descendant process is finally completed (assuming that
> + * last process is finally completed (assuming that
> * nothing else has changed for the group in the meantime, in
> * terms of composition of the group and active/inactive state of child
> * groups and processes). To accomplish this, an additional
> @@ -525,7 +525,7 @@ struct bfq_data {
> * we resort to the following tradeoff between simplicity and
> * accuracy: for an inactive group that is still counted in
> * num_groups_with_pending_reqs, we decrement
> - * num_groups_with_pending_reqs when the first descendant
> + * num_groups_with_pending_reqs when the first
> * process of the group remains with no request waiting for
> * completion.
> *
> @@ -533,12 +533,12 @@ struct bfq_data {
> * carefulness: to avoid multiple decrements, we flag a group,
> * more precisely an entity representing a group, as still
> * counted in num_groups_with_pending_reqs when it becomes
> - * inactive. Then, when the first descendant queue of the
> + * inactive. Then, when the first queue of the
> * entity remains with no request waiting for completion,
> * num_groups_with_pending_reqs is decremented, and this flag
> * is reset. After this flag is reset for the entity,
> * num_groups_with_pending_reqs won't be decremented any
> - * longer in case a new descendant queue of the entity remains
> + * longer in case a new queue of the entity remains
> * with no request waiting for completion.
> */
> unsigned int num_groups_with_pending_reqs;
> diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
> index 5549ccf09cd2..5e8224c96921 100644
> --- a/block/bfq-wf2q.c
> +++ b/block/bfq-wf2q.c
> @@ -984,19 +984,6 @@ static void __bfq_activate_entity(struct bfq_entity *entity,
> entity->on_st_or_in_serv = true;
> }
>
> -#ifdef CONFIG_BFQ_GROUP_IOSCHED
> - if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */
> - struct bfq_group *bfqg =
> - container_of(entity, struct bfq_group, entity);
> - struct bfq_data *bfqd = bfqg->bfqd;
> -
> - if (!entity->in_groups_with_pending_reqs) {
> - entity->in_groups_with_pending_reqs = true;
> - bfqd->num_groups_with_pending_reqs++;
> - }
> - }
> -#endif
> -
> bfq_update_fin_time_enqueue(entity, st, backshifted);
> }
>
> @@ -1653,7 +1640,8 @@ void bfq_add_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
> if (!entity->in_groups_with_pending_reqs) {
> entity->in_groups_with_pending_reqs = true;
> #ifdef CONFIG_BFQ_GROUP_IOSCHED
> - bfqq_group(bfqq)->num_queues_with_pending_reqs++;
> + if (!(bfqq_group(bfqq)->num_queues_with_pending_reqs++))
> + bfqq->bfqd->num_groups_with_pending_reqs++;
> #endif
> }
> }
> @@ -1665,7 +1653,8 @@ void bfq_del_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
> if (entity->in_groups_with_pending_reqs) {
> entity->in_groups_with_pending_reqs = false;
> #ifdef CONFIG_BFQ_GROUP_IOSCHED
> - bfqq_group(bfqq)->num_queues_with_pending_reqs--;
> + if (!(--bfqq_group(bfqq)->num_queues_with_pending_reqs))
> + bfqq->bfqd->num_groups_with_pending_reqs--;
> #endif
> }
> }
> @@ -1694,6 +1683,10 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
>
> if (!bfqq->dispatched) {
> bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
> + /*
> + * Next function is invoked last, because it causes bfqq to be
> + * freed. DO NOT use bfqq after the next function invocation.
> + */
Great, you moved this comment to the best place.
Thanks,
Paolo
> bfq_weights_tree_remove(bfqd, bfqq);
> }
> }
> --
> 2.31.1
>
> Il giorno 27 set 2022, alle ore 18:32, Paolo Valente <[email protected]> ha scritto:
>
>
>
>> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>>
>> From: Yu Kuai <[email protected]>
>>
>> Currently, bfq can't handle sync io concurrently as long as they
>> are not issued from root group. This is because
>> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
>> bfq_asymmetric_scenario().
>>
>> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>>
>> Before this patch:
>> 1) root group will never be counted.
>> 2) Count if bfqg or it's child bfqgs have pending requests.
>> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>>
>> After this patch:
>> 1) root group is counted.
>> 2) Count if bfqg have pending requests.
>> 3) Don't count if bfqg complete all the requests.
>>
>> With this change, the occasion that only one group is activated can be
>> detected, and next patch will support concurrent sync io in the
>> occasion.
>>
>> Signed-off-by: Yu Kuai <[email protected]>
>> Reviewed-by: Jan Kara <[email protected]>
>> ---
>> block/bfq-iosched.c | 42 ------------------------------------------
>> block/bfq-iosched.h | 18 +++++++++---------
>> block/bfq-wf2q.c | 23 ++++++++---------------
>> 3 files changed, 17 insertions(+), 66 deletions(-)
>>
>> diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
>> index 0dcae2f52896..970b302a7a3e 100644
>> --- a/block/bfq-iosched.c
>> +++ b/block/bfq-iosched.c
>> @@ -970,48 +970,6 @@ void __bfq_weights_tree_remove(struct bfq_data *bfqd,
>> void bfq_weights_tree_remove(struct bfq_data *bfqd,
>> struct bfq_queue *bfqq)
>> {
>> - struct bfq_entity *entity = bfqq->entity.parent;
>> -
>> - for_each_entity(entity) {
>> - struct bfq_sched_data *sd = entity->my_sched_data;
>> -
>> - if (sd->next_in_service || sd->in_service_entity) {
>> - /*
>> - * entity is still active, because either
>> - * next_in_service or in_service_entity is not
>> - * NULL (see the comments on the definition of
>> - * next_in_service for details on why
>> - * in_service_entity must be checked too).
>> - *
>> - * As a consequence, its parent entities are
>> - * active as well, and thus this loop must
>> - * stop here.
>> - */
>> - break;
>> - }
>> -
>> - /*
>> - * The decrement of num_groups_with_pending_reqs is
>> - * not performed immediately upon the deactivation of
>> - * entity, but it is delayed to when it also happens
>> - * that the first leaf descendant bfqq of entity gets
>> - * all its pending requests completed. The following
>> - * instructions perform this delayed decrement, if
>> - * needed. See the comments on
>> - * num_groups_with_pending_reqs for details.
>> - */
>> - if (entity->in_groups_with_pending_reqs) {
>> - entity->in_groups_with_pending_reqs = false;
>> - bfqd->num_groups_with_pending_reqs--;
>> - }
>> - }
>> -
>> - /*
>> - * Next function is invoked last, because it causes bfqq to be
>> - * freed if the following holds: bfqq is not in service and
>> - * has no dispatched request. DO NOT use bfqq after the next
>> - * function invocation.
>> - */
>> __bfq_weights_tree_remove(bfqd, bfqq,
>> &bfqd->queue_weights_tree);
>
> Why are you keeping the wrapper function bfq_weights_tree_remove() if it contains only the invocation of __bfq_weights_tree_remove()?
>
I had not seen patch 6/6, sorry.
Paolo
>> }
>> diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
>> index 338ff5418ea8..257acb54c6dc 100644
>> --- a/block/bfq-iosched.h
>> +++ b/block/bfq-iosched.h
>> @@ -496,27 +496,27 @@ struct bfq_data {
>> struct rb_root_cached queue_weights_tree;
>>
>> /*
>> - * Number of groups with at least one descendant process that
>> + * Number of groups with at least one process that
>> * has at least one request waiting for completion. Note that
>> * this accounts for also requests already dispatched, but not
>> * yet completed. Therefore this number of groups may differ
>> * (be larger) than the number of active groups, as a group is
>> * considered active only if its corresponding entity has
>> - * descendant queues with at least one request queued. This
>> + * queues with at least one request queued. This
>> * number is used to decide whether a scenario is symmetric.
>> * For a detailed explanation see comments on the computation
>> * of the variable asymmetric_scenario in the function
>> * bfq_better_to_idle().
>> *
>> * However, it is hard to compute this number exactly, for
>> - * groups with multiple descendant processes. Consider a group
>> - * that is inactive, i.e., that has no descendant process with
>> + * groups with multiple processes. Consider a group
>> + * that is inactive, i.e., that has no process with
>> * pending I/O inside BFQ queues. Then suppose that
>> * num_groups_with_pending_reqs is still accounting for this
>> - * group, because the group has descendant processes with some
>> + * group, because the group has processes with some
>> * I/O request still in flight. num_groups_with_pending_reqs
>> * should be decremented when the in-flight request of the
>> - * last descendant process is finally completed (assuming that
>> + * last process is finally completed (assuming that
>> * nothing else has changed for the group in the meantime, in
>> * terms of composition of the group and active/inactive state of child
>> * groups and processes). To accomplish this, an additional
>> @@ -525,7 +525,7 @@ struct bfq_data {
>> * we resort to the following tradeoff between simplicity and
>> * accuracy: for an inactive group that is still counted in
>> * num_groups_with_pending_reqs, we decrement
>> - * num_groups_with_pending_reqs when the first descendant
>> + * num_groups_with_pending_reqs when the first
>> * process of the group remains with no request waiting for
>> * completion.
>> *
>> @@ -533,12 +533,12 @@ struct bfq_data {
>> * carefulness: to avoid multiple decrements, we flag a group,
>> * more precisely an entity representing a group, as still
>> * counted in num_groups_with_pending_reqs when it becomes
>> - * inactive. Then, when the first descendant queue of the
>> + * inactive. Then, when the first queue of the
>> * entity remains with no request waiting for completion,
>> * num_groups_with_pending_reqs is decremented, and this flag
>> * is reset. After this flag is reset for the entity,
>> * num_groups_with_pending_reqs won't be decremented any
>> - * longer in case a new descendant queue of the entity remains
>> + * longer in case a new queue of the entity remains
>> * with no request waiting for completion.
>> */
>> unsigned int num_groups_with_pending_reqs;
>> diff --git a/block/bfq-wf2q.c b/block/bfq-wf2q.c
>> index 5549ccf09cd2..5e8224c96921 100644
>> --- a/block/bfq-wf2q.c
>> +++ b/block/bfq-wf2q.c
>> @@ -984,19 +984,6 @@ static void __bfq_activate_entity(struct bfq_entity *entity,
>> entity->on_st_or_in_serv = true;
>> }
>>
>> -#ifdef CONFIG_BFQ_GROUP_IOSCHED
>> - if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */
>> - struct bfq_group *bfqg =
>> - container_of(entity, struct bfq_group, entity);
>> - struct bfq_data *bfqd = bfqg->bfqd;
>> -
>> - if (!entity->in_groups_with_pending_reqs) {
>> - entity->in_groups_with_pending_reqs = true;
>> - bfqd->num_groups_with_pending_reqs++;
>> - }
>> - }
>> -#endif
>> -
>> bfq_update_fin_time_enqueue(entity, st, backshifted);
>> }
>>
>> @@ -1653,7 +1640,8 @@ void bfq_add_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
>> if (!entity->in_groups_with_pending_reqs) {
>> entity->in_groups_with_pending_reqs = true;
>> #ifdef CONFIG_BFQ_GROUP_IOSCHED
>> - bfqq_group(bfqq)->num_queues_with_pending_reqs++;
>> + if (!(bfqq_group(bfqq)->num_queues_with_pending_reqs++))
>> + bfqq->bfqd->num_groups_with_pending_reqs++;
>> #endif
>> }
>> }
>> @@ -1665,7 +1653,8 @@ void bfq_del_bfqq_in_groups_with_pending_reqs(struct bfq_queue *bfqq)
>> if (entity->in_groups_with_pending_reqs) {
>> entity->in_groups_with_pending_reqs = false;
>> #ifdef CONFIG_BFQ_GROUP_IOSCHED
>> - bfqq_group(bfqq)->num_queues_with_pending_reqs--;
>> + if (!(--bfqq_group(bfqq)->num_queues_with_pending_reqs))
>> + bfqq->bfqd->num_groups_with_pending_reqs--;
>> #endif
>> }
>> }
>> @@ -1694,6 +1683,10 @@ void bfq_del_bfqq_busy(struct bfq_queue *bfqq, bool expiration)
>>
>> if (!bfqq->dispatched) {
>> bfq_del_bfqq_in_groups_with_pending_reqs(bfqq);
>> + /*
>> + * Next function is invoked last, because it causes bfqq to be
>> + * freed. DO NOT use bfqq after the next function invocation.
>> + */
>
> Great, you moved this comment to the best place.
>
> Thanks,
> Paolo
>
>> bfq_weights_tree_remove(bfqd, bfqq);
>> }
>> }
>> --
>> 2.31.1
Hi, Paolo
?? 2022/09/28 0:38, Paolo Valente д??:
>
>
>> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>>
>> From: Yu Kuai <[email protected]>
>>
>> Changes in v11:
>> - keep the comments in bfq_weights_tree_remove() and move it to the
>> caller where bfqq can be freed.
>> - add two followed up cleanup patches.
>>
>> Changes in v10:
>> - Add reviewed-tag for patch 2
>>
>> Changes in v9:
>> - also update how many bfqqs have pending_reqs bfq_bfqq_move().
>> - fix one language in patch 4
>> - Add reviewed-tag for patch 1,3,4
>>
>> Changes in v8:
>> - Instead of using whether bfqq is busy, using whether bfqq has pending
>> requests. As Paolo pointed out the former way is problematic.
>>
>> Changes in v7:
>> - fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
>> also retest this patchset on v5.18 to make sure functionality is
>> correct.
>> - move the updating of 'bfqd->busy_queues' into new apis
>>
>> Changes in v6:
>> - add reviewed-by tag for patch 1
>>
>> Changes in v5:
>> - rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
>> - fix wrong definition in patch 1
>> - fix spelling mistake in patch 2: leaset -> least
>> - update comments in patch 3
>> - add reviewed-by tag in patch 2,3
>>
>> Changes in v4:
>> - split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
>> suggested by Jan Kara.
>> - remove unused 'in_groups_with_pending_reqs',
>>
>> Changes in v3:
>> - remove the cleanup patch that is irrelevant now(I'll post it
>> separately).
>> - instead of hacking wr queues and using weights tree insertion/removal,
>> using bfq_add/del_bfqq_busy() to count the number of groups
>> (suggested by Jan Kara).
>>
>> Changes in v2:
>> - Use a different approch to count root group, which is much simple.
>>
>> Currently, bfq can't handle sync io concurrently as long as they
>> are not issued from root group. This is because
>> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
>> bfq_asymmetric_scenario().
>>
>> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>>
>> Before this patchset:
>> 1) root group will never be counted.
>> 2) Count if bfqg or it's child bfqgs have pending requests.
>> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>>
>> After this patchset:
>> 1) root group is counted.
>> 2) Count if bfqg has pending requests.
>> 3) Don't count if bfqg complete all the requests.
>>
>> With the above changes, concurrent sync io can be supported if only
>> one group is activated.
>>
>> fio test script(startdelay is used to avoid queue merging):
>> [global]
>> filename=/dev/sda
>> allow_mounted_write=0
>> ioengine=psync
>> direct=1
>> ioscheduler=bfq
>> offset_increment=10g
>> group_reporting
>> rw=randwrite
>> bs=4k
>>
>> [test1]
>> numjobs=1
>>
>> [test2]
>> startdelay=1
>> numjobs=1
>>
>> [test3]
>> startdelay=2
>> numjobs=1
>>
>> [test4]
>> startdelay=3
>> numjobs=1
>>
>> [test5]
>> startdelay=4
>> numjobs=1
>>
>> [test6]
>> startdelay=5
>> numjobs=1
>>
>> [test7]
>> startdelay=6
>> numjobs=1
>>
>> [test8]
>> startdelay=7
>> numjobs=1
>>
>> test result:
>> running fio on root cgroup
>> v5.18: 112 Mib/s
>> v5.18-patched: 112 Mib/s
>>
>> running fio on non-root cgroup
>> v5.18: 51.2 Mib/s
>> v5.18-patched: 112 Mib/s
>>
>> Note that I also test null_blk with "irqmode=2
>> completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
>> that service guarantees are still preserved.
>>
>
> Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
I'm runnnig some tests manually, just issuing same io to two cgroups,
and changing weights manually, specifically (1:10, 2:8, ..., 5:5),
then observe bandwidth from two cgroups.
Of course I'm glad to try your benchmark suite.
Thanks,
Kuai
>
> Thanks,
> Paolo
>
>> Previous versions:
>> RFC: https://lore.kernel.org/all/[email protected]/
>> v1: https://lore.kernel.org/all/[email protected]/
>> v2: https://lore.kernel.org/all/[email protected]/
>> v3: https://lore.kernel.org/all/[email protected]/
>> v4: https://lore.kernel.org/all/[email protected]/
>> v5: https://lore.kernel.org/all/[email protected]/
>> v6: https://lore.kernel.org/all/[email protected]/
>> v7: https://lore.kernel.org/all/[email protected]/
>>
>>
>> Yu Kuai (6):
>> block, bfq: support to track if bfqq has pending requests
>> block, bfq: record how many queues have pending requests
>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>> block, bfq: do not idle if only one group is activated
>> block, bfq: cleanup bfq_weights_tree add/remove apis
>> block, bfq: cleanup __bfq_weights_tree_remove()
>>
>> block/bfq-cgroup.c | 10 +++++++
>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>> block/bfq-iosched.h | 30 +++++++++----------
>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>
>> --
>> 2.31.1
>>
>
> .
>
> Il giorno 11 ott 2022, alle ore 10:11, Yu Kuai <[email protected]> ha scritto:
>
> Hi, paolo
>
> 在 2022/09/28 0:38, Paolo Valente 写道:
>>> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>>>
>>> From: Yu Kuai <[email protected]>
>>>
>>> Changes in v11:
>>> - keep the comments in bfq_weights_tree_remove() and move it to the
>>> caller where bfqq can be freed.
>>> - add two followed up cleanup patches.
>>>
>>> Changes in v10:
>>> - Add reviewed-tag for patch 2
>>>
>>> Changes in v9:
>>> - also update how many bfqqs have pending_reqs bfq_bfqq_move().
>>> - fix one language in patch 4
>>> - Add reviewed-tag for patch 1,3,4
>>>
>>> Changes in v8:
>>> - Instead of using whether bfqq is busy, using whether bfqq has pending
>>> requests. As Paolo pointed out the former way is problematic.
>>>
>>> Changes in v7:
>>> - fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
>>> also retest this patchset on v5.18 to make sure functionality is
>>> correct.
>>> - move the updating of 'bfqd->busy_queues' into new apis
>>>
>>> Changes in v6:
>>> - add reviewed-by tag for patch 1
>>>
>>> Changes in v5:
>>> - rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
>>> - fix wrong definition in patch 1
>>> - fix spelling mistake in patch 2: leaset -> least
>>> - update comments in patch 3
>>> - add reviewed-by tag in patch 2,3
>>>
>>> Changes in v4:
>>> - split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
>>> suggested by Jan Kara.
>>> - remove unused 'in_groups_with_pending_reqs',
>>>
>>> Changes in v3:
>>> - remove the cleanup patch that is irrelevant now(I'll post it
>>> separately).
>>> - instead of hacking wr queues and using weights tree insertion/removal,
>>> using bfq_add/del_bfqq_busy() to count the number of groups
>>> (suggested by Jan Kara).
>>>
>>> Changes in v2:
>>> - Use a different approch to count root group, which is much simple.
>>>
>>> Currently, bfq can't handle sync io concurrently as long as they
>>> are not issued from root group. This is because
>>> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
>>> bfq_asymmetric_scenario().
>>>
>>> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>>>
>>> Before this patchset:
>>> 1) root group will never be counted.
>>> 2) Count if bfqg or it's child bfqgs have pending requests.
>>> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>>>
>>> After this patchset:
>>> 1) root group is counted.
>>> 2) Count if bfqg has pending requests.
>>> 3) Don't count if bfqg complete all the requests.
>>>
>>> With the above changes, concurrent sync io can be supported if only
>>> one group is activated.
>>>
>>> fio test script(startdelay is used to avoid queue merging):
>>> [global]
>>> filename=/dev/sda
>>> allow_mounted_write=0
>>> ioengine=psync
>>> direct=1
>>> ioscheduler=bfq
>>> offset_increment=10g
>>> group_reporting
>>> rw=randwrite
>>> bs=4k
>>>
>>> [test1]
>>> numjobs=1
>>>
>>> [test2]
>>> startdelay=1
>>> numjobs=1
>>>
>>> [test3]
>>> startdelay=2
>>> numjobs=1
>>>
>>> [test4]
>>> startdelay=3
>>> numjobs=1
>>>
>>> [test5]
>>> startdelay=4
>>> numjobs=1
>>>
>>> [test6]
>>> startdelay=5
>>> numjobs=1
>>>
>>> [test7]
>>> startdelay=6
>>> numjobs=1
>>>
>>> [test8]
>>> startdelay=7
>>> numjobs=1
>>>
>>> test result:
>>> running fio on root cgroup
>>> v5.18: 112 Mib/s
>>> v5.18-patched: 112 Mib/s
>>>
>>> running fio on non-root cgroup
>>> v5.18: 51.2 Mib/s
>>> v5.18-patched: 112 Mib/s
>>>
>>> Note that I also test null_blk with "irqmode=2
>>> completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
>>> that service guarantees are still preserved.
>>>
>> Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
>
> Is there any test that you wish me to try?
>
> By the way, I think for the case that multiple groups are activaced, (
> specifically num_groups_with_pendind_rqs > 1), io path in bfq is the
> same with or without this patchset.
>
The tests cases you mentioned are ok for me (whatever tool or personal
code you use to run them). Just show me your results with and without
your patchset applied.
Thanks,
Paolo
> Thanks,
> Kuai
>> Thanks,
>> Paolo
>>> Previous versions:
>>> RFC: https://lore.kernel.org/all/[email protected]/
>>> v1: https://lore.kernel.org/all/[email protected]/
>>> v2: https://lore.kernel.org/all/[email protected]/
>>> v3: https://lore.kernel.org/all/[email protected]/
>>> v4: https://lore.kernel.org/all/[email protected]/
>>> v5: https://lore.kernel.org/all/[email protected]/
>>> v6: https://lore.kernel.org/all/[email protected]/
>>> v7: https://lore.kernel.org/all/[email protected]/
>>>
>>>
>>> Yu Kuai (6):
>>> block, bfq: support to track if bfqq has pending requests
>>> block, bfq: record how many queues have pending requests
>>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>>> block, bfq: do not idle if only one group is activated
>>> block, bfq: cleanup bfq_weights_tree add/remove apis
>>> block, bfq: cleanup __bfq_weights_tree_remove()
>>>
>>> block/bfq-cgroup.c | 10 +++++++
>>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>>> block/bfq-iosched.h | 30 +++++++++----------
>>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>>
>>> --
>>> 2.31.1
>>>
>> .
Hi, paolo
?? 2022/09/28 0:38, Paolo Valente д??:
>
>
>> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>>
>> From: Yu Kuai <[email protected]>
>>
>> Changes in v11:
>> - keep the comments in bfq_weights_tree_remove() and move it to the
>> caller where bfqq can be freed.
>> - add two followed up cleanup patches.
>>
>> Changes in v10:
>> - Add reviewed-tag for patch 2
>>
>> Changes in v9:
>> - also update how many bfqqs have pending_reqs bfq_bfqq_move().
>> - fix one language in patch 4
>> - Add reviewed-tag for patch 1,3,4
>>
>> Changes in v8:
>> - Instead of using whether bfqq is busy, using whether bfqq has pending
>> requests. As Paolo pointed out the former way is problematic.
>>
>> Changes in v7:
>> - fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
>> also retest this patchset on v5.18 to make sure functionality is
>> correct.
>> - move the updating of 'bfqd->busy_queues' into new apis
>>
>> Changes in v6:
>> - add reviewed-by tag for patch 1
>>
>> Changes in v5:
>> - rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
>> - fix wrong definition in patch 1
>> - fix spelling mistake in patch 2: leaset -> least
>> - update comments in patch 3
>> - add reviewed-by tag in patch 2,3
>>
>> Changes in v4:
>> - split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
>> suggested by Jan Kara.
>> - remove unused 'in_groups_with_pending_reqs',
>>
>> Changes in v3:
>> - remove the cleanup patch that is irrelevant now(I'll post it
>> separately).
>> - instead of hacking wr queues and using weights tree insertion/removal,
>> using bfq_add/del_bfqq_busy() to count the number of groups
>> (suggested by Jan Kara).
>>
>> Changes in v2:
>> - Use a different approch to count root group, which is much simple.
>>
>> Currently, bfq can't handle sync io concurrently as long as they
>> are not issued from root group. This is because
>> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
>> bfq_asymmetric_scenario().
>>
>> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>>
>> Before this patchset:
>> 1) root group will never be counted.
>> 2) Count if bfqg or it's child bfqgs have pending requests.
>> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>>
>> After this patchset:
>> 1) root group is counted.
>> 2) Count if bfqg has pending requests.
>> 3) Don't count if bfqg complete all the requests.
>>
>> With the above changes, concurrent sync io can be supported if only
>> one group is activated.
>>
>> fio test script(startdelay is used to avoid queue merging):
>> [global]
>> filename=/dev/sda
>> allow_mounted_write=0
>> ioengine=psync
>> direct=1
>> ioscheduler=bfq
>> offset_increment=10g
>> group_reporting
>> rw=randwrite
>> bs=4k
>>
>> [test1]
>> numjobs=1
>>
>> [test2]
>> startdelay=1
>> numjobs=1
>>
>> [test3]
>> startdelay=2
>> numjobs=1
>>
>> [test4]
>> startdelay=3
>> numjobs=1
>>
>> [test5]
>> startdelay=4
>> numjobs=1
>>
>> [test6]
>> startdelay=5
>> numjobs=1
>>
>> [test7]
>> startdelay=6
>> numjobs=1
>>
>> [test8]
>> startdelay=7
>> numjobs=1
>>
>> test result:
>> running fio on root cgroup
>> v5.18: 112 Mib/s
>> v5.18-patched: 112 Mib/s
>>
>> running fio on non-root cgroup
>> v5.18: 51.2 Mib/s
>> v5.18-patched: 112 Mib/s
>>
>> Note that I also test null_blk with "irqmode=2
>> completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
>> that service guarantees are still preserved.
>>
>
> Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
Is there any test that you wish me to try?
By the way, I think for the case that multiple groups are activaced, (
specifically num_groups_with_pendind_rqs > 1), io path in bfq is the
same with or without this patchset.
Thanks,
Kuai
>
> Thanks,
> Paolo
>
>> Previous versions:
>> RFC: https://lore.kernel.org/all/[email protected]/
>> v1: https://lore.kernel.org/all/[email protected]/
>> v2: https://lore.kernel.org/all/[email protected]/
>> v3: https://lore.kernel.org/all/[email protected]/
>> v4: https://lore.kernel.org/all/[email protected]/
>> v5: https://lore.kernel.org/all/[email protected]/
>> v6: https://lore.kernel.org/all/[email protected]/
>> v7: https://lore.kernel.org/all/[email protected]/
>>
>>
>> Yu Kuai (6):
>> block, bfq: support to track if bfqq has pending requests
>> block, bfq: record how many queues have pending requests
>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>> block, bfq: do not idle if only one group is activated
>> block, bfq: cleanup bfq_weights_tree add/remove apis
>> block, bfq: cleanup __bfq_weights_tree_remove()
>>
>> block/bfq-cgroup.c | 10 +++++++
>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>> block/bfq-iosched.h | 30 +++++++++----------
>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>
>> --
>> 2.31.1
>>
>
> .
>
Hi, Paolo
在 2022/10/11 16:21, Paolo Valente 写道:
>
>
>> Il giorno 11 ott 2022, alle ore 10:11, Yu Kuai <[email protected]> ha scritto:
>>
>> Hi, paolo
>>
>> 在 2022/09/28 0:38, Paolo Valente 写道:
>>>> Il giorno 16 set 2022, alle ore 09:19, Yu Kuai <[email protected]> ha scritto:
>>>>
>>>> From: Yu Kuai <[email protected]>
>>>>
>>>> Changes in v11:
>>>> - keep the comments in bfq_weights_tree_remove() and move it to the
>>>> caller where bfqq can be freed.
>>>> - add two followed up cleanup patches.
>>>>
>>>> Changes in v10:
>>>> - Add reviewed-tag for patch 2
>>>>
>>>> Changes in v9:
>>>> - also update how many bfqqs have pending_reqs bfq_bfqq_move().
>>>> - fix one language in patch 4
>>>> - Add reviewed-tag for patch 1,3,4
>>>>
>>>> Changes in v8:
>>>> - Instead of using whether bfqq is busy, using whether bfqq has pending
>>>> requests. As Paolo pointed out the former way is problematic.
>>>>
>>>> Changes in v7:
>>>> - fix mismatch bfq_inc/del_busy_queues() and bfqq_add/del_bfqq_busy(),
>>>> also retest this patchset on v5.18 to make sure functionality is
>>>> correct.
>>>> - move the updating of 'bfqd->busy_queues' into new apis
>>>>
>>>> Changes in v6:
>>>> - add reviewed-by tag for patch 1
>>>>
>>>> Changes in v5:
>>>> - rename bfq_add_busy_queues() to bfq_inc_busy_queues() in patch 1
>>>> - fix wrong definition in patch 1
>>>> - fix spelling mistake in patch 2: leaset -> least
>>>> - update comments in patch 3
>>>> - add reviewed-by tag in patch 2,3
>>>>
>>>> Changes in v4:
>>>> - split bfq_update_busy_queues() to bfq_add/dec_busy_queues(),
>>>> suggested by Jan Kara.
>>>> - remove unused 'in_groups_with_pending_reqs',
>>>>
>>>> Changes in v3:
>>>> - remove the cleanup patch that is irrelevant now(I'll post it
>>>> separately).
>>>> - instead of hacking wr queues and using weights tree insertion/removal,
>>>> using bfq_add/del_bfqq_busy() to count the number of groups
>>>> (suggested by Jan Kara).
>>>>
>>>> Changes in v2:
>>>> - Use a different approch to count root group, which is much simple.
>>>>
>>>> Currently, bfq can't handle sync io concurrently as long as they
>>>> are not issued from root group. This is because
>>>> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
>>>> bfq_asymmetric_scenario().
>>>>
>>>> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>>>>
>>>> Before this patchset:
>>>> 1) root group will never be counted.
>>>> 2) Count if bfqg or it's child bfqgs have pending requests.
>>>> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>>>>
>>>> After this patchset:
>>>> 1) root group is counted.
>>>> 2) Count if bfqg has pending requests.
>>>> 3) Don't count if bfqg complete all the requests.
>>>>
>>>> With the above changes, concurrent sync io can be supported if only
>>>> one group is activated.
>>>>
>>>> fio test script(startdelay is used to avoid queue merging):
>>>> [global]
>>>> filename=/dev/sda
>>>> allow_mounted_write=0
>>>> ioengine=psync
>>>> direct=1
>>>> ioscheduler=bfq
>>>> offset_increment=10g
>>>> group_reporting
>>>> rw=randwrite
>>>> bs=4k
>>>>
>>>> [test1]
>>>> numjobs=1
>>>>
>>>> [test2]
>>>> startdelay=1
>>>> numjobs=1
>>>>
>>>> [test3]
>>>> startdelay=2
>>>> numjobs=1
>>>>
>>>> [test4]
>>>> startdelay=3
>>>> numjobs=1
>>>>
>>>> [test5]
>>>> startdelay=4
>>>> numjobs=1
>>>>
>>>> [test6]
>>>> startdelay=5
>>>> numjobs=1
>>>>
>>>> [test7]
>>>> startdelay=6
>>>> numjobs=1
>>>>
>>>> [test8]
>>>> startdelay=7
>>>> numjobs=1
>>>>
>>>> test result:
>>>> running fio on root cgroup
>>>> v5.18: 112 Mib/s
>>>> v5.18-patched: 112 Mib/s
>>>>
>>>> running fio on non-root cgroup
>>>> v5.18: 51.2 Mib/s
>>>> v5.18-patched: 112 Mib/s
>>>>
>>>> Note that I also test null_blk with "irqmode=2
>>>> completion_nsec=100000000(100ms) hw_queue_depth=1", and tests show
>>>> that service guarantees are still preserved.
>>>>
>>> Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
>>
>> Is there any test that you wish me to try?
>>
>> By the way, I think for the case that multiple groups are activaced, (
>> specifically num_groups_with_pendind_rqs > 1), io path in bfq is the
>> same with or without this patchset.
I just ran the test for one time, result is a liiter inconsistent, do
you think it's in the normal fluctuation range?
test script:
fio -filename=/dev/nullb0 -ioengine=libaio -ioscheduler=bfq -jumjobs=1
-iodepth=64 -direct=1 -bs=4k -rw=randread -runtime=60 -name=test
without this patchset:
| | | | | | |
| --------------- | ---- | ---- | ---- | ---- | ---- |
| cg1 weight | 10 | 20 | 30 | 40 | 50 |
| cg2 weight | 90 | 80 | 70 | 60 | 50 |
| cg1 bw MiB/s | 25.8 | 51.0 | 80.1 | 90.5 | 138 |
| cg2 bw MiB/s | 193 | 179 | 162 | 127 | 136 |
| cg2 bw / cg1 bw | 7.48 | 3.51 | 2.02 | 1.40 | 0.98 |
with this patchset
| | | | | | |
| --------------- | ---- | ---- | ---- | ---- | ---- |
| cg1 weight | 10 | 20 | 30 | 40 | 50 |
| cg2 weight | 90 | 80 | 70 | 60 | 50 |
| cg1 bw MiB/s | 21.5 | 43.9 | 62.7 | 87.4 | 136 |
| cg2 bw MiB/s | 195 | 185 | 173 | 138 | 141 |
| cg2 bw / cg1 bw | 9.07 | 4.21 | 2.75 | 1.57 | 0.96 |
>>
>
> The tests cases you mentioned are ok for me (whatever tool or personal
> code you use to run them). Just show me your results with and without
> your patchset applied.
>
> Thanks,
> Paolo
>
>> Thanks,
>> Kuai
>>> Thanks,
>>> Paolo
>>>> Previous versions:
>>>> RFC: https://lore.kernel.org/all/[email protected]/
>>>> v1: https://lore.kernel.org/all/[email protected]/
>>>> v2: https://lore.kernel.org/all/[email protected]/
>>>> v3: https://lore.kernel.org/all/[email protected]/
>>>> v4: https://lore.kernel.org/all/[email protected]/
>>>> v5: https://lore.kernel.org/all/[email protected]/
>>>> v6: https://lore.kernel.org/all/[email protected]/
>>>> v7: https://lore.kernel.org/all/[email protected]/
>>>>
>>>>
>>>> Yu Kuai (6):
>>>> block, bfq: support to track if bfqq has pending requests
>>>> block, bfq: record how many queues have pending requests
>>>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>>>> block, bfq: do not idle if only one group is activated
>>>> block, bfq: cleanup bfq_weights_tree add/remove apis
>>>> block, bfq: cleanup __bfq_weights_tree_remove()
>>>>
>>>> block/bfq-cgroup.c | 10 +++++++
>>>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>>>> block/bfq-iosched.h | 30 +++++++++----------
>>>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>>>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>>>
>>>> --
>>>> 2.31.1
>>>>
>>> .
>
> .
>
Hi, Paolo
在 2022/10/11 17:36, Yu Kuai 写道:
>>>> Your patches seem ok to me now (thanks for you contribution and,
>>>> above all, for your patience). I have only a high-level concern:
>>>> what do you mean when you say that service guarantees are still
>>>> preserved? What test did you run exactly? This point is very
>>>> important to me. I'd like to see some convincing test with
>>>> differentiated weights. In case you don't have other tools for
>>>> executing such tests quickly, you may want to use the
>>>> bandwidth-latency test in my simple S benchmark suite (for which I'm
>>>> willing to help).
>>>
>>> Is there any test that you wish me to try?
>>>
>>> By the way, I think for the case that multiple groups are activaced, (
>>> specifically num_groups_with_pendind_rqs > 1), io path in bfq is the
>>> same with or without this patchset.
>
> I just ran the test for one time, result is a liiter inconsistent, do
> you think it's in the normal fluctuation range?
I rerun the manually test for 5 times, here is the average result:
without this patchset / with this patchset:
| --------------- | ------------- | ------------ | -------------- |
------------- | -------------- |
| cg1 weight | 10 | 20 | 30 | 40
| 50 |
| cg2 weight | 90 | 80 | 70 | 60
| 50 |
| cg1 bw MiB/s | 21.4 / 21.74 | 42.72 / 46.6 | 63.82 / 61.52 |
94.74 / 90.92 | 140 / 138.2 |
| cg2 bw MiB/s | 197.2 / 197.4 | 182 / 181.2 | 171.2 / 173.44 | 162
/ 156.8 | 138.6 / 137.04 |
| cg2 bw / cg1 bw | 9.22 / 9.08 | 4.26 / 3.89 | 2.68 / 2.82 | 1.71
/ 1.72 | 0.99 / 0.99 |
>
> test script:
> fio -filename=/dev/nullb0 -ioengine=libaio -ioscheduler=bfq -jumjobs=1
> -iodepth=64 -direct=1 -bs=4k -rw=randread -runtime=60 -name=test
>
> without this patchset:
> | | | | | | |
> | --------------- | ---- | ---- | ---- | ---- | ---- |
> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
> | cg1 bw MiB/s | 25.8 | 51.0 | 80.1 | 90.5 | 138 |
> | cg2 bw MiB/s | 193 | 179 | 162 | 127 | 136 |
> | cg2 bw / cg1 bw | 7.48 | 3.51 | 2.02 | 1.40 | 0.98 |
>
> with this patchset
> | | | | | | |
> | --------------- | ---- | ---- | ---- | ---- | ---- |
> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
> | cg1 bw MiB/s | 21.5 | 43.9 | 62.7 | 87.4 | 136 |
> | cg2 bw MiB/s | 195 | 185 | 173 | 138 | 141 |
> | cg2 bw / cg1 bw | 9.07 | 4.21 | 2.75 | 1.57 | 0.96 |
>>>
>>
>> The tests cases you mentioned are ok for me (whatever tool or personal
>> code you use to run them). Just show me your results with and without
>> your patchset applied.
>>
>> Thanks,
>> Paolo
>>
>>> Thanks,
>>> Kuai
>>>> Thanks,
>>>> Paolo
>>>>> Previous versions:
>>>>> RFC:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v1:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v2:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v3:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>> v4:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v5:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v6:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>> v7:
>>>>> https://lore.kernel.org/all/[email protected]/
>>>>>
>>>>>
>>>>>
>>>>> Yu Kuai (6):
>>>>> block, bfq: support to track if bfqq has pending requests
>>>>> block, bfq: record how many queues have pending requests
>>>>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>>>>> block, bfq: do not idle if only one group is activated
>>>>> block, bfq: cleanup bfq_weights_tree add/remove apis
>>>>> block, bfq: cleanup __bfq_weights_tree_remove()
>>>>>
>>>>> block/bfq-cgroup.c | 10 +++++++
>>>>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>>>>> block/bfq-iosched.h | 30 +++++++++----------
>>>>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>>>>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>>>>
>>>>> --
>>>>> 2.31.1
>>>>>
>>>> .
>>
>> .
>>
>
> .
>
> Il giorno 18 ott 2022, alle ore 06:00, Yu Kuai <[email protected]> ha scritto:
>
> Hi, Paolo
>
> 在 2022/10/11 17:36, Yu Kuai 写道:
>>>>> Your patches seem ok to me now (thanks for you contribution and, above all, for your patience). I have only a high-level concern: what do you mean when you say that service guarantees are still preserved? What test did you run exactly? This point is very important to me. I'd like to see some convincing test with differentiated weights. In case you don't have other tools for executing such tests quickly, you may want to use the bandwidth-latency test in my simple S benchmark suite (for which I'm willing to help).
>>>>
>>>> Is there any test that you wish me to try?
>>>>
>>>> By the way, I think for the case that multiple groups are activaced, (
>>>> specifically num_groups_with_pendind_rqs > 1), io path in bfq is the
>>>> same with or without this patchset.
>> I just ran the test for one time, result is a liiter inconsistent, do
>> you think it's in the normal fluctuation range?
>
> I rerun the manually test for 5 times, here is the average result:
>
> without this patchset / with this patchset:
>
> | --------------- | ------------- | ------------ | -------------- | ------------- | -------------- |
> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
> | cg1 bw MiB/s | 21.4 / 21.74 | 42.72 / 46.6 | 63.82 / 61.52 | 94.74 / 90.92 | 140 / 138.2 |
> | cg2 bw MiB/s | 197.2 / 197.4 | 182 / 181.2 | 171.2 / 173.44 | 162 / 156.8 | 138.6 / 137.04 |
> | cg2 bw / cg1 bw | 9.22 / 9.08 | 4.26 / 3.89 | 2.68 / 2.82 | 1.71 / 1.72 | 0.99 / 0.99 |
Great! Results are (statistically) the same, with and without your
patchset. For me your patches are ok. Thank you very much for this
contribution, and sorry again for my delay.
Acked-by: Paolo Valente <[email protected]>
Thanks,
Paolo
>
>> test script:
>> fio -filename=/dev/nullb0 -ioengine=libaio -ioscheduler=bfq -jumjobs=1 -iodepth=64 -direct=1 -bs=4k -rw=randread -runtime=60 -name=test
>> without this patchset:
>> | | | | | | |
>> | --------------- | ---- | ---- | ---- | ---- | ---- |
>> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
>> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
>> | cg1 bw MiB/s | 25.8 | 51.0 | 80.1 | 90.5 | 138 |
>> | cg2 bw MiB/s | 193 | 179 | 162 | 127 | 136 |
>> | cg2 bw / cg1 bw | 7.48 | 3.51 | 2.02 | 1.40 | 0.98 |
>> with this patchset
>> | | | | | | |
>> | --------------- | ---- | ---- | ---- | ---- | ---- |
>> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
>> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
>> | cg1 bw MiB/s | 21.5 | 43.9 | 62.7 | 87.4 | 136 |
>> | cg2 bw MiB/s | 195 | 185 | 173 | 138 | 141 |
>> | cg2 bw / cg1 bw | 9.07 | 4.21 | 2.75 | 1.57 | 0.96 |
>>>>
>>>
>>> The tests cases you mentioned are ok for me (whatever tool or personal
>>> code you use to run them). Just show me your results with and without
>>> your patchset applied.
>>>
>>> Thanks,
>>> Paolo
>>>
>>>> Thanks,
>>>> Kuai
>>>>> Thanks,
>>>>> Paolo
>>>>>> Previous versions:
>>>>>> RFC: https://lore.kernel.org/all/[email protected]/
>>>>>> v1: https://lore.kernel.org/all/[email protected]/
>>>>>> v2: https://lore.kernel.org/all/[email protected]/
>>>>>> v3: https://lore.kernel.org/all/[email protected]/
>>>>>> v4: https://lore.kernel.org/all/[email protected]/
>>>>>> v5: https://lore.kernel.org/all/[email protected]/
>>>>>> v6: https://lore.kernel.org/all/[email protected]/
>>>>>> v7: https://lore.kernel.org/all/[email protected]/
>>>>>>
>>>>>>
>>>>>> Yu Kuai (6):
>>>>>> block, bfq: support to track if bfqq has pending requests
>>>>>> block, bfq: record how many queues have pending requests
>>>>>> block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
>>>>>> block, bfq: do not idle if only one group is activated
>>>>>> block, bfq: cleanup bfq_weights_tree add/remove apis
>>>>>> block, bfq: cleanup __bfq_weights_tree_remove()
>>>>>>
>>>>>> block/bfq-cgroup.c | 10 +++++++
>>>>>> block/bfq-iosched.c | 71 +++++++--------------------------------------
>>>>>> block/bfq-iosched.h | 30 +++++++++----------
>>>>>> block/bfq-wf2q.c | 69 ++++++++++++++++++++++++++-----------------
>>>>>> 4 files changed, 76 insertions(+), 104 deletions(-)
>>>>>>
>>>>>> --
>>>>>> 2.31.1
>>>>>>
>>>>> .
>>>
>>> .
>>>
>> .
>
在 2022/10/25 14:34, Paolo VALENTE 写道:
>>
>> I rerun the manually test for 5 times, here is the average result:
>>
>> without this patchset / with this patchset:
>>
>> | --------------- | ------------- | ------------ | -------------- | ------------- | -------------- |
>> | cg1 weight | 10 | 20 | 30 | 40 | 50 |
>> | cg2 weight | 90 | 80 | 70 | 60 | 50 |
>> | cg1 bw MiB/s | 21.4 / 21.74 | 42.72 / 46.6 | 63.82 / 61.52 | 94.74 / 90.92 | 140 / 138.2 |
>> | cg2 bw MiB/s | 197.2 / 197.4 | 182 / 181.2 | 171.2 / 173.44 | 162 / 156.8 | 138.6 / 137.04 |
>> | cg2 bw / cg1 bw | 9.22 / 9.08 | 4.26 / 3.89 | 2.68 / 2.82 | 1.71 / 1.72 | 0.99 / 0.99 |
>
> Great! Results are (statistically) the same, with and without your
> patchset. For me your patches are ok. Thank you very much for this
> contribution, and sorry again for my delay.
>
> Acked-by: Paolo Valente <[email protected]>
Thanks for the review, it's nice to get this done finally!
>
> Thanks,
> Paolo
Hi, Jens
?? 2022/09/16 15:19, Yu Kuai д??:
> From: Yu Kuai <[email protected]>
>
>
> Currently, bfq can't handle sync io concurrently as long as they
> are not issued from root group. This is because
> 'bfqd->num_groups_with_pending_reqs > 0' is always true in
> bfq_asymmetric_scenario().
>
> The way that bfqg is counted into 'num_groups_with_pending_reqs':
>
> Before this patchset:
> 1) root group will never be counted.
> 2) Count if bfqg or it's child bfqgs have pending requests.
> 3) Don't count if bfqg and it's child bfqgs complete all the requests.
>
> After this patchset:
> 1) root group is counted.
> 2) Count if bfqg has pending requests.
> 3) Don't count if bfqg complete all the requests.
>
> With the above changes, concurrent sync io can be supported if only
> one group is activated.
Can you apply this patchset?
Thanks,
Kuai
On Fri, 16 Sep 2022 15:19:36 +0800, Yu Kuai wrote:
> From: Yu Kuai <[email protected]>
>
> Changes in v11:
> - keep the comments in bfq_weights_tree_remove() and move it to the
> caller where bfqq can be freed.
> - add two followed up cleanup patches.
>
> [...]
Applied, thanks!
[1/6] block, bfq: support to track if bfqq has pending requests
commit: 3d89bd12d352e20f4f7c8f11a0f1a712b95a5295
[2/6] block, bfq: record how many queues have pending requests
commit: 60a6e10c537a7459dd53882186bd16fff257fb03
[3/6] block, bfq: refactor the counting of 'num_groups_with_pending_reqs'
commit: 71f8ca77cb8764d46f656b725999e8b8b1aec215
[4/6] block, bfq: do not idle if only one group is activated
commit: eed3ecc991c90a4a0ce32ea2b35378dc351f012b
[5/6] block, bfq: cleanup bfq_weights_tree add/remove apis
commit: afdba14612622ec75896e5646950b3562a9aadd3
[6/6] block, bfq: cleanup __bfq_weights_tree_remove()
commit: eb5bca73655cb6aa3bb608253e1e47283240c933
Best regards,
--
Jens Axboe