timer: Refactor the timer wheel
Subsystems (17)
cover timer: Refactor the timer wheel
This is the third version of the timer wheel rework series. The previous versions can be found here:
V1: http://lkml.kernel.org/r/[email protected] V2: http://lkml.kernel.org/r/[email protected] V3: http://lkml.kernel.org/r/[email protected]
The series is also available in git:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git WIP.timers
Changes vs. V3:
- Folded the delta fixes into the affected patches
Thanks,
tglx
--- arch/x86/kernel/apic/x2apic_uv_x.c | 4 arch/x86/kernel/cpu/mcheck/mce.c | 4 block/genhd.c | 5 drivers/cpufreq/powernv-cpufreq.c | 5 drivers/mmc/host/jz4740_mmc.c | 2 drivers/net/ethernet/tile/tilepro.c | 4 drivers/power/bq27xxx_battery.c | 5 drivers/tty/metag_da.c | 4 drivers/tty/mips_ejtag_fdc.c | 4 drivers/usb/host/ohci-hcd.c | 1 drivers/usb/host/xhci.c | 2 include/linux/list.h | 10 include/linux/timer.h | 34 - kernel/signal.c | 24 kernel/time/tick-internal.h | 1 kernel/time/tick-sched.c | 45 - kernel/time/timer.c | 1101 +++++++++++++++++++++--------------- lib/random32.c | 1 net/ipv4/inet_connection_sock.c | 7 net/ipv4/inet_timewait_sock.c | 5 20 files changed, 740 insertions(+), 528 deletions(-)
PATCH 1/22 timer: Make pinned a timer property
We want to move the timer migration from a push to a pull model. This requires to store the pinned attribute of a timer in the timer itself. This must happen at initialization time.
Add the helper macros for this.
--- include/linux/timer.h | 25 ++++++++++++++++++++++--- kernel/time/timer.c | 10 +++++----- 2 files changed, 27 insertions(+), 8 deletions(-)
include/linux/timer.h +22 -3
@@ -62,7 +62,8 @@ struct timer_list {#define TIMER_MIGRATING 0x00080000#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING)#define TIMER_DEFERRABLE 0x00100000 -#define TIMER_IRQSAFE 0x00200000 +#define TIMER_PINNED 0x00200000 +#define TIMER_IRQSAFE 0x00400000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
@@ -78,9 +79,15 @@ struct timer_list {#define TIMER_INITIALIZER (_function, _expires, _data) \ __TIMER_INITIALIZER((_function), (_expires), (_data), 0) +#define TIMER_PINNED_INITIALIZER (_function, _expires, _data) \ + __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_PINNED) +#define TIMER_DEFERRED_INITIALIZER (_function, _expires, _data) \ __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE) +#define TIMER_PINNED_DEFERRED_INITIALIZER (_function, _expires, _data) \ + __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE | TIMER_PINNED) +#define DEFINE_TIMER (_name, _function, _expires, _data) \ struct timer_list _name = \ TIMER_INITIALIZER(_function, _expires, _data)
@@ -124,8 +131,12 @@ static inline void init_timer_on_stack_k#define init_timer (timer) \ __init_timer((timer), 0) +#define init_timer_pinned (timer) \ + __init_timer((timer), TIMER_PINNED)#define init_timer_deferrable (timer) \ __init_timer((timer), TIMER_DEFERRABLE) +#define init_timer_pinned_deferrable (timer) \ + __init_timer((timer), TIMER_DEFERRABLE | TIMER_PINNED)#define init_timer_on_stack (timer) \ __init_timer_on_stack((timer), 0)
@@ -145,12 +156,20 @@ static inline void init_timer_on_stack_k#define setup_timer (timer, fn, data) \ __setup_timer((timer), (fn), (data), 0) +#define setup_pinned_timer (timer, fn, data) \ + __setup_timer((timer), (fn), (data), TIMER_PINNED)#define setup_deferrable_timer (timer, fn, data) \ __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE) +#define setup_pinned_deferrable_timer (timer, fn, data) \ + __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)#define setup_timer_on_stack (timer, fn, data) \ __setup_timer_on_stack((timer), (fn), (data), 0) +#define setup_pinned_timer_on_stack (timer, fn, data) \ + __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED)#define setup_deferrable_timer_on_stack (timer, fn, data) \ __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) +#define setup_pinned_deferrable_timer_on_stack (timer, fn, data) \ + __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)/** * timer_pending - is a timer pending?
@@ -175,8 +194,8 @@ extern int mod_timer_pinned(struct timerextern void set_timer_slack (struct timer_list *time,int slack_hz); -#define TIMER_NOT_PINNED 0 -#define TIMER_PINNED 1 +#define MOD_TIMER_NOT_PINNED 0 +#define MOD_TIMER_PINNED 1/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +5 -5
@@ -782,7 +782,7 @@ static inline intdebug_activate (timer, expires); - new_base =get_target_base (base, pinned); + new_base =get_target_base (base, pinned || timer->flags &TIMER_PINNED );if (base != new_base) {/*
@@ -825,7 +825,7 @@ static inline int*/ int mod_timer_pending (struct timer_list *timer,unsigned long expires) { -return __mod_timer (timer, expires, true,TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, true,MOD_TIMER_NOT_PINNED ); }EXPORT_SYMBOL (mod_timer_pending);
@@ -900,7 +900,7 @@ int mod_timer(struct timer_list *timer,if (timer_pending (timer) && timer->expires == expires)return 1 ; -return __mod_timer (timer, expires, false,TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, false,MOD_TIMER_NOT_PINNED ); }EXPORT_SYMBOL (mod_timer);
@@ -928,7 +928,7 @@ int mod_timer_pinned(struct timer_list *if (timer->expires == expires &&timer_pending (timer))return 1 ; -return __mod_timer (timer, expires, false,TIMER_PINNED ); +return __mod_timer (timer, expires, false,MOD_TIMER_PINNED ); }EXPORT_SYMBOL (mod_timer_pinned);
@@ -1512,7 +1512,7 @@ signed long __sched schedule_timeout(sig expire = timeout + jiffies;setup_timer_on_stack (&timer, process_timeout, (unsigned long )current); -__mod_timer (&timer, expire, false,TIMER_NOT_PINNED ); +__mod_timer (&timer, expire, false,MOD_TIMER_NOT_PINNED );schedule ();del_singleshot_timer_sync (&timer);
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Make 'pinned' a timer property
timers: Make 'pinned' a timer property
Commit-ID: e675447bda51c1ea72d1ac9132ce3bed974f1da3 Gitweb: http://git.kernel.org/tip/e675447bda51c1ea72d1ac9132ce3bed974f1da3 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:15 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:13 +0200
timers: Make 'pinned' a timer property
We want to move the timer migration logic from a 'push' to a 'pull' model.
Under the current 'push' model pinned timers are handled via a runtime API variant: mod_timer_pinned().
The 'pull' model requires us to store the pinned attribute of a timer in the timer_list structure itself, as a new TIMER_PINNED bit in timer->flags.
This flag must be set at initialization time and the timer APIs recognize the flag.
This patch:
- Implements the new flag and associated new-style initialization methods
- makes mod_timer() recognize new-style pinned timers,
- and adds some migration helper facility to allow step by step conversion of old-style to new-style pinned timers.
--- include/linux/timer.h | 25 ++++++++++++++++++++++--- kernel/time/timer.c | 10 +++++----- 2 files changed, 27 insertions(+), 8 deletions(-)
include/linux/timer.h +22 -3
@@ -62,7 +62,8 @@ struct timer_list {#define TIMER_MIGRATING 0x00080000#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING)#define TIMER_DEFERRABLE 0x00100000 -#define TIMER_IRQSAFE 0x00200000 +#define TIMER_PINNED 0x00200000 +#define TIMER_IRQSAFE 0x00400000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
@@ -78,9 +79,15 @@ struct timer_list {#define TIMER_INITIALIZER (_function, _expires, _data) \ __TIMER_INITIALIZER((_function), (_expires), (_data), 0) +#define TIMER_PINNED_INITIALIZER (_function, _expires, _data) \ + __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_PINNED) +#define TIMER_DEFERRED_INITIALIZER (_function, _expires, _data) \ __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE) +#define TIMER_PINNED_DEFERRED_INITIALIZER (_function, _expires, _data) \ + __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE | TIMER_PINNED) +#define DEFINE_TIMER (_name, _function, _expires, _data) \ struct timer_list _name = \ TIMER_INITIALIZER(_function, _expires, _data)
@@ -124,8 +131,12 @@ static inline void init_timer_on_stack_key(struct timer_list *timer,#define init_timer (timer) \ __init_timer((timer), 0) +#define init_timer_pinned (timer) \ + __init_timer((timer), TIMER_PINNED)#define init_timer_deferrable (timer) \ __init_timer((timer), TIMER_DEFERRABLE) +#define init_timer_pinned_deferrable (timer) \ + __init_timer((timer), TIMER_DEFERRABLE | TIMER_PINNED)#define init_timer_on_stack (timer) \ __init_timer_on_stack((timer), 0)
@@ -145,12 +156,20 @@ static inline void init_timer_on_stack_key(struct timer_list *timer,#define setup_timer (timer, fn, data) \ __setup_timer((timer), (fn), (data), 0) +#define setup_pinned_timer (timer, fn, data) \ + __setup_timer((timer), (fn), (data), TIMER_PINNED)#define setup_deferrable_timer (timer, fn, data) \ __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE) +#define setup_pinned_deferrable_timer (timer, fn, data) \ + __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)#define setup_timer_on_stack (timer, fn, data) \ __setup_timer_on_stack((timer), (fn), (data), 0) +#define setup_pinned_timer_on_stack (timer, fn, data) \ + __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED)#define setup_deferrable_timer_on_stack (timer, fn, data) \ __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE) +#define setup_pinned_deferrable_timer_on_stack (timer, fn, data) \ + __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)/** * timer_pending - is a timer pending?
@@ -175,8 +194,8 @@ extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);extern void set_timer_slack (struct timer_list *time,int slack_hz); -#define TIMER_NOT_PINNED 0 -#define TIMER_PINNED 1 +#define MOD_TIMER_NOT_PINNED 0 +#define MOD_TIMER_PINNED 1/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +5 -5
@@ -782,7 +782,7 @@ __mod_timer(struct timer_list *timer, unsigned long expires,debug_activate (timer, expires); - new_base =get_target_base (base, pinned); + new_base =get_target_base (base, pinned || timer->flags &TIMER_PINNED );if (base != new_base) {/*
@@ -825,7 +825,7 @@ out_unlock:*/ int mod_timer_pending (struct timer_list *timer,unsigned long expires) { -return __mod_timer (timer, expires, true,TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, true,MOD_TIMER_NOT_PINNED ); }EXPORT_SYMBOL (mod_timer_pending);
@@ -900,7 +900,7 @@ int mod_timer(struct timer_list *timer, unsigned long expires)if (timer_pending (timer) && timer->expires == expires)return 1 ; -return __mod_timer (timer, expires, false,TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, false,MOD_TIMER_NOT_PINNED ); }EXPORT_SYMBOL (mod_timer);
@@ -928,7 +928,7 @@ int mod_timer_pinned(struct timer_list *timer, unsigned long expires)if (timer->expires == expires &&timer_pending (timer))return 1 ; -return __mod_timer (timer, expires, false,TIMER_PINNED ); +return __mod_timer (timer, expires, false,MOD_TIMER_PINNED ); }EXPORT_SYMBOL (mod_timer_pinned);
@@ -1512,7 +1512,7 @@ signed long __sched schedule_timeout(signed long timeout) expire = timeout + jiffies;setup_timer_on_stack (&timer, process_timeout, (unsigned long )current); -__mod_timer (&timer, expire, false,TIMER_NOT_PINNED ); +__mod_timer (&timer, expire, false,MOD_TIMER_NOT_PINNED );schedule ();del_singleshot_timer_sync (&timer);
PATCH 2/22 x86/apic/uv: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- arch/x86/kernel/apic/x2apic_uv_x.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/kernel/apic/x2apic_uv_x.c +2 -2
@@ -919,7 +919,7 @@ static void uv_heartbeat(unsigned long iuv_set_scir_bits (bits);/* enable next timer period */ -mod_timer_pinned (timer, jiffies +SCIR_CPU_HB_INTERVAL ); +mod_timer (timer, jiffies +SCIR_CPU_HB_INTERVAL ); }static void uv_heartbeat_enable (int cpu)
@@ -928,7 +928,7 @@ static void uv_heartbeat_enable(int cpu)struct timer_list *timer = &uv_cpu_scir_info (cpu)->timer;uv_set_cpu_scir_bits (cpu,SCIR_CPU_HEARTBEAT |SCIR_CPU_ACTIVITY ); -setup_timer (timer, uv_heartbeat, cpu); +setup_pinned_timer (timer, uv_heartbeat, cpu); timer->expires = jiffies +SCIR_CPU_HB_INTERVAL ;add_timer_on (timer, cpu);uv_cpu_scir_info (cpu)->enabled =1 ;
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, x86/apic/uv: Initialize the UV heartbeat timer as pinned
timers, x86/apic/uv: Initialize the UV heartbeat timer as pinned
Commit-ID: 920a4a70c55058a9997f2e35bf41503acf87c301 Gitweb: http://git.kernel.org/tip/920a4a70c55058a9997f2e35bf41503acf87c301 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:16 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:14 +0200
timers, x86/apic/uv: Initialize the UV heartbeat timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- arch/x86/kernel/apic/x2apic_uv_x.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/kernel/apic/x2apic_uv_x.c +2 -2
@@ -919,7 +919,7 @@ static void uv_heartbeat(unsigned long ignored)uv_set_scir_bits (bits);/* enable next timer period */ -mod_timer_pinned (timer, jiffies +SCIR_CPU_HB_INTERVAL ); +mod_timer (timer, jiffies +SCIR_CPU_HB_INTERVAL ); }static void uv_heartbeat_enable (int cpu)
@@ -928,7 +928,7 @@ static void uv_heartbeat_enable(int cpu)struct timer_list *timer = &uv_cpu_scir_info (cpu)->timer;uv_set_cpu_scir_bits (cpu,SCIR_CPU_HEARTBEAT |SCIR_CPU_ACTIVITY ); -setup_timer (timer, uv_heartbeat, cpu); +setup_pinned_timer (timer, uv_heartbeat, cpu); timer->expires = jiffies +SCIR_CPU_HB_INTERVAL ;add_timer_on (timer, cpu);uv_cpu_scir_info (cpu)->enabled =1 ;
PATCH 3/22 x86/mce: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- arch/x86/kernel/cpu/mcheck/mce.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/kernel/cpu/mcheck/mce.c +2 -2
@@ -1309,7 +1309,7 @@ static void __restart_timer(struct timerif (timer_pending (t)) {if (time_before (when, t->expires)) -mod_timer_pinned (t, when); +mod_timer (t, when); }else { t->expires =round_jiffies (when);add_timer_on (t,smp_processor_id ());
@@ -1735,7 +1735,7 @@ static void __mcheck_cpu_init_timer(voidstruct timer_list *t =this_cpu_ptr (&mce_timer);unsigned int cpu =smp_processor_id (); -setup_timer (t, mce_timer_fn, cpu); +setup_pinned_timer (t, mce_timer_fn, cpu);mce_start_timer (cpu, t); }
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, x86/mce: Initialize MCE restart timer as pinned
timers, x86/mce: Initialize MCE restart timer as pinned
Commit-ID: f9c287ba3861714a1959accf14e815c44291bec4 Gitweb: http://git.kernel.org/tip/f9c287ba3861714a1959accf14e815c44291bec4 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:17 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:14 +0200
timers, x86/mce: Initialize MCE restart timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- arch/x86/kernel/cpu/mcheck/mce.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/kernel/cpu/mcheck/mce.c +2 -2
@@ -1309,7 +1309,7 @@ static void __restart_timer(struct timer_list *t, unsigned long interval)if (timer_pending (t)) {if (time_before (when, t->expires)) -mod_timer_pinned (t, when); +mod_timer (t, when); }else { t->expires =round_jiffies (when);add_timer_on (t,smp_processor_id ());
@@ -1735,7 +1735,7 @@ static void __mcheck_cpu_init_timer(void)struct timer_list *t =this_cpu_ptr (&mce_timer);unsigned int cpu =smp_processor_id (); -setup_timer (t, mce_timer_fn, cpu); +setup_pinned_timer (t, mce_timer_fn, cpu);mce_start_timer (cpu, t); }
PATCH 4/22 cpufreq/powernv: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- drivers/cpufreq/powernv-cpufreq.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/cpufreq/powernv-cpufreq.c +2 -3
@@ -530,8 +530,7 @@ static inline void queue_gpstate_timer(else timer_interval =GPSTATE_TIMER_INTERVAL ; -mod_timer_pinned (&gpstates->timer, jiffies + -msecs_to_jiffies (timer_interval)); +mod_timer (&gpstates->timer, jiffies +msecs_to_jiffies (timer_interval)); }/**
@@ -699,7 +698,7 @@ static int powernv_cpufreq_cpu_init(stru policy->driver_data = gpstates;/* initialize timer */ -init_timer_deferrable (&gpstates->timer); +init_timer_pinned_deferrable (&gpstates->timer); gpstates->timer.data = (unsigned long )policy; gpstates->timer.function = gpstate_timer_handler; gpstates->timer.expires = jiffies +
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, cpufreq/powernv: Initialize the gpstate timer as pinned
timers, cpufreq/powernv: Initialize the gpstate timer as pinned
Commit-ID: 7bc54b652f13119f64e87dd96bb792efbfc5a786 Gitweb: http://git.kernel.org/tip/7bc54b652f13119f64e87dd96bb792efbfc5a786 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:18 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:14 +0200
timers, cpufreq/powernv: Initialize the gpstate timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- drivers/cpufreq/powernv-cpufreq.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/cpufreq/powernv-cpufreq.c +2 -3
@@ -530,8 +530,7 @@ static inline void queue_gpstate_timer(struct global_pstate_info *gpstates)else timer_interval =GPSTATE_TIMER_INTERVAL ; -mod_timer_pinned (&gpstates->timer, jiffies + -msecs_to_jiffies (timer_interval)); +mod_timer (&gpstates->timer, jiffies +msecs_to_jiffies (timer_interval)); }/**
@@ -699,7 +698,7 @@ static int powernv_cpufreq_cpu_init(struct cpufreq_policy *policy) policy->driver_data = gpstates;/* initialize timer */ -init_timer_deferrable (&gpstates->timer); +init_timer_pinned_deferrable (&gpstates->timer); gpstates->timer.data = (unsigned long )policy; gpstates->timer.function = gpstate_timer_handler; gpstates->timer.expires = jiffies +
PATCH 5/22 driver/net/ethernet/tile: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- drivers/net/ethernet/tile/tilepro.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/ethernet/tile/tilepro.c +2 -2
@@ -588,7 +588,7 @@ static bool tile_net_lepp_free_comps(strstatic void tile_net_schedule_egress_timer (struct tile_net_cpu *info) {if (!info->egress_timer_scheduled) { -mod_timer_pinned (&info->egress_timer, jiffies +1 ); +mod_timer (&info->egress_timer, jiffies +1 ); info->egress_timer_scheduled = true; } }
@@ -1004,7 +1004,7 @@ static void tile_net_register(void *dev_BUG ();/* Initialize the egress timer. */ -init_timer (&info->egress_timer); +init_timer_pinned (&info->egress_timer); info->egress_timer.data = (long )info; info->egress_timer.function = tile_net_handle_egress_timer;
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, driver/net/ethernet/tile: Initialize the egress timer as pinned
timers, driver/net/ethernet/tile: Initialize the egress timer as pinned
Commit-ID: 25df57605edbe92b6f4215226bd40e1a465ef6b4 Gitweb: http://git.kernel.org/tip/25df57605edbe92b6f4215226bd40e1a465ef6b4 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:19 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:14 +0200
timers, driver/net/ethernet/tile: Initialize the egress timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- drivers/net/ethernet/tile/tilepro.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/ethernet/tile/tilepro.c +2 -2
@@ -588,7 +588,7 @@ static bool tile_net_lepp_free_comps(struct net_device *dev, bool all)static void tile_net_schedule_egress_timer (struct tile_net_cpu *info) {if (!info->egress_timer_scheduled) { -mod_timer_pinned (&info->egress_timer, jiffies +1 ); +mod_timer (&info->egress_timer, jiffies +1 ); info->egress_timer_scheduled = true; } }
@@ -1004,7 +1004,7 @@ static void tile_net_register(void *dev_ptr)BUG ();/* Initialize the egress timer. */ -init_timer (&info->egress_timer); +init_timer_pinned (&info->egress_timer); info->egress_timer.data = (long )info; info->egress_timer.function = tile_net_handle_egress_timer;
PATCH 6/22 drivers/tty/metag_da: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- drivers/tty/metag_da.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/tty/metag_da.c +2 -2
@@ -323,12 +323,12 @@ static void dashtty_timer(unsigned longif (channel >=0 )fetch_data (channel); -mod_timer_pinned (&poll_timer, jiffies +DA_TTY_POLL ); +mod_timer (&poll_timer, jiffies +DA_TTY_POLL ); }static void add_poll_timer (struct timer_list *poll_timer) { -setup_timer (poll_timer, dashtty_timer,0 ); +setup_pinned_timer (poll_timer, dashtty_timer,0 ); poll_timer->expires = jiffies +DA_TTY_POLL ;/*
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, drivers/tty/metag_da: Initialize the poll timer as pinned
timers, drivers/tty/metag_da: Initialize the poll timer as pinned
Commit-ID: 01bab536b1fe982fcba8144e2ee11ac889a22f0e Gitweb: http://git.kernel.org/tip/01bab536b1fe982fcba8144e2ee11ac889a22f0e Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:21 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:25:14 +0200
timers, drivers/tty/metag_da: Initialize the poll timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- drivers/tty/metag_da.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/tty/metag_da.c +2 -2
@@ -323,12 +323,12 @@ static void dashtty_timer(unsigned long ignored)if (channel >=0 )fetch_data (channel); -mod_timer_pinned (&poll_timer, jiffies +DA_TTY_POLL ); +mod_timer (&poll_timer, jiffies +DA_TTY_POLL ); }static void add_poll_timer (struct timer_list *poll_timer) { -setup_timer (poll_timer, dashtty_timer,0 ); +setup_pinned_timer (poll_timer, dashtty_timer,0 ); poll_timer->expires = jiffies +DA_TTY_POLL ;/*
PATCH 7/22 drivers/tty/mips_ejtag: Initialize timer as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- drivers/tty/mips_ejtag_fdc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/tty/mips_ejtag_fdc.c +2 -2
@@ -689,7 +689,7 @@ static void mips_ejtag_fdc_tty_timer(unsmips_ejtag_fdc_handle (priv);if (!priv->removing) -mod_timer_pinned (&priv->poll_timer, jiffies +FDC_TTY_POLL ); +mod_timer (&priv->poll_timer, jiffies +FDC_TTY_POLL ); }/* TTY Port operations */
@@ -1002,7 +1002,7 @@ static int mips_ejtag_fdc_tty_probe(struraw_spin_unlock_irq (&priv->lock); }else {/* If we didn't get an usable IRQ, poll instead */ -setup_timer (&priv->poll_timer, mips_ejtag_fdc_tty_timer, +setup_pinned_timer (&priv->poll_timer, mips_ejtag_fdc_tty_timer, (unsigned long )priv); priv->poll_timer.expires = jiffies +FDC_TTY_POLL ;/*
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, drivers/tty/mips_ejtag: Initialize the poll timer as pinned
timers, drivers/tty/mips_ejtag: Initialize the poll timer as pinned
Commit-ID: 853f90d49bbabcf4e01c615402c1bea1871d7646 Gitweb: http://git.kernel.org/tip/853f90d49bbabcf4e01c615402c1bea1871d7646 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:22 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:34:59 +0200
timers, drivers/tty/mips_ejtag: Initialize the poll timer as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- drivers/tty/mips_ejtag_fdc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/tty/mips_ejtag_fdc.c +2 -2
@@ -689,7 +689,7 @@ static void mips_ejtag_fdc_tty_timer(unsigned long opaque)mips_ejtag_fdc_handle (priv);if (!priv->removing) -mod_timer_pinned (&priv->poll_timer, jiffies +FDC_TTY_POLL ); +mod_timer (&priv->poll_timer, jiffies +FDC_TTY_POLL ); }/* TTY Port operations */
@@ -1002,7 +1002,7 @@ static int mips_ejtag_fdc_tty_probe(struct mips_cdmm_device *dev)raw_spin_unlock_irq (&priv->lock); }else {/* If we didn't get an usable IRQ, poll instead */ -setup_timer (&priv->poll_timer, mips_ejtag_fdc_tty_timer, +setup_pinned_timer (&priv->poll_timer, mips_ejtag_fdc_tty_timer, (unsigned long )priv); priv->poll_timer.expires = jiffies +FDC_TTY_POLL ;/*
PATCH 8/22 net/ipv4/inet: Initialize timers as pinned
In reply to Thomas GleixnerPinned timers must carry that attribute in the timer itself. No functional change.
--- net/ipv4/inet_connection_sock.c | 7 ++++--- net/ipv4/inet_timewait_sock.c | 5 +++-- 2 files changed, 7 insertions(+), 5 deletions(-)
net/ipv4/inet_connection_sock.c +4 -3
@@ -603,7 +603,7 @@ static void reqsk_timer_handler(unsignedif (req->num_timeout++ ==0 )atomic_dec (&queue->young); timeo =min (TCP_TIMEOUT_INIT << req->num_timeout,TCP_RTO_MAX ); -mod_timer_pinned (&req->rsk_timer, jiffies + timeo); +mod_timer (&req->rsk_timer, jiffies + timeo);return ; } drop:
@@ -617,8 +617,9 @@ static void reqsk_queue_hash_req(struct req->num_timeout =0 ; req->sk =NULL ; -setup_timer (&req->rsk_timer, reqsk_timer_handler, (unsigned long )req); -mod_timer_pinned (&req->rsk_timer, jiffies + timeout); +setup_pinned_timer (&req->rsk_timer, reqsk_timer_handler, + (unsigned long )req); +mod_timer (&req->rsk_timer, jiffies + timeout);inet_ehash_insert (req_to_sk (req),NULL );/* before letting lookups find us, make sure all req fields
net/ipv4/inet_timewait_sock.c +3 -2
@@ -188,7 +188,8 @@ struct inet_timewait_sock *inet_twsk_all tw->tw_prot = sk->sk_prot_creator;atomic64_set (&tw->tw_cookie,atomic64_read (&sk->sk_cookie));twsk_net_set (tw,sock_net (sk)); -setup_timer (&tw->tw_timer, tw_timer_handler, (unsigned long )tw); +setup_pinned_timer (&tw->tw_timer, tw_timer_handler, + (unsigned long )tw);/* * Because we use RCU lookups, we should not set tw_refcnt * to a non null value before everything is setup for this
@@ -248,7 +249,7 @@ void __inet_twsk_schedule(struct inet_ti tw->tw_kill = timeo <=4 *HZ ;if (!rearm) { -BUG_ON (mod_timer_pinned (&tw->tw_timer, jiffies + timeo)); +BUG_ON (mod_timer (&tw->tw_timer, jiffies + timeo));atomic_inc (&tw->tw_dr->tw_count); }else {mod_timer_pending (&tw->tw_timer, jiffies + timeo);
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers, net/ipv4/inet: Initialize connection request timers as pinned
timers, net/ipv4/inet: Initialize connection request timers as pinned
Commit-ID: f3438bc7813c439a06104ba074301c8bdd64ac8b Gitweb: http://git.kernel.org/tip/f3438bc7813c439a06104ba074301c8bdd64ac8b Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:23 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:06 +0200
timers, net/ipv4/inet: Initialize connection request timers as pinned
Pinned timers must carry the pinned attribute in the timer structure itself, so convert the code to the new API.
No functional change.
--- net/ipv4/inet_connection_sock.c | 7 ++++--- net/ipv4/inet_timewait_sock.c | 5 +++-- 2 files changed, 7 insertions(+), 5 deletions(-)
net/ipv4/inet_connection_sock.c +4 -3
@@ -603,7 +603,7 @@ static void reqsk_timer_handler(unsigned long data)if (req->num_timeout++ ==0 )atomic_dec (&queue->young); timeo =min (TCP_TIMEOUT_INIT << req->num_timeout,TCP_RTO_MAX ); -mod_timer_pinned (&req->rsk_timer, jiffies + timeo); +mod_timer (&req->rsk_timer, jiffies + timeo);return ; } drop:
@@ -617,8 +617,9 @@ static void reqsk_queue_hash_req(struct request_sock *req, req->num_timeout =0 ; req->sk =NULL ; -setup_timer (&req->rsk_timer, reqsk_timer_handler, (unsigned long )req); -mod_timer_pinned (&req->rsk_timer, jiffies + timeout); +setup_pinned_timer (&req->rsk_timer, reqsk_timer_handler, + (unsigned long )req); +mod_timer (&req->rsk_timer, jiffies + timeout);inet_ehash_insert (req_to_sk (req),NULL );/* before letting lookups find us, make sure all req fields
net/ipv4/inet_timewait_sock.c +3 -2
@@ -188,7 +188,8 @@ struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk, tw->tw_prot = sk->sk_prot_creator;atomic64_set (&tw->tw_cookie,atomic64_read (&sk->sk_cookie));twsk_net_set (tw,sock_net (sk)); -setup_timer (&tw->tw_timer, tw_timer_handler, (unsigned long )tw); +setup_pinned_timer (&tw->tw_timer, tw_timer_handler, + (unsigned long )tw);/* * Because we use RCU lookups, we should not set tw_refcnt * to a non null value before everything is setup for this
@@ -248,7 +249,7 @@ void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo, bool rearm) tw->tw_kill = timeo <=4 *HZ ;if (!rearm) { -BUG_ON (mod_timer_pinned (&tw->tw_timer, jiffies + timeo)); +BUG_ON (mod_timer (&tw->tw_timer, jiffies + timeo));atomic_inc (&tw->tw_dr->tw_count); }else {mod_timer_pending (&tw->tw_timer, jiffies + timeo);
PATCH 9/22 timer: Remove mod_timer_pinned
In reply to Thomas GleixnerWe switched all users to initialize the timers as pinned and call mod_timer(). Remove the now unused function.
--- include/linux/timer.h | 3 --- kernel/time/timer.c | 39 +++++---------------------------------- 2 files changed, 5 insertions(+), 37 deletions(-)
include/linux/timer.h +0 -3
@@ -190,12 +190,9 @@ extern void add_timer_on(struct timer_liextern int del_timer (struct timer_list * timer);extern int mod_timer (struct timer_list *timer,unsigned long expires);extern int mod_timer_pending (struct timer_list *timer,unsigned long expires); -extern int mod_timer_pinned (struct timer_list *timer,unsigned long expires);extern void set_timer_slack (struct timer_list *time,int slack_hz); -#define MOD_TIMER_NOT_PINNED 0 -#define MOD_TIMER_PINNED 1/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +5 -34
@@ -764,8 +764,7 @@ static struct tvec_base *lock_timer_base }static inline int -__mod_timer (struct timer_list *timer,unsigned long expires, -bool pending_only,int pinned) +__mod_timer (struct timer_list *timer,unsigned long expires,bool pending_only) {struct tvec_base *base, *new_base;unsigned long flags;
@@ -782,7 +781,7 @@ static inline intdebug_activate (timer, expires); - new_base =get_target_base (base, pinned || timer->flags &TIMER_PINNED ); + new_base =get_target_base (base, timer->flags &TIMER_PINNED );if (base != new_base) {/*
@@ -825,7 +824,7 @@ static inline int*/ int mod_timer_pending (struct timer_list *timer,unsigned long expires) { -return __mod_timer (timer, expires, true,MOD_TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, true); }EXPORT_SYMBOL (mod_timer_pending);
@@ -900,39 +899,11 @@ int mod_timer(struct timer_list *timer,if (timer_pending (timer) && timer->expires == expires)return 1 ; -return __mod_timer (timer, expires, false,MOD_TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, false); }EXPORT_SYMBOL (mod_timer);/** -* mod_timer_pinned - modify a timer's timeout -* @timer: the timer to be modified -* @expires: new timeout in jiffies -* -* mod_timer_pinned() is a way to update the expire field of an -* active timer (if the timer is inactive it will be activated) -* and to ensure that the timer is scheduled on the current CPU. -* -* Note that this does not prevent the timer from being migrated -* when the current CPU goes offline. If this is a problem for -* you, use CPU-hotplug notifiers to handle it correctly, for -* example, cancelling the timer when the corresponding CPU goes -* offline. -* -* mod_timer_pinned(timer, expires) is equivalent to: -* -* del_timer(timer); timer->expires = expires; add_timer(timer); -*/ -int mod_timer_pinned (struct timer_list *timer,unsigned long expires) -{ -if (timer->expires == expires &&timer_pending (timer)) -return 1 ; - -return __mod_timer (timer, expires, false,MOD_TIMER_PINNED ); -} -EXPORT_SYMBOL (mod_timer_pinned); - -/** * add_timer - start a timer * @timer: the timer to be added *
@@ -1512,7 +1483,7 @@ signed long __sched schedule_timeout(sig expire = timeout + jiffies;setup_timer_on_stack (&timer, process_timeout, (unsigned long )current); -__mod_timer (&timer, expire, false,MOD_TIMER_NOT_PINNED ); +__mod_timer (&timer, expire, false);schedule ();del_singleshot_timer_sync (&timer);
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Remove the deprecated mod_timer_pinned() API
timers: Remove the deprecated mod_timer_pinned() API
Commit-ID: 177ec0a0a531695210b277d734b2f92ee5796303 Gitweb: http://git.kernel.org/tip/177ec0a0a531695210b277d734b2f92ee5796303 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:24 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:06 +0200
timers: Remove the deprecated mod_timer_pinned() API
We switched all users to initialize the timers as pinned and call mod_timer(). Remove the now unused timer API function.
--- include/linux/timer.h | 3 --- kernel/time/timer.c | 39 +++++---------------------------------- 2 files changed, 5 insertions(+), 37 deletions(-)
include/linux/timer.h +0 -3
@@ -190,12 +190,9 @@ extern void add_timer_on(struct timer_list *timer, int cpu);extern int del_timer (struct timer_list * timer);extern int mod_timer (struct timer_list *timer,unsigned long expires);extern int mod_timer_pending (struct timer_list *timer,unsigned long expires); -extern int mod_timer_pinned (struct timer_list *timer,unsigned long expires);extern void set_timer_slack (struct timer_list *time,int slack_hz); -#define MOD_TIMER_NOT_PINNED 0 -#define MOD_TIMER_PINNED 1/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +5 -34
@@ -764,8 +764,7 @@ static struct tvec_base *lock_timer_base(struct timer_list *timer, }static inline int -__mod_timer (struct timer_list *timer,unsigned long expires, -bool pending_only,int pinned) +__mod_timer (struct timer_list *timer,unsigned long expires,bool pending_only) {struct tvec_base *base, *new_base;unsigned long flags;
@@ -782,7 +781,7 @@ __mod_timer(struct timer_list *timer, unsigned long expires,debug_activate (timer, expires); - new_base =get_target_base (base, pinned || timer->flags &TIMER_PINNED ); + new_base =get_target_base (base, timer->flags &TIMER_PINNED );if (base != new_base) {/*
@@ -825,7 +824,7 @@ out_unlock:*/ int mod_timer_pending (struct timer_list *timer,unsigned long expires) { -return __mod_timer (timer, expires, true,MOD_TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, true); }EXPORT_SYMBOL (mod_timer_pending);
@@ -900,39 +899,11 @@ int mod_timer(struct timer_list *timer, unsigned long expires)if (timer_pending (timer) && timer->expires == expires)return 1 ; -return __mod_timer (timer, expires, false,MOD_TIMER_NOT_PINNED ); +return __mod_timer (timer, expires, false); }EXPORT_SYMBOL (mod_timer);/** -* mod_timer_pinned - modify a timer's timeout -* @timer: the timer to be modified -* @expires: new timeout in jiffies -* -* mod_timer_pinned() is a way to update the expire field of an -* active timer (if the timer is inactive it will be activated) -* and to ensure that the timer is scheduled on the current CPU. -* -* Note that this does not prevent the timer from being migrated -* when the current CPU goes offline. If this is a problem for -* you, use CPU-hotplug notifiers to handle it correctly, for -* example, cancelling the timer when the corresponding CPU goes -* offline. -* -* mod_timer_pinned(timer, expires) is equivalent to: -* -* del_timer(timer); timer->expires = expires; add_timer(timer); -*/ -int mod_timer_pinned (struct timer_list *timer,unsigned long expires) -{ -if (timer->expires == expires &&timer_pending (timer)) -return 1 ; - -return __mod_timer (timer, expires, false,MOD_TIMER_PINNED ); -} -EXPORT_SYMBOL (mod_timer_pinned); - -/** * add_timer - start a timer * @timer: the timer to be added *
@@ -1512,7 +1483,7 @@ signed long __sched schedule_timeout(signed long timeout) expire = timeout + jiffies;setup_timer_on_stack (&timer, process_timeout, (unsigned long )current); -__mod_timer (&timer, expire, false,MOD_TIMER_NOT_PINNED ); +__mod_timer (&timer, expire, false);schedule ();del_singleshot_timer_sync (&timer);
PATCH 10/22 signal: Use hrtimer for sigtimedwait
In reply to Thomas GleixnerWe've converted most timeout related syscalls to hrtimers. sigtimedwait() did not get this treatment. Convert it so we get a reasonable accuracy and remove the user space exposure to the timer wheel properties.
--- kernel/signal.c | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-)
kernel/signal.c +10 -14
@@ -2751,23 +2751,18 @@ int copy_siginfo_to_user(siginfo_t __use* @ts: upper bound on process time suspension */ int do_sigtimedwait (const sigset_t *which,siginfo_t *info, -const struct timespec *ts) +const struct timespec *ts) { +ktime_t *to =NULL , timeout = { .tv64 =KTIME_MAX };struct task_struct *tsk = current; -long timeout =MAX_SCHEDULE_TIMEOUT ;sigset_t mask = *which; -int sig; +int sig, ret =0 ;if (ts) {if (!timespec_valid (ts))return -EINVAL ; - timeout =timespec_to_jiffies (ts); -/* -* We can be close to the next tick, add another one -* to ensure we will wait at least the time asked for. -*/ -if (ts->tv_sec || ts->tv_nsec) - timeout++; + timeout =timespec_to_ktime (*ts); + to = &timeout; }/*
@@ -2778,7 +2773,7 @@ int do_sigtimedwait(const sigset_t *whicspin_lock_irq (&tsk->sighand->siglock); sig =dequeue_signal (tsk, &mask, info); -if (!sig && timeout) { +if (!sig && timeout.tv64) {/* * None ready, temporarily unblock those we're interested * while we are sleeping in so that we'll be awakened when
@@ -2790,8 +2785,9 @@ int do_sigtimedwait(const sigset_t *whicrecalc_sigpending ();spin_unlock_irq (&tsk->sighand->siglock); - timeout =freezable_schedule_timeout_interruptible (timeout); - +__set_current_state (TASK_INTERRUPTIBLE ); + ret =freezable_schedule_hrtimeout_range (to, tsk->timer_slack_ns, +HRTIMER_MODE_REL );spin_lock_irq (&tsk->sighand->siglock);__set_task_blocked (tsk, &tsk->real_blocked);sigemptyset (&tsk->real_blocked);
@@ -2801,7 +2797,7 @@ int do_sigtimedwait(const sigset_t *whicif (sig)return sig; -return timeout ? -EINTR : -EAGAIN ; +return ret ? -EINTR : -EAGAIN ; }/**
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] signals: Use hrtimer for sigtimedwait()
signals: Use hrtimer for sigtimedwait()
Commit-ID: 2b1ecc3d1a6b10f8fbac7f83d80db30b5a2c2791 Gitweb: http://git.kernel.org/tip/2b1ecc3d1a6b10f8fbac7f83d80db30b5a2c2791 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:25 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:07 +0200
signals: Use hrtimer for sigtimedwait()
We've converted most timeout related syscalls to hrtimers, but sigtimedwait() did not get this treatment.
Convert it so we get a reasonable accuracy and remove the user space exposure to the timer wheel properties.
--- kernel/signal.c | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-)
kernel/signal.c +10 -14
@@ -2751,23 +2751,18 @@ int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)* @ts: upper bound on process time suspension */ int do_sigtimedwait (const sigset_t *which,siginfo_t *info, -const struct timespec *ts) +const struct timespec *ts) { +ktime_t *to =NULL , timeout = { .tv64 =KTIME_MAX };struct task_struct *tsk = current; -long timeout =MAX_SCHEDULE_TIMEOUT ;sigset_t mask = *which; -int sig; +int sig, ret =0 ;if (ts) {if (!timespec_valid (ts))return -EINVAL ; - timeout =timespec_to_jiffies (ts); -/* -* We can be close to the next tick, add another one -* to ensure we will wait at least the time asked for. -*/ -if (ts->tv_sec || ts->tv_nsec) - timeout++; + timeout =timespec_to_ktime (*ts); + to = &timeout; }/*
@@ -2778,7 +2773,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,spin_lock_irq (&tsk->sighand->siglock); sig =dequeue_signal (tsk, &mask, info); -if (!sig && timeout) { +if (!sig && timeout.tv64) {/* * None ready, temporarily unblock those we're interested * while we are sleeping in so that we'll be awakened when
@@ -2790,8 +2785,9 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,recalc_sigpending ();spin_unlock_irq (&tsk->sighand->siglock); - timeout =freezable_schedule_timeout_interruptible (timeout); - +__set_current_state (TASK_INTERRUPTIBLE ); + ret =freezable_schedule_hrtimeout_range (to, tsk->timer_slack_ns, +HRTIMER_MODE_REL );spin_lock_irq (&tsk->sighand->siglock);__set_task_blocked (tsk, &tsk->real_blocked);sigemptyset (&tsk->real_blocked);
@@ -2801,7 +2797,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,if (sig)return sig; -return timeout ? -EINTR : -EAGAIN ; +return ret ? -EINTR : -EAGAIN ; }/**
PATCH 11/22 hlist: Add hlist_is_singular_node() helper
In reply to Thomas GleixnerRequired to figure out whether the entry is the only one in the hlist.
--- include/linux/list.h | 10 ++++++++++ 1 file changed, 10 insertions(+)
include/linux/list.h +10 -0
@@ -679,6 +679,16 @@ static inline bool hlist_fake(struct hli }/* +* Check whether the node is the only node of the head without +* accessing head. +*/ +static inline bool hlist_is_singular_node (struct hlist_node *n, +struct hlist_head *h) +{ +return !n->next && n->pprev == &h->first; +} + +/* * Move a list from one list head to another. Fixup the pprev * reference of the first entry if it exists. */
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] hlist: Add hlist_is_singular_node() helper
hlist: Add hlist_is_singular_node() helper
Commit-ID: 15dba1e37b5cfd7fab9bc84e0f05f35c918f4eef Gitweb: http://git.kernel.org/tip/15dba1e37b5cfd7fab9bc84e0f05f35c918f4eef Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:27 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:07 +0200
hlist: Add hlist_is_singular_node() helper
Required to figure out whether the entry is the only one in the hlist.
--- include/linux/list.h | 10 ++++++++++ 1 file changed, 10 insertions(+)
include/linux/list.h +10 -0
@@ -679,6 +679,16 @@ static inline bool hlist_fake(struct hlist_node *h) }/* +* Check whether the node is the only node of the head without +* accessing head: +*/ +static inline bool +hlist_is_singular_node (struct hlist_node *n,struct hlist_head *h) +{ +return !n->next && n->pprev == &h->first; +} + +/* * Move a list from one list head to another. Fixup the pprev * reference of the first entry if it exists. */
PATCH 12/22 timer: Give a few structs and members proper names
In reply to Thomas GleixnerSome of the names are not longer correct and others are simply too long to type. Clean it up before we switch the wheel implementation over to the new scheme.
No functional change.
--- kernel/time/timer.c | 118 ++++++++++++++++++++++++++-------------------------- 1 file changed, 59 insertions(+), 59 deletions(-)
kernel/time/timer.c +59 -59
@@ -77,10 +77,10 @@ struct tvec_root {struct hlist_head vec[TVR_SIZE ]; }; -struct tvec_base { +struct timer_base {spinlock_t lock;struct timer_list *running_timer; -unsigned long timer_jiffies; +unsigned long clk;unsigned long next_timer;unsigned long active_timers;unsigned long all_timers;
@@ -95,7 +95,7 @@ struct tvec_base { }____cacheline_aligned ; -static DEFINE_PER_CPU(struct tvec_base, tvec_bases); +static DEFINE_PER_CPU(struct timer_base, timer_bases);#if defined(CONFIG_SMP ) && defined(CONFIG_NO_HZ_COMMON )unsigned int sysctl_timer_migration =1 ;
@@ -106,15 +106,15 @@ void timers_update_migration(bool updateunsigned int cpu;/* Avoid the loop, if nothing to update */ -if (this_cpu_read (tvec_bases.migration_enabled) == on) +if (this_cpu_read (timer_bases.migration_enabled) == on)return ;for_each_possible_cpu (cpu) { -per_cpu (tvec_bases.migration_enabled, cpu) = on; +per_cpu (timer_bases.migration_enabled, cpu) = on;per_cpu (hrtimer_bases.migration_enabled, cpu) = on;if (!update_nohz)continue ; -per_cpu (tvec_bases.nohz_active, cpu) = true; +per_cpu (timer_bases.nohz_active, cpu) = true;per_cpu (hrtimer_bases.nohz_active, cpu) = true; } }
@@ -134,18 +134,18 @@ int timer_migration_handler(struct ctl_t return ret; } -static inline struct tvec_base *get_target_base (struct tvec_base *base, +static inline struct timer_base *get_target_base (struct timer_base *base,int pinned) {if (pinned || !base->migration_enabled) -return this_cpu_ptr (&tvec_bases); -return per_cpu_ptr (&tvec_bases,get_nohz_timer_target ()); +return this_cpu_ptr (&timer_bases); +return per_cpu_ptr (&timer_bases,get_nohz_timer_target ()); }#else -static inline struct tvec_base *get_target_base (struct tvec_base *base, +static inline struct timer_base *get_target_base (struct timer_base *base,int pinned) { -return this_cpu_ptr (&tvec_bases); +return this_cpu_ptr (&timer_bases); }#endif
@@ -371,10 +371,10 @@ void set_timer_slack(struct timer_list *EXPORT_SYMBOL_GPL (set_timer_slack);static void -__internal_add_timer (struct tvec_base *base,struct timer_list *timer) +__internal_add_timer (struct timer_base *base,struct timer_list *timer) {unsigned long expires = timer->expires; -unsigned long idx = expires - base->timer_jiffies; +unsigned long idx = expires - base->clk;struct hlist_head *vec;if (idx <TVR_SIZE ) {
@@ -394,7 +394,7 @@ static void* Can happen if you add a timer with expires == jiffies, * or you set a timer to go off in the past */ - vec = base->tv1.vec + (base->timer_jiffies &TVR_MASK ); + vec = base->tv1.vec + (base->clk &TVR_MASK ); }else {int i;/* If the timeout is larger than MAX_TVAL (on 64-bit
@@ -403,7 +403,7 @@ static void*/ if (idx >MAX_TVAL ) { idx =MAX_TVAL ; - expires = idx + base->timer_jiffies; + expires = idx + base->clk; } i = (expires >> (TVR_BITS +3 *TVN_BITS )) &TVN_MASK ; vec = base->tv5.vec + i;
@@ -412,11 +412,11 @@ static voidhlist_add_head (&timer->entry, vec); } -static void internal_add_timer (struct tvec_base *base,struct timer_list *timer) +static void internal_add_timer (struct timer_base *base,struct timer_list *timer) {/* Advance base->jiffies, if the base is empty */ if (!base->all_timers++) - base->timer_jiffies = jiffies; + base->clk = jiffies;__internal_add_timer (base, timer);/*
@@ -707,7 +707,7 @@ static inline void detach_timer(struct t }static inline void -detach_expired_timer (struct timer_list *timer,struct tvec_base *base) +detach_expired_timer (struct timer_list *timer,struct timer_base *base) {detach_timer (timer, true);if (!(timer->flags &TIMER_DEFERRABLE ))
@@ -715,7 +715,7 @@ detach_expired_timer(struct timer_list * base->all_timers--; } -static int detach_if_pending (struct timer_list *timer,struct tvec_base *base, +static int detach_if_pending (struct timer_list *timer,struct timer_base *base,bool clear_pending) {if (!timer_pending (timer))
@@ -725,16 +725,16 @@ static int detach_if_pending(struct timeif (!(timer->flags &TIMER_DEFERRABLE )) { base->active_timers--;if (timer->expires == base->next_timer) - base->next_timer = base->timer_jiffies; + base->next_timer = base->clk; }/* If this was the last timer, advance base->jiffies */ if (!--base->all_timers) - base->timer_jiffies = jiffies; + base->clk = jiffies;return 1 ; }/* -* We are using hashed locking: holding per_cpu(tvec_bases).lock +* We are using hashed locking: holding per_cpu(timer_bases).lock * means that all timers which are tied to this base via timer->base are * locked, and the base itself is locked too. *
@@ -744,16 +744,16 @@ static int detach_if_pending(struct time* When the timer's base is locked and removed from the list, the * TIMER_MIGRATING flag is set, FIXME */ -static struct tvec_base *lock_timer_base (struct timer_list *timer, +static struct timer_base *lock_timer_base (struct timer_list *timer,unsigned long *flags) __acquires(timer->base->lock) {for (;;) {u32 tf = timer->flags; -struct tvec_base *base; +struct timer_base *base;if (!(tf &TIMER_MIGRATING )) { - base =per_cpu_ptr (&tvec_bases, tf &TIMER_CPUMASK ); + base =per_cpu_ptr (&timer_bases, tf &TIMER_CPUMASK );spin_lock_irqsave (&base->lock, *flags);if (timer->flags == tf)return base;
@@ -766,7 +766,7 @@ static struct tvec_base *lock_timer_basestatic inline int __mod_timer (struct timer_list *timer,unsigned long expires,bool pending_only) { -struct tvec_base *base, *new_base; +struct timer_base *base, *new_base;unsigned long flags;int ret =0 ;
@@ -933,8 +933,8 @@ EXPORT_SYMBOL(add_timer);*/ void add_timer_on (struct timer_list *timer,int cpu) { -struct tvec_base *new_base =per_cpu_ptr (&tvec_bases, cpu); -struct tvec_base *base; +struct timer_base *new_base =per_cpu_ptr (&timer_bases, cpu); +struct timer_base *base;unsigned long flags;timer_stats_timer_set_start_info (timer);
@@ -975,7 +975,7 @@ EXPORT_SYMBOL_GPL(add_timer_on);*/ int del_timer (struct timer_list *timer) { -struct tvec_base *base; +struct timer_base *base;unsigned long flags;int ret =0 ;
@@ -1001,7 +1001,7 @@ EXPORT_SYMBOL(del_timer);*/ int try_to_del_timer_sync (struct timer_list *timer) { -struct tvec_base *base; +struct timer_base *base;unsigned long flags;int ret =-1 ;
@@ -1085,7 +1085,7 @@ int del_timer_sync(struct timer_list *tiEXPORT_SYMBOL (del_timer_sync);#endif -static int cascade (struct tvec_base *base,struct tvec *tv,int index) +static int cascade (struct timer_base *base,struct tvec *tv,int index) {/* cascade all the timers from tv up one level */ struct timer_list *timer;
@@ -1149,7 +1149,7 @@ static void call_timer_fn(struct timer_l } } -#define INDEX (N ) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK) +#define INDEX (N ) ((base->clk >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)/** * __run_timers - run all expired timers (if any) on this CPU.
@@ -1158,23 +1158,23 @@ static void call_timer_fn(struct timer_l* This function cascades all vectors and executes all expired timer * vectors. */ -static inline void __run_timers (struct tvec_base *base) +static inline void __run_timers (struct timer_base *base) {struct timer_list *timer;spin_lock_irq (&base->lock); -while (time_after_eq (jiffies, base->timer_jiffies)) { +while (time_after_eq (jiffies, base->clk)) {struct hlist_head work_list;struct hlist_head *head = &work_list;int index;if (!base->all_timers) { - base->timer_jiffies = jiffies; + base->clk = jiffies;break ; } - index = base->timer_jiffies &TVR_MASK ; + index = base->clk &TVR_MASK ;/* * Cascade timers:
@@ -1184,7 +1184,7 @@ static inline void __run_timers(struct t (!cascade(base, &base->tv3, INDEX(1))) && !cascade(base, &base->tv4, INDEX(2)))cascade (base, &base->tv5,INDEX (3 )); - ++base->timer_jiffies; + ++base->clk;hlist_move_list (base->tv1.vec + index, head);while (!hlist_empty (head)) {void (*fn)(unsigned long );
@@ -1222,16 +1222,16 @@ static inline void __run_timers(struct t* is used on S/390 to stop all activity when a CPU is idle. * This function needs to be called with interrupts disabled. */ -static unsigned long __next_timer_interrupt (struct tvec_base *base) +static unsigned long __next_timer_interrupt (struct timer_base *base) { -unsigned long timer_jiffies = base->timer_jiffies; -unsigned long expires = timer_jiffies +NEXT_TIMER_MAX_DELTA ; +unsigned long clk = base->clk; +unsigned long expires = clk +NEXT_TIMER_MAX_DELTA ;int index, slot, array, found =0 ;struct timer_list *nte;struct tvec *varray[4 ];/* Look for timer events in tv1. */ - index = slot = timer_jiffies &TVR_MASK ; + index = slot = clk &TVR_MASK ; do { hlist_for_each_entry(nte, base->tv1.vec + slot, entry) { if (nte->flags & TIMER_DEFERRABLE)
@@ -1250,8 +1250,8 @@ static unsigned long __next_timer_interr cascade:/* Calculate the next cascade event */ if (index) - timer_jiffies +=TVR_SIZE - index; - timer_jiffies >>=TVR_BITS ; + clk +=TVR_SIZE - index; + clk >>=TVR_BITS ;/* Check tv2-tv5. */ varray[0 ] = &base->tv2;
@@ -1262,7 +1262,7 @@ static unsigned long __next_timer_interrfor (array =0 ; array <4 ; array++) {struct tvec *varp = varray[array]; - index = slot = timer_jiffies &TVN_MASK ; + index = slot = clk &TVN_MASK ; do { hlist_for_each_entry(nte, varp->vec + slot, entry) { if (nte->flags & TIMER_DEFERRABLE)
@@ -1286,8 +1286,8 @@ static unsigned long __next_timer_interr }while (slot != index);if (index) - timer_jiffies +=TVN_SIZE - index; - timer_jiffies >>=TVN_BITS ; + clk +=TVN_SIZE - index; + clk >>=TVN_BITS ; }return expires; }
@@ -1335,7 +1335,7 @@ static u64 cmp_next_hrtimer_event(u64 ba*/ u64 get_next_timer_interrupt (unsigned long basej,u64 basem) { -struct tvec_base *base =this_cpu_ptr (&tvec_bases); +struct timer_base *base =this_cpu_ptr (&timer_bases);u64 expires =KTIME_MAX ;unsigned long nextevt;
@@ -1348,7 +1348,7 @@ u64 get_next_timer_interrupt(unsigned lospin_lock (&base->lock);if (base->active_timers) { -if (time_before_eq (base->next_timer, base->timer_jiffies)) +if (time_before_eq (base->next_timer, base->clk)) base->next_timer =__next_timer_interrupt (base); nextevt = base->next_timer;if (time_before_eq (nextevt, basej))
@@ -1387,9 +1387,9 @@ void update_process_times(int user_tick)*/ static void run_timer_softirq (struct softirq_action *h) { -struct tvec_base *base =this_cpu_ptr (&tvec_bases); +struct timer_base *base =this_cpu_ptr (&timer_bases); -if (time_after_eq (jiffies, base->timer_jiffies)) +if (time_after_eq (jiffies, base->clk))__run_timers (base); }
@@ -1534,7 +1534,7 @@ signed long __sched schedule_timeout_idlEXPORT_SYMBOL (schedule_timeout_idle);#ifdef CONFIG_HOTPLUG_CPU -static void migrate_timer_list (struct tvec_base *new_base,struct hlist_head *head) +static void migrate_timer_list (struct timer_base *new_base,struct hlist_head *head) {struct timer_list *timer;int cpu = new_base->cpu;
@@ -1550,13 +1550,13 @@ static void migrate_timer_list(struct tvstatic void migrate_timers (int cpu) { -struct tvec_base *old_base; -struct tvec_base *new_base; +struct timer_base *old_base; +struct timer_base *new_base;int i;BUG_ON (cpu_online (cpu)); - old_base =per_cpu_ptr (&tvec_bases, cpu); - new_base =get_cpu_ptr (&tvec_bases); + old_base =per_cpu_ptr (&timer_bases, cpu); + new_base =get_cpu_ptr (&timer_bases);/* * The caller is globally serialized and nobody else * takes two locks at once, deadlock is not possible.
@@ -1580,7 +1580,7 @@ static void migrate_timers(int cpu)spin_unlock (&old_base->lock);spin_unlock_irq (&new_base->lock); -put_cpu_ptr (&tvec_bases); +put_cpu_ptr (&timer_bases); } static int timer_cpu_notify(struct notifier_block *self,
@@ -1608,13 +1608,13 @@ static inline void timer_register_cpu_nostatic void __init init_timer_cpu (int cpu) { -struct tvec_base *base =per_cpu_ptr (&tvec_bases, cpu); +struct timer_base *base =per_cpu_ptr (&timer_bases, cpu); base->cpu = cpu;spin_lock_init (&base->lock); - base->timer_jiffies = jiffies; - base->next_timer = base->timer_jiffies; + base->clk = jiffies; + base->next_timer = base->clk; }static void __init init_timer_cpus (void )
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Give a few structs and members proper names
timers: Give a few structs and members proper names
Commit-ID: 494af3ed7848de08640d98ee5aff57a45c137c3c Gitweb: http://git.kernel.org/tip/494af3ed7848de08640d98ee5aff57a45c137c3c Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:28 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:08 +0200
timers: Give a few structs and members proper names
Some of the names in the internal implementation of the timer code are not longer correct and others are simply too long to type.
Clean it up before we switch the wheel implementation over to the new scheme.
No functional change.
--- kernel/time/timer.c | 118 ++++++++++++++++++++++++++-------------------------- 1 file changed, 59 insertions(+), 59 deletions(-)
kernel/time/timer.c +59 -59
@@ -77,10 +77,10 @@ struct tvec_root {struct hlist_head vec[TVR_SIZE ]; }; -struct tvec_base { +struct timer_base {spinlock_t lock;struct timer_list *running_timer; -unsigned long timer_jiffies; +unsigned long clk;unsigned long next_timer;unsigned long active_timers;unsigned long all_timers;
@@ -95,7 +95,7 @@ struct tvec_base { }____cacheline_aligned ; -static DEFINE_PER_CPU(struct tvec_base, tvec_bases); +static DEFINE_PER_CPU(struct timer_base, timer_bases);#if defined(CONFIG_SMP ) && defined(CONFIG_NO_HZ_COMMON )unsigned int sysctl_timer_migration =1 ;
@@ -106,15 +106,15 @@ void timers_update_migration(bool update_nohz)unsigned int cpu;/* Avoid the loop, if nothing to update */ -if (this_cpu_read (tvec_bases.migration_enabled) == on) +if (this_cpu_read (timer_bases.migration_enabled) == on)return ;for_each_possible_cpu (cpu) { -per_cpu (tvec_bases.migration_enabled, cpu) = on; +per_cpu (timer_bases.migration_enabled, cpu) = on;per_cpu (hrtimer_bases.migration_enabled, cpu) = on;if (!update_nohz)continue ; -per_cpu (tvec_bases.nohz_active, cpu) = true; +per_cpu (timer_bases.nohz_active, cpu) = true;per_cpu (hrtimer_bases.nohz_active, cpu) = true; } }
@@ -134,18 +134,18 @@ int timer_migration_handler(struct ctl_table *table, int write, return ret; } -static inline struct tvec_base *get_target_base (struct tvec_base *base, +static inline struct timer_base *get_target_base (struct timer_base *base,int pinned) {if (pinned || !base->migration_enabled) -return this_cpu_ptr (&tvec_bases); -return per_cpu_ptr (&tvec_bases,get_nohz_timer_target ()); +return this_cpu_ptr (&timer_bases); +return per_cpu_ptr (&timer_bases,get_nohz_timer_target ()); }#else -static inline struct tvec_base *get_target_base (struct tvec_base *base, +static inline struct timer_base *get_target_base (struct timer_base *base,int pinned) { -return this_cpu_ptr (&tvec_bases); +return this_cpu_ptr (&timer_bases); }#endif
@@ -371,10 +371,10 @@ void set_timer_slack(struct timer_list *timer, int slack_hz)EXPORT_SYMBOL_GPL (set_timer_slack);static void -__internal_add_timer (struct tvec_base *base,struct timer_list *timer) +__internal_add_timer (struct timer_base *base,struct timer_list *timer) {unsigned long expires = timer->expires; -unsigned long idx = expires - base->timer_jiffies; +unsigned long idx = expires - base->clk;struct hlist_head *vec;if (idx <TVR_SIZE ) {
@@ -394,7 +394,7 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)* Can happen if you add a timer with expires == jiffies, * or you set a timer to go off in the past */ - vec = base->tv1.vec + (base->timer_jiffies &TVR_MASK ); + vec = base->tv1.vec + (base->clk &TVR_MASK ); }else {int i;/* If the timeout is larger than MAX_TVAL (on 64-bit
@@ -403,7 +403,7 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)*/ if (idx >MAX_TVAL ) { idx =MAX_TVAL ; - expires = idx + base->timer_jiffies; + expires = idx + base->clk; } i = (expires >> (TVR_BITS +3 *TVN_BITS )) &TVN_MASK ; vec = base->tv5.vec + i;
@@ -412,11 +412,11 @@ __internal_add_timer(struct tvec_base *base, struct timer_list *timer)hlist_add_head (&timer->entry, vec); } -static void internal_add_timer (struct tvec_base *base,struct timer_list *timer) +static void internal_add_timer (struct timer_base *base,struct timer_list *timer) {/* Advance base->jiffies, if the base is empty */ if (!base->all_timers++) - base->timer_jiffies = jiffies; + base->clk = jiffies;__internal_add_timer (base, timer);/*
@@ -707,7 +707,7 @@ static inline void detach_timer(struct timer_list *timer, bool clear_pending) }static inline void -detach_expired_timer (struct timer_list *timer,struct tvec_base *base) +detach_expired_timer (struct timer_list *timer,struct timer_base *base) {detach_timer (timer, true);if (!(timer->flags &TIMER_DEFERRABLE ))
@@ -715,7 +715,7 @@ detach_expired_timer(struct timer_list *timer, struct tvec_base *base) base->all_timers--; } -static int detach_if_pending (struct timer_list *timer,struct tvec_base *base, +static int detach_if_pending (struct timer_list *timer,struct timer_base *base,bool clear_pending) {if (!timer_pending (timer))
@@ -725,16 +725,16 @@ static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,if (!(timer->flags &TIMER_DEFERRABLE )) { base->active_timers--;if (timer->expires == base->next_timer) - base->next_timer = base->timer_jiffies; + base->next_timer = base->clk; }/* If this was the last timer, advance base->jiffies */ if (!--base->all_timers) - base->timer_jiffies = jiffies; + base->clk = jiffies;return 1 ; }/* -* We are using hashed locking: holding per_cpu(tvec_bases).lock +* We are using hashed locking: holding per_cpu(timer_bases).lock * means that all timers which are tied to this base via timer->base are * locked, and the base itself is locked too. *
@@ -744,16 +744,16 @@ static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,* When the timer's base is locked and removed from the list, the * TIMER_MIGRATING flag is set, FIXME */ -static struct tvec_base *lock_timer_base (struct timer_list *timer, +static struct timer_base *lock_timer_base (struct timer_list *timer,unsigned long *flags) __acquires(timer->base->lock) {for (;;) {u32 tf = timer->flags; -struct tvec_base *base; +struct timer_base *base;if (!(tf &TIMER_MIGRATING )) { - base =per_cpu_ptr (&tvec_bases, tf &TIMER_CPUMASK ); + base =per_cpu_ptr (&timer_bases, tf &TIMER_CPUMASK );spin_lock_irqsave (&base->lock, *flags);if (timer->flags == tf)return base;
@@ -766,7 +766,7 @@ static struct tvec_base *lock_timer_base(struct timer_list *timer,static inline int __mod_timer (struct timer_list *timer,unsigned long expires,bool pending_only) { -struct tvec_base *base, *new_base; +struct timer_base *base, *new_base;unsigned long flags;int ret =0 ;
@@ -933,8 +933,8 @@ EXPORT_SYMBOL(add_timer);*/ void add_timer_on (struct timer_list *timer,int cpu) { -struct tvec_base *new_base =per_cpu_ptr (&tvec_bases, cpu); -struct tvec_base *base; +struct timer_base *new_base =per_cpu_ptr (&timer_bases, cpu); +struct timer_base *base;unsigned long flags;timer_stats_timer_set_start_info (timer);
@@ -975,7 +975,7 @@ EXPORT_SYMBOL_GPL(add_timer_on);*/ int del_timer (struct timer_list *timer) { -struct tvec_base *base; +struct timer_base *base;unsigned long flags;int ret =0 ;
@@ -1001,7 +1001,7 @@ EXPORT_SYMBOL(del_timer);*/ int try_to_del_timer_sync (struct timer_list *timer) { -struct tvec_base *base; +struct timer_base *base;unsigned long flags;int ret =-1 ;
@@ -1085,7 +1085,7 @@ int del_timer_sync(struct timer_list *timer)EXPORT_SYMBOL (del_timer_sync);#endif -static int cascade (struct tvec_base *base,struct tvec *tv,int index) +static int cascade (struct timer_base *base,struct tvec *tv,int index) {/* cascade all the timers from tv up one level */ struct timer_list *timer;
@@ -1149,7 +1149,7 @@ static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long), } } -#define INDEX (N ) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK) +#define INDEX (N ) ((base->clk >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)/** * __run_timers - run all expired timers (if any) on this CPU.
@@ -1158,23 +1158,23 @@ static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),* This function cascades all vectors and executes all expired timer * vectors. */ -static inline void __run_timers (struct tvec_base *base) +static inline void __run_timers (struct timer_base *base) {struct timer_list *timer;spin_lock_irq (&base->lock); -while (time_after_eq (jiffies, base->timer_jiffies)) { +while (time_after_eq (jiffies, base->clk)) {struct hlist_head work_list;struct hlist_head *head = &work_list;int index;if (!base->all_timers) { - base->timer_jiffies = jiffies; + base->clk = jiffies;break ; } - index = base->timer_jiffies &TVR_MASK ; + index = base->clk &TVR_MASK ;/* * Cascade timers:
@@ -1184,7 +1184,7 @@ static inline void __run_timers(struct tvec_base *base) (!cascade(base, &base->tv3, INDEX(1))) && !cascade(base, &base->tv4, INDEX(2)))cascade (base, &base->tv5,INDEX (3 )); - ++base->timer_jiffies; + ++base->clk;hlist_move_list (base->tv1.vec + index, head);while (!hlist_empty (head)) {void (*fn)(unsigned long );
@@ -1222,16 +1222,16 @@ static inline void __run_timers(struct tvec_base *base)* is used on S/390 to stop all activity when a CPU is idle. * This function needs to be called with interrupts disabled. */ -static unsigned long __next_timer_interrupt (struct tvec_base *base) +static unsigned long __next_timer_interrupt (struct timer_base *base) { -unsigned long timer_jiffies = base->timer_jiffies; -unsigned long expires = timer_jiffies +NEXT_TIMER_MAX_DELTA ; +unsigned long clk = base->clk; +unsigned long expires = clk +NEXT_TIMER_MAX_DELTA ;int index, slot, array, found =0 ;struct timer_list *nte;struct tvec *varray[4 ];/* Look for timer events in tv1. */ - index = slot = timer_jiffies &TVR_MASK ; + index = slot = clk &TVR_MASK ; do { hlist_for_each_entry(nte, base->tv1.vec + slot, entry) { if (nte->flags & TIMER_DEFERRABLE)
@@ -1250,8 +1250,8 @@ static unsigned long __next_timer_interrupt(struct tvec_base *base) cascade:/* Calculate the next cascade event */ if (index) - timer_jiffies +=TVR_SIZE - index; - timer_jiffies >>=TVR_BITS ; + clk +=TVR_SIZE - index; + clk >>=TVR_BITS ;/* Check tv2-tv5. */ varray[0 ] = &base->tv2;
@@ -1262,7 +1262,7 @@ cascade:for (array =0 ; array <4 ; array++) {struct tvec *varp = varray[array]; - index = slot = timer_jiffies &TVN_MASK ; + index = slot = clk &TVN_MASK ; do { hlist_for_each_entry(nte, varp->vec + slot, entry) { if (nte->flags & TIMER_DEFERRABLE)
@@ -1286,8 +1286,8 @@ cascade: }while (slot != index);if (index) - timer_jiffies +=TVN_SIZE - index; - timer_jiffies >>=TVN_BITS ; + clk +=TVN_SIZE - index; + clk >>=TVN_BITS ; }return expires; }
@@ -1335,7 +1335,7 @@ static u64 cmp_next_hrtimer_event(u64 basem, u64 expires)*/ u64 get_next_timer_interrupt (unsigned long basej,u64 basem) { -struct tvec_base *base =this_cpu_ptr (&tvec_bases); +struct timer_base *base =this_cpu_ptr (&timer_bases);u64 expires =KTIME_MAX ;unsigned long nextevt;
@@ -1348,7 +1348,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)spin_lock (&base->lock);if (base->active_timers) { -if (time_before_eq (base->next_timer, base->timer_jiffies)) +if (time_before_eq (base->next_timer, base->clk)) base->next_timer =__next_timer_interrupt (base); nextevt = base->next_timer;if (time_before_eq (nextevt, basej))
@@ -1387,9 +1387,9 @@ void update_process_times(int user_tick)*/ static void run_timer_softirq (struct softirq_action *h) { -struct tvec_base *base =this_cpu_ptr (&tvec_bases); +struct timer_base *base =this_cpu_ptr (&timer_bases); -if (time_after_eq (jiffies, base->timer_jiffies)) +if (time_after_eq (jiffies, base->clk))__run_timers (base); }
@@ -1534,7 +1534,7 @@ signed long __sched schedule_timeout_idle(signed long timeout)EXPORT_SYMBOL (schedule_timeout_idle);#ifdef CONFIG_HOTPLUG_CPU -static void migrate_timer_list (struct tvec_base *new_base,struct hlist_head *head) +static void migrate_timer_list (struct timer_base *new_base,struct hlist_head *head) {struct timer_list *timer;int cpu = new_base->cpu;
@@ -1550,13 +1550,13 @@ static void migrate_timer_list(struct tvec_base *new_base, struct hlist_head *hestatic void migrate_timers (int cpu) { -struct tvec_base *old_base; -struct tvec_base *new_base; +struct timer_base *old_base; +struct timer_base *new_base;int i;BUG_ON (cpu_online (cpu)); - old_base =per_cpu_ptr (&tvec_bases, cpu); - new_base =get_cpu_ptr (&tvec_bases); + old_base =per_cpu_ptr (&timer_bases, cpu); + new_base =get_cpu_ptr (&timer_bases);/* * The caller is globally serialized and nobody else * takes two locks at once, deadlock is not possible.
@@ -1580,7 +1580,7 @@ static void migrate_timers(int cpu)spin_unlock (&old_base->lock);spin_unlock_irq (&new_base->lock); -put_cpu_ptr (&tvec_bases); +put_cpu_ptr (&timer_bases); } static int timer_cpu_notify(struct notifier_block *self,
@@ -1608,13 +1608,13 @@ static inline void timer_register_cpu_notifier(void) { }static void __init init_timer_cpu (int cpu) { -struct tvec_base *base =per_cpu_ptr (&tvec_bases, cpu); +struct timer_base *base =per_cpu_ptr (&timer_bases, cpu); base->cpu = cpu;spin_lock_init (&base->lock); - base->timer_jiffies = jiffies; - base->next_timer = base->timer_jiffies; + base->clk = jiffies; + base->next_timer = base->clk; }static void __init init_timer_cpus (void )
PATCH 13/22 timer: Reduce the CPU index space to 256k
In reply to Thomas GleixnerWe want to store the array index in the flags space. 256k CPUs should be enough for a while.
--- include/linux/timer.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
include/linux/timer.h +5 -5
@@ -58,12 +58,12 @@ struct timer_list {* workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! */ -#define TIMER_CPUMASK 0x0007FFFF -#define TIMER_MIGRATING 0x00080000 +#define TIMER_CPUMASK 0x0003FFFF +#define TIMER_MIGRATING 0x00040000#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING) -#define TIMER_DEFERRABLE 0x00100000 -#define TIMER_PINNED 0x00200000 -#define TIMER_IRQSAFE 0x00400000 +#define TIMER_DEFERRABLE 0x00080000 +#define TIMER_PINNED 0x00100000 +#define TIMER_IRQSAFE 0x00200000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Reduce the CPU index space to 256k
timers: Reduce the CPU index space to 256k
Commit-ID: b0d6e2dcb284f1f4dcb4b92760f49eeaf5fc0bc7 Gitweb: http://git.kernel.org/tip/b0d6e2dcb284f1f4dcb4b92760f49eeaf5fc0bc7 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:29 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:08 +0200
timers: Reduce the CPU index space to 256k
We want to store the array index in the flags space. 256k CPUs should be enough for a while.
--- include/linux/timer.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
include/linux/timer.h +5 -5
@@ -58,12 +58,12 @@ struct timer_list {* workqueue locking issues. It's not meant for executing random crap * with interrupts disabled. Abuse is monitored! */ -#define TIMER_CPUMASK 0x0007FFFF -#define TIMER_MIGRATING 0x00080000 +#define TIMER_CPUMASK 0x0003FFFF +#define TIMER_MIGRATING 0x00040000#define TIMER_BASEMASK (TIMER_CPUMASK | TIMER_MIGRATING) -#define TIMER_DEFERRABLE 0x00100000 -#define TIMER_PINNED 0x00200000 -#define TIMER_IRQSAFE 0x00400000 +#define TIMER_DEFERRABLE 0x00080000 +#define TIMER_PINNED 0x00100000 +#define TIMER_IRQSAFE 0x00200000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
PATCH 14/22 timer: Switch to a non cascading wheel
In reply to Thomas GleixnerThe current timer wheel has some drawbacks:
1) Cascading
Cascading can be an unbound operation and is completely pointless in most cases because the vast majority of the timer wheel timers are canceled or rearmed before expiration.
2) No fast lookup of the next expiring timer
In NOHZ scenarios the first timer soft interrupt after a long NOHZ period must fast forward the base time to current jiffies. As we have no way to find the next expiring timer fast, the code loops and increments the base time by one and checks for expired timers in each step.
After a thorough analysis of real world data gathered on laptops, workstations, webservers and other machines (thanks Chris!) I came to the conclusion that the current 'classic' timer wheel implementation can be modified to address the above issues.
The vast majority of timer wheel timers is canceled or rearmed before expiry. Most of them are timeouts for networking and other I/O tasks. The nature of timeouts is to catch the exception from normal operation (TCP ack timed out, disk does not respond, etc.). For these kind of timeouts the accuracy is not really a concern. In case the timeout fires, performance is down the drain already.
The few timers which actually expire can be split into two categories:
1) Short expiry times which expect halfways accurate expiry
2) Long term expiry times are inaccurate today already due to the batching which is done for NOHZ.
So for long term expiry timers we can avoid the cascading property and just leave them in the less granular outer wheels until expiry or cancelation. Timers which are armed with a timeout larger than the wheel capacity are not longer cascaded. We expire them with the longest possible timeout (6+ days). We have not observed such timeouts in our data collection, but at least we handle them with the least surprising effect.
To avoid extending the wheel levels for HZ=1000 so we can accomodate the longest observed timeouts (5 days in the network conntrack code) we reduce the first level granularity on HZ=1000 to 4ms, which effectively is the same as the HZ=250 behaviour. From our data analysis there is nothing which relies on that 1ms granularity and as a side effect we get better batching and timer locality for the networking code as well.
Contrary to the classic wheel the granularity of the next wheel is not the capacity of the first wheel. The granularities of the wheels are in the currently chosen setting 8 times the granularity of the previous wheel. So for HZ=250 we end up with the following granularity levels:
Level Offset Granularity Range
0 0 4 ms 0 ms - 252 ms
1 64 32 ms 256 ms - 2044 ms (256ms - ~2s)
2 128 256 ms 2048 ms - 16380 ms (~2s - ~16s)
3 192 2048 ms (~2s) 16384 ms - 131068 ms (~16s - ~2m)
4 256 16384 ms (~16s) 131072 ms - 1048572 ms (~2m - ~17m)
5 320 131072 ms (~2m) 1048576 ms - 8388604 ms (~17m - ~2h)
6 384 1048576 ms (~17m) 8388608 ms - 67108863 ms (~2h - ~18h)
7 448 8388608 ms (~2h) 67108864 ms - 536870911 ms (~18h - ~6d)
That's a worst case inaccuracy of 12.5% for the timers which are queued at the beginning of a level.
So the new wheel concept addresses the old issues:
1) Cascading is avoided (except for extreme long time timers)
2) By keeping the timers in the bucket until expiry/cancelation we can track the buckets which have timers enqueued in a bucket bitmap and therefor can lookup the next expiring timer fast and time bound.
A further benefit of the concept is, that the slack calculation which is done on every timer start is not longer necessary because the granularity levels provide natural batching already.
Our extensive testing with various loads did not show any performance degradation vs. the current wheel implementation.
This patch does not address the 'fast lookup' issue as we wanted to make sure that there is no regression introduced by the wheel redesign. The optimizations are in follow up patches.
[ Contains fixes from Anna-Maria Gleixner and Richard Cochran ]
---
v4: Simplify wheel constants handling as pointed out by George Spelvin. Switch
to a non cascading wheel and let HZ=1000 have reduced granularity to accomodate the 5days timeouts of the networking code.
v3: fix return value of __next_timer_interrupt()
v2: change HASH_SIZE to TOT_HASH_SIZE (as Richard mentioned)
include/linux/timer.h | 2 kernel/time/timer.c | 825 ++++++++++++++++++++++++++++---------------------- 2 files changed, 467 insertions(+), 360 deletions(-)
include/linux/timer.h +2 -0
@@ -64,6 +64,8 @@ struct timer_list {#define TIMER_DEFERRABLE 0x00080000#define TIMER_PINNED 0x00100000#define TIMER_IRQSAFE 0x00200000 +#define TIMER_ARRAYSHIFT 22 +#define TIMER_ARRAYMASK 0xFFC00000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
kernel/time/timer.c +465 -360
1,032 lines not on this page · raw message
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Switch to a non-cascading wheel
timers: Switch to a non-cascading wheel
Commit-ID: 500462a9de657f86edaa102f8ab6bff7f7e43fc2 Gitweb: http://git.kernel.org/tip/500462a9de657f86edaa102f8ab6bff7f7e43fc2 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:30 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:09 +0200
timers: Switch to a non-cascading wheel
The current timer wheel has some drawbacks:
1) Cascading:
Cascading can be an unbound operation and is completely pointless in most cases because the vast majority of the timer wheel timers are canceled or rearmed before expiration. (They are used as timeout safeguards, not as real timers to measure time.)
2) No fast lookup of the next expiring timer:
In NOHZ scenarios the first timer soft interrupt after a long NOHZ period must fast forward the base time to the current value of jiffies. As we have no way to find the next expiring timer fast, the code loops linearly and increments the base time one by one and checks for expired timers in each step. This causes unbound overhead spikes exactly in the moment when we should wake up as fast as possible.
After a thorough analysis of real world data gathered on laptops, workstations, webservers and other machines (thanks Chris!) I came to the conclusion that the current 'classic' timer wheel implementation can be modified to address the above issues.
The vast majority of timer wheel timers is canceled or rearmed before expiry. Most of them are timeouts for networking and other I/O tasks. The nature of timeouts is to catch the exception from normal operation (TCP ack timed out, disk does not respond, etc.). For these kinds of timeouts the accuracy of the timeout is not really a concern. Timeouts are very often approximate worst-case values and in case the timeout fires, we already waited for a long time and performance is down the drain already.
The few timers which actually expire can be split into two categories:
1) Short expiry times which expect halfways accurate expiry
2) Long term expiry times are inaccurate today already due to the batching which is done for NOHZ automatically and also via the set_timer_slack() API.
So for long term expiry timers we can avoid the cascading property and just leave them in the less granular outer wheels until expiry or cancelation. Timers which are armed with a timeout larger than the wheel capacity are no longer cascaded. We expire them with the longest possible timeout (6+ days). We have not observed such timeouts in our data collection, but at least we handle them, applying the rule of the least surprise.
To avoid extending the wheel levels for HZ=1000 so we can accomodate the longest observed timeouts (5 days in the network conntrack code) we reduce the first level granularity on HZ=1000 to 4ms, which effectively is the same as the HZ=250 behaviour. From our data analysis there is nothing which relies on that 1ms granularity and as a side effect we get better batching and timer locality for the networking code as well.
Contrary to the classic wheel the granularity of the next wheel is not the capacity of the first wheel. The granularities of the wheels are in the currently chosen setting 8 times the granularity of the previous wheel.
So for HZ=250 we end up with the following granularity levels:
Level Offset Granularity Range
0 0 4 ms 0 ms - 252 ms
1 64 32 ms 256 ms - 2044 ms (256ms - ~2s)
2 128 256 ms 2048 ms - 16380 ms (~2s - ~16s)
3 192 2048 ms (~2s) 16384 ms - 131068 ms (~16s - ~2m)
4 256 16384 ms (~16s) 131072 ms - 1048572 ms (~2m - ~17m)
5 320 131072 ms (~2m) 1048576 ms - 8388604 ms (~17m - ~2h)
6 384 1048576 ms (~17m) 8388608 ms - 67108863 ms (~2h - ~18h)
7 448 8388608 ms (~2h) 67108864 ms - 536870911 ms (~18h - ~6d)That's a worst case inaccuracy of 12.5% for the timers which are queued at the beginning of a level.
So the new wheel concept addresses the old issues:
1) Cascading is avoided completely
2) By keeping the timers in the bucket until expiry/cancelation we can track the buckets which have timers enqueued in a bucket bitmap and therefore can look up the next expiring timer very fast and O(1).
A further benefit of the concept is that the slack calculation which is done on every timer start is no longer necessary because the granularity levels provide natural batching already.
Our extensive testing with various loads did not show any performance degradation vs. the current wheel implementation.
This patch does not address the 'fast lookup' issue as we wanted to make sure that there is no regression introduced by the wheel redesign. The optimizations are in follow up patches.
This patch contains fixes from Anna-Maria Gleixner and Richard Cochran.
--- include/linux/timer.h | 2 + kernel/time/timer.c | 829 ++++++++++++++++++++++++++++---------------------- 2 files changed, 469 insertions(+), 362 deletions(-)
include/linux/timer.h +2 -0
@@ -64,6 +64,8 @@ struct timer_list {#define TIMER_DEFERRABLE 0x00080000#define TIMER_PINNED 0x00100000#define TIMER_IRQSAFE 0x00200000 +#define TIMER_ARRAYSHIFT 22 +#define TIMER_ARRAYMASK 0xFFC00000#define __TIMER_INITIALIZER (_function, _expires, _data, _flags) { \ .entry = { .next = TIMER_ENTRY_STATIC }, \
kernel/time/timer.c +467 -362
1,034 lines not on this page · raw message
Re: [patch 4 14/22] timer: Switch to a non cascading wheel
In reply to Thomas GleixnerQuoted 1 line · Thomas Gleixner
The current timer wheel has some drawbacks:
...
It looks like this change (commit 500462a9de657f86edaa102f8ab6bff7f7e43fc2 in linux.git) breaks one of the automated test cases I'm using to test hostapd and wpa_supplicant with mac80211_hwsim from the kernel. I'm not sure what exactly causes this (did not really expect git bisect to point to timers..), but this seems to be very reproducible for me under kvm (though, this apparently did not happen on another device, so I'm not completely sure what it is needed to reproduce) with the ap_wps_er_http_proto test cases failing to connect 20 TCP stream sockets to a server on the localhost. The client side is a python test script and the server is hostapd. The failure shows up with about the 13th of those socket connects failing while all others (both before and after this failed one) going through.
Would you happen to have any idea why this commit has such a difference in behavior? I'm currently working around this in my test script with the following change, but it might be worth while to confirm whether there is something in the kernel change that resulted in unexpected behavior.
http://w1.fi/cgit/hostap/commit/?id=2d6a526ac3885605f34df4037fc79ad330565b23
The test code looked like this in python:
addr = (url.hostname, url.port)
socks = {}
for i in range(20):
socks[i] = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
socks[i].connect(addr)
With that connect() call being the failing (time out) operation and it seemed to happen for i == 13 most of the time. This shows up only with commit 500462a9de657f86edaa102f8ab6bff7f7e43fc2 included in the kernel (i.e., test with commit b0d6e2dcb284f1f4dcb4b92760f49eeaf5fc0bc7 as the kernel snapshot does not show this behavior). Changes in 500462a9 were not trivial to revert on top of the current master, so I have not checked whether the current master branch would get rid of the failure if only this one commit were reverted.
I can reproduce this easily, so if someone wants to get more details of the issue, just let me know how to collect whatever would be useful.
- Jouni
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 8 lines · Jouni Malinen
The test code looked like this in python:
addr = (url.hostname, url.port)
socks = {}
for i in range(20):
socks[i] = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
socks[i].connect(addr)
You getting a timeout on TCP connect()? Isn't that timeout really long, like 75 seconds or something?
Quoted 3 lines
I can reproduce this easily, so if someone wants to get more details of the issue, just let me know how to collect whatever would be useful.
Can you provide a simple test case or explain in more detail how you run your test? I would like to reproduce the issue it here.
Thanks,
Richard
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 10 lines · On Thu, Aug 11, 2016 at 11:25 PM, <[email protected]> wrote:
Quoted 8 lines · Jouni Malinen
The test code looked like this in python:
addr = (url.hostname, url.port)
socks = {}
for i in range(20):
socks[i] = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
socks[i].connect(addr)
Quoted 2 lines
You getting a timeout on TCP
connect()? Isn't that timeout really long, like 75 seconds or something?
Yes, it looks like a TCP connect() timeout. I use a significantly reduced timeout in the test scripts since they are run unattended and are supposed to terminate in reasonable amount of time.. That said, this specific test case should not really have used as short a timeout as it did, i.e., just one second. Interestingly enough, increasing that to just 1.1 seconds was enough to make the test case pass.. Looking at the time it takes to execute connect(), it is 1.02 - 1.08 seconds for the timing out (with timeout=1sec) case which is now at i=14 while all the other 19 calls take 0.0 seconds..
If I increase that 20 to 50, I get more of such about 1.03 second results at i=17, i=34, i=48..
Looking more at what exactly is happening at the TCP layer, this is likely related to the server behavior since listen() backlog is set to 10 and if there are 10 parallel connections, the last one if immediately closed before reading anything. Somehow this combination with this kernel patch applied makes one of the connect() calls take that surprisingly long 1.02 or so seconds.
Looking at a sniffer capture (*), the three-way TCP connection goes through fine for the first 15 connect() calls, but the 15th one does not get a response to SYN. This SYN is the frame 47 in the capture file with srcport == 60802. There is no SYN,ACK for it. The about one second unexpected time for connect() comes from this, i.e., the connection is completed only after the client side does TCP retransmission of the SYN (frame #77) a second later and the server side replies with RST,ACK (frame #78).
2 0.039135 127.0.0.1 -> 127.0.0.1 TCP 74 60772 > 49152 [SYN]
Seq=0 Win=43690 Len=0 MSS=65495 SACK_PERM=1 TSval=4294937755 TSecr=0 WS=64
3 0.039146 127.0.0.1 -> 127.0.0.1 TCP 74 49152 > 60772 [SYN,
ACK] Seq=0 Ack=1 Win=43690 Len=0 MSS=65495 SACK_PERM=1 TSval=4294937755 TSecr=4294937755 WS=64
4 0.039156 127.0.0.1 -> 127.0.0.1 TCP 66 60772 > 49152 [ACK]
Seq=1 Ack=1 Win=43712 Len=0 TSval=4294937755 TSecr=4294937755
...
47 0.042559 127.0.0.1 -> 127.0.0.1 TCP 74 60802 > 49152 [SYN]
Seq=0 Win=43690 Len=0 MSS=65495 SACK_PERM=1 TSval=4294937756 TSecr=0 WS=64
77 1.119943 127.0.0.1 -> 127.0.0.1 TCP 74 [TCP
Retransmission] 60802 > 49152 [SYN] Seq=0 Win=43690 Len=0 MSS=65495 SACK_PERM=1 TSval=4294937864 TSecr=0 WS=64
78 1.119953 127.0.0.1 -> 127.0.0.1 TCP 54 49152 > 60802 [RST,
ACK] Seq=1 Ack=1 Win=0 Len=0
So it looks like the issue is in one of the SYN,ACK frames getting completely lost..
(*) http://w1.fi/p/tcp-lo.pcap
Quoted 2 lines
Can you provide a simple test case or explain in more detail how you run your test? I would like to reproduce the issue it here.
I'm not sure how to make a simple test case for this taken into account this seems to have some unknown timing dependencies.. A quick loop of 20 TCP socket() + connect() calls with a server side that does listen() with backlog 10 and non-blocking operations with 10th and following incoming sockets getting close() immediately is what the test case ends up doing, but whether a simple program doing that without all of python and wpa_supplicant processing giving suitable timing is unclear..
These files describe the test setup that I'm using to run this:
http://w1.fi/cgit/hostap/plain/tests/hwsim/README
http://w1.fi/cgit/hostap/plain/tests/hwsim/vm/README
with the actual test case being executed with
tests/hwsim/vm$ ./vm-run.sh ap_wps_er_http_proto
- Jouni
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
Jouni,
If I understand the test correctly, then the slightly different kernel timer behavior is ok, but the test isn't quite right. Let explain what I mean.
First off, reading test_ap_wps.py, the point of the test is to see if ten simultaneous connections are possible. I guess the server implements a hard coded limit on the number of clients. (BTW where is the server loop?)
You said that the server also sets 'backlog' to ten. The backlog controls the size of the queue holding incoming connections that are in the SYN_RCVD or ESTABLISHED state but have not yet been accept(2)-ed by the server. This is *not* the same as the number of possible simultaneous connections.
Quoted 3 lines · Jouni Malinen
Yes, it looks like a TCP
connect()timeout. I use a significantly reduced timeout in the test scripts since they are run unattended and are supposed to terminate in reasonable amount of time.. That said,
I did not find where the client sets the one second timeout. Where does this happen?
Quoted 2 lines
If I increase that 20 to 50, I get more of such about 1.03 second results at i=17, i=34, i=48..
Can you provide the timings when the test runs on the older kernel?
Quoted 4 lines
Looking more at what exactly is happening at the TCP layer, this is likely related to the server behavior since
listen()backlog is set to 10 and if there are 10 parallel connections, the last one if immediately closed before reading anything.
To clarify, when the backlog is exceed, the new connection is not closed. Instead, the SYN is simply ignored, and the client is expect to re-transmit the SYN in the normal TCP fashion.
Quoted 8 lines
Looking at a sniffer capture (*), the three-way TCP connection goes through fine for the first 15
connect()calls, but the 15th one does not get a response to SYN. This SYN is the frame 47 in the capture file with srcport == 60802. There is no SYN,ACK for it. The about one second unexpected time forconnect()comes from this, i.e., the connection is completed only after the client side does TCP retransmission of the SYN (frame #77) a second later and the server side replies with RST,ACK (frame #78).
This is the expected behavior.
Quoted 2 lines
So it looks like the issue is in one of the SYN,ACK frames getting completely lost..
No, the frame is not missing. It was never sent because the backlog was exceeded.
Here is what I suspect is happening. By sending 20 SYN frames to a port with a backlog of 10, it saturates the queue. One SYN is ignored by the kernel, and a race begins between the connect() timeout and the SYN re-transmission. If the client's re-transmitted SYN and then the server's SYN,ACK returns before the connect timeout, then the call to connect() succeeds. With the new timer wheel, the result of the race is different.
There a couple of ways to deal with this. One is to increase the backlog on the server side. Another is to increase the connect() timeout to a multiple of the re-transmission interval.
Thoughts?
Thanks,
Richard
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 64 lines · Richard Cochran
Jouni,
If I understand the test correctly, then the slightly different kernel timer behavior is ok, but the test isn't quite right. Let explain what I mean.
First off, reading
test_ap_wps.py, the point of the test is to see if ten simultaneous connections are possible. I guess the server implements a hard coded limit on the number of clients. (BTW where is the server loop?)You said that the server also sets 'backlog' to ten. The backlog controls the size of the queue holding incoming connections that are in the
SYN_RCVDor ESTABLISHED state but have not yet been accept(2)-ed by the server. This is *not* the same as the number of possible simultaneous connections.Quoted 3 lines · Jouni Malinen
Yes, it looks like a TCP
connect()timeout. I use a significantly reduced timeout in the test scripts since they are run unattended and are supposed to terminate in reasonable amount of time.. That said,I did not find where the client sets the one second timeout. Where does this happen?
Quoted 2 lines
If I increase that 20 to 50, I get more of such about 1.03 second results at i=17, i=34, i=48..
Can you provide the timings when the test runs on the older kernel?
Quoted 4 lines
Looking more at what exactly is happening at the TCP layer, this is likely related to the server behavior since
listen()backlog is set to 10 and if there are 10 parallel connections, the last one if immediately closed before reading anything.To clarify, when the backlog is exceed, the new connection is not closed. Instead, the SYN is simply ignored, and the client is expect to re-transmit the SYN in the normal TCP fashion.
Quoted 8 lines
Looking at a sniffer capture (*), the three-way TCP connection goes through fine for the first 15
connect()calls, but the 15th one does not get a response to SYN. This SYN is the frame 47 in the capture file with srcport == 60802. There is no SYN,ACK for it. The about one second unexpected time forconnect()comes from this, i.e., the connection is completed only after the client side does TCP retransmission of the SYN (frame #77) a second later and the server side replies with RST,ACK (frame #78).This is the expected behavior.
Quoted 2 lines
So it looks like the issue is in one of the SYN,ACK frames getting completely lost..
No, the frame is not missing. It was never sent because the backlog was exceeded.
Here is what I suspect is happening. By sending 20 SYN frames to a port with a backlog of 10, it saturates the queue. One SYN is ignored by the kernel, and a race begins between the
connect()timeout and the SYN re-transmission. If the client's re-transmitted SYN and then the server's SYN,ACK returns before the connect timeout, then the call toconnect()succeeds. With the new timer wheel, the result of the race is different.
Quoted 6 lines
There a couple of ways to deal with this. One is to increase the backlog on the server side. Another is to increase the
connect()timeout to a multiple of the re-transmission interval.Thoughts?
I am coming late to the party, but yes, test looks flaky.
(Relying on having very precise SYN retransmits when listen backlog on server side is full)
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
In reply to Richard CochranQuoted 8 lines · Richard Cochran
If I understand the test correctly, then the slightly different kernel timer behavior is ok, but the test isn't quite right. Let explain what I mean.
First off, reading
test_ap_wps.py, the point of the test is to see if ten simultaneous connections are possible. I guess the server implements a hard coded limit on the number of clients. (BTW where is the server loop?)
Yes, I think I wrote that test case to hit a specific code path in the server side. The server implementation is here:
http://w1.fi/cgit/hostap/plain/src/wps/http_server.c
Quoted 5 lines
You said that the server also sets 'backlog' to ten. The backlog controls the size of the queue holding incoming connections that are in the
SYN_RCVDor ESTABLISHED state but have not yet been accept(2)-ed by the server. This is *not* the same as the number of possible simultaneous connections.
This is indeed what seems to be the key area that had a small change in timing. After some more experimentation on various timing, it is starting to look like the TCP initiator side retransmission timing is now different after this kernel commit and that is hit for the case where the server process does not have enough time to accept() the incoming connections and listen() backlog ends up dropping it instead.
Quoted 7 lines · Jouni Malinen
Quoted 3 lines
Yes, it looks like a TCP
connect()timeout. I use a significantly reduced timeout in the test scripts since they are run unattended and are supposed to terminate in reasonable amount of time.. That said,I did not find where the client sets the one second timeout. Where does this happen?
There is a socket.setdefaulttimeout(1) call in wps_er_start().
Quoted 4 lines
Quoted 2 lines
If I increase that 20 to 50, I get more of such about 1.03 second results at i=17, i=34, i=48..
Can you provide the timings when the test runs on the older kernel?
I had not realized this previously due to the test case passing, but the same retransmit SYN case was happening with older kernels, it just was done a tiny bit faster to escape that 1.0 second timeout limit.. That about 1.03 sec value after this kernel commit is 1.0 sec before this kernel commit. In other words, something in this specific kernel commit seems to add about 0.03 sec delay to the TCP SYN retransmission. That said, I realize that this is quite unlikely timeout to use for connect() in real world and as such, it looks simply as a side effect of a test case that was using way too close timing requirement in the first place.
Quoted 8 lines
Quoted 4 lines
Looking more at what exactly is happening at the TCP layer, this is likely related to the server behavior since
listen()backlog is set to 10 and if there are 10 parallel connections, the last one if immediately closed before reading anything.To clarify, when the backlog is exceed, the new connection is not closed. Instead, the SYN is simply ignored, and the client is expect to re-transmit the SYN in the normal TCP fashion.
That closing was referring to what the server code in http_server.c does, i.e., it does call close() after accept()ing the 10th parallel connection. I had not realized that this was actually hitting the listen() backlog in this specific case around the 15th socket, but yes, that does indeed explain the behavior shown in the sniffer capture.
I was also able to confirm that if I add a short wait in the test loop between each connect() call, things work fine with this kernel commit included, i.e., the "issue" was triggered only when this listen() backlog case was hit.
Quoted 7 lines
Here is what I suspect is happening. By sending 20 SYN frames to a port with a backlog of 10, it saturates the queue. One SYN is ignored by the kernel, and a race begins between the
connect()timeout and the SYN re-transmission. If the client's re-transmitted SYN and then the server's SYN,ACK returns before the connect timeout, then the call toconnect()succeeds. With the new timer wheel, the result of the race is different.
Yes, that does indeed look exactly what is happening.
Quoted 3 lines
There a couple of ways to deal with this. One is to increase the backlog on the server side. Another is to increase the
connect()timeout to a multiple of the re-transmission interval.
Taken into account this is a test case for testing a specific code path in http_server.c that is very unlikely to be hit in real world and a way too short timeout for connect(), it is clear to me that the proper fix here is to fix the test case to use a longer connect() timeout especially now that I saw the 1.0 sec time with older kernel as well.
Signature · 1 line
Jouni Malinen PGP id EFC895FA
Re: [PREEMPT-RT] [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 6 lines · Jouni Malinen
I had not realized this previously due to the test case passing, but the same retransmit SYN case was happening with older kernels, it just was done a tiny bit faster to escape that 1.0 second timeout limit.. That about 1.03 sec value after this kernel commit is 1.0 sec before this kernel commit. In other words, something in this specific kernel commit seems to add about 0.03 sec delay to the TCP SYN retransmission.
Yes, and this 3% increase in the timeout expiration interval is an expected result using the new timer wheel. See the large comment at the top of kernel/time/timer.c and the lkml discussion about this series.
Quoted 4 lines
That
said, I realize that this is quite unlikely timeout to use forconnect()in real world and as such, it looks simply as a side effect of a test case that was using way too close timing requirement in the first place.
Right, and user space should not rely on the exact timing of TCP SYN re-transmission!
Thanks,
Richard
Re: [patch 4 14/22] timer: Switch to a non cascading wheel
In reply to Jouni MalinenQuoted 21 lines · Jouni Malinen
Quoted 1 line · Thomas Gleixner
The current timer wheel has some drawbacks:
...
It looks like this change (commit
500462a9de657f86edaa102f8ab6bff7f7e43fc2in linux.git) breaks one of the automated test cases I'm using to test hostapd andwpa_supplicantwithmac80211_hwsimfrom the kernel. I'm not sure what exactly causes this (did not really expect git bisect to point to timers..), but this
seems to be very reproducible for me under kvm (though, this apparently did not happen on another device, so I'm not completely sure what it is needed to reproduce) with theap_wps_er_http_prototest cases failing to connect 20 TCP stream sockets to a server on the
localhost. The client side is a python test script and the server is hostapd. The failure shows up with about the 13th of those socket connects failing while all others (both before and after this failed one) going through.
Quoted 2 lines
Would you happen to have any idea why this commit has such a difference in behavior?
I have a vague hypothesis, more of a question actually.
How does the new timer wheel code handle lost timer ticks?
If a KVM guest does not run for a while, because the host is scheduling something else, the guest generally only gets one timer tick after the guest is scheduled back in.
If there are multiple lost ticks, they will remain lost.
Could that cause the new timer wheel code to skip over timer buckets occasionally, or is this hypothesis bunk?
Signature · 1 line
All Rights Reversed.
Re: [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 29 lines · Rik van Riel
Quoted 21 lines · Jouni Malinen
Quoted 1 line · Thomas Gleixner
The current timer wheel has some drawbacks:
...
It looks like this change (commit
500462a9de657f86edaa102f8ab6bff7f7e43fc2in linux.git) breaks one of the automated test cases I'm using to test hostapd andwpa_supplicantwithmac80211_hwsimfrom the kernel. I'm not sure what exactly causes this (did not really expect git bisect to point to timers..), but this
seems to be very reproducible for me under kvm (though, this apparently did not happen on another device, so I'm not completely sure what it is needed to reproduce) with theap_wps_er_http_prototest cases failing to connect 20 TCP stream sockets to a server on the
localhost. The client side is a python test script and the server is hostapd. The failure shows up with about the 13th of those socket connects failing while all others (both before and after this failed one) going through.Quoted 2 lines
Would you happen to have any idea why this commit has such a difference in behavior?
I have a vague hypothesis, more of a question actually.
How does the new timer wheel code handle lost timer ticks?
Quoted 8 lines
If a KVM guest does not run for a while, because the host is scheduling something else, the guest generally only gets one timer tick after the guest is scheduled back in.
If there are multiple lost ticks, they will remain lost.
Could that cause the new timer wheel code to skip over timer buckets occasionally, or is this hypothesis bunk?
FWIW, I do appear to be seeing more lost wakeups on current mainline than on v4.7, but not enough of a difference to get a reliable bisction in reasonable time.
Thanx, Paul
Re: [patch 4 14/22] timer: Switch to a non cascading wheel
Quoted 3 lines · Paul E. McKenney
FWIW, I do appear to be seeing more lost wakeups on current mainline than on v4.7, but not enough of a difference to get a reliable bisction in reasonable time.
We are seeing reproducible hangs* when running Steven's stress-cpu-hotplug under kvm. This hang goes back to v4.7 at least. I couldn't reproduce this with bare metal. Thomas thought it was a virtualization issue, not related to the hotplug rework. He is away until next week. Maybe he knows more to say...
To reproduce, run
while [ 1 ]; do ./stress-cpu-hotplug ; done
and wait about 20 minutes (or longer).
Thanks,
Richard
* INFO: task cpuhp/7:49 blocked for more than 120 seconds
Re: [patch 4 14/22] timer: Switch to a non cascading wheel
In reply to Rik van RielQuoted 2 lines · Rik van Riel
Could that cause the new timer wheel code to skip over timer buckets occasionally, or is this hypothesis bunk?
The new wheel is not different from the old one in this respect. Each base keeps its own jiffies counter. When returning from a long sleep, the base counter can be behind the current jiffies value by more than one. In __run_timers() we loop through all the missed jiffies:
while (time_after_eq(jiffies, base->clk)) {
levels = collect_expired_timers(base, heads);
base->clk++;
while (levels--)
expire_timers(base, heads + levels);
}So the hypothesis is incorrect.
Thanks,
Richard
PATCH 15/22 timer: Remove slack leftovers
In reply to Thomas GleixnerWe now have implicit batching in the timer wheel. The slack is not longer used. Remove it.
--- block/genhd.c | 5 ----- drivers/mmc/host/jz4740_mmc.c | 2 -- drivers/power/bq27xxx_battery.c | 5 +---- drivers/usb/host/ohci-hcd.c | 1 - drivers/usb/host/xhci.c | 2 -- include/linux/timer.h | 4 ---- kernel/time/timer.c | 19 ------------------- lib/random32.c | 1 - 8 files changed, 1 insertion(+), 38 deletions(-)
block/genhd.c +0 -5
@@ -1523,12 +1523,7 @@ static void __disk_unblock_events(structif (--ev->block) goto out_unlock; -/* -* Not exactly a latency critical operation, set poll timer -* slack to 25% and kick event check. -*/ intv =disk_events_poll_jiffies (disk); -set_timer_slack (&ev->dwork.timer, intv /4 );if (check_now)queue_delayed_work (system_freezable_power_efficient_wq, &ev->dwork,0 );
drivers/mmc/host/jz4740_mmc.c +0 -2
@@ -1068,8 +1068,6 @@ static int jz4740_mmc_probe(struct platfjz4740_mmc_clock_disable (host);setup_timer (&host->timeout_timer, jz4740_mmc_timeout, (unsigned long )host); -/* It is not important when it times out, it just needs to timeout. */ -set_timer_slack (&host->timeout_timer,HZ ); host->use_dma = true;if (host->use_dma &&jz4740_mmc_acquire_dma_channels (host) !=0 )
drivers/power/bq27xxx_battery.c +1 -4
@@ -735,11 +735,8 @@ static void bq27xxx_battery_poll(structbq27xxx_battery_update (di); -if (poll_interval >0 ) { -/* The timer does not have to be accurate. */ -set_timer_slack (&di->work.timer, poll_interval *HZ /4 ); +if (poll_interval >0 )schedule_delayed_work (&di->work, poll_interval *HZ ); - } }/*
drivers/usb/host/ohci-hcd.c +0 -1
@@ -500,7 +500,6 @@ static int ohci_init (struct ohci_hcd *osetup_timer (&ohci->io_watchdog, io_watchdog_func, (unsigned long ) ohci); -set_timer_slack (&ohci->io_watchdog,msecs_to_jiffies (20 )); ohci->hcca =dma_alloc_coherent (hcd->self.controller,sizeof (*ohci->hcca), &ohci->hcca_dma,GFP_KERNEL );
drivers/usb/host/xhci.c +0 -2
@@ -490,8 +490,6 @@ static void compliance_mode_recovery_tim xhci->comp_mode_recovery_timer.expires = jiffies +msecs_to_jiffies (COMP_MODE_RCVRY_MSECS ); -set_timer_slack (&xhci->comp_mode_recovery_timer, -msecs_to_jiffies (COMP_MODE_RCVRY_MSECS ));add_timer (&xhci->comp_mode_recovery_timer);xhci_dbg_trace (xhci, trace_xhci_dbg_quirks,"Compliance mode recovery timer initialized" );
include/linux/timer.h +0 -4
@@ -19,7 +19,6 @@ struct timer_list {void (*function)(unsigned long );unsigned long data;u32 flags; -int slack;#ifdef CONFIG_TIMER_STATS int start_pid;
@@ -73,7 +72,6 @@ struct timer_list { .expires = (_expires), \ .data = (_data), \ .flags = (_flags), \ - .slack = -1, \__TIMER_LOCKDEP_MAP_INITIALIZER ( \ __FILE__":" __stringify(__LINE__)) \ }
@@ -193,8 +191,6 @@ extern int del_timer(struct timer_list *extern int mod_timer (struct timer_list *timer,unsigned long expires);extern int mod_timer_pending (struct timer_list *timer,unsigned long expires); -extern void set_timer_slack (struct timer_list *time,int slack_hz); -/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +0 -19
@@ -447,24 +447,6 @@ unsigned long round_jiffies_up_relative( }EXPORT_SYMBOL_GPL (round_jiffies_up_relative); -/** -* set_timer_slack - set the allowed slack for a timer -* @timer: the timer to be modified -* @slack_hz: the amount of time (in jiffies) allowed for rounding -* -* Set the amount of time, in jiffies, that a certain timer has -* in terms of slack. By setting this value, the timer subsystem -* will schedule the actual timer somewhere between -* the time mod_timer() asks for, and that time plus the slack. -* -* By setting the slack to -1, a percentage of the delay is used -* instead. -*/ -void set_timer_slack (struct timer_list *timer,int slack_hz) -{ - timer->slack = slack_hz; -} -EXPORT_SYMBOL_GPL (set_timer_slack);static inline unsigned int timer_get_idx (struct timer_list *timer) {
@@ -775,7 +757,6 @@ static void do_init_timer(struct timer_l { timer->entry.pprev =NULL ; timer->flags = flags |raw_smp_processor_id (); - timer->slack =-1 ;#ifdef CONFIG_TIMER_STATS timer->start_site =NULL ; timer->start_pid =-1 ;
lib/random32.c +0 -1
@@ -233,7 +233,6 @@ static void __prandom_timer(unsigned lonstatic void __init __prandom_start_seed_timer (void ) { -set_timer_slack (&seed_timer,HZ ); seed_timer.expires = jiffies +msecs_to_jiffies (40 *MSEC_PER_SEC );add_timer (&seed_timer); }
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Remove set_timer_slack() leftovers
timers: Remove set_timer_slack() leftovers
Commit-ID: 53bf837b78d155b8e1110b3c25b4d0d6391b8ff3 Gitweb: http://git.kernel.org/tip/53bf837b78d155b8e1110b3c25b4d0d6391b8ff3 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:31 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:09 +0200
timers: Remove set_timer_slack() leftovers
We now have implicit batching in the timer wheel. The slack API is no longer used, so remove it.
--- block/genhd.c | 5 ----- drivers/mmc/host/jz4740_mmc.c | 2 -- drivers/power/bq27xxx_battery.c | 5 +---- drivers/usb/host/ohci-hcd.c | 1 - drivers/usb/host/xhci.c | 2 -- include/linux/timer.h | 4 ---- kernel/time/timer.c | 19 ------------------- lib/random32.c | 1 - 8 files changed, 1 insertion(+), 38 deletions(-)
block/genhd.c +0 -5
@@ -1523,12 +1523,7 @@ static void __disk_unblock_events(struct gendisk *disk, bool check_now)if (--ev->block) goto out_unlock; -/* -* Not exactly a latency critical operation, set poll timer -* slack to 25% and kick event check. -*/ intv =disk_events_poll_jiffies (disk); -set_timer_slack (&ev->dwork.timer, intv /4 );if (check_now)queue_delayed_work (system_freezable_power_efficient_wq, &ev->dwork,0 );
drivers/mmc/host/jz4740_mmc.c +0 -2
@@ -1068,8 +1068,6 @@ static int jz4740_mmc_probe(struct platform_device* pdev)jz4740_mmc_clock_disable (host);setup_timer (&host->timeout_timer, jz4740_mmc_timeout, (unsigned long )host); -/* It is not important when it times out, it just needs to timeout. */ -set_timer_slack (&host->timeout_timer,HZ ); host->use_dma = true;if (host->use_dma &&jz4740_mmc_acquire_dma_channels (host) !=0 )
drivers/power/bq27xxx_battery.c +1 -4
@@ -735,11 +735,8 @@ static void bq27xxx_battery_poll(struct work_struct *work)bq27xxx_battery_update (di); -if (poll_interval >0 ) { -/* The timer does not have to be accurate. */ -set_timer_slack (&di->work.timer, poll_interval *HZ /4 ); +if (poll_interval >0 )schedule_delayed_work (&di->work, poll_interval *HZ ); - } }/*
drivers/usb/host/ohci-hcd.c +0 -1
@@ -500,7 +500,6 @@ static int ohci_init (struct ohci_hcd *ohci)setup_timer (&ohci->io_watchdog, io_watchdog_func, (unsigned long ) ohci); -set_timer_slack (&ohci->io_watchdog,msecs_to_jiffies (20 )); ohci->hcca =dma_alloc_coherent (hcd->self.controller,sizeof (*ohci->hcca), &ohci->hcca_dma,GFP_KERNEL );
drivers/usb/host/xhci.c +0 -2
@@ -490,8 +490,6 @@ static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci) xhci->comp_mode_recovery_timer.expires = jiffies +msecs_to_jiffies (COMP_MODE_RCVRY_MSECS ); -set_timer_slack (&xhci->comp_mode_recovery_timer, -msecs_to_jiffies (COMP_MODE_RCVRY_MSECS ));add_timer (&xhci->comp_mode_recovery_timer);xhci_dbg_trace (xhci, trace_xhci_dbg_quirks,"Compliance mode recovery timer initialized" );
include/linux/timer.h +0 -4
@@ -19,7 +19,6 @@ struct timer_list {void (*function)(unsigned long );unsigned long data;u32 flags; -int slack;#ifdef CONFIG_TIMER_STATS int start_pid;
@@ -73,7 +72,6 @@ struct timer_list { .expires = (_expires), \ .data = (_data), \ .flags = (_flags), \ - .slack = -1, \__TIMER_LOCKDEP_MAP_INITIALIZER ( \ __FILE__":" __stringify(__LINE__)) \ }
@@ -193,8 +191,6 @@ extern int del_timer(struct timer_list * timer);extern int mod_timer (struct timer_list *timer,unsigned long expires);extern int mod_timer_pending (struct timer_list *timer,unsigned long expires); -extern void set_timer_slack (struct timer_list *time,int slack_hz); -/* * The jiffies value which is added to now, when there is no timer * in the timer wheel:
kernel/time/timer.c +0 -19
@@ -447,24 +447,6 @@ unsigned long round_jiffies_up_relative(unsigned long j) }EXPORT_SYMBOL_GPL (round_jiffies_up_relative); -/** -* set_timer_slack - set the allowed slack for a timer -* @timer: the timer to be modified -* @slack_hz: the amount of time (in jiffies) allowed for rounding -* -* Set the amount of time, in jiffies, that a certain timer has -* in terms of slack. By setting this value, the timer subsystem -* will schedule the actual timer somewhere between -* the time mod_timer() asks for, and that time plus the slack. -* -* By setting the slack to -1, a percentage of the delay is used -* instead. -*/ -void set_timer_slack (struct timer_list *timer,int slack_hz) -{ - timer->slack = slack_hz; -} -EXPORT_SYMBOL_GPL (set_timer_slack);static inline unsigned int timer_get_idx (struct timer_list *timer) {
@@ -775,7 +757,6 @@ static void do_init_timer(struct timer_list *timer, unsigned int flags, { timer->entry.pprev =NULL ; timer->flags = flags |raw_smp_processor_id (); - timer->slack =-1 ;#ifdef CONFIG_TIMER_STATS timer->start_site =NULL ; timer->start_pid =-1 ;
lib/random32.c +0 -1
@@ -233,7 +233,6 @@ static void __prandom_timer(unsigned long dontcare)static void __init __prandom_start_seed_timer (void ) { -set_timer_slack (&seed_timer,HZ ); seed_timer.expires = jiffies +msecs_to_jiffies (40 *MSEC_PER_SEC );add_timer (&seed_timer); }
Re: [patch 4 15/22] timer: Remove slack leftovers
In reply to Thomas GleixnerHi Thomas,
Quoted 8 lines · Thomas Gleixner
We now have implicit batching in the timer wheel. The slack is not longer used. Remove it.
-set_timer_slack(&ev->dwork.timer, intv / 4);
-set_timer_slack(&host->timeout_timer, HZ);
-set_timer_slack(&di->work.timer, poll_interval * HZ / 4);
-set_timer_slack(&ohci->io_watchdog, msecs_to_jiffies(20));
- set_timer_slack(&xhci->comp_mode_recovery_timer,
etc...
The current mod_timer implementation has this code:
/*
* This is a common optimization triggered by the
* networking code - if the timer is re-modified
* to be the same thing then just return:
*/
if (timer_pending(timer) && timer->expires == expires)
return 1;In a (currently out-of-tree, but hopefully mergable soon) driver of mine, I call mod_timer in the hot path. Every time some very frequent event happens, I call mod_timer to move the timer back to be at "jiffies + TIMEOUT".
Quoted 1 line
From a brief look at
timer.c, it looked like__mod_timerwas rather
expensive. So, as an optimization, I wanted the "timer_pending(timer) && timer->expires == expires" condition to be hit in most of the cases. I accomplished this by doing:
set_timer_slack(timer, HZ / 4);
This ensured that we'd only wind up calling __mod_timer 4 times per second, at most.
With the removal of the slack concept, I no longer can do this. I haven't reviewed this series in depth, but I'm wondering if you'd recommend a different optimization instead. Or, have things been reworked so much, that calling mod_timer is now always inexpensive?
Thanks,
Jason
Re: [patch 4 15/22] timer: Remove slack leftovers
Quoted 8 lines · Jason A. Donenfeld
Quoted 3 lines · Thomas Gleixner
We now have implicit batching in the timer wheel. The slack is not longer used. Remove it.
From a brief look attimer.c, it looked like__mod_timerwas ratherexpensive. So, as an optimization, I wanted the "
timer_pending(timer)&&timer->expires== expires" condition to be hit in most of the cases. I accomplished this by doing:
Quoted 8 lines
set_timer_slack(timer, HZ / 4);This ensured that we'd only wind up calling
__mod_timer4 times per second, at most.With the removal of the slack concept, I no longer can do this. I haven't reviewed this series in depth, but I'm wondering if you'd recommend a different optimization instead. Or, have things been
Well, this really depends on the TIMEOUT value you have. The code now does implicit batching for larger timeouts by queueing the timers into wheels with coarse grained granularity. As long as your new TIMEOUT value ends up in the same bucket then that's equivalent to the slack thing.
Can you give me a ballpark of your TIMEOUT value?
Quoted 1 line
reworked so much, that calling
mod_timeris now always inexpensive?
When you take the slow (queueing) path, it's still expensive, not as bad as the previous one, but not really cheap either.
Thanks,
tglx
Re: [patch 4 15/22] timer: Remove slack leftovers
Hi Thomas,
Quoted 7 lines · Thomas Gleixner
Well, this really depends on the TIMEOUT value you have. The code now does implicit batching for larger timeouts by queueing the timers into wheels with coarse grained granularity. As long as your new TIMEOUT value ends up in the same bucket then that's equivalent to the slack thing.
Can you give me a ballpark of your TIMEOUT value?
Generally either 5 seconds, 10 seconds, or 25 seconds.
Are these okay? Is the 25 case substantially different from the 5 case?
Quoted 2 lines
When you take the slow (queueing) path, it's still expensive, not as bad as the previous one, but not really cheap either.
Hmm, okay.
Re: [patch 4 15/22] timer: Remove slack leftovers
Quoted 9 lines · Jason A. Donenfeld
Hi Thomas,
Quoted 6 lines · Thomas Gleixner
Well, this really depends on the TIMEOUT value you have. The code now does implicit batching for larger timeouts by queueing the timers into wheels with coarse grained granularity. As long as your new TIMEOUT value ends up in the same bucket then that's equivalent to the slack thing.
Quoted 5 lines
Quoted 1 line
Can you give me a ballpark of your TIMEOUT value?
Generally either 5 seconds, 10 seconds, or 25 seconds.
Are these okay? Is the 25 case substantially different from the 5 case?
I suppose, anyway, it's easy enough just to provide my own coalescing function. Actually, I'd rather have it batch timers to fire earlier rather than later, in my case. So, I can do something like this to round down to the nearest ~ quarter of a second:
static inline unsigned long slack_time(unsigned long time)
{
return time & ~(BIT_MASK(ilog2(HZ / 4) + 1) - 1);
}
mod_timer(&timer, slack_time(jiffies + TIMEOUT));This seems to do roughly what I want.
Jason
PATCH 16/22 timer: Move __run_timers() function
In reply to Thomas GleixnerFrom: Anna-Maria Gleixner <[email protected]>
Move __run_timers() below __next_timer_interrupt() and next_pending_bucket() in preparation for __run_timers() NOHZ optimization.
No functional change.
--- kernel/time/timer.c | 52 ++++++++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 26 deletions(-)
kernel/time/timer.c +26 -26
@@ -1277,32 +1277,6 @@ static int collect_expired_timers(structreturn levels; } -/** -* __run_timers - run all expired timers (if any) on this CPU. -* @base: the timer vector to be processed. -*/ -static inline void __run_timers (struct timer_base *base) -{ -struct hlist_head heads[LVL_DEPTH ]; -int levels; - -if (!time_after_eq (jiffies, base->clk)) -return ; - -spin_lock_irq (&base->lock); - -while (time_after_eq (jiffies, base->clk)) { - - levels =collect_expired_timers (base, heads); - base->clk++; - -while (levels--) -expire_timers (base, heads + levels); - } - base->running_timer =NULL ; -spin_unlock_irq (&base->lock); -} -#ifdef CONFIG_NO_HZ_COMMON /* * Find the next pending bucket of a level. Search from @offset + @clk upwards
@@ -1472,6 +1446,32 @@ void update_process_times(int user_tick)run_posix_cpu_timers (p); } +/** +* __run_timers - run all expired timers (if any) on this CPU. +* @base: the timer vector to be processed. +*/ +static inline void __run_timers (struct timer_base *base) +{ +struct hlist_head heads[LVL_DEPTH ]; +int levels; + +if (!time_after_eq (jiffies, base->clk)) +return ; + +spin_lock_irq (&base->lock); + +while (time_after_eq (jiffies, base->clk)) { + + levels =collect_expired_timers (base, heads); + base->clk++; + +while (levels--) +expire_timers (base, heads + levels); + } + base->running_timer =NULL ; +spin_unlock_irq (&base->lock); +} +/* * This function runs timers and the timer-tq in bottom half context. */
tip-bot for Anna-Maria Gleixner
merge bot[tip:timers/core] timers: Move __run_timers() function
timers: Move __run_timers() function
Commit-ID: 73420fea80c6c376d91a69defe64013baa0d7e95 Gitweb: http://git.kernel.org/tip/73420fea80c6c376d91a69defe64013baa0d7e95 Author: Anna-Maria Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:33 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:09 +0200
timers: Move __run_timers() function
Move __run_timers() below __next_timer_interrupt() and next_pending_bucket() in preparation for __run_timers() NOHZ optimization.
No functional change.
--- kernel/time/timer.c | 52 ++++++++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 26 deletions(-)
kernel/time/timer.c +26 -26
@@ -1277,32 +1277,6 @@ static int collect_expired_timers(struct timer_base *base,return levels; } -/** -* __run_timers - run all expired timers (if any) on this CPU. -* @base: the timer vector to be processed. -*/ -static inline void __run_timers (struct timer_base *base) -{ -struct hlist_head heads[LVL_DEPTH ]; -int levels; - -if (!time_after_eq (jiffies, base->clk)) -return ; - -spin_lock_irq (&base->lock); - -while (time_after_eq (jiffies, base->clk)) { - - levels =collect_expired_timers (base, heads); - base->clk++; - -while (levels--) -expire_timers (base, heads + levels); - } - base->running_timer =NULL ; -spin_unlock_irq (&base->lock); -} -#ifdef CONFIG_NO_HZ_COMMON /* * Find the next pending bucket of a level. Search from @offset + @clk upwards
@@ -1472,6 +1446,32 @@ void update_process_times(int user_tick)run_posix_cpu_timers (p); } +/** +* __run_timers - run all expired timers (if any) on this CPU. +* @base: the timer vector to be processed. +*/ +static inline void __run_timers (struct timer_base *base) +{ +struct hlist_head heads[LVL_DEPTH ]; +int levels; + +if (!time_after_eq (jiffies, base->clk)) +return ; + +spin_lock_irq (&base->lock); + +while (time_after_eq (jiffies, base->clk)) { + + levels =collect_expired_timers (base, heads); + base->clk++; + +while (levels--) +expire_timers (base, heads + levels); + } + base->running_timer =NULL ; +spin_unlock_irq (&base->lock); +} +/* * This function runs timers and the timer-tq in bottom half context. */
PATCH 17/22 timer: Optimize collect timers for NOHZ
In reply to Thomas GleixnerFrom: Anna-Maria Gleixner <[email protected]>
After a NOHZ idle sleep the wheel must be forwarded to current jiffies. There might be expired timers so the current code loops and checks the epxired buckets for timers. This can take quite some time for long NOHZ idle periods.
The pending bitmask in the timer base allows us to do a quick search for the next expiring timer and therefor a fast forward of the base time which prevents pointless long lasting loops.
For a 3 second idle sleep this reduces the catchup time from ~1ms to 5us.
--- kernel/time/timer.c | 49 +++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 41 insertions(+), 8 deletions(-)
kernel/time/timer.c +41 -8
@@ -1252,8 +1252,8 @@ static void expire_timers(struct timer_b } } -static int collect_expired_timers (struct timer_base *base, -struct hlist_head *heads) +static int __collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) {unsigned long clk = base->clk;struct hlist_head *vec;
@@ -1279,9 +1279,9 @@ static int collect_expired_timers(struct#ifdef CONFIG_NO_HZ_COMMON /* -* Find the next pending bucket of a level. Search from @offset + @clk upwards -* and if nothing there, search from start of the level (@offset) up to -* @offset + clk. +* Find the next pending bucket of a level. Search from level start (@offset) +* + @clk upwards and if nothing there, search from start of the level +* (@offset) up to @offset + clk. */ static int next_pending_bucket (struct timer_base *base,unsigned offset,unsigned clk)
@@ -1298,14 +1298,14 @@ static int next_pending_bucket(struct ti }/* -* Search the first expiring timer in the various clock levels. +* Search the first expiring timer in the various clock levels. Caller must +* hold base->lock. */ static unsigned long __next_timer_interrupt (struct timer_base *base) {unsigned long clk, next, adj;unsigned lvl, offset =0 ; -spin_lock (&base->lock); next = base->clk +NEXT_TIMER_MAX_DELTA ; clk = base->clk;for (lvl =0 ; lvl <LVL_DEPTH ; lvl++, offset +=LVL_SIZE ) {
@@ -1358,7 +1358,6 @@ static unsigned long __next_timer_interr clk >>=LVL_CLK_SHIFT ; clk += adj; } -spin_unlock (&base->lock);return next; }
@@ -1416,7 +1415,10 @@ u64 get_next_timer_interrupt(unsigned loif (cpu_is_offline (smp_processor_id ()))return expires; +spin_lock (&base->lock); nextevt =__next_timer_interrupt (base); +spin_unlock (&base->lock); +if (time_before_eq (nextevt, basej)) expires = basem;else
@@ -1424,6 +1426,37 @@ u64 get_next_timer_interrupt(unsigned lo return cmp_next_hrtimer_event(basem, expires); } + +static int collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) +{ +/* +* NOHZ optimization. After a long idle sleep we need to forward the +* base to current jiffies. Avoid a loop by searching the bitfield for +* the next expiring timer. +*/ +if ((long )(jiffies - base->clk) >2 ) { +unsigned long next =__next_timer_interrupt (base); + +/* +* If the next timer is ahead of time forward to current +* jiffies, otherwise forward to the next expiry time. +*/ +if (time_after (next, jiffies)) { +/* The call site will increment clock! */ + base->clk = jiffies -1 ; +return 0 ; + } + base->clk = next; + } +return __collect_expired_timers (base, heads); +} +#else +static inline int collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) +{ +return __collect_expired_timers (base, heads); +}#endif /*
tip-bot for Anna-Maria Gleixner
merge bot[tip:timers/core] timers: Optimize collect_expired_timers() for NOHZ
timers: Optimize collect_expired_timers() for NOHZ
Commit-ID: 236968383cf5cd48835ff0d8a265e299e220d140 Gitweb: http://git.kernel.org/tip/236968383cf5cd48835ff0d8a265e299e220d140 Author: Anna-Maria Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:34 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:10 +0200
timers: Optimize collect_expired_timers() for NOHZ
After a NOHZ idle sleep the timer wheel must be forwarded to current jiffies. There might be expired timers so the current code loops and checks the expired buckets for timers. This can take quite some time for long NOHZ idle periods.
The pending bitmask in the timer base allows us to do a quick search for the next expiring timer and therefore a fast forward of the base time which prevents pointless long lasting loops.
For a 3 seconds idle sleep this reduces the catchup time from ~1ms to 5us.
--- kernel/time/timer.c | 49 +++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 41 insertions(+), 8 deletions(-)
kernel/time/timer.c +41 -8
@@ -1252,8 +1252,8 @@ static void expire_timers(struct timer_base *base, struct hlist_head *head) } } -static int collect_expired_timers (struct timer_base *base, -struct hlist_head *heads) +static int __collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) {unsigned long clk = base->clk;struct hlist_head *vec;
@@ -1279,9 +1279,9 @@ static int collect_expired_timers(struct timer_base *base,#ifdef CONFIG_NO_HZ_COMMON /* -* Find the next pending bucket of a level. Search from @offset + @clk upwards -* and if nothing there, search from start of the level (@offset) up to -* @offset + clk. +* Find the next pending bucket of a level. Search from level start (@offset) +* + @clk upwards and if nothing there, search from start of the level +* (@offset) up to @offset + clk. */ static int next_pending_bucket (struct timer_base *base,unsigned offset,unsigned clk)
@@ -1298,14 +1298,14 @@ static int next_pending_bucket(struct timer_base *base, unsigned offset, }/* -* Search the first expiring timer in the various clock levels. +* Search the first expiring timer in the various clock levels. Caller must +* hold base->lock. */ static unsigned long __next_timer_interrupt (struct timer_base *base) {unsigned long clk, next, adj;unsigned lvl, offset =0 ; -spin_lock (&base->lock); next = base->clk +NEXT_TIMER_MAX_DELTA ; clk = base->clk;for (lvl =0 ; lvl <LVL_DEPTH ; lvl++, offset +=LVL_SIZE ) {
@@ -1358,7 +1358,6 @@ static unsigned long __next_timer_interrupt(struct timer_base *base) clk >>=LVL_CLK_SHIFT ; clk += adj; } -spin_unlock (&base->lock);return next; }
@@ -1416,7 +1415,10 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)if (cpu_is_offline (smp_processor_id ()))return expires; +spin_lock (&base->lock); nextevt =__next_timer_interrupt (base); +spin_unlock (&base->lock); +if (time_before_eq (nextevt, basej)) expires = basem;else
@@ -1424,6 +1426,37 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem) return cmp_next_hrtimer_event(basem, expires); } + +static int collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) +{ +/* +* NOHZ optimization. After a long idle sleep we need to forward the +* base to current jiffies. Avoid a loop by searching the bitfield for +* the next expiring timer. +*/ +if ((long )(jiffies - base->clk) >2 ) { +unsigned long next =__next_timer_interrupt (base); + +/* +* If the next timer is ahead of time forward to current +* jiffies, otherwise forward to the next expiry time. +*/ +if (time_after (next, jiffies)) { +/* The call site will increment clock! */ + base->clk = jiffies -1 ; +return 0 ; + } + base->clk = next; + } +return __collect_expired_timers (base, heads); +} +#else +static inline int collect_expired_timers (struct timer_base *base, +struct hlist_head *heads) +{ +return __collect_expired_timers (base, heads); +}#endif /*
PATCH 18/22 tick/sched: Remove pointless empty function
In reply to Thomas GleixnerThis was a failed attempt to optimize the timer expiry in idle, which was disabled and never revisited. Remove the cruft.
--- kernel/time/tick-sched.c | 33 +-------------------------------- 1 file changed, 1 insertion(+), 32 deletions(-)
kernel/time/tick-sched.c +1 -32
@@ -1092,35 +1092,6 @@ static void tick_nohz_switch_to_nohz(voitick_nohz_activate (ts,NOHZ_MODE_LOWRES ); } -/* -* When NOHZ is enabled and the tick is stopped, we need to kick the -* tick timer from irq_enter() so that the jiffies update is kept -* alive during long running softirqs. That's ugly as hell, but -* correctness is key even if we need to fix the offending softirq in -* the first place. -* -* Note, this is different to tick_nohz_restart. We just kick the -* timer and do not touch the other magic bits which need to be done -* when idle is left. -*/ -static void tick_nohz_kick_tick (struct tick_sched *ts,ktime_t now) -{ -#if 0 -/* Switch back to 2.6.27 behaviour */ -ktime_t delta; - -/* -* Do not touch the tick device, when the next expiry is either -* already reached or less/equal than the tick period. -*/ - delta =ktime_sub (hrtimer_get_expires (&ts->sched_timer), now); -if (delta.tv64 <= tick_period.tv64) -return ; - -tick_nohz_restart (ts, now); -#endif -} -static inline void tick_nohz_irq_enter (void ) {struct tick_sched *ts =this_cpu_ptr (&tick_cpu_sched);
@@ -1131,10 +1102,8 @@ static inline void tick_nohz_irq_enter(v now =ktime_get ();if (ts->idle_active)tick_nohz_stop_idle (ts, now); -if (ts->tick_stopped) { +if (ts->tick_stopped) tick_nohz_update_jiffies(now); -tick_nohz_kick_tick (ts, now); - } }#else
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers/nohz: Remove pointless tick_nohz_kick_tick() function
timers/nohz: Remove pointless tick_nohz_kick_tick() function
Commit-ID: ff00673292bd42a3688b33de47252a6a3c3f424c Gitweb: http://git.kernel.org/tip/ff00673292bd42a3688b33de47252a6a3c3f424c Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:35 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:10 +0200
timers/nohz: Remove pointless tick_nohz_kick_tick() function
This was a failed attempt to optimize the timer expiry in idle, which was disabled and never revisited. Remove the cruft.
--- kernel/time/tick-sched.c | 33 +-------------------------------- 1 file changed, 1 insertion(+), 32 deletions(-)
kernel/time/tick-sched.c +1 -32
@@ -1092,35 +1092,6 @@ static void tick_nohz_switch_to_nohz(void)tick_nohz_activate (ts,NOHZ_MODE_LOWRES ); } -/* -* When NOHZ is enabled and the tick is stopped, we need to kick the -* tick timer from irq_enter() so that the jiffies update is kept -* alive during long running softirqs. That's ugly as hell, but -* correctness is key even if we need to fix the offending softirq in -* the first place. -* -* Note, this is different to tick_nohz_restart. We just kick the -* timer and do not touch the other magic bits which need to be done -* when idle is left. -*/ -static void tick_nohz_kick_tick (struct tick_sched *ts,ktime_t now) -{ -#if 0 -/* Switch back to 2.6.27 behaviour */ -ktime_t delta; - -/* -* Do not touch the tick device, when the next expiry is either -* already reached or less/equal than the tick period. -*/ - delta =ktime_sub (hrtimer_get_expires (&ts->sched_timer), now); -if (delta.tv64 <= tick_period.tv64) -return ; - -tick_nohz_restart (ts, now); -#endif -} -static inline void tick_nohz_irq_enter (void ) {struct tick_sched *ts =this_cpu_ptr (&tick_cpu_sched);
@@ -1131,10 +1102,8 @@ static inline void tick_nohz_irq_enter(void) now =ktime_get ();if (ts->idle_active)tick_nohz_stop_idle (ts, now); -if (ts->tick_stopped) { +if (ts->tick_stopped) tick_nohz_update_jiffies(now); -tick_nohz_kick_tick (ts, now); - } }#else
PATCH 19/22 timer: Forward wheel clock whenever possible
In reply to Thomas GleixnerThe wheel clock is stale when a cpu goes into a long idle sleep. This has the side effect, that timers which are queued end up in the outer wheel levels. That results in coarser granularity.
To solve this, we keep track of the idle state and forward the wheel clock whenever it's possible.
--- kernel/time/tick-internal.h | 1 kernel/time/tick-sched.c | 12 ++++ kernel/time/timer.c | 128 ++++++++++++++++++++++++++++++++++++-------- 3 files changed, 120 insertions(+), 21 deletions(-)
kernel/time/tick-internal.h +1 -0
@@ -164,3 +164,4 @@ static inline void timers_update_migrati DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);extern u64 get_next_timer_interrupt (unsigned long basej,u64 basem); +void timer_clear_idle (void );
kernel/time/tick-sched.c +12 -0
@@ -700,6 +700,12 @@ static ktime_t tick_nohz_stop_sched_tick delta = next_tick - basemono;if (delta <= (u64 )TICK_NSEC ) { tick.tv64 =0 ; + +/* +* Tell the timer code that the base is not idle, i.e. undo +* the effect of get_next_timer_interrupt(). +*/ +timer_clear_idle ();/* * We've not stopped the tick yet, and there's a timer in the * next period, so no point in stopping it either, bail.
@@ -809,6 +815,12 @@ static void tick_nohz_restart_sched_ticktick_do_update_jiffies64 (now);cpu_load_update_nohz_stop (); +/* +* Clear the timer idle flag, so we avoid IPIs on remote queueing and +* the clock forward checks in the enqueue path. +*/ +timer_clear_idle (); +calc_load_exit_idle ();touch_softlockup_watchdog_sched ();/*
kernel/time/timer.c +107 -21
172 lines not on this page · raw message
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Forward the wheel clock whenever possible
timers: Forward the wheel clock whenever possible
Commit-ID: a683f390b93f4d1292f849fc48d28e322046120f Gitweb: http://git.kernel.org/tip/a683f390b93f4d1292f849fc48d28e322046120f Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:36 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:11 +0200
timers: Forward the wheel clock whenever possible
The wheel clock is stale when a CPU goes into a long idle sleep. This has the side effect that timers which are queued end up in the outer wheel levels. That results in coarser granularity.
To solve this, we keep track of the idle state and forward the wheel clock whenever possible.
--- kernel/time/tick-internal.h | 1 + kernel/time/tick-sched.c | 12 +++++ kernel/time/timer.c | 128 ++++++++++++++++++++++++++++++++++++-------- 3 files changed, 120 insertions(+), 21 deletions(-)
kernel/time/tick-internal.h +1 -0
@@ -164,3 +164,4 @@ static inline void timers_update_migration(bool update_nohz) { } DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);extern u64 get_next_timer_interrupt (unsigned long basej,u64 basem); +void timer_clear_idle (void );
kernel/time/tick-sched.c +12 -0
@@ -700,6 +700,12 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts, delta = next_tick - basemono;if (delta <= (u64 )TICK_NSEC ) { tick.tv64 =0 ; + +/* +* Tell the timer code that the base is not idle, i.e. undo +* the effect of get_next_timer_interrupt(): +*/ +timer_clear_idle ();/* * We've not stopped the tick yet, and there's a timer in the * next period, so no point in stopping it either, bail.
@@ -809,6 +815,12 @@ static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)tick_do_update_jiffies64 (now);cpu_load_update_nohz_stop (); +/* +* Clear the timer idle flag, so we avoid IPIs on remote queueing and +* the clock forward checks in the enqueue path: +*/ +timer_clear_idle (); +calc_load_exit_idle ();touch_softlockup_watchdog_sched ();/*
kernel/time/timer.c +107 -21
179 lines not on this page · raw message
PATCH 20/22 timer: Only wake softirq if necessary
In reply to Thomas GleixnerWith the wheel forwading in place and with the HZ=1000 4ms folding we can avoid running the softirq at all.
--- kernel/time/timer.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/time/timer.c +11 -0
@@ -1608,7 +1608,18 @@ static void run_timer_softirq(struct sof*/ void run_local_timers (void ) { +struct timer_base *base =this_cpu_ptr (&timer_bases[BASE_STD ]); +hrtimer_run_queues (); +/* Raise the softirq only if required. */ +if (time_before (jiffies, base->clk)) { +if (!IS_ENABLED (CONFIG_NO_HZ_COMMON ) || !base->nohz_active) +return ; +/* CPU is awake, so check the deferrable base. */ + base++; +if (time_before (jiffies, base->clk)) +return ; + }raise_softirq (TIMER_SOFTIRQ ); }
tip-bot for Thomas Gleixner
merge bot[tip:timers/core] timers: Only wake softirq if necessary
timers: Only wake softirq if necessary
Commit-ID: 4e85876a9d2a977b4a07389da8c07edf76d10825 Gitweb: http://git.kernel.org/tip/4e85876a9d2a977b4a07389da8c07edf76d10825 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:37 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:11 +0200
timers: Only wake softirq if necessary
With the wheel forwading in place and with the HZ=1000 4ms folding we can avoid running the softirq at all.
--- kernel/time/timer.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/time/timer.c +11 -0
@@ -1608,7 +1608,18 @@ static void run_timer_softirq(struct softirq_action *h)*/ void run_local_timers (void ) { +struct timer_base *base =this_cpu_ptr (&timer_bases[BASE_STD ]); +hrtimer_run_queues (); +/* Raise the softirq only if required. */ +if (time_before (jiffies, base->clk)) { +if (!IS_ENABLED (CONFIG_NO_HZ_COMMON ) || !base->nohz_active) +return ; +/* CPU is awake, so check the deferrable base. */ + base++; +if (time_before (jiffies, base->clk)) +return ; + }raise_softirq (TIMER_SOFTIRQ ); }
PATCH 21/22 timer: Split out index calculation
In reply to Thomas GleixnerFrom: Anna-Maria Gleixner <[email protected]>
For further optimizations we need to seperate index calculation and queueing. No functional change.
--- kernel/time/timer.c | 47 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 15 deletions(-)
kernel/time/timer.c +32 -15
@@ -471,12 +471,9 @@ static inline unsigned calc_index(unsignreturn LVL_OFFS (lvl) + (expires &LVL_MASK ); } -static void -__internal_add_timer (struct timer_base *base,struct timer_list *timer) +static int calc_wheel_index (unsigned long expires,unsigned long clk) { -unsigned long expires = timer->expires; -unsigned long delta = expires - base->clk; -struct hlist_head *vec; +unsigned long delta = expires - clk;unsigned int idx;if (delta <LVL_START (1 )) {
@@ -496,7 +493,7 @@ static void }else if (LVL_DEPTH >8 && delta <LVL_START (8 )) { idx =calc_index (expires,7 ); }else if ((long ) delta <0 ) { - idx = base->clk &LVL_MASK ; + idx = clk &LVL_MASK ; }else {/* * Force expire obscene large timeouts to expire at the
@@ -507,20 +504,33 @@ static void idx =calc_index (expires,LVL_DEPTH -1 ); } -/* -* Enqueue the timer into the array bucket, mark it pending in -* the bitmap and store the index in the timer flags. -*/ - vec = base->vectors + idx; -hlist_add_head (&timer->entry, vec); +return idx; +} + +/* +* Enqueue the timer into the hash bucket, mark it pending in +* the bitmap and store the index in the timer flags. +*/ +static void enqueue_timer (struct timer_base *base,struct timer_list *timer, +unsigned int idx) +{ +hlist_add_head (&timer->entry, base->vectors + idx);__set_bit (idx, base->pending_map);timer_set_idx (timer, idx); } -static void internal_add_timer (struct timer_base *base,struct timer_list *timer) +static void +__internal_add_timer (struct timer_base *base,struct timer_list *timer) { -__internal_add_timer (base, timer); +unsigned int idx; + + idx =calc_wheel_index (timer->expires, base->clk); +enqueue_timer (base, timer, idx); +} +static void +trigger_dyntick_cpu (struct timer_base *base,struct timer_list *timer) +{if (!IS_ENABLED (CONFIG_NO_HZ_COMMON ) || !base->nohz_active)return ;
@@ -551,7 +561,14 @@ static void internal_add_timer(struct ti* wheel */ base->next_expiry = timer->expires; -wake_up_nohz_cpu (base->cpu); +wake_up_nohz_cpu (base->cpu); +} + +static void +internal_add_timer (struct timer_base *base,struct timer_list *timer) +{ +__internal_add_timer (base, timer); +trigger_dyntick_cpu (base, timer); }#ifdef CONFIG_TIMER_STATS
tip-bot for Anna-Maria Gleixner
merge bot[tip:timers/core] timers: Split out index calculation
timers: Split out index calculation
Commit-ID: ffdf047728f8f93df896b58049c7513856027141 Gitweb: http://git.kernel.org/tip/ffdf047728f8f93df896b58049c7513856027141 Author: Anna-Maria Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:39 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:12 +0200
timers: Split out index calculation
For further optimizations we need to seperate index calculation from queueing. No functional change.
--- kernel/time/timer.c | 47 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 15 deletions(-)
kernel/time/timer.c +32 -15
@@ -471,12 +471,9 @@ static inline unsigned calc_index(unsigned expires, unsigned lvl)return LVL_OFFS (lvl) + (expires &LVL_MASK ); } -static void -__internal_add_timer (struct timer_base *base,struct timer_list *timer) +static int calc_wheel_index (unsigned long expires,unsigned long clk) { -unsigned long expires = timer->expires; -unsigned long delta = expires - base->clk; -struct hlist_head *vec; +unsigned long delta = expires - clk;unsigned int idx;if (delta <LVL_START (1 )) {
@@ -496,7 +493,7 @@ __internal_add_timer(struct timer_base *base, struct timer_list *timer) }else if (LVL_DEPTH >8 && delta <LVL_START (8 )) { idx =calc_index (expires,7 ); }else if ((long ) delta <0 ) { - idx = base->clk &LVL_MASK ; + idx = clk &LVL_MASK ; }else {/* * Force expire obscene large timeouts to expire at the
@@ -507,20 +504,33 @@ __internal_add_timer(struct timer_base *base, struct timer_list *timer) idx =calc_index (expires,LVL_DEPTH -1 ); } -/* -* Enqueue the timer into the array bucket, mark it pending in -* the bitmap and store the index in the timer flags. -*/ - vec = base->vectors + idx; -hlist_add_head (&timer->entry, vec); +return idx; +} + +/* +* Enqueue the timer into the hash bucket, mark it pending in +* the bitmap and store the index in the timer flags. +*/ +static void enqueue_timer (struct timer_base *base,struct timer_list *timer, +unsigned int idx) +{ +hlist_add_head (&timer->entry, base->vectors + idx);__set_bit (idx, base->pending_map);timer_set_idx (timer, idx); } -static void internal_add_timer (struct timer_base *base,struct timer_list *timer) +static void +__internal_add_timer (struct timer_base *base,struct timer_list *timer) { -__internal_add_timer (base, timer); +unsigned int idx; + + idx =calc_wheel_index (timer->expires, base->clk); +enqueue_timer (base, timer, idx); +} +static void +trigger_dyntick_cpu (struct timer_base *base,struct timer_list *timer) +{if (!IS_ENABLED (CONFIG_NO_HZ_COMMON ) || !base->nohz_active)return ;
@@ -551,7 +561,14 @@ static void internal_add_timer(struct timer_base *base, struct timer_list *timer* wheel: */ base->next_expiry = timer->expires; -wake_up_nohz_cpu (base->cpu); +wake_up_nohz_cpu (base->cpu); +} + +static void +internal_add_timer (struct timer_base *base,struct timer_list *timer) +{ +__internal_add_timer (base, timer); +trigger_dyntick_cpu (base, timer); }#ifdef CONFIG_TIMER_STATS
PATCH 22/22 timer: Optimization for same expiry time in mod_timer()
In reply to Thomas GleixnerFrom: Anna-Maria Gleixner <[email protected]>
The existing optimization for same expiry time in mod_timer() checks whether the timer expiry time is the same as the new requested expiry time. In the old timer wheel implementation this does not take the slack batching into account, neither does the new implementation evaluate whether the new expiry time will requeue the timer to the same bucket.
To optimize that, we can calculate the resulting bucket and check if the new expiry time is different from the current expiry time. This calculation happens outside the base lock held region. If the resulting bucket is the same we can avoid taking the base lock and requeueing the timer.
If the timer needs to be requeued then we have to check under the base lock whether the base time has changed between the lockless calculation and taking the lock. If it has changed we need to recalculate under the lock.
This optimization takes effect for timers which are enqueued into the less granular wheel levels (1 and above). With a simple test case the functionality has been verified:
Before After
Match: 5.5% 86.6%
Requeue: 94.5% 13.4% Recalc: <0.01%
In the non optimized case the timer is requeued in 94.5% of the cases. With the index optimization in place the requeue rate drops to 13.4%. The case where the lockless index calculation has to be redone is less than 0.01%.
With a real world test case (networking) we observed the following changes:
Before After
Match: 97.8% 99.7%
Requeue: 2.2% 0.3% Recalc: <0.001%
That means two percent less lock/requeue/unlock operations in one of the hot path use cases of timers.
--- kernel/time/timer.c | 51 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 35 insertions(+), 16 deletions(-)
kernel/time/timer.c +35 -16
@@ -960,28 +960,36 @@ static inline int __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only) { struct timer_base *base, *new_base; -unsigned long flags; +unsigned int idx =UINT_MAX ; +unsigned long clk =0 , flags;int ret =0 ;/* -* TODO: Calculate the array bucket of the timer right here w/o -* holding the base lock. This allows to check not only -* timer->expires == expires below, but also whether the timer -* ends up in the same bucket. If we really need to requeue -* the timer then we check whether base->clk have -* advanced between here and locking the timer base. If -* jiffies advanced we have to recalc the array bucket with the -* lock held. -*/ - -/* -* This is a common optimization triggered by the -* networking code - if the timer is re-modified -* to be the same thing then just return: +* This is a common optimization triggered by the networking code - if +* the timer is re-modified to be the same thing or ends up in the +* same array bucket then just return: */ if (timer_pending (timer)) {if (timer->expires == expires)return 1 ; +/* +* Take the current timer_jiffies of base, but without holding +* the lock! +*/ + base =get_timer_base (timer->flags); + clk = base->clk; + + idx =calc_wheel_index (expires, clk); + +/* +* Retrieve and compare the array index of the pending +* timer. If it matches set the expiry to the new value so a +* subsequent call will exit in the expires check above. +*/ +if (idx ==timer_get_idx (timer)) { + timer->expires = expires; +return 1 ; + } }timer_stats_timer_set_start_info (timer);
@@ -1018,7 +1026,18 @@ static inline int } timer->expires = expires; -internal_add_timer (base, timer); +/* +* If idx was calculated above and the base time did not advance +* between calculating idx and taking the lock, only enqueue_timer() +* and trigger_dyntick_cpu() is required. Otherwise we need to +* (re)calculate the wheel index via internal_add_timer(). +*/ +if (idx !=UINT_MAX && clk == base->clk) { +enqueue_timer (base, timer, idx); +trigger_dyntick_cpu (base, timer); + }else { +internal_add_timer (base, timer); + } out_unlock:spin_unlock_irqrestore (&base->lock, flags);
tip-bot for Anna-Maria Gleixner
merge bot[tip:timers/core] timers: Implement optimization for same expiry time in mod_timer()
timers: Implement optimization for same expiry time in mod_timer()
Commit-ID: f00c0afdfa625165a609513bc74164d56752ec3e Gitweb: http://git.kernel.org/tip/f00c0afdfa625165a609513bc74164d56752ec3e Author: Anna-Maria Gleixner <[email protected]> AuthorDate: Mon, 4 Jul 2016 09:50:40 +0000 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 7 Jul 2016 10:35:12 +0200
timers: Implement optimization for same expiry time in mod_timer()
The existing optimization for same expiry time in mod_timer() checks whether the timer expiry time is the same as the new requested expiry time. In the old timer wheel implementation this does not take the slack batching into account, neither does the new implementation evaluate whether the new expiry time will requeue the timer to the same bucket.
To optimize that, we can calculate the resulting bucket and check if the new expiry time is different from the current expiry time. This calculation happens outside the base lock held region. If the resulting bucket is the same we can avoid taking the base lock and requeueing the timer.
If the timer needs to be requeued then we have to check under the base lock whether the base time has changed between the lockless calculation and taking the lock. If it has changed we need to recalculate under the lock.
This optimization takes effect for timers which are enqueued into the less granular wheel levels (1 and above). With a simple test case the functionality has been verified:
Before After Match: 5.5% 86.6% Requeue: 94.5% 13.4% Recalc: <0.01%
In the non optimized case the timer is requeued in 94.5% of the cases. With the index optimization in place the requeue rate drops to 13.4%. The case where the lockless index calculation has to be redone is less than 0.01%.
With a real world test case (networking) we observed the following changes:
Before After
Match: 97.8% 99.7%
Requeue: 2.2% 0.3%
Recalc: <0.001%
That means two percent fewer lock/requeue/unlock operations done in one of the hot path use cases of timers.
--- kernel/time/timer.c | 51 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 35 insertions(+), 16 deletions(-)
kernel/time/timer.c +35 -16
@@ -960,28 +960,36 @@ static inline int __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only) { struct timer_base *base, *new_base; -unsigned long flags; +unsigned int idx =UINT_MAX ; +unsigned long clk =0 , flags;int ret =0 ;/* -* TODO: Calculate the array bucket of the timer right here w/o -* holding the base lock. This allows to check not only -* timer->expires == expires below, but also whether the timer -* ends up in the same bucket. If we really need to requeue -* the timer then we check whether base->clk have -* advanced between here and locking the timer base. If -* jiffies advanced we have to recalc the array bucket with the -* lock held. -*/ - -/* -* This is a common optimization triggered by the -* networking code - if the timer is re-modified -* to be the same thing then just return: +* This is a common optimization triggered by the networking code - if +* the timer is re-modified to have the same timeout or ends up in the +* same array bucket then just return: */ if (timer_pending (timer)) {if (timer->expires == expires)return 1 ; +/* +* Take the current timer_jiffies of base, but without holding +* the lock! +*/ + base =get_timer_base (timer->flags); + clk = base->clk; + + idx =calc_wheel_index (expires, clk); + +/* +* Retrieve and compare the array index of the pending +* timer. If it matches set the expiry to the new value so a +* subsequent call will exit in the expires check above. +*/ +if (idx ==timer_get_idx (timer)) { + timer->expires = expires; +return 1 ; + } }timer_stats_timer_set_start_info (timer);
@@ -1018,7 +1026,18 @@ __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only) } timer->expires = expires; -internal_add_timer (base, timer); +/* +* If 'idx' was calculated above and the base time did not advance +* between calculating 'idx' and taking the lock, only enqueue_timer() +* and trigger_dyntick_cpu() is required. Otherwise we need to +* (re)calculate the wheel index via internal_add_timer(). +*/ +if (idx !=UINT_MAX && clk == base->clk) { +enqueue_timer (base, timer, idx); +trigger_dyntick_cpu (base, timer); + }else { +internal_add_timer (base, timer); + } out_unlock:spin_unlock_irqrestore (&base->lock, flags);