sched,time: make irq time accounting work for nohz_idle
cover sched,time: make irq time accounting work for nohz_idle
This patch series seems to make irq time accounting work with nohz_idle, by having it re-use the same strategy used for steal time accounting in Wanpeng Li's patch.
It applies on top of an earlier version of Wanpeng Li's patch.
It gets rid of some code duplication, but needs a little bit more work. Specifically, selecting CONFIG_IRQ_TIME_ACCOUNTING at the same time as CONFIG_TICK_BASED_ACCOUNTING probably breaks :)
I am posting this because it works, and because I would like to know what other changes I need to make at the same time.
PATCH 1/5 sched,time: count actually elapsed irq & softirq time
From: Rik van Riel <[email protected]>
Currently, if there was any irq or softirq time during 'ticks' jiffies, the entire period will be accounted as irq or softirq time.
This is inaccurate if only a subset of 'ticks' jiffies was actually spent handling irqs, and could conceivably mis-count all of the ticks during a period as irq time, when there was some irq and some softirq time.
Fix this by changing irqtime_account_hi_update and irqtime_account_si_update to round elapsed irq and softirq time to jiffies, and return the number of jiffies spent in each mode, similar to how steal time is handled.
Additionally, have irqtime_account_process_tick take into account how much time was spent in each of steal, irq, and softirq time.
The latter could help improve the accuracy of timekeeping when returning from idle on a NO_HZ_IDLE CPU.
Properly accounting how much time was spent in hardirq and softirq time will also allow the NO_HZ_FULL code to re-use these same functions for hardirq and softirq accounting.
--- kernel/sched/cputime.c | 54 +++++++++++++++++++++++++++++++------------------- 1 file changed, 34 insertions(+), 20 deletions(-)
kernel/sched/cputime.c +34 -20
@@ -79,34 +79,36 @@ void irqtime_account_irq(struct task_struct *curr) }EXPORT_SYMBOL_GPL (irqtime_account_irq); -static int irqtime_account_hi_update (void ) +static unsigned long irqtime_account_hi_update (void ) {u64 *cpustat = kcpustat_this_cpu->cpustat; +unsigned long irq_jiffies;unsigned long flags; -u64 latest_ns; -int ret =0 ; +u64 irq;local_irq_save (flags); - latest_ns =this_cpu_read (cpu_hardirq_time); -if (nsecs_to_cputime64 (latest_ns) > cpustat[CPUTIME_IRQ ]) - ret =1 ; + irq =this_cpu_read (cpu_hardirq_time) - cpustat[CPUTIME_IRQ ]; + irq_jiffies =cputime_to_jiffies (irq); +if (irq_jiffies) + cpustat[CPUTIME_IRQ ] +=jiffies_to_cputime (irq_jiffies);local_irq_restore (flags); -return ret; +return irq_jiffies; } -static int irqtime_account_si_update (void ) +static unsigned long irqtime_account_si_update (void ) {u64 *cpustat = kcpustat_this_cpu->cpustat; +unsigned long si_jiffies;unsigned long flags; -u64 latest_ns; -int ret =0 ; +u64 softirq;local_irq_save (flags); - latest_ns =this_cpu_read (cpu_softirq_time); -if (nsecs_to_cputime64 (latest_ns) > cpustat[CPUTIME_SOFTIRQ ]) - ret =1 ; + delta =this_cpu_read (cpu_softirq_time) - cpustat[CPUTIME_SOFTIRQ ]; + si_jiffies =cputime_to_jiffies (delta); +if (si_jiffies) + cpustat[CPUSTIME_SOFTIRQ ] +=jiffies_to_cputime (si_jiffies);local_irq_restore (flags); -return ret; +return si_jiffies; }#else /* CONFIG_IRQ_TIME_ACCOUNTING */
@@ -345,18 +347,30 @@ static void irqtime_account_process_tick(struct task_struct *p, int user_tick,cputime_t scaled =cputime_to_scaled (cputime_one_jiffy);u64 cputime = (__force u64 ) cputime_one_jiffy;u64 *cpustat = kcpustat_this_cpu->cpustat; +unsigned long other; -if (steal_account_process_tick ()) +/* +* Subtract steal, irq & softirq time (if any) from ticks. +* These are counted in nanoseconds and not aligned with jiffies. +* Multiple of these could "break a jiffy" simultaneously due to +* rounding; be careful to not account too much of this time at once. +*/ + other =steal_account_process_tick (); +if (other >= ticks) +return ; + + other +=irqtime_account_hi_update (); +if (other >= ticks) +return ; + + other +=irqtime_account_si_update (); +if (other >= ticks)return ; cputime *= ticks; scaled *= ticks; -if (irqtime_account_hi_update ()) { - cpustat[CPUTIME_IRQ ] += cputime; - }else if (irqtime_account_si_update ()) { - cpustat[CPUTIME_SOFTIRQ ] += cputime; - }else if (this_cpu_ksoftirqd () == p) { +if (this_cpu_ksoftirqd () == p) {/* * ksoftirqd time do not get accounted in cpu_softirq_time. * So, we have to handle it separately here.
Signature · 1 line
2.5.5
PATCH 2/5 nohz,cputime: remove VTIME_GEN vtime irq time code
In reply to [email protected]From: Rik van Riel <[email protected]>
The CONFIG_VIRT_CPU_ACCOUNTING_GEN irq time tracking code does not appear to currently work right.
On CPUs that are nohz_full, people typically do not assign IRQs. On the housekeeping CPU (when a system is booted up with nohz_full), sampling should work ok to determine irq and softirq time use, but that only covers the housekeeping CPU itself, not the other non-nohz_full CPUs.
On CPUs that are nohz_idle (the typical way a distro kernel is booted), irq time is not accounted at all while the CPU is idle, due to the lack of timer ticks.
Remove the VTIME_GEN vtime irq time code. The next patch will allow NO_HZ_FULL kernels to use the IRQ_TIME_ACCOUNTING code.
--- include/linux/vtime.h | 32 +++++++++++++---------------- kernel/sched/cputime.c | 55 ++++++++++++++++++++++++++++---------------------- 2 files changed, 45 insertions(+), 42 deletions(-)
include/linux/vtime.h +14 -18
@@ -64,17 +64,6 @@ extern void vtime_account_system(struct task_struct *tsk);extern void vtime_account_idle (struct task_struct *tsk);extern void vtime_account_user (struct task_struct *tsk); -#ifdef __ARCH_HAS_VTIME_ACCOUNT -extern void vtime_account_irq_enter (struct task_struct *tsk); -#else -extern void vtime_common_account_irq_enter (struct task_struct *tsk); -static inline void vtime_account_irq_enter (struct task_struct *tsk) -{ -if (vtime_accounting_cpu_enabled ()) -vtime_common_account_irq_enter (tsk); -} -#endif /* __ARCH_HAS_VTIME_ACCOUNT */ -#else /* !CONFIG_VIRT_CPU_ACCOUNTING */ static inline void vtime_task_switch (struct task_struct *prev) { }
@@ -85,13 +74,8 @@ static inline void vtime_account_irq_enter(struct task_struct *tsk) { }#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN extern void arch_vtime_task_switch (struct task_struct *tsk); -extern void vtime_gen_account_irq_exit (struct task_struct *tsk); - -static inline void vtime_account_irq_exit (struct task_struct *tsk) -{ -if (vtime_accounting_cpu_enabled ()) -vtime_gen_account_irq_exit (tsk); -} +static inline void vtime_account_irq_enter (struct task_struct *tsk) { } +static inline void vtime_account_irq_exit (struct task_struct *tsk) { }extern void vtime_user_enter (struct task_struct *tsk);
@@ -113,6 +97,18 @@ static inline void vtime_user_exit(struct task_struct *tsk) { }static inline void vtime_guest_enter (struct task_struct *tsk) { }static inline void vtime_guest_exit (struct task_struct *tsk) { }static inline void vtime_init_idle (struct task_struct *tsk,int cpu) { } + +#ifdef __ARCH_HAS_VTIME_ACCOUNT +extern void vtime_account_irq_enter (struct task_struct *tsk); +#else +extern void vtime_common_account_irq_enter (struct task_struct *tsk); +static inline void vtime_account_irq_enter (struct task_struct *tsk) +{ +if (vtime_accounting_cpu_enabled ()) +vtime_common_account_irq_enter (tsk); +} +#endif /* __ARCH_HAS_VTIME_ACCOUNT */ +#endif #ifdef CONFIG_IRQ_TIME_ACCOUNTING
kernel/sched/cputime.c +31 -24
102 lines not on this page · raw message
Signature · 1 line
2.5.5
PATCH 3/5 cputime: allow irq time accounting to be selected as an option
In reply to [email protected]From: Rik van Riel <[email protected]>
Allow CONFIG_IRQ_TIME_ACCOUNTING to be selected as an option, on top of CONFIG_VIRT_CPU_ACCOUNTING_GEN (and potentially others?).
This allows for the irq time accounting code to be used with nohz_idle CPUs, which is how several distributions ship their kernels. Using the same code for several timer modes also allows us to drop duplicate code.
--- init/Kconfig | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
init/Kconfig +3 -3
@@ -375,9 +375,11 @@ config VIRT_CPU_ACCOUNTING_GEN If unsure, say N. +endchoice + config IRQ_TIME_ACCOUNTING bool "Fine granularity task level IRQ time accounting" - depends on HAVE_IRQ_TIME_ACCOUNTING && !NO_HZ_FULL + depends on HAVE_IRQ_TIME_ACCOUNTING && !VIRT_CPU_ACCOUNTING_NATIVE help Select this option to enable fine granularity task irq time accounting. This is done by reading a timestamp on each
@@ -386,8 +388,6 @@ config IRQ_TIME_ACCOUNTING If in doubt, say N here. -endchoice - config BSD_PROCESS_ACCT bool "BSD Process Accounting" depends on MULTIUSER
Signature · 1 line
2.5.5
PATCH 4/5 irqtime: add irq type parameter to irqtime_account_irq
In reply to [email protected]From: Rik van Riel <[email protected]>
Add an irq type parameter and documentation to irqtime_account_irq, this can be used to distinguish between transitioning from process context to hardirq time, and from process context to softirq time.
This is necessary to be able to remove the local_irq_disable from irqtime_account_irq.
--- include/linux/hardirq.h | 20 ++++++++++---------- include/linux/vtime.h | 12 ++++++------ kernel/sched/cputime.c | 9 ++++++++- kernel/softirq.c | 6 +++--- 4 files changed, 27 insertions(+), 20 deletions(-)
include/linux/hardirq.h +10 -10
@@ -32,11 +32,11 @@ extern void rcu_nmi_exit(void);* always balanced, so the interrupted value of ->hardirq_context * will always be restored. */ -#define __irq_enter () \ - do { \ - account_irq_enter_time(current); \ - preempt_count_add(HARDIRQ_OFFSET); \ - trace_hardirq_enter(); \ +#define __irq_enter () \ + do { \ + account_irq_enter_time(current, HARDIRQ_OFFSET); \ + preempt_count_add(HARDIRQ_OFFSET); \ + trace_hardirq_enter(); \ } while (0)/*
@@ -47,11 +47,11 @@ extern void irq_enter(void);/* * Exit irq context without processing softirqs: */ -#define __irq_exit () \ - do { \ - trace_hardirq_exit(); \ - account_irq_exit_time(current); \ - preempt_count_sub(HARDIRQ_OFFSET); \ +#define __irq_exit () \ + do { \ + trace_hardirq_exit(); \ + account_irq_exit_time(current, HARDIRQ_OFFSET); \ + preempt_count_sub(HARDIRQ_OFFSET); \ } while (0)/*
include/linux/vtime.h +6 -6
@@ -112,21 +112,21 @@ static inline void vtime_account_irq_enter(struct task_struct *tsk)#endif #ifdef CONFIG_IRQ_TIME_ACCOUNTING -extern void irqtime_account_irq (struct task_struct *tsk); +extern void irqtime_account_irq (struct task_struct *tsk,int irqtype);#else -static inline void irqtime_account_irq (struct task_struct *tsk) { } +static inline void irqtime_account_irq (struct task_struct *tsk,int irqtype) { }#endif -static inline void account_irq_enter_time (struct task_struct *tsk) +static inline void account_irq_enter_time (struct task_struct *tsk,int irqtype) {vtime_account_irq_enter (tsk); -irqtime_account_irq (tsk); +irqtime_account_irq (tsk, irqtype); } -static inline void account_irq_exit_time (struct task_struct *tsk) +static inline void account_irq_exit_time (struct task_struct *tsk,int irqtype) {vtime_account_irq_exit (tsk); -irqtime_account_irq (tsk); +irqtime_account_irq (tsk, irqtype); }#endif /* _LINUX_KERNEL_VTIME_H */
kernel/sched/cputime.c +8 -1
@@ -46,8 +46,15 @@ DEFINE_PER_CPU(seqcount_t, irq_time_seq);/* * Called before incrementing preempt_count on {soft,}irq_enter * and before decrementing preempt_count on {soft,}irq_exit. +* +* There are six possible transitions: +* process -> softirq, softirq -> process +* process -> hardirq, hardirq -> process +* softirq -> hardirq, hardirq -> softirq +* +* When exiting hardirq or softirq time, account the elapsed time. */ -void irqtime_account_irq (struct task_struct *curr) +void irqtime_account_irq (struct task_struct *curr,int irqtype) {unsigned long flags;s64 delta;
kernel/softirq.c +3 -3
@@ -245,7 +245,7 @@ asmlinkage __visible void __softirq_entry __do_softirq(void) current->flags &= ~PF_MEMALLOC ; pending =local_softirq_pending (); -account_irq_enter_time (current); +account_irq_enter_time (current,SOFTIRQ_OFFSET );__local_bh_disable_ip (_RET_IP_,SOFTIRQ_OFFSET ); in_hardirq =lockdep_softirq_start ();
@@ -295,7 +295,7 @@ asmlinkage __visible void __softirq_entry __do_softirq(void) }lockdep_softirq_end (in_hardirq); -account_irq_exit_time (current); +account_irq_exit_time (current,SOFTIRQ_OFFSET );__local_bh_enable (SOFTIRQ_OFFSET );WARN_ON_ONCE (in_interrupt ());tsk_restore_flags (current, old_flags,PF_MEMALLOC );
@@ -385,7 +385,7 @@ void irq_exit(void)WARN_ON_ONCE (!irqs_disabled ());#endif -account_irq_exit_time (current); +account_irq_exit_time (current,HARDIRQ_OFFSET );preempt_count_sub (HARDIRQ_OFFSET );if (!in_interrupt () &&local_softirq_pending ())invoke_softirq ();
Signature · 1 line
2.5.5
PATCH 5/5 irqtime: drop local_irq_save/restore from irqtime_account_irq
In reply to [email protected]From: Rik van Riel <[email protected]>
Drop local_irq_save/restore from irqtime_account_irq. Instead, have softirq and hardirq track their time spent independently, with the softirq code subtracting hardirq time that happened during the duration of the softirq run.
The softirq code can be interrupted by hardirq code at any point in time, but it can check whether it got a consistent snapshot of the timekeeping variables it wants, and loop around in the unlikely case that it did not.
--- kernel/sched/cputime.c | 54 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 11 deletions(-)
kernel/sched/cputime.c +43 -11
@@ -26,7 +26,9 @@DEFINE_PER_CPU (u64, cpu_hardirq_time);DEFINE_PER_CPU (u64, cpu_softirq_time); -static DEFINE_PER_CPU(u64, irq_start_time); +static DEFINE_PER_CPU(u64, hardirq_start_time); +static DEFINE_PER_CPU(u64, softirq_start_time); +static DEFINE_PER_CPU(u64, prev_hardirq_time);static int sched_clock_irqtime;void enable_sched_clock_irqtime (void )
@@ -53,36 +55,66 @@ DEFINE_PER_CPU(seqcount_t, irq_time_seq);* softirq -> hardirq, hardirq -> softirq * * When exiting hardirq or softirq time, account the elapsed time. +* +* When exiting softirq time, subtract the amount of hardirq time that +* interrupted this softirq run, to avoid double accounting of that time. */ void irqtime_account_irq (struct task_struct *curr,int irqtype) { -unsigned long flags; -s64 delta; +u64 prev_softirq_start; +u64 prev_hardirq; +u64 hardirq_time; +s64 delta =0 ;int cpu;if (!sched_clock_irqtime)return ; -local_irq_save (flags); - cpu =smp_processor_id (); - delta =sched_clock_cpu (cpu) -__this_cpu_read (irq_start_time); -__this_cpu_add (irq_start_time, delta); + prev_hardirq =__this_cpu_read (prev_hardirq_time); + prev_softirq_start =__this_cpu_read (softirq_start_time); +/* +* Softirq context may get interrupted by hardirq context, +* on the same CPU. At softirq +*/ +if (irqtype ==HARDIRQ_OFFSET ) { + delta =sched_clock_cpu (cpu) -__this_cpu_read (hardirq_start_time); +__this_cpu_add (hardirq_start_time, delta); + }else do { + hardirq_time =READ_ONCE (per_cpu (cpu_hardirq_time, cpu)); +u64 now =sched_clock_cpu (cpu); + + delta = now - prev_softirq_start; +if (in_serving_softirq ()) { +/* +* Leaving softirq context. Avoid double counting by +* subtracting hardirq time from this interval. +*/ + delta -= hardirq_time - prev_hardirq; + }else { +/* Entering softirq context. Note start times. */ +__this_cpu_write (softirq_start_time, now); +__this_cpu_write (prev_hardirq_time, hardirq_time); + } +/* +* If a hardirq happened during this calculation, it may not +* have gotten a consistent snapshot. Try again. +*/ + }while (hardirq_time !=READ_ONCE (per_cpu (cpu_hardirq_time, cpu))); -irq_time_write_begin ();/* * We do not account for softirq time from ksoftirqd here. * We want to continue accounting softirq time to ksoftirqd thread * in that case, so as not to confuse scheduler with a special task * that do not consume any time, but still wants to run. */ -if (hardirq_count ()) +if (irqtype ==HARDIRQ_OFFSET &&hardirq_count ())__this_cpu_add (cpu_hardirq_time, delta); -else if (in_serving_softirq () && curr !=this_cpu_ksoftirqd ()) +else if (irqtype ==SOFTIRQ_OFFSET &&in_serving_softirq () && + curr !=this_cpu_ksoftirqd ())__this_cpu_add (cpu_softirq_time, delta);irq_time_write_end (); -local_irq_restore (flags); }EXPORT_SYMBOL_GPL (irqtime_account_irq);
Signature · 1 line
2.5.5