sched/fair: Task based throttle time accounting

With task based throttle model, the previous way to check cfs_rq's
nr_queued to decide if throttled time should be accounted doesn't work
as expected, e.g. when a cfs_rq which has a single task is throttled,
that task could later block in kernel mode instead of being dequeued on
limbo list and accounting this as throttled time is not accurate.

Rework throttle time accounting for a cfs_rq as follows:
- start accounting when the first task gets throttled in its hierarchy;
- stop accounting on unthrottle.

Note that there will be a time gap between when a cfs_rq is throttled
and when a task in its hierarchy is actually throttled. This accounting
mechanism only starts accounting in the latter case.

Suggested-by: Chengming Zhou <chengming.zhou@linux.dev> # accounting mechanism
Co-developed-by: K Prateek Nayak <kprateek.nayak@amd.com> # simplify implementation
Signed-off-by: K Prateek Nayak <kprateek.nayak@amd.com>
Signed-off-by: Aaron Lu <ziqianlu@bytedance.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Tested-by: Valentin Schneider <vschneid@redhat.com>
Tested-by: Matteo Martelli <matteo.martelli@codethink.co.uk>
Tested-by: K Prateek Nayak <kprateek.nayak@amd.com>
Link: https://lore.kernel.org/r/20250829081120.806-5-ziqianlu@bytedance.com

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 25b1014d4ef866f63cb0f2ebab6bb0de9a5b5b3f..bdc9bfa0b9efa2b0509409247ad6183f0a00c41f 100644 (file)
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -5293,19 +5293,12 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
                check_enqueue_throttle(cfs_rq);
                list_add_leaf_cfs_rq(cfs_rq);
 #ifdef CONFIG_CFS_BANDWIDTH
-               if (throttled_hierarchy(cfs_rq)) {
+               if (cfs_rq->pelt_clock_throttled) {
                        struct rq *rq = rq_of(cfs_rq);
 
-                       if (cfs_rq_throttled(cfs_rq) && !cfs_rq->throttled_clock)
-                               cfs_rq->throttled_clock = rq_clock(rq);
-                       if (!cfs_rq->throttled_clock_self)
-                               cfs_rq->throttled_clock_self = rq_clock(rq);
-
-                       if (cfs_rq->pelt_clock_throttled) {
-                               cfs_rq->throttled_clock_pelt_time += rq_clock_pelt(rq) -
-                                       cfs_rq->throttled_clock_pelt;
-                               cfs_rq->pelt_clock_throttled = 0;
-                       }
+                       cfs_rq->throttled_clock_pelt_time += rq_clock_pelt(rq) -
+                               cfs_rq->throttled_clock_pelt;
+                       cfs_rq->pelt_clock_throttled = 0;
                }
 #endif
        }
@@ -5393,7 +5386,7 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
                 * DELAY_DEQUEUE relies on spurious wakeups, special task
                 * states must not suffer spurious wakeups, excempt them.
                 */
-               if (flags & DEQUEUE_SPECIAL)
+               if (flags & (DEQUEUE_SPECIAL | DEQUEUE_THROTTLE))
                        delay = false;
 
                WARN_ON_ONCE(delay && se->sched_delayed);
@@ -5799,7 +5792,7 @@ static void throttle_cfs_rq_work(struct callback_head *work)
                rq = scope.rq;
                update_rq_clock(rq);
                WARN_ON_ONCE(p->throttled || !list_empty(&p->throttle_node));
-               dequeue_task_fair(rq, p, DEQUEUE_SLEEP | DEQUEUE_SPECIAL);
+               dequeue_task_fair(rq, p, DEQUEUE_SLEEP | DEQUEUE_THROTTLE);
                list_add(&p->throttle_node, &cfs_rq->throttled_limbo_list);
                /*
                 * Must not set throttled before dequeue or dequeue will
@@ -5959,6 +5952,17 @@ static inline void task_throttle_setup_work(struct task_struct *p)
        task_work_add(p, &p->sched_throttle_work, TWA_RESUME);
 }
 
+static void record_throttle_clock(struct cfs_rq *cfs_rq)
+{
+       struct rq *rq = rq_of(cfs_rq);
+
+       if (cfs_rq_throttled(cfs_rq) && !cfs_rq->throttled_clock)
+               cfs_rq->throttled_clock = rq_clock(rq);
+
+       if (!cfs_rq->throttled_clock_self)
+               cfs_rq->throttled_clock_self = rq_clock(rq);
+}
+
 static int tg_throttle_down(struct task_group *tg, void *data)
 {
        struct rq *rq = data;
@@ -5967,21 +5971,17 @@ static int tg_throttle_down(struct task_group *tg, void *data)
        if (cfs_rq->throttle_count++)
                return 0;
 
-
-       /* group is entering throttled state, stop time */
-       WARN_ON_ONCE(cfs_rq->throttled_clock_self);
-       if (cfs_rq->nr_queued)
-               cfs_rq->throttled_clock_self = rq_clock(rq);
-       else {
-               /*
-                * For cfs_rqs that still have entities enqueued, PELT clock
-                * stop happens at dequeue time when all entities are dequeued.
-                */
+       /*
+        * For cfs_rqs that still have entities enqueued, PELT clock
+        * stop happens at dequeue time when all entities are dequeued.
+        */
+       if (!cfs_rq->nr_queued) {
                list_del_leaf_cfs_rq(cfs_rq);
                cfs_rq->throttled_clock_pelt = rq_clock_pelt(rq);
                cfs_rq->pelt_clock_throttled = 1;
        }
 
+       WARN_ON_ONCE(cfs_rq->throttled_clock_self);
        WARN_ON_ONCE(!list_empty(&cfs_rq->throttled_limbo_list));
        return 0;
 }
@@ -6024,8 +6024,6 @@ static bool throttle_cfs_rq(struct cfs_rq *cfs_rq)
         */
        cfs_rq->throttled = 1;
        WARN_ON_ONCE(cfs_rq->throttled_clock);
-       if (cfs_rq->nr_queued)
-               cfs_rq->throttled_clock = rq_clock(rq);
        return true;
 }
 
@@ -6733,6 +6731,7 @@ static void task_throttle_setup_work(struct task_struct *p) {}
 static bool task_is_throttled(struct task_struct *p) { return false; }
 static void dequeue_throttled_task(struct task_struct *p, int flags) {}
 static bool enqueue_throttled_task(struct task_struct *p) { return false; }
+static void record_throttle_clock(struct cfs_rq *cfs_rq) {}
 
 static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq)
 {
@@ -7051,6 +7050,7 @@ static int dequeue_entities(struct rq *rq, struct sched_entity *se, int flags)
        bool was_sched_idle = sched_idle_rq(rq);
        bool task_sleep = flags & DEQUEUE_SLEEP;
        bool task_delayed = flags & DEQUEUE_DELAYED;
+       bool task_throttled = flags & DEQUEUE_THROTTLE;
        struct task_struct *p = NULL;
        int h_nr_idle = 0;
        int h_nr_queued = 0;
@@ -7084,6 +7084,9 @@ static int dequeue_entities(struct rq *rq, struct sched_entity *se, int flags)
                if (cfs_rq_is_idle(cfs_rq))
                        h_nr_idle = h_nr_queued;
 
+               if (throttled_hierarchy(cfs_rq) && task_throttled)
+                       record_throttle_clock(cfs_rq);
+
                /* Don't dequeue parent if it has other entities besides us */
                if (cfs_rq->load.weight) {
                        slice = cfs_rq_min_slice(cfs_rq);
@@ -7120,6 +7123,9 @@ static int dequeue_entities(struct rq *rq, struct sched_entity *se, int flags)
 
                if (cfs_rq_is_idle(cfs_rq))
                        h_nr_idle = h_nr_queued;
+
+               if (throttled_hierarchy(cfs_rq) && task_throttled)
+                       record_throttle_clock(cfs_rq);
        }
 
        sub_nr_running(rq, h_nr_queued);

diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 6e1b37bb8c9b1c0aa68b2d7cd352f34a85bd2705..b5367c514c143f8477f652180f4c601830192bf1 100644 (file)
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -2344,6 +2344,7 @@ extern const u32          sched_prio_to_wmult[40];
 #define DEQUEUE_SPECIAL                0x10
 #define DEQUEUE_MIGRATING      0x100 /* Matches ENQUEUE_MIGRATING */
 #define DEQUEUE_DELAYED                0x200 /* Matches ENQUEUE_DELAYED */
+#define DEQUEUE_THROTTLE       0x800
 
 #define ENQUEUE_WAKEUP         0x01
 #define ENQUEUE_RESTORE                0x02