[PATCH] sched/fair: Restart hrtick after same-task repicks

[PATCH] sched/fair: Restart hrtick after same-task repicks

[Shubhang Kaushik (Ampere)]

Fair hrtick is implemented with a one-shot timer, so each precise
preemption point has to be programmed explicitly. The usual fair path
does this from set_next_task_fair(), which calls hrtick_start_fair().

The missed path is:

  hrtick
    -> task_tick_fair(..., queued=1)
       -> entity_tick()
	  -> resched_curr()
    -> schedule()
       -> pick_task_fair() picks current again
       -> put_prev_set_next_task()
	  -> next == prev
	  -> return

Since set_next_task_fair() is skipped, hrtick_start_fair() is not called
and no new fair hrtick is started.

Record when a queued fair hrtick may need a restart, and consume that
state only from the same-task fast path. Limit this to cases where more
than one fair entity is runnable and all queued fair entities are
runnable, avoiding extra hrticks for delayed-dequeue and pipe-like cases
where queued entities are not all competing for CPU time.

Signed-off-by: Shubhang Kaushik (Ampere) <sh@gentwo.org>
---
On v7.2-rc7 mainline (3aa1dcaa4f6f), with HRTICK enabled,
base_slice_ns=3000000, and two CPU-bound tasks pinned to one CPU, the
nice-0 task's runtime intervals above 8ms dropped from 228 in a 10s
perf sched capture to 34-38 across repeated runs with this change.

A similar missed hrtick start was previously reported for the older
pick_next_task_fair() flow:
  Message-ID: <20241111074841.8802-1-shijie@os.amperecomputing.com>
---
 kernel/sched/core.c  |  2 ++
 kernel/sched/fair.c  | 29 ++++++++++++++++++++++++++++-
 kernel/sched/sched.h | 21 ++++++++++++++++++++-
 3 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 96226707c2f6135341aa779b8262f113e103d8ad..5ec8c3f752fa48149469907edb595ede0769e94a 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -1013,12 +1013,14 @@ static inline void hrtick_schedule_exit(struct rq *rq)
 		__hrtimer_rearm_deferred();
 
 	rq->hrtick_sched = HRTICK_SCHED_NONE;
+	rq->hrtick_rearm_fair = false;
 }
 
 static void hrtick_rq_init(struct rq *rq)
 {
 	INIT_CSD(&rq->hrtick_csd, __hrtick_start, rq);
 	rq->hrtick_sched = HRTICK_SCHED_NONE;
+	rq->hrtick_rearm_fair = false;
 	hrtimer_setup(&rq->hrtick_timer, hrtick, CLOCK_MONOTONIC,
 		      HRTIMER_MODE_REL_HARD | HRTIMER_MODE_LAZY_REARM);
 }
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index d78467ec6ee1343050fcc2794dafb38ade3599e5..2d90a9a84175833bdb78f6f78d23b124105fcb82 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -7681,6 +7681,22 @@ static void hrtick_start_fair(struct rq *rq, struct task_struct *p)
 	hrtick_start(rq, (scale * delta) / 1024);
 }
 
+void __hrtick_rearm_fair(struct rq *rq, struct task_struct *p)
+{
+	rq->hrtick_rearm_fair = false;
+
+	if (!hrtick_enabled_fair(rq))
+		return;
+
+	if (hrtick_active(rq))
+		return;
+
+	if (p->sched_class != &fair_sched_class)
+		return;
+
+	hrtick_start_fair(rq, p);
+}
+
 /*
  * Called on enqueue to start the hrtick when h_nr_queued becomes more than 1.
  */
@@ -14858,8 +14874,19 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
 		entity_tick(cfs_rq, se, queued);
 	}
 
-	if (queued)
+	if (queued) {
+		/*
+		 * Fair hrtick is one-shot. If this hrtick-triggered
+		 * reschedule picks the same task again, set_next_task_fair()
+		 * will be skipped. Mark that path for a possible restart, but
+		 * avoid delayed-dequeue cases where queued entities are not all
+		 * runnable.
+		 */
+		rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
+					rq->cfs.h_nr_runnable > 1 &&
+					rq->cfs.h_nr_runnable == rq->cfs.h_nr_queued;
 		return;
+	}
 
 	if (static_branch_unlikely(&sched_numa_balancing))
 		task_tick_numa(rq, curr);
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 56acf502ba260ab18bacd7a4c2efdec612d50125..faf63eea233981fbd7e0a13b652f0c37d292ef35 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -1313,6 +1313,7 @@ struct rq {
 	ktime_t			hrtick_time;
 	ktime_t			hrtick_delay;
 	unsigned int		hrtick_sched;
+	bool			hrtick_rearm_fair;
 #endif
 
 #ifdef CONFIG_SCHEDSTATS
@@ -2745,6 +2746,18 @@ static inline void set_next_task(struct rq *rq, struct task_struct *next)
 	next->sched_class->set_next_task(rq, next, false);
 }
 
+#ifdef CONFIG_SCHED_HRTICK
+void __hrtick_rearm_fair(struct rq *rq, struct task_struct *p);
+
+static inline void hrtick_rearm_fair(struct rq *rq, struct task_struct *p)
+{
+	if (rq->hrtick_rearm_fair)
+		__hrtick_rearm_fair(rq, p);
+}
+#else
+static inline void hrtick_rearm_fair(struct rq *rq, struct task_struct *p) { }
+#endif
+
 static inline void
 __put_prev_set_next_dl_server(struct rq *rq,
 			      struct task_struct *prev,
@@ -2763,8 +2776,14 @@ static inline void put_prev_set_next_task(struct rq *rq,
 
 	__put_prev_set_next_dl_server(rq, prev, next);
 
-	if (next == prev)
+	if (next == prev) {
+		/*
+		 * Same-task repicks skip class callbacks. Restart fair hrtick
+		 * if the queued tick path marked it as needed.
+		 */
+		hrtick_rearm_fair(rq, next);
 		return;
+	}
 
 	prev->sched_class->put_prev_task(rq, prev, next);
 	next->sched_class->set_next_task(rq, next, true);

---
base-commit: 3aa1dcaa4f6f5ae08936491e08bd456f331f2d40
change-id: 20260813-sched-fair-hrtick-restart-ab9d3d47ef78

Best regards,
-- 
Shubhang Kaushik (Ampere) <sh@gentwo.org>

Re: [PATCH] sched/fair: Restart hrtick after same-task repicks

[kernel test robot]

:::::: 
:::::: Manual check reason: "linux-review patch is more than 7 days old, verify it wasn't already superseded"
:::::: 

BCC: lkp@intel.com
CC: oe-kbuild-all@lists.linux.dev
In-Reply-To: <20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb@gentwo.org>
References: <20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb@gentwo.org>
TO: "Shubhang Kaushik (Ampere)" <sh@gentwo.org>
TO: Ingo Molnar <mingo@redhat.com>
TO: Peter Zijlstra <peterz@infradead.org>
TO: Juri Lelli <juri.lelli@redhat.com>
TO: Vincent Guittot <vincent.guittot@linaro.org>
TO: Dietmar Eggemann <dietmar.eggemann@arm.com>
TO: Steven Rostedt <rostedt@goodmis.org>
TO: Ben Segall <bsegall@google.com>
TO: Mel Gorman <mgorman@suse.de>
TO: Valentin Schneider <vschneid@redhat.com>
TO: K Prateek Nayak <kprateek.nayak@amd.com>
TO: Shubhang Kaushik <shubhang@os.amperecomputing.com>
TO: Christoph Lameter <cl@linux-foundation.org>
CC: linux-kernel@vger.kernel.org
CC: "Shubhang Kaushik (Ampere)" <sh@gentwo.org>

Hi Shubhang,

kernel test robot noticed the following build errors:

[auto build test ERROR on 3aa1dcaa4f6f5ae08936491e08bd456f331f2d40]

url:    https://github.com/intel-lab-lkp/linux/commits/Shubhang-Kaushik-Ampere/sched-fair-Restart-hrtick-after-same-task-repicks/20260813-142348
base:   3aa1dcaa4f6f5ae08936491e08bd456f331f2d40
patch link:    https://lore.kernel.org/r/20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb%40gentwo.org
patch subject: [PATCH] sched/fair: Restart hrtick after same-task repicks
:::::: branch date: 13 hours ago
:::::: commit date: 13 hours ago
config: alpha-allnoconfig (https://download.01.org/0day-ci/archive/20260825/202608250251.11earlUX-lkp@intel.com/config)
compiler: alpha-linux-gcc (GCC) 16.1.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260825/202608250251.11earlUX-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/r/202608250251.11earlUX-lkp@intel.com/

All errors (new ones prefixed by >>):

   kernel/sched/fair.c: In function 'task_tick_fair':
>> kernel/sched/fair.c:14885:19: error: 'struct rq' has no member named 'hrtick_rearm_fair'
   14885 |                 rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
         |                   ^~


vim +14885 kernel/sched/fair.c

8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14858  
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14859  /*
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14860   * scheduler tick hitting a task of our scheduling class.
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14861   *
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14862   * NOTE: This function can be called remotely by the tick offload that
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14863   * goes along full dynticks. Therefore no local assumption can be made
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14864   * and everything must be accessed through the @rq and @curr passed in
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14865   * parameters.
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14866   */
8f4d37ec073c17 kernel/sched_fair.c Peter Zijlstra            2008-01-25  14867  static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14868  {
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14869  	struct sched_entity *se = &curr->se;
f666241e6bd5d9 kernel/sched/fair.c Peter Zijlstra            2026-06-02  14870  	struct cfs_rq *cfs_rq;
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14871  
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14872  	for_each_sched_entity(se) {
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14873  		cfs_rq = cfs_rq_of(se);
8f4d37ec073c17 kernel/sched_fair.c Peter Zijlstra            2008-01-25  14874  		entity_tick(cfs_rq, se, queued);
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14875  	}
18bf2805d9b30c kernel/sched/fair.c Ben Segall                2012-10-04  14876  
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14877) 	if (queued) {
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14878) 		/*
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14879) 		 * Fair hrtick is one-shot. If this hrtick-triggered
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14880) 		 * reschedule picks the same task again, set_next_task_fair()
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14881) 		 * will be skipped. Mark that path for a possible restart, but
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14882) 		 * avoid delayed-dequeue cases where queued entities are not all
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14883) 		 * runnable.
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14884) 		 */
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13 @14885) 		rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14886) 					rq->cfs.h_nr_runnable > 1 &&
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14887) 					rq->cfs.h_nr_runnable == rq->cfs.h_nr_queued;
95a0155224a658 kernel/sched/fair.c Peter Zijlstra            2025-09-01  14888  		return;
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14889) 	}
95a0155224a658 kernel/sched/fair.c Peter Zijlstra            2025-09-01  14890  
b52da86e0ad58f kernel/sched/fair.c Srikar Dronamraju         2015-10-02  14891  	if (static_branch_unlikely(&sched_numa_balancing))
cbee9f88ec1b8d kernel/sched/fair.c Peter Zijlstra            2012-10-25  14892  		task_tick_numa(rq, curr);
3b1baa6496e6b7 kernel/sched/fair.c Morten Rasmussen          2018-07-04  14893  
df0d98475954d6 kernel/sched/fair.c Peter Zijlstra (Intel     2026-04-01  14894) 	task_tick_cache(rq, curr);
df0d98475954d6 kernel/sched/fair.c Peter Zijlstra (Intel     2026-04-01  14895) 
3b1baa6496e6b7 kernel/sched/fair.c Morten Rasmussen          2018-07-04  14896  	update_misfit_status(curr, rq);
be3a51e68f2f1b kernel/sched/fair.c Shrikanth Hegde           2024-03-07  14897  	check_update_overutilized_status(task_rq(curr));
8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14898  
8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14899  	task_tick_core(rq, curr);
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14900  }
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14901  

--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Re: [PATCH] sched/fair: Restart hrtick after same-task repicks

[kernel test robot]

:::::: 
:::::: Manual check reason: "linux-review patch is more than 7 days old, verify it wasn't already superseded"
:::::: 

BCC: lkp@intel.com
CC: llvm@lists.linux.dev
CC: oe-kbuild-all@lists.linux.dev
In-Reply-To: <20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb@gentwo.org>
References: <20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb@gentwo.org>
TO: "Shubhang Kaushik (Ampere)" <sh@gentwo.org>
TO: Ingo Molnar <mingo@redhat.com>
TO: Peter Zijlstra <peterz@infradead.org>
TO: Juri Lelli <juri.lelli@redhat.com>
TO: Vincent Guittot <vincent.guittot@linaro.org>
TO: Dietmar Eggemann <dietmar.eggemann@arm.com>
TO: Steven Rostedt <rostedt@goodmis.org>
TO: Ben Segall <bsegall@google.com>
TO: Mel Gorman <mgorman@suse.de>
TO: Valentin Schneider <vschneid@redhat.com>
TO: K Prateek Nayak <kprateek.nayak@amd.com>
TO: Shubhang Kaushik <shubhang@os.amperecomputing.com>
TO: Christoph Lameter <cl@linux-foundation.org>
CC: linux-kernel@vger.kernel.org
CC: "Shubhang Kaushik (Ampere)" <sh@gentwo.org>

Hi Shubhang,

kernel test robot noticed the following build errors:

[auto build test ERROR on 3aa1dcaa4f6f5ae08936491e08bd456f331f2d40]

url:    https://github.com/intel-lab-lkp/linux/commits/Shubhang-Kaushik-Ampere/sched-fair-Restart-hrtick-after-same-task-repicks/20260813-142348
base:   3aa1dcaa4f6f5ae08936491e08bd456f331f2d40
patch link:    https://lore.kernel.org/r/20260813-sched-fair-hrtick-restart-v1-1-4230d1e18fbb%40gentwo.org
patch subject: [PATCH] sched/fair: Restart hrtick after same-task repicks
:::::: branch date: 14 hours ago
:::::: commit date: 14 hours ago
config: s390-randconfig-002-20260825 (https://download.01.org/0day-ci/archive/20260825/202608250340.cxCp0maB-lkp@intel.com/config)
compiler: clang version 24.0.0git (https://github.com/llvm/llvm-project 935bfc708590c60147a79c7df145bb6e68b1d388)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260825/202608250340.cxCp0maB-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/r/202608250340.cxCp0maB-lkp@intel.com/

All errors (new ones prefixed by >>):

>> kernel/sched/fair.c:14885:7: error: no member named 'hrtick_rearm_fair' in 'struct rq'
    14885 |                 rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
          |                 ~~  ^
   1 error generated.


vim +14885 kernel/sched/fair.c

8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14858  
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14859  /*
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14860   * scheduler tick hitting a task of our scheduling class.
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14861   *
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14862   * NOTE: This function can be called remotely by the tick offload that
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14863   * goes along full dynticks. Therefore no local assumption can be made
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14864   * and everything must be accessed through the @rq and @curr passed in
d84b31313ef8a8 kernel/sched/fair.c Frederic Weisbecker       2018-02-21  14865   * parameters.
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14866   */
8f4d37ec073c17 kernel/sched_fair.c Peter Zijlstra            2008-01-25  14867  static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14868  {
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14869  	struct sched_entity *se = &curr->se;
f666241e6bd5d9 kernel/sched/fair.c Peter Zijlstra            2026-06-02  14870  	struct cfs_rq *cfs_rq;
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14871  
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14872  	for_each_sched_entity(se) {
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14873  		cfs_rq = cfs_rq_of(se);
8f4d37ec073c17 kernel/sched_fair.c Peter Zijlstra            2008-01-25  14874  		entity_tick(cfs_rq, se, queued);
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14875  	}
18bf2805d9b30c kernel/sched/fair.c Ben Segall                2012-10-04  14876  
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14877) 	if (queued) {
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14878) 		/*
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14879) 		 * Fair hrtick is one-shot. If this hrtick-triggered
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14880) 		 * reschedule picks the same task again, set_next_task_fair()
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14881) 		 * will be skipped. Mark that path for a possible restart, but
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14882) 		 * avoid delayed-dequeue cases where queued entities are not all
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14883) 		 * runnable.
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14884) 		 */
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13 @14885) 		rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14886) 					rq->cfs.h_nr_runnable > 1 &&
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14887) 					rq->cfs.h_nr_runnable == rq->cfs.h_nr_queued;
95a0155224a658 kernel/sched/fair.c Peter Zijlstra            2025-09-01  14888  		return;
c6c981b4c656c8 kernel/sched/fair.c Shubhang Kaushik (Ampere  2026-08-13  14889) 	}
95a0155224a658 kernel/sched/fair.c Peter Zijlstra            2025-09-01  14890  
b52da86e0ad58f kernel/sched/fair.c Srikar Dronamraju         2015-10-02  14891  	if (static_branch_unlikely(&sched_numa_balancing))
cbee9f88ec1b8d kernel/sched/fair.c Peter Zijlstra            2012-10-25  14892  		task_tick_numa(rq, curr);
3b1baa6496e6b7 kernel/sched/fair.c Morten Rasmussen          2018-07-04  14893  
df0d98475954d6 kernel/sched/fair.c Peter Zijlstra (Intel     2026-04-01  14894) 	task_tick_cache(rq, curr);
df0d98475954d6 kernel/sched/fair.c Peter Zijlstra (Intel     2026-04-01  14895) 
3b1baa6496e6b7 kernel/sched/fair.c Morten Rasmussen          2018-07-04  14896  	update_misfit_status(curr, rq);
be3a51e68f2f1b kernel/sched/fair.c Shrikanth Hegde           2024-03-07  14897  	check_update_overutilized_status(task_rq(curr));
8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14898  
8039e96fcc1de3 kernel/sched/fair.c Vineeth Pillai            2020-11-17  14899  	task_tick_core(rq, curr);
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14900  }
bf0f6f24a1ece8 kernel/sched_fair.c Ingo Molnar               2007-07-09  14901  

--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

Re: [PATCH] sched/fair: Restart hrtick after same-task repicks

[Shubhang]

Hello everyone,

A gentle ping for this patch, sent on August 13.

A fair hrtick is one-shot. When it expires and schedule() selects the
current fair task again, the next == prev path skips
set_next_task_fair(), which normally starts the next fair hrtick.
Consequently, no new fair hrtick is armed after that same-task repick.

The patch starts a new one-shot fair hrtick only in this next == prev
path, and only when all queued fair entities are runnable
(h_nr_runnable == h_nr_queued).

Could you please comment on whether this is the appropriate point and
condition for starting the next fair hrtick?

Thanks,
Shubhang Kaushik

Re: [PATCH] sched/fair: Restart hrtick after same-task repicks

[Zhan Xusheng]

From: Zhan Xusheng <zhanxusheng@xiaomi.com>

On Thu, 13 Aug 2026 14:23:48 -0700, Shubhang Kaushik (Ampere) wrote:
> +		rq->hrtick_rearm_fair = hrtick_enabled_fair(rq) &&
> +				rq->cfs.h_nr_runnable > 1 &&
> +				rq->cfs.h_nr_runnable == rq->cfs.h_nr_queued;

The last term switches the fix off whenever anything on the rq sits in
delayed dequeue.  set_delayed() decrements h_nr_runnable and leaves
h_nr_queued alone (kernel/sched/fair.c:6398), clear_delayed() puts it
back (6418), so the two differ exactly while a delay-dequeued entity is
present.  With DELAY_DEQUEUE that is routine, and it says nothing about
whether the running task still needs its slice bounded.

Your test cannot show that either way: two CPU-bound tasks pinned to one
CPU never sleep, so nothing is ever delay-dequeued there and the term is
true for the whole run.  Adding a third task that sleeps in a loop should
bring the missed hrtick back while the term is false.

If the intent is only to skip rqs whose other queued entities are not
competing for the CPU, h_nr_runnable > 1 already says that by itself.

> +static inline void hrtick_rearm_fair(struct rq *rq, struct task_struct *p)
> +{
> +	if (rq->hrtick_rearm_fair)
> +		__hrtick_rearm_fair(rq, p);
> +}

What does the rq field buy?  __hrtick_rearm_fair() already tests
hrtick_enabled_fair(), hrtick_active() and the class, and a same-task
repick that finds no hrtick armed wants one regardless of what triggered
the repick.  If there is a same-task repick that must not arm one, the
changelog is the place to name it.

Last one is only a question.  entity_tick() -> update_curr() ->
update_deadline() has already pushed se->deadline by a slice before
task_tick_fair() reaches the queued branch, so hrtick_start_fair() would
compute a valid delay if called right there, with no new field and no
change to put_prev_set_next_task().  The difference I can see is that the
tick callback runs with rq->hrtick_sched == 0, so hrtick_start() would
program the hrtimer immediately from inside its own callback instead of
leaving it to hrtick_schedule_exit().  Is that what moved you to the pick
side?

Thanks,
Zhan Xusheng