1 files changed, 49 insertions, 2 deletions

diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index 77651d817ecd..0b02bf302de0 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -196,6 +196,9 @@ struct bfq_entity {
 
         /* flag, set to request a weight, ioprio or ioprio_class change  */
         int prio_changed;
+
+        /* flag, set if the entity is counted in groups_with_pending_reqs */
+        bool in_groups_with_pending_reqs;
 };
 
 struct bfq_group;
@@ -448,10 +451,54 @@ struct bfq_data {
          * bfq_weights_tree_[add|remove] for further details).
          */
         struct rb_root queue_weights_tree;
+
         /*
-         * number of groups with requests still waiting for completion
+         * Number of groups with at least one descendant 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
+         * 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
+         * 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
+         * 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
+         * 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
+         * pending-request counter must be added to entities, and must
+         * be updated correctly. To avoid this additional field and operations,
+         * 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
+         * process of the group remains with no request waiting for
+         * completion.
+         *
+         * Even this simpler decrement strategy requires a little
+         * 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
+         * 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
+         * with no request waiting for completion.
          */
-        unsigned int num_active_groups;
+        unsigned int num_groups_with_pending_reqs;
 
         /*
          * Number of bfq_queues containing requests (including the