timers: Exclude isolated cpus from timer migation
Subsystems (6)
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
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
@@ -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
@@ -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
@@ -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
PATCH v2 2/3 timers: Add the available mask in timer migration
In reply to Gabriele MonacoKeep 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
@@ -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
PATCH v2 3/3 timers: Exclude isolated cpus from timer migation
In reply to Gabriele MonacoThe 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
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 thenohz_fulllist
* is in an isolated cpusetDue 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).Signed-off-by Gabriele Monaco <[email protected]>--- 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@@ -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@@ -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@@ -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@@ -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@@ -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
-1raw_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
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 thenohz_fulllist
* is in an isolated cpusetDue 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).Signed-off-by Gabriele Monaco <[email protected]>---
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@@ -190,4 +190,10 @@ int timers_dead_cpu(unsigned int cpu); #define timers_dead_cpu NULL #endifinclude/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@@ -1323,7 +1323,7 @@ static bool partition_xcpus_del(int old_prs,struct cpuset *parent, return isolcpus_updated; }
-static voidupdate_unbound_workqueue_cpumask(bool isolcpus_updated)
+static voidupdate_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 & updateeffective_xcpus*/
update_cpumasks_hier(cs, &tmpmask, !new_prs);kernel/time/tick- renamed from kernel/time/tick-internal.h +0
-0
internal.h
indexfaac36de35b9e..75580f7c69c64100644kernel/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@@ -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 baseis_idlevalue 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@@ -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 inttmigr_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 inttmigr_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 totmigr_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
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 thenohz_fulllist
* 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 remoteQuoted 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@@ -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 inttmigr_cpu_available(unsigned int cpu)
{
- structtmigr_cpu*tmc =this_cpu_ptr(&tmigr_cpu);
+ structtmigr_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 totmigr_cpu_available().
Quoted 3 lines
Since
tmigr_cpu_availableis 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_availableis 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
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 thenohz_fulllist
* is in an isolated cpusetDue 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 startedQuoted 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@@ -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 inttmigr_cpu_available(unsigned int cpu){
- structtmigr_cpu*tmc =this_cpu_ptr(&tmigr_cpu); + structtmigr_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" bootQuoted 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 totmigr_cpu_available().Quoted 4 lines
Since
tmigr_cpu_availableis 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