Skip to contentSkip to conversation

timers: Exclude isolated cpus from timer migation

PATCH Superseded Gabriele Monaco 2 participants 8 messages Apr 15, 2025 – Apr 16, 2025

Subsystems (6)

v2 of 16 Superseded Latest is v16 →

lore
Share & tools
lore
#0 lore raw

v2 cover timers: Exclude isolated cpus from timer migation

The timer migration mechanism allows active CPUs to pull timers from idle ones to improve the overall idle time. This is however undesired when CPU intensive workloads run on isolated cores, as the algorithm would move the timers from housekeeping to isolated cores, negatively affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs, and the CPU with lowest count in a timer migration hierarchy (here 1 and 65) appears as always active and continuously pulls global timers, from the housekeeping CPUs. This ends up moving driver work (e.g. delayed work) to isolated CPUs and causes latency spikes:

before the change:

 # oslat -c 1-31,33-63,65-95,97-127 -D 62s
 ...
  Maximum:     1203 10 3 4 ... 5 (us)

after the change:

 # oslat -c 1-31,33-63,65-95,97-127 -D 62s
 ...
  Maximum:      10 4 3 4 3 ... 5 (us)

Exclude isolated cores from the timer migration algorithm, extend the concept of unavailable cores, currently used for offline ones, to isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

A core is considered unavailable as idle if:
* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Due to how the timer migration algorithm works, any CPU part of the hierarchy can have their global timers pulled by remote CPUs and have to pull remote timers, only skipping pulling remote timers would break the logic.
For this reason, we prevents isolated CPUs from pulling remote global timers, but also the other way around: any global timer started on an isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if considered inappropriate, can usually be mitigated with other isolation techniques (e.g. IRQ pinning).

The first 2 patches are preparatory work to change the concept of online/offline to available/unavailable and keep track of those in a separate cpumask.

The third patch extends the unavailable status to isolated CPUs, which is the main contribution of the series.

Changes since v1 [1]:
* split into smaller patches
* use available mask instead of unavailable
* simplification and cleanup

[1] - https://lore.kernel.org/lkml/[email protected]

Gabriele Monaco (3):
timers: Rename tmigr 'online' bit to 'available'
timers: Add the available mask in timer migration
timers: Exclude isolated cpus from timer migation

 include/linux/timer.h                  |  6 +++
 include/trace/events/timer_migration.h |  4 +-
 kernel/cgroup/cpuset.c                 | 14 ++++---
 kernel/time/tick-internal.h            |  1 +
 kernel/time/timer.c                    | 10 +++++
 kernel/time/timer_migration.c          | 58 +++++++++++++++++++-------
 kernel/time/timer_migration.h          |  2 +-
 7 files changed, 71 insertions(+), 24 deletions(-)

base-commit: 834a4a689699090a406d1662b03affa8b155d025

Signature · 1 line
2.49.0
#1 lore raw

PATCH v2 1/3 timers: Rename tmigr 'online' bit to 'available'

The timer migration hierarchy excludes offline CPUs via the tmigr_is_not_available function, which is essentially checking the online bit for the CPU.

Rename the online bit to available and all references in function names and tracepoint to generalise the concept of available CPUs.

---
 include/trace/events/timer_migration.h |  4 ++--
 kernel/time/timer_migration.c          | 22 +++++++++++-----------
 kernel/time/timer_migration.h          |  2 +-
 3 files changed, 14 insertions(+), 14 deletions(-)
include/trace/events/timer_migration.h +2 -2
index 47db5eaf2f9ab..61171b13c687c 100644
@@ -173,14 +173,14 @@ DEFINE_EVENT(tmigr_cpugroup, tmigr_cpu_active,
 	TP_ARGS(tmc)
 );
 
-DEFINE_EVENT(tmigr_cpugroup, tmigr_cpu_online,
+DEFINE_EVENT(tmigr_cpugroup, tmigr_cpu_available,
 
 	TP_PROTO(struct tmigr_cpu *tmc),
 
 	TP_ARGS(tmc)
 );
 
-DEFINE_EVENT(tmigr_cpugroup, tmigr_cpu_offline,
+DEFINE_EVENT(tmigr_cpugroup, tmigr_cpu_unavailable,
 
 	TP_PROTO(struct tmigr_cpu *tmc),
 
kernel/time/timer_migration.c +11 -11
index 2f6330831f084..7efd897c79599 100644
@@ -427,7 +427,7 @@ static DEFINE_PER_CPU(struct tmigr_cpu, tmigr_cpu);
 
 static inline bool tmigr_is_not_available(struct tmigr_cpu *tmc)
 {
-	return !(tmc->tmgroup && tmc->online);
+	return !(tmc->tmgroup && tmc->available);
 }
 
 /*
@@ -926,7 +926,7 @@ static void tmigr_handle_remote_cpu(unsigned int cpu, u64 now,
 	 * updated the event takes care when hierarchy is completely
 	 * idle. Otherwise the migrator does it as the event is enqueued.
 	 */
-	if (!tmc->online || tmc->remote || tmc->cpuevt.ignore ||
+	if (!tmc->available || tmc->remote || tmc->cpuevt.ignore ||
 	    now < tmc->cpuevt.nextevt.expires) {
 		raw_spin_unlock_irq(&tmc->lock);
 		return;
@@ -973,7 +973,7 @@ static void tmigr_handle_remote_cpu(unsigned int cpu, u64 now,
 	 * (See also section "Required event and timerqueue update after a
 	 * remote expiry" in the documentation at the top)
 	 */
-	if (!tmc->online || !tmc->idle) {
+	if (!tmc->available || !tmc->idle) {
 		timer_unlock_remote_bases(cpu);
 		goto unlock;
 	}
@@ -1435,19 +1435,19 @@ static long tmigr_trigger_active(void *unused)
 {
 	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
 
-	WARN_ON_ONCE(!tmc->online || tmc->idle);
+	WARN_ON_ONCE(!tmc->available || tmc->idle);
 
 	return 0;
 }
 
-static int tmigr_cpu_offline(unsigned int cpu)
+static int tmigr_cpu_unavailable(unsigned int cpu)
 {
 	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
 	int migrator;
 	u64 firstexp;
 
 	raw_spin_lock_irq(&tmc->lock);
-	tmc->online = false;
+	tmc->available = false;
 	WRITE_ONCE(tmc->wakeup, KTIME_MAX);
 
 	/*
@@ -1455,7 +1455,7 @@ static int tmigr_cpu_offline(unsigned int cpu)
 	 * offline; Therefore nextevt value is set to KTIME_MAX
 	 */
 	firstexp = __tmigr_cpu_deactivate(tmc, KTIME_MAX);
-	trace_tmigr_cpu_offline(tmc);
+	trace_tmigr_cpu_unavailable(tmc);
 	raw_spin_unlock_irq(&tmc->lock);
 
 	if (firstexp != KTIME_MAX) {
@@ -1466,7 +1466,7 @@ static int tmigr_cpu_offline(unsigned int cpu)
 	return 0;
 }
 
-static int tmigr_cpu_online(unsigned int cpu)
+static int tmigr_cpu_available(unsigned int cpu)
 {
 	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
 
@@ -1475,11 +1475,11 @@ static int tmigr_cpu_online(unsigned int cpu)
 		return -EINVAL;
 
 	raw_spin_lock_irq(&tmc->lock);
-	trace_tmigr_cpu_online(tmc);
+	trace_tmigr_cpu_available(tmc);
 	tmc->idle = timer_base_is_idle();
 	if (!tmc->idle)
 		__tmigr_cpu_activate(tmc);
-	tmc->online = true;
+	tmc->available = true;
 	raw_spin_unlock_irq(&tmc->lock);
 	return 0;
 }
@@ -1850,7 +1850,7 @@ static int __init tmigr_init(void)
 		goto err;
 
 	ret = cpuhp_setup_state(CPUHP_AP_TMIGR_ONLINE, "tmigr:online",
-				tmigr_cpu_online, tmigr_cpu_offline);
+				tmigr_cpu_available, tmigr_cpu_unavailable);
 	if (ret)
 		goto err;
 
kernel/time/timer_migration.h +1 -1
index ae19f70f8170f..70879cde6fdd0 100644
@@ -97,7 +97,7 @@ struct tmigr_group {
  */
 struct tmigr_cpu {
 	raw_spinlock_t		lock;
-	bool			online;
+	bool			available;
 	bool			idle;
 	bool			remote;
 	struct tmigr_group	*tmgroup;
Signature · 1 line
2.49.0
#2 lore raw

PATCH v2 2/3 timers: Add the available mask in timer migration

In reply to Gabriele Monaco

Keep track of the CPUs available for timer migration in a cpumask. This prepares the ground to generalise the concept of unavailable CPUs.

---
 kernel/time/timer_migration.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)
kernel/time/timer_migration.c +11 -1
index 7efd897c79599..1fae38fbac8c2 100644
@@ -422,6 +422,9 @@ static unsigned int tmigr_crossnode_level __read_mostly;
 
 static DEFINE_PER_CPU(struct tmigr_cpu, tmigr_cpu);
 
+/* CPUs available for migration */
+static cpumask_var_t tmigr_available_cpumask;
+
 #define TMIGR_NONE	0xFF
 #define BIT_CNT		8
 
@@ -1449,6 +1452,7 @@ static int tmigr_cpu_unavailable(unsigned int cpu)
 	raw_spin_lock_irq(&tmc->lock);
 	tmc->available = false;
 	WRITE_ONCE(tmc->wakeup, KTIME_MAX);
+	cpumask_clear_cpu(cpu, tmigr_available_cpumask);
 
 	/*
 	 * CPU has to handle the local events on his own, when on the way to
@@ -1459,7 +1463,7 @@ static int tmigr_cpu_unavailable(unsigned int cpu)
 	raw_spin_unlock_irq(&tmc->lock);
 
 	if (firstexp != KTIME_MAX) {
-		migrator = cpumask_any_but(cpu_online_mask, cpu);
+		migrator = cpumask_any(tmigr_available_cpumask);
 		work_on_cpu(migrator, tmigr_trigger_active, NULL);
 	}
 
@@ -1480,6 +1484,7 @@ static int tmigr_cpu_available(unsigned int cpu)
 	if (!tmc->idle)
 		__tmigr_cpu_activate(tmc);
 	tmc->available = true;
+	cpumask_set_cpu(cpu, tmigr_available_cpumask);
 	raw_spin_unlock_irq(&tmc->lock);
 	return 0;
 }
@@ -1801,6 +1806,11 @@ static int __init tmigr_init(void)
 	if (ncpus == 1)
 		return 0;
 
+	if (!zalloc_cpumask_var(&tmigr_available_cpumask, GFP_KERNEL)) {
+		ret = -ENOMEM;
+		goto err;
+	}
+
 	/*
 	 * Calculate the required hierarchy levels. Unfortunately there is no
 	 * reliable information available, unless all possible CPUs have been
Signature · 1 line
2.49.0
#3 lore raw

PATCH v2 3/3 timers: Exclude isolated cpus from timer migation

In reply to Gabriele Monaco

The timer migration mechanism allows active CPUs to pull timers from idle ones to improve the overall idle time. This is however undesired when CPU intensive workloads run on isolated cores, as the algorithm would move the timers from housekeeping to isolated cores, negatively affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs, and the CPU with lowest count in a timer migration hierarchy (here 1 and 65) appears as always active and continuously pulls global timers, from the housekeeping CPUs. This ends up moving driver work (e.g. delayed work) to isolated CPUs and causes latency spikes:

before the change:

 # oslat -c 1-31,33-63,65-95,97-127 -D 62s
 ...
  Maximum:     1203 10 3 4 ... 5 (us)

after the change:

 # oslat -c 1-31,33-63,65-95,97-127 -D 62s
 ...
  Maximum:      10 4 3 4 3 ... 5 (us)

Exclude isolated cores from the timer migration algorithm, extend the concept of unavailable cores, currently used for offline ones, to isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

A core is considered unavailable as idle if:
* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Due to how the timer migration algorithm works, any CPU part of the hierarchy can have their global timers pulled by remote CPUs and have to pull remote timers, only skipping pulling remote timers would break the logic.
For this reason, we prevents isolated CPUs from pulling remote global timers, but also the other way around: any global timer started on an isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if considered inappropriate, can usually be mitigated with other isolation techniques (e.g. IRQ pinning).

---
 include/linux/timer.h         |  6 ++++++
 kernel/cgroup/cpuset.c        | 14 ++++++++------
 kernel/time/tick-internal.h   |  1 +
 kernel/time/timer.c           | 10 ++++++++++
 kernel/time/timer_migration.c | 24 +++++++++++++++++++++---
 5 files changed, 46 insertions(+), 9 deletions(-)
include/linux/timer.h +6 -0
index 10596d7c3a346..4722e075d9843 100644
@@ -190,4 +190,10 @@ int timers_dead_cpu(unsigned int cpu);
 #define timers_dead_cpu		NULL
 #endif
 
+#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
+extern void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask);
+#else
+static inline void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask) { }
+#endif
+
 #endif
kernel/cgroup/cpuset.c +8 -6
index 306b604300914..866b4b8188118 100644
@@ -1323,7 +1323,7 @@ static bool partition_xcpus_del(int old_prs, struct cpuset *parent,
 	return isolcpus_updated;
 }
 
-static void update_unbound_workqueue_cpumask(bool isolcpus_updated)
+static void update_exclusion_cpumasks(bool isolcpus_updated)
 {
 	int ret;
 
@@ -1334,6 +1334,8 @@ static void update_unbound_workqueue_cpumask(bool isolcpus_updated)
 
 	ret = workqueue_unbound_exclude_cpumask(isolated_cpus);
 	WARN_ON_ONCE(ret < 0);
+
+	tmigr_isolated_exclude_cpumask(isolated_cpus);
 }
 
 /**
@@ -1454,7 +1456,7 @@ static int remote_partition_enable(struct cpuset *cs, int new_prs,
 	list_add(&cs->remote_sibling, &remote_children);
 	cpumask_copy(cs->effective_xcpus, tmp->new_cpus);
 	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 	cpuset_force_rebuild();
 	cs->prs_err = 0;
 
@@ -1495,7 +1497,7 @@ static void remote_partition_disable(struct cpuset *cs, struct tmpmasks *tmp)
 	compute_effective_exclusive_cpumask(cs, NULL, NULL);
 	reset_partition_data(cs);
 	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 	cpuset_force_rebuild();
 
 	/*
@@ -1563,7 +1565,7 @@ static void remote_cpus_update(struct cpuset *cs, struct cpumask *xcpus,
 	if (xcpus)
 		cpumask_copy(cs->exclusive_cpus, xcpus);
 	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 	if (adding || deleting)
 		cpuset_force_rebuild();
 
@@ -1906,7 +1908,7 @@ static int update_parent_effective_cpumask(struct cpuset *cs, int cmd,
 		WARN_ON_ONCE(parent->nr_subparts < 0);
 	}
 	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 
 	if ((old_prs != new_prs) && (cmd == partcmd_update))
 		update_partition_exclusive_flag(cs, new_prs);
@@ -2931,7 +2933,7 @@ static int update_prstate(struct cpuset *cs, int new_prs)
 	else if (isolcpus_updated)
 		isolated_cpus_update(old_prs, new_prs, cs->effective_xcpus);
 	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 
 	/* Force update if switching back to member & update effective_xcpus */
 	update_cpumasks_hier(cs, &tmpmask, !new_prs);
kernel/time/tick-internal.h +1 -0
index faac36de35b9e..75580f7c69c64 100644
@@ -167,6 +167,7 @@ extern void fetch_next_timer_interrupt_remote(unsigned long basej, u64 basem,
 extern void timer_lock_remote_bases(unsigned int cpu);
 extern void timer_unlock_remote_bases(unsigned int cpu);
 extern bool timer_base_is_idle(void);
+extern bool timer_base_remote_is_idle(unsigned int cpu);
 extern void timer_expire_remote(unsigned int cpu);
 # endif
 #else /* CONFIG_NO_HZ_COMMON */
kernel/time/timer.c +10 -0
index 4d915c0a263c3..f04960091eba9 100644
@@ -2162,6 +2162,16 @@ bool timer_base_is_idle(void)
 	return __this_cpu_read(timer_bases[BASE_LOCAL].is_idle);
 }
 
+/**
+ * timer_base_remote_is_idle() - Return whether timer base is set idle for cpu
+ *
+ * Returns value of local timer base is_idle value for remote cpu.
+ */
+bool timer_base_remote_is_idle(unsigned int cpu)
+{
+	return per_cpu(timer_bases[BASE_LOCAL].is_idle, cpu);
+}
+
 static void __run_timer_base(struct timer_base *base);
 
 /**
kernel/time/timer_migration.c +21 -3
index 1fae38fbac8c2..6fe6ca798e98d 100644
@@ -10,6 +10,7 @@
 #include <linux/spinlock.h>
 #include <linux/timerqueue.h>
 #include <trace/events/ipi.h>
+#include <linux/sched/isolation.h>
 
 #include "timer_migration.h"
 #include "tick-internal.h"
@@ -1445,7 +1446,7 @@ static long tmigr_trigger_active(void *unused)
 
 static int tmigr_cpu_unavailable(unsigned int cpu)
 {
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
 	int migrator;
 	u64 firstexp;
 
@@ -1472,15 +1473,18 @@ static int tmigr_cpu_unavailable(unsigned int cpu)
 
 static int tmigr_cpu_available(unsigned int cpu)
 {
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
 
 	/* Check whether CPU data was successfully initialized */
 	if (WARN_ON_ONCE(!tmc->tmgroup))
 		return -EINVAL;
 
+	/* Isolated CPUs don't participate in timer migration */
+	if (cpu_is_isolated(cpu))
+		return 0;
 	raw_spin_lock_irq(&tmc->lock);
 	trace_tmigr_cpu_available(tmc);
-	tmc->idle = timer_base_is_idle();
+	tmc->idle = timer_base_remote_is_idle(cpu);
 	if (!tmc->idle)
 		__tmigr_cpu_activate(tmc);
 	tmc->available = true;
@@ -1489,6 +1493,20 @@ static int tmigr_cpu_available(unsigned int cpu)
 	return 0;
 }
 
+void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask)
+{
+	int cpu;
+
+	lockdep_assert_cpus_held();
+
+	for_each_cpu_and(cpu, exclude_cpumask, tmigr_available_cpumask)
+		tmigr_cpu_unavailable(cpu);
+
+	for_each_cpu_andnot(cpu, cpu_online_mask, exclude_cpumask)
+		if (!cpumask_test_cpu(cpu, tmigr_available_cpumask))
+			tmigr_cpu_available(cpu);
+}
+
 static void tmigr_init_group(struct tmigr_group *group, unsigned int lvl,
 			     int node)
 {
Signature · 1 line
2.49.0
#4 lore raw
Quoted 25 lines · Gabriele Monaco

The timer migration mechanism allows active CPUs to pull timers from idle ones to improve the overall idle time. This is however undesired when CPU intensive workloads run on isolated cores, as the algorithm would move the timers from housekeeping to isolated cores, negatively affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs, and the CPU with lowest count in a timer migration hierarchy (here 1 and 65) appears as always active and continuously pulls global timers, from the housekeeping CPUs. This ends up moving driver work (e.g. delayed work) to isolated CPUs and causes latency spikes:

before the change:

  # oslat -c 1-31,33-63,65-95,97-127 -D 62s
  ...
   Maximum:     1203 10 3 4 ... 5 (us)

after the change:

  # oslat -c 1-31,33-63,65-95,97-127 -D 62s
  ...
   Maximum:      10 4 3 4 3 ... 5 (us)
Quoted 5 lines

Exclude isolated cores from the timer migration algorithm, extend the concept of unavailable cores, currently used for offline ones, to isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

I think you mean "A core is available if NOT isolated and NOT offline". Right?

Quoted 166 lines

A core is considered unavailable as idle if:
* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Due to how the timer migration algorithm works, any CPU part of the hierarchy can have their global timers pulled by remote CPUs and have to pull remote timers, only skipping pulling remote timers would break the logic.
For this reason, we prevents isolated CPUs from pulling remote global timers, but also the other way around: any global timer started on an isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if considered inappropriate, can usually be mitigated with other isolation techniques (e.g. IRQ pinning).

---
  include/linux/timer.h         |  6 ++++++
  kernel/cgroup/cpuset.c        | 14 ++++++++------
  kernel/time/tick-internal.h   |  1 +
  kernel/time/timer.c           | 10 ++++++++++
  kernel/time/timer_migration.c | 24 +++++++++++++++++++++---
  5 files changed, 46 insertions(+), 9 deletions(-)
include/linux/timer.h +6 -0
index 10596d7c3a346..4722e075d9843 100644
@@ -190,4 +190,10 @@ int timers_dead_cpu(unsigned int cpu);
  #define timers_dead_cpu		NULL
  #endif
 
+#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
+extern void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask);
+#else
+static inline void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask) { }
+#endif
+
  #endif
kernel/cgroup/cpuset.c +8 -6
index 306b604300914..866b4b8188118 100644
@@ -1323,7 +1323,7 @@ static bool partition_xcpus_del(int old_prs, struct cpuset *parent,
  	return isolcpus_updated;
  }
 
-static void update_unbound_workqueue_cpumask(bool isolcpus_updated)
+static void update_exclusion_cpumasks(bool isolcpus_updated)
  {
  	int ret;
 
@@ -1334,6 +1334,8 @@ static void update_unbound_workqueue_cpumask(bool isolcpus_updated)
 
  	ret = workqueue_unbound_exclude_cpumask(isolated_cpus);
  	WARN_ON_ONCE(ret < 0);
+
+	tmigr_isolated_exclude_cpumask(isolated_cpus);
  }
 
  /**
@@ -1454,7 +1456,7 @@ static int remote_partition_enable(struct cpuset *cs, int new_prs,
  	list_add(&cs->remote_sibling, &remote_children);
  	cpumask_copy(cs->effective_xcpus, tmp->new_cpus);
  	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
  	cpuset_force_rebuild();
  	cs->prs_err = 0;
 
@@ -1495,7 +1497,7 @@ static void remote_partition_disable(struct cpuset *cs, struct tmpmasks *tmp)
  	compute_effective_exclusive_cpumask(cs, NULL, NULL);
  	reset_partition_data(cs);
  	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
  	cpuset_force_rebuild();
 
  	/*
@@ -1563,7 +1565,7 @@ static void remote_cpus_update(struct cpuset *cs, struct cpumask *xcpus,
  	if (xcpus)
  		cpumask_copy(cs->exclusive_cpus, xcpus);
  	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
  	if (adding || deleting)
  		cpuset_force_rebuild();
 
@@ -1906,7 +1908,7 @@ static int update_parent_effective_cpumask(struct cpuset *cs, int cmd,
  		WARN_ON_ONCE(parent->nr_subparts < 0);
  	}
  	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 
  	if ((old_prs != new_prs) && (cmd == partcmd_update))
  		update_partition_exclusive_flag(cs, new_prs);
@@ -2931,7 +2933,7 @@ static int update_prstate(struct cpuset *cs, int new_prs)
  	else if (isolcpus_updated)
  		isolated_cpus_update(old_prs, new_prs, cs->effective_xcpus);
  	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
 
  	/* Force update if switching back to member & update effective_xcpus */
  	update_cpumasks_hier(cs, &tmpmask, !new_prs);
kernel/time/tick-internal.h +1 -0
index faac36de35b9e..75580f7c69c64 100644
@@ -167,6 +167,7 @@ extern void fetch_next_timer_interrupt_remote(unsigned long basej, u64 basem,
  extern void timer_lock_remote_bases(unsigned int cpu);
  extern void timer_unlock_remote_bases(unsigned int cpu);
  extern bool timer_base_is_idle(void);
+extern bool timer_base_remote_is_idle(unsigned int cpu);
  extern void timer_expire_remote(unsigned int cpu);
  # endif
  #else /* CONFIG_NO_HZ_COMMON */
kernel/time/timer.c +10 -0
index 4d915c0a263c3..f04960091eba9 100644
@@ -2162,6 +2162,16 @@ bool timer_base_is_idle(void)
  	return __this_cpu_read(timer_bases[BASE_LOCAL].is_idle);
  }
 
+/**
+ * timer_base_remote_is_idle() - Return whether timer base is set idle for cpu
+ *
+ * Returns value of local timer base is_idle value for remote cpu.
+ */
+bool timer_base_remote_is_idle(unsigned int cpu)
+{
+	return per_cpu(timer_bases[BASE_LOCAL].is_idle, cpu);
+}
+
  static void __run_timer_base(struct timer_base *base);
 
  /**
kernel/time/timer_migration.c +2 -1
index 1fae38fbac8c2..6fe6ca798e98d 100644
@@ -10,6 +10,7 @@
  #include <linux/spinlock.h>
  #include <linux/timerqueue.h>
  #include <trace/events/ipi.h>
+#include <linux/sched/isolation.h>
 
  #include "timer_migration.h"
  #include "tick-internal.h"
@@ -1445,7 +1446,7 @@ static long tmigr_trigger_active(void *unused)
 
  static int tmigr_cpu_unavailable(unsigned int cpu)
  {
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
  	int migrator;
  	u64 firstexp;
 
@@ -1472,15 +1473,18 @@ static int tmigr_cpu_unavailable(unsigned int cpu)
 
  static int tmigr_cpu_available(unsigned int cpu)
  {

kernel/time/timer_migration.c static int tmigr_cpu_unavailable(unsigned int cpu) · line 1484

Quoted 10 lines
kernel/time/timer_migration.c +4 -1
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
 
  	/* Check whether CPU data was successfully initialized */
  	if (WARN_ON_ONCE(!tmc->tmgroup))
  		return -EINVAL;
 
+	/* Isolated CPUs don't participate in timer migration */
+	if (cpu_is_isolated(cpu))
+		return 0;

There are two main sets of isolated CPUs used by cpu_is_isolated() - boot-time isolated CPUs via "isolcpus" and "nohz_full" boot command time options and runtime isolated CPUs via cpuset isolated partitions. The check for runtime isolated CPUs is redundant here as those CPUs won't be passed to tmigr_cpu_available(). So this call is effectively removing the boot time isolated CPUs away from the available cpumask especially during the boot up process. Maybe you can add some comment about this behavioral change.

Quoted 18 lines
kernel/time/timer_migration.c +8 -1
  	raw_spin_lock_irq(&tmc->lock);
  	trace_tmigr_cpu_available(tmc);
-	tmc->idle = timer_base_is_idle();
+	tmc->idle = timer_base_remote_is_idle(cpu);
  	if (!tmc->idle)
  		__tmigr_cpu_activate(tmc);
  	tmc->available = true;
@@ -1489,6 +1493,20 @@ static int tmigr_cpu_available(unsigned int cpu)
  	return 0;
  }
 
+void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask)
+{
+	int cpu;
+
+	lockdep_assert_cpus_held();
+
+	for_each_cpu_and(cpu, exclude_cpumask, tmigr_available_cpumask)

kernel/time/timer_migration.c static int tmigr_cpu_available(unsigned int cpu) · line 1512

Quoted 10 lines
kernel/time/timer_migration.c +7 -0
+		tmigr_cpu_unavailable(cpu);
+
+	for_each_cpu_andnot(cpu, cpu_online_mask, exclude_cpumask)
+		if (!cpumask_test_cpu(cpu, tmigr_available_cpumask))
+			tmigr_cpu_available(cpu);
+}
+
  static void tmigr_init_group(struct tmigr_group *group, unsigned int lvl,
  			     int node)
  {

So far, I haven't seen any major issue with this patch series.

Cheers,
Longman

#5 lore raw
Quoted 40 lines · Waiman Long
Quoted 32 lines · Gabriele Monaco

The timer migration mechanism allows active CPUs to pull timers from
idle ones to improve the overall idle time. This is however undesired
when CPU intensive workloads run on isolated cores, as the algorithm
would move the timers from housekeeping to isolated cores, negatively
affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs,
and the CPU with lowest count in a timer migration hierarchy (here 1
and 65) appears as always active and continuously pulls global timers,
from the housekeeping CPUs. This ends up moving driver work (e.g. delayed work) to isolated CPUs and causes latency spikes:

before the change:

  # oslat -c 1-31,33-63,65-95,97-127 -D 62s
  ...
   Maximum:     1203 10 3 4 ... 5 (us)

after the change:

  # oslat -c 1-31,33-63,65-95,97-127 -D 62s
  ...
   Maximum:      10 4 3 4 3 ... 5 (us)
Quoted 6 lines

Exclude isolated cores from the timer migration algorithm, extend the
concept of unavailable cores, currently used for offline ones, to isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

Quoted 3 lines

I think you mean "A core is available if NOT isolated and NOT offline".
Right?

Yes, of course.. My bad. Thanks for spotting.

Quoted 200 lines
Quoted 196 lines

A core is considered unavailable as idle if:
* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Due to how the timer migration algorithm works, any CPU part of the hierarchy can have their global timers pulled by remote CPUs and have to
pull remote timers, only skipping pulling remote timers would break the
logic.
For this reason, we prevents isolated CPUs from pulling remote global
timers, but also the other way around: any global timer started on an
isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if considered inappropriate, can usually be mitigated with other isolation
techniques (e.g. IRQ pinning).

---
  include/linux/timer.h         |  6 ++++++ kernel/cgroup/cpuset.c        | 14 ++++++++------ kernel/time/tick-internal.h   |  1 + kernel/time/timer.c           | 10 ++++++++++ kernel/time/timer_migration.c | 24 +++++++++++++++++++++---

  5 files changed, 46 insertions(+), 9 deletions(-)
include/linux/timer.h +0 -0
index 10596d7c3a346..4722e075d9843 100644
@@ -190,4 +190,10 @@ int timers_dead_cpu(unsigned int cpu);
   #define timers_dead_cpu		NULL
   #endif

include/linux/timer.h +2 -0
+#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
+extern void tmigr_isolated_exclude_cpumask(cpumask_var_t

exclude_cpumask);

include/linux/timer.h +2 -0
+#else
+static inline void tmigr_isolated_exclude_cpumask(cpumask_var_t

exclude_cpumask) { }

include/linux/timer.h +2 -0
+#endif
+

  #endif

kernel/cgroup/cpuset.c +0 -0
index 306b604300914..866b4b8188118 100644
@@ -1323,7 +1323,7 @@ static bool partition_xcpus_del(int old_prs,
 struct cpuset *parent,
   	return isolcpus_updated;
   }


-static void update_unbound_workqueue_cpumask(bool isolcpus_updated)
+static void update_exclusion_cpumasks(bool isolcpus_updated) {
   int ret;

kernel/cgroup/cpuset.c +0 -0
@@ -1334,6 +1334,8 @@ static void
 update_unbound_workqueue_cpumask(bool isolcpus_updated)


   ret = workqueue_unbound_exclude_cpumask(isolated_cpus); WARN_ON_ONCE(ret < 0);

kernel/cgroup/cpuset.c +2 -0
+
+	tmigr_isolated_exclude_cpumask(isolated_cpus);

  }

  /**

kernel/cgroup/cpuset.c +1 -1
@@ -1454,7 +1456,7 @@ static int remote_partition_enable(struct
 cpuset *cs, int new_prs,
   	list_add(&cs->remote_sibling, &remote_children);
   	cpumask_copy(cs->effective_xcpus, tmp->new_cpus);
   	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
   	cpuset_force_rebuild();
   	cs->prs_err = 0;

kernel/cgroup/cpuset.c +1 -1
@@ -1495,7 +1497,7 @@ static void remote_partition_disable(struct
 cpuset *cs, struct tmpmasks *tmp)
   	compute_effective_exclusive_cpumask(cs, NULL, NULL);
   	reset_partition_data(cs);
   	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
   	cpuset_force_rebuild();


   /*

kernel/cgroup/cpuset.c +1 -1
@@ -1563,7 +1565,7 @@ static void remote_cpus_update(struct cpuset
 *cs, struct cpumask *xcpus,
   	if (xcpus)
   		cpumask_copy(cs->exclusive_cpus, xcpus);
   	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);
   	if (adding || deleting)
   		cpuset_force_rebuild();

kernel/cgroup/cpuset.c +1 -1
@@ -1906,7 +1908,7 @@ static int
 update_parent_effective_cpumask(struct cpuset *cs, int cmd,
   		WARN_ON_ONCE(parent->nr_subparts < 0);
   	}
   	spin_unlock_irq(&callback_lock);
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);


   if ((old_prs != new_prs) && (cmd == partcmd_update)) update_partition_exclusive_flag(cs, new_prs);

kernel/cgroup/cpuset.c +0 -0
@@ -2931,7 +2933,7 @@ static int update_prstate(struct cpuset *cs,
 int new_prs)
   	else if (isolcpus_updated)

   isolated_cpus_update(old_prs, new_prs, cs-

Quoted 1 line

effective_xcpus);

   spin_unlock_irq(&callback_lock);

kernel/cgroup/cpuset.c +1 -1
-	update_unbound_workqueue_cpumask(isolcpus_updated);
+	update_exclusion_cpumasks(isolcpus_updated);


   /* Force update if switching back to member & update effective_xcpus */
   update_cpumasks_hier(cs, &tmpmask, !new_prs);

kernel/time/tick- renamed from kernel/time/tick-internal.h +0 -0

internal.h
index faac36de35b9e..75580f7c69c64 100644

kernel/time/tick-internal.h +1 -0
@@ -167,6 +167,7 @@ extern void
 fetch_next_timer_interrupt_remote(unsigned long basej, u64 basem,
   extern void timer_lock_remote_bases(unsigned int cpu);
   extern void timer_unlock_remote_bases(unsigned int cpu);
   extern bool timer_base_is_idle(void);
+extern bool timer_base_remote_is_idle(unsigned int cpu);
   extern void timer_expire_remote(unsigned int cpu);
   # endif

  #else /* CONFIG_NO_HZ_COMMON */

kernel/time/timer.c +0 -0
index 4d915c0a263c3..f04960091eba9 100644
@@ -2162,6 +2162,16 @@ bool timer_base_is_idle(void)
   	return __this_cpu_read(timer_bases[BASE_LOCAL].is_idle);
   }


+/**
+ * timer_base_remote_is_idle() - Return whether timer base is set idle for cpu
+ *
+ * Returns value of local timer base is_idle value for remote cpu.
+ */

kernel/time/timer.c +5 -0
+bool timer_base_remote_is_idle(unsigned int cpu)
+{
+	return per_cpu(timer_bases[BASE_LOCAL].is_idle, cpu);
+}
+

  static void __run_timer_base(struct timer_base *base);
  /**

kernel/time/timer_migration.c +1 -0
index 1fae38fbac8c2..6fe6ca798e98d 100644
@@ -10,6 +10,7 @@
   #include <linux/spinlock.h>
   #include <linux/timerqueue.h>
   #include <trace/events/ipi.h>
+#include <linux/sched/isolation.h>


  #include "timer_migration.h"
  #include "tick-internal.h"

kernel/time/timer_migration.c +0 -0
@@ -1445,7 +1446,7 @@ static long tmigr_trigger_active(void
 *unused)


  static int tmigr_cpu_unavailable(unsigned int cpu) {

kernel/time/timer_migration.c +1 -1
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);

   int migrator;
   u64 firstexp;

kernel/time/timer_migration.c +0 -0
@@ -1472,15 +1473,18 @@ static int tmigr_cpu_unavailable(unsigned
 int cpu)


  static int tmigr_cpu_available(unsigned int cpu) {

kernel/time/timer_migration.c +1 -1
-	struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+	struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);


   /* Check whether CPU data was successfully initialized */ if (WARN_ON_ONCE(!tmc->tmgroup))
   return -EINVAL;

kernel/time/timer_migration.c static int tmigr_cpu_unavailable(unsigned int cpu) · line 1484

Quoted 3 lines
kernel/time/timer_migration.c +3 -0
+	/* Isolated CPUs don't participate in timer migration */
+	if (cpu_is_isolated(cpu))
+		return 0;
Quoted 7 lines

There are two main sets of isolated CPUs used by cpu_is_isolated() - boot-time isolated CPUs via "isolcpus" and "nohz_full" boot command time
options and runtime isolated CPUs via cpuset isolated partitions. The check for runtime isolated CPUs is redundant here as those CPUs won't be
passed to tmigr_cpu_available().

Since tmigr_cpu_available is shared between isolated and offline CPUs, I added this check also to make sure bringing an isolated CPU back online won't make it available for tmigr.

Quoted 6 lines

So this call is effectively removing
the boot time isolated CPUs away from the available cpumask especially
during the boot up process. Maybe you can add some comment about this behavioral change.

Do you mean I should make clear that the check in tmigr_cpu_available is especially meaningful at boot time (i.e. when CPUs are first brought online)?

Yeah, I probably should, good point. I had that kind of comment in v1 while allocating the mask and removed it while changing a few things.

I'm going to make that comment more verbose to clarify when exactly it's needed.

Quoted 27 lines
Quoted 27 lines

   raw_spin_lock_irq(&tmc->lock);
   trace_tmigr_cpu_available(tmc);

kernel/time/timer_migration.c +1 -1
-	tmc->idle = timer_base_is_idle();
+	tmc->idle = timer_base_remote_is_idle(cpu);

   if (!tmc->idle)
   __tmigr_cpu_activate(tmc);
   tmc->available = true;

kernel/time/timer_migration.c +0 -0
@@ -1489,6 +1493,20 @@ static int tmigr_cpu_available(unsigned int
 cpu)
   	return 0;
   }

kernel/time/timer_migration.c +7 -0
+void tmigr_isolated_exclude_cpumask(cpumask_var_t exclude_cpumask)
+{
+	int cpu;
+
+	lockdep_assert_cpus_held();
+
+	for_each_cpu_and(cpu, exclude_cpumask,

tmigr_available_cpumask)

kernel/time/timer_migration.c +4 -0
+		tmigr_cpu_unavailable(cpu);
+
+	for_each_cpu_andnot(cpu, cpu_online_mask, exclude_cpumask)
+		if (!cpumask_test_cpu(cpu,

tmigr_available_cpumask))

kernel/time/timer_migration.c +1 -0
+			tmigr_cpu_available(cpu);
Quoted 9 lines
Quoted 6 lines
kernel/time/timer_migration.c +2 -0
+}
+

  static void tmigr_init_group(struct tmigr_group *group, unsigned int lvl,
        int node)
  {

So far, I haven't seen any major issue with this patch series.

Thanks for the review!

Cheers,
Gabriele

#6 lore raw
Quoted 41 lines · Gabriele Monaco
Quoted 39 lines · Waiman Long
Quoted 38 lines · Gabriele Monaco

The timer migration mechanism allows active CPUs to pull timers from
idle ones to improve the overall idle time. This is however undesired
when CPU intensive workloads run on isolated cores, as the algorithm
would move the timers from housekeeping to isolated cores, negatively
affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs,
and the CPU with lowest count in a timer migration hierarchy (here 1
and 65) appears as always active and continuously pulls global timers,
from the housekeeping CPUs. This ends up moving driver work (e.g. delayed work) to isolated CPUs and causes latency spikes:

before the change:

   # oslat -c 1-31,33-63,65-95,97-127 -D 62s
   ...
    Maximum:     1203 10 3 4 ... 5 (us)

after the change:

   # oslat -c 1-31,33-63,65-95,97-127 -D 62s
   ...
    Maximum:      10 4 3 4 3 ... 5 (us)

Exclude isolated cores from the timer migration algorithm, extend the
concept of unavailable cores, currently used for offline ones, to isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

Quoted 6 lines
Quoted 3 lines

I think you mean "A core is available if NOT isolated and NOT offline".
Right?

Yes, of course.. My bad. Thanks for spotting.

Quoted 1 line
Quoted 1 line

A core is considered unavailable as idle if:

What do you mean by "unavailable as idle"? An idle CPU is different from an unvailable CPU, I think.

Quoted 4 lines
Quoted 4 lines
Quoted 4 lines

* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Quoted 15 lines
Quoted 7 lines
Quoted 7 lines

Due to how the timer migration algorithm works, any CPU part of the hierarchy can have their global timers pulled by remote CPUs and have to
pull remote timers, only skipping pulling remote timers would break the
logic.
For this reason, we prevents isolated CPUs from pulling remote

Quoted 8 lines
Quoted 8 lines

global
timers, but also the other way around: any global timer started on an
isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if considered inappropriate, can usually be mitigated with other isolation
techniques (e.g. IRQ pinning).

BTW, I am not that familiar with the timer migration code. Does marking an isolated CPU as unavailable (previously offline) make the above behavior happen?

Now unavailable CPUs include the isolated CPUs. We may need to look at some of the online (now available) flag check within the timer migration code to make sure that they are still doing the right thing.

Quoted 39 lines
Quoted 31 lines
Quoted 31 lines
kernel/time/timer_migration.c +2 -1
index 1fae38fbac8c2..6fe6ca798e98d 100644
@@ -10,6 +10,7 @@
    #include <linux/spinlock.h>
    #include <linux/timerqueue.h>
    #include <trace/events/ipi.h>
+#include <linux/sched/isolation.h>
       #include "timer_migration.h"
    #include "tick-internal.h"
@@ -1445,7 +1446,7 @@ static long tmigr_trigger_active(void
 *unused)
       static int tmigr_cpu_unavailable(unsigned int cpu)
    {
-    struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+    struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
        int migrator;
        u64 firstexp;

   @@ -1472,15 +1473,18 @@ static int tmigr_cpu_unavailable(unsigned int cpu)
      static int tmigr_cpu_available(unsigned int cpu)
   {
-    struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+    struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu); /* Check whether CPU data was successfully initialized */ if (WARN_ON_ONCE(!tmc->tmgroup))
           return -EINVAL;
   +    /* Isolated CPUs don't participate in timer migration */ +    if (cpu_is_isolated(cpu))

Quoted 8 lines
Quoted 1 line

+        return 0;

There are two main sets of isolated CPUs used by cpu_is_isolated() - boot-time isolated CPUs via "isolcpus" and "nohz_full" boot command time
options and runtime isolated CPUs via cpuset isolated partitions. The check for runtime isolated CPUs is redundant here as those CPUs won't be
passed to tmigr_cpu_available().

Quoted 3 lines

Since tmigr_cpu_available is shared between isolated and offline CPUs, I added this check also to make sure bringing an isolated CPU back online won't make it available for tmigr.

Good point, so the check is indeed needed.

Quoted 10 lines
Quoted 7 lines

So this call is effectively removing
the boot time isolated CPUs away from the available cpumask especially
during the boot up process. Maybe you can add some comment about this behavioral change.

Do you mean I should make clear that the check in tmigr_cpu_available is especially meaningful at boot time (i.e. when CPUs are first brought online)?

The current timgr code doesn't look at boot time isolated CPUs. The cpu_is_isolated() check skips those boot time isolated CPUs from the mask. I think this should be noted.

Quoted 6 lines

Yeah, I probably should, good point. I had that kind of comment in v1 while allocating the mask and removed it while changing a few things.

I'm going to make that comment more verbose to clarify when exactly it's needed.

Thanks,
Longman

#7 lore raw
Quoted 50 lines · Waiman Long
Quoted 49 lines · Gabriele Monaco
Quoted 47 lines · Waiman Long
Quoted 35 lines · Gabriele Monaco

The timer migration mechanism allows active CPUs to pull timers from
idle ones to improve the overall idle time. This is however undesired
when CPU intensive workloads run on isolated cores, as the algorithm
would move the timers from housekeeping to isolated cores, negatively
affecting the isolation.

This effect was noticed on a 128 cores machine running oslat on the
isolated cores (1-31,33-63,65-95,97-127). The tool monopolises CPUs,
and the CPU with lowest count in a timer migration hierarchy (here
1
and 65) appears as always active and continuously pulls global timers,
from the housekeeping CPUs. This ends up moving driver work (e.g.
delayed work) to isolated CPUs and causes latency spikes:

before the change:

   # oslat -c 1-31,33-63,65-95,97-127 -D 62s
   ...
    Maximum:     1203 10 3 4 ... 5 (us)

after the change:

   # oslat -c 1-31,33-63,65-95,97-127 -D 62s
   ...
    Maximum:      10 4 3 4 3 ... 5 (us)
Quoted 8 lines

Exclude isolated cores from the timer migration algorithm, extend
the
concept of unavailable cores, currently used for offline ones, to
isolated ones:
* A core is unavailable if isolated or offline;
* A core is available if isolated and offline;

I think you mean "A core is available if NOT isolated and NOT offline".
Right?

Quoted 6 lines
Quoted 3 lines

Yes, of course.. My bad. Thanks for spotting.

Quoted 1 line
Quoted 1 line

A core is considered unavailable as idle if:

What do you mean by "unavailable as idle"? An idle CPU is different from
an unvailable CPU, I think.

Here I mean unavailable for tmigr, see below for why I got that term. If you find it misleading I could look for a better term to represent the concept.

Quoted 30 lines
Quoted 16 lines
Quoted 16 lines
Quoted 16 lines

* is in the isolcpus list
* is in the nohz_full list
* is in an isolated cpuset

Due to how the timer migration algorithm works, any CPU part of the
hierarchy can have their global timers pulled by remote CPUs and
have to
pull remote timers, only skipping pulling remote timers would break
the
logic.
For this reason, we prevents isolated CPUs from pulling remote global
timers, but also the other way around: any global timer started

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

on
an
isolated CPU will run there. This does not break the concept of isolation (global timers don't come from outside the CPU) and, if
considered inappropriate, can usually be mitigated with other isolation
techniques (e.g. IRQ pinning).

BTW, I am not that familiar with the timer migration code. Does marking
an isolated CPU as unavailable (previously offline) make the above behavior happen?

Quoted 6 lines

Now unavailable CPUs include the isolated CPUs. We may need to look at
some of the online (now available) flag check within the timer migration
code to make sure that they are still doing the right thing.

The original tmigr code excludes offline CPUs from the hierarchy, those clearly won't have timers and everything works.
This series changes that concept to unavailable (I took the name from tmigr_is_not_available, which used to check if a CPU was online and initialised for tmigr) to also include isolated CPUs.

A CPU is then unavailable because it's offline, isolated or both, this effectively prevents it from joining the hierarchy.
One noticeable difference is that isolated CPUs can still have global timers, the fact they don't participate in the hierarchy would isolate also those (which won't migrate). This is what I kind of missed in v1 but acknowledging that, everything seems to work.

That's as far as I could see, of course, reviewers might find some corner cases I didn't consider.

Quoted 67 lines
Quoted 47 lines
Quoted 39 lines
Quoted 28 lines
kernel/time/timer_migration.c +2 -1
index 1fae38fbac8c2..6fe6ca798e98d 100644
@@ -10,6 +10,7 @@
    #include <linux/spinlock.h>
    #include <linux/timerqueue.h>
    #include <trace/events/ipi.h>
+#include <linux/sched/isolation.h>
       #include "timer_migration.h"
    #include "tick-internal.h"
@@ -1445,7 +1446,7 @@ static long tmigr_trigger_active(void
 *unused)
       static int tmigr_cpu_unavailable(unsigned int cpu)
    {
-    struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu);
+    struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);
        int migrator;
        u64 firstexp;

   @@ -1472,15 +1473,18 @@ static int tmigr_cpu_unavailable(unsigned
int cpu)
      static int tmigr_cpu_available(unsigned int cpu) {
-    struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu); +    struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu);

Quoted 8 lines

          /* Check whether CPU data was successfully initialized */
       if (WARN_ON_ONCE(!tmc->tmgroup))
           return -EINVAL;
   +    /* Isolated CPUs don't participate in timer migration */
+    if (cpu_is_isolated(cpu))
+        return 0;

There are two main sets of isolated CPUs used by cpu_is_isolated() -
boot-time isolated CPUs via "isolcpus" and "nohz_full" boot

Quoted 8 lines

command
time
options and runtime isolated CPUs via cpuset isolated partitions. The
check for runtime isolated CPUs is redundant here as those CPUs won't
be
passed to tmigr_cpu_available().

Quoted 4 lines

Since tmigr_cpu_available is shared between isolated and offline CPUs,
I added this check also to make sure bringing an isolated CPU back online won't make it available for tmigr.

Good point, so the check is indeed needed.

Quoted 8 lines
Quoted 8 lines

So this call is effectively removing
the boot time isolated CPUs away from the available cpumask especially
during the boot up process. Maybe you can add some comment about this
behavioral change.

Quoted 5 lines

Do you mean I should make clear that the check in tmigr_cpu_available
is especially meaningful at boot time (i.e. when CPUs are first brought
online)?

Quoted 4 lines

The current timgr code doesn't look at boot time isolated CPUs. The cpu_is_isolated() check skips those boot time isolated CPUs from the mask. I think this should be noted.

Right, will add a note about that.

Thanks again,
Gabriele