sched,time: fix irq time accounting with nohz_idle

kernel/sched/cputime.c +1 -1

index 3d60e5d76fdb..018bae2ada36 100644
@@ -79,40 +79,50 @@ void irqtime_account_irq(struct task_struct *curr)
 }
 EXPORT_SYMBOL_GPL(irqtime_account_irq);
 
-static int irqtime_account_hi_update(void)
+static cputime_t irqtime_account_hi_update(cputime_t maxtime)
 {
 	u64 *cpustat = kcpustat_this_cpu->cpustat;
 	unsigned long flags;

kernel/sched/cputime.c +4 -2

+	irq_cputime = min(irq_cputime, maxtime);
+	cpustat[CPUTIME_IRQ] += irq_cputime;
 	local_irq_restore(flags);
-	return ret;
+	return irq_cputime;
 }
 
-static int irqtime_account_si_update(void)
+static cputime_t irqtime_account_si_update(cputime_t maxtime)
 {
 	u64 *cpustat = kcpustat_this_cpu->cpustat;

kernel/sched/cputime.c +15 -2

+			  cpustat[CPUTIME_SOFTIRQ];
+	softirq_cputime = min(softirq_cputime, maxtime);
+	cpustat[CPUTIME_SOFTIRQ] += softirq_cputime;
 	local_irq_restore(flags);
-	return ret;
+	return softirq_cputime;
 }
 
 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
 
 #define sched_clock_irqtime	(0)
 
+static cputime_t irqtime_account_hi_update(cputime_t dummy)
+{
+	return 0;
+}
+
+static cputime_t irqtime_account_si_update(cputime_t dummy)
+{
+	return 0;
+}
+
 #endif /* !CONFIG_IRQ_TIME_ACCOUNTING */
 
 static inline void task_group_account_field(struct task_struct *p, int index,

@@ -257,32 +267,45 @@ void account_idle_time(cputime_t cputime)
 		cpustat[CPUTIME_IDLE] += (__force u64) cputime;
 }
 
-static __always_inline unsigned long steal_account_process_tick(unsigned long max_jiffies)
+static __always_inline cputime_t steal_account_process_time(cputime_t maxtime)

kernel/sched/cputime.c +3 -9

-		/*
-		 * steal is in nsecs but our caller is expecting steal
-		 * time in jiffies. Lets cast the result to jiffies
-		 * granularity and account the rest on the next rounds.
-		 */
-		steal_jiffies = min(nsecs_to_jiffies(steal), max_jiffies);
-		this_rq()->prev_steal_time += jiffies_to_nsecs(steal_jiffies);
+		steal_cputime = min(nsecs_to_cputime(steal), maxtime);
+		account_steal_time(steal_cputime);
 
-		account_steal_time(jiffies_to_cputime(steal_jiffies));
-		return steal_jiffies;
+		return steal_cputime;

Quoted 23 lines · On Thu, Jun 30, 2016 at 03:35:47PM -0400, [email protected] wrote:

kernel/sched/cputime.c +0 -0

index 3d60e5d76fdb..018bae2ada36 100644
@@ -79,40 +79,50 @@ void irqtime_account_irq(struct task_struct
 *curr)
  }
  EXPORT_SYMBOL_GPL(irqtime_account_irq);

kernel/sched/cputime.c +1 -1

-static int irqtime_account_hi_update(void)
+static cputime_t irqtime_account_hi_update(cputime_t maxtime)

 {
  u64 *cpustat = kcpustat_this_cpu->cpustat; unsigned long flags;

kernel/sched/cputime.c +1 -2

-	u64 latest_ns;
-	int ret = 0;
+	cputime_t irq_cputime;

  local_irq_save(flags);

kernel/sched/cputime.c +1 -3

-	latest_ns = this_cpu_read(cpu_hardirq_time);
-	if (nsecs_to_cputime64(latest_ns) > cpustat[CPUTIME_IRQ])
-		ret = 1;
+	irq_cputime =

kernel/sched/cputime.c void irqtime_account_irq(struct task_struct *curr) · line 90

Quoted 2 lines

nsecs_to_cputime(this_cpu_read(cpu_hardirq_time)) -

kernel/sched/cputime.c +1 -0

+		      cpustat[CPUTIME_IRQ];

We might want to keep nsecs_to_cputime64(). If cputime_t == jiffies_t == unsigned long,
we may have a problem after 49 days of interrupts. Arguably that's a lot of IRQs
but lets be paranoid.

Quoted 22 lines

kernel/sched/cputime.c +2 -0

+	irq_cputime = min(irq_cputime, maxtime);
+	cpustat[CPUTIME_IRQ] += irq_cputime;

  local_irq_restore(flags);

kernel/sched/cputime.c +1 -1

-	return ret;
+	return irq_cputime;

 }

kernel/sched/cputime.c +1 -1

-static int irqtime_account_si_update(void)
+static cputime_t irqtime_account_si_update(cputime_t maxtime)

 {
  u64 *cpustat = kcpustat_this_cpu->cpustat; unsigned long flags;

kernel/sched/cputime.c +1 -2

-	u64 latest_ns;
-	int ret = 0;
+	cputime_t softirq_cputime;

  local_irq_save(flags);

kernel/sched/cputime.c +0 -2

-	latest_ns = this_cpu_read(cpu_softirq_time);
-	if (nsecs_to_cputime64(latest_ns) >

cpustat[CPUTIME_SOFTIRQ])

kernel/sched/cputime.c +1 -1

-		ret = 1;
+	softirq_cputime =

Quoted 1 line

nsecs_to_cputime(this_cpu_read(cpu_softirq_time)) -

Ditto.

Quoted 43 lines

kernel/sched/cputime.c +3 -0

+			  cpustat[CPUTIME_SOFTIRQ];
+	softirq_cputime = min(softirq_cputime, maxtime);
+	cpustat[CPUTIME_SOFTIRQ] += softirq_cputime;

  local_irq_restore(flags);

kernel/sched/cputime.c +1 -1

-	return ret;
+	return softirq_cputime;

 }

 #else /* CONFIG_IRQ_TIME_ACCOUNTING */

 #define sched_clock_irqtime (0)

kernel/sched/cputime.c +10 -0

+static cputime_t irqtime_account_hi_update(cputime_t dummy)
+{
+	return 0;
+}
+
+static cputime_t irqtime_account_si_update(cputime_t dummy)
+{
+	return 0;
+}
+

 #endif /* !CONFIG_IRQ_TIME_ACCOUNTING */

 static inline void task_group_account_field(struct task_struct *p, int index,

kernel/sched/cputime.c +0 -0

@@ -257,32 +267,45 @@ void account_idle_time(cputime_t cputime)
  		cpustat[CPUTIME_IDLE] += (__force u64) cputime;
  }

-static __always_inline unsigned long steal_account_process_tick(unsigned long max_jiffies) +static __always_inline cputime_t steal_account_process_time(cputime_t maxtime)
 {
 #ifdef CONFIG_PARAVIRT
  if (static_key_false(&paravirt_steal_enabled)) {

kernel/sched/cputime.c +1 -0

+		cputime_t steal_cputime;

  u64 steal;

kernel/sched/cputime.c +0 -1

-		unsigned long steal_jiffies;

  steal = paravirt_steal_clock(smp_processor_id()); steal -= this_rq()->prev_steal_time;

kernel/sched/cputime.c void account_idle_time(cputime_t cputime) · line 279

Quoted 1 line

kernel/sched/cputime.c +1 -0

+		this_rq()->prev_steal_time += steal;

We are accounting steal_cputime but you make it remember steal_nsecs. This is
leaking quite some steal time in the way.

Imagine that cputime_t == jiffies_t and HZ=100. paravirt_steal_clock() returns 199 nsecs. prev_steal_time gets added those 199.
nsecs_to_cputime() return 1 jiffy (we are one nsec off the next jiffy). So
account_steal_time() is accounting 1 jiffy and the 99 remaining nsecs are leaked.
If some more steal time is to be accounted on the next tick, the 99 previous nsecs
are forgotten.

A non-leaking sequence would rather be:

	steal = paravirt_steal_clock(smp_processor_id());
	steal -= this_rq()->prev_steal_time;
	steal_cputime = min(nsecs_to_cputime(steal), maxtime);
	account_steal_time(steal_cputime);
	this_rq()->prev_steal_time += cputime_to_nsecs(steal_cputime);

Thanks!

Quoted 24 lines · Frederic Weisbecker

Quoted 23 lines · On Thu, Jun 30, 2016 at 03:35:47PM -0400, [email protected] wrote:

kernel/sched/cputime.c +0 -0

index 3d60e5d76fdb..018bae2ada36 100644
@@ -79,40 +79,50 @@ void irqtime_account_irq(struct task_struct
 *curr)
  }
  EXPORT_SYMBOL_GPL(irqtime_account_irq);

kernel/sched/cputime.c +1 -1

-static int irqtime_account_hi_update(void)
+static cputime_t irqtime_account_hi_update(cputime_t maxtime)

 {
  u64 *cpustat = kcpustat_this_cpu->cpustat; unsigned long flags;

kernel/sched/cputime.c +1 -2

-	u64 latest_ns;
-	int ret = 0;
+	cputime_t irq_cputime;

  local_irq_save(flags);

kernel/sched/cputime.c +1 -3

-	latest_ns = this_cpu_read(cpu_hardirq_time);
-	if (nsecs_to_cputime64(latest_ns) > cpustat[CPUTIME_IRQ])
-		ret = 1;
+	irq_cputime =

Quoted 8 lines

kernel/sched/cputime.c void irqtime_account_irq(struct task_struct *curr) · line 90

Quoted 2 lines

nsecs_to_cputime(this_cpu_read(cpu_hardirq_time)) -

kernel/sched/cputime.c +1 -0

+		      cpustat[CPUTIME_IRQ];

We might want to keep nsecs_to_cputime64(). If cputime_t == jiffies_t == unsigned long,
we may have a problem after 49 days of interrupts. Arguably that's a lot of IRQs
but lets be paranoid.

The macro nsecs_to_cputime64 is only defined in
cputime_jiffies.h though, not in cputime_nsecs.h

Want me to add a #define to the second file?

...

Quoted 1 line · On Tue, 5 Jul 2016 14:40:34 +0200 Frederic Weisbecker <[email protected]>…

...

Thanks for the review Frederic. Here is a fixed version of patch 1, the other three still seem to apply cleanly.

---8<---

Subject: sched,time: count actually elapsed irq & softirq time

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 the time 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.

This can actually happen when irqtime_account_process_tick is called from account_idle_ticks, which can pass a larger number of ticks down all at once.

Fix this by changing irqtime_account_hi_update, irqtime_account_si_update, and steal_account_process_ticks to work with cputime_t time units, and return the amount of time spent in each mode.

Rename steal_account_process_ticks to steal_account_process_time, to reflect that time is now accounted in cputime_t, instead of ticks.

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 cputime accounting 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.

Signed-off-by Rik van Riel <[email protected]>

---
 include/asm-generic/cputime_nsecs.h |   2 +
 kernel/sched/cputime.c              | 124 ++++++++++++++++++++++--------------
 2 files changed, 79 insertions(+), 47 deletions(-)

include/asm-generic/cputime_nsecs.h +0 -0

index 0f1c6f315cdc..918ebb01486c 100644

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.

Signed-off-by Rik van Riel <[email protected]>

---
 kernel/sched/cputime.c | 72 +++++++++++++++++++++++++++++++++++++++++---------
 kernel/sched/sched.h   | 38 +++++++++++++++++++++-----
 2 files changed, 90 insertions(+), 20 deletions(-)

kernel/sched/cputime.c +15 -7

index a0aefd4c7ea6..b78991fac228 100644
@@ -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)

@@ -41,6 +43,7 @@ void disable_sched_clock_irqtime(void)
 
 #ifndef CONFIG_64BIT
 DEFINE_PER_CPU(seqcount_t, irq_time_seq);
+DEFINE_PER_CPU(seqcount_t, softirq_time_seq);
 #endif /* CONFIG_64BIT */
 
 /*

@@ -53,36 +56,79 @@ 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;
+	u64 prev_softirq_start;
+	bool leaving_softirq;
+	u64 prev_hardirq;
+	u64 hardirq_time;
 	s64 delta;
 	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);
 
-	irq_time_write_begin();
+	/*
+	 * Hardirq time accounting is pretty straightforward. If not in
+	 * hardirq context yet (entering hardirq), set the start time.
+	 * If already in hardirq context (leaving), account the elapsed time.

Quoted 12 lines · On Thu, Jun 30, 2016 at 03:35:50PM -0400, [email protected] wrote:

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.

Quoted 1 line

Signed-off-by Rik van Riel <[email protected]>

So the purpose is to get rid of local_irq_save/restore()? Is it really worth such complication?

Quoted 72 lines

---
 kernel/sched/cputime.c | 72
+++++++++++++++++++++++++++++++++++++++++---------
 kernel/sched/sched.h   | 38 +++++++++++++++++++++-----

 2 files changed, 90 insertions(+), 20 deletions(-)

kernel/sched/cputime.c +0 -0

index a0aefd4c7ea6..b78991fac228 100644
@@ -26,7 +26,9 @@
  DEFINE_PER_CPU(u64, cpu_hardirq_time);
  DEFINE_PER_CPU(u64, cpu_softirq_time);

kernel/sched/cputime.c +3 -1

-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)

kernel/sched/cputime.c +0 -0

@@ -41,6 +43,7 @@ void disable_sched_clock_irqtime(void)

 #ifndef CONFIG_64BIT
 DEFINE_PER_CPU(seqcount_t, irq_time_seq); +DEFINE_PER_CPU(seqcount_t, softirq_time_seq); #endif /* CONFIG_64BIT */

 /*

kernel/sched/cputime.c +2 -0

@@ -53,36 +56,79 @@ 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) {

kernel/sched/cputime.c +4 -1

-	unsigned long flags;
+	u64 prev_softirq_start;
+	bool leaving_softirq;
+	u64 prev_hardirq;
+	u64 hardirq_time;

  s64 delta;
  int cpu;

  if (!sched_clock_irqtime)
  return;

kernel/sched/cputime.c +0 -2

-	local_irq_save(flags);
-

  cpu = smp_processor_id();

kernel/sched/cputime.c +0 -1

-	delta = sched_clock_cpu(cpu) -

__this_cpu_read(irq_start_time);

kernel/sched/cputime.c +0 -1

-	__this_cpu_add(irq_start_time, delta);

kernel/sched/cputime.c +2 -1

-	irq_time_write_begin();
+	/*
+	 * Hardirq time accounting is pretty straightforward. If

not in

kernel/sched/cputime.c +1 -0

+	 * hardirq context yet (entering hardirq), set the start

time.

kernel/sched/cputime.c +1 -0

+	 * If already in hardirq context (leaving), account the

elapsed time.

kernel/sched/cputime.c +4 -0

+	 */
+	if (irqtype == HARDIRQ_OFFSET) {
+		bool leaving_hardirq = hardirq_count();
+		delta = sched_clock_cpu(cpu) -

__this_cpu_read(hardirq_start_time);

kernel/sched/cputime.c DEFINE_PER_CPU(seqcount_t, irq_time_seq); · line 90

Quoted 6 lines

kernel/sched/cputime.c +6 -0

+		__this_cpu_add(hardirq_start_time, delta);
+		if (leaving_hardirq) {
+			hardirq_time_write_begin();
+			__this_cpu_add(cpu_hardirq_time, delta);
+			hardirq_time_write_end();
+		}

This doesn't seem to work with nesting hardirqs.

Thanks.

Quoted 13 lines · Frederic Weisbecker

kernel/sched/cputime.c DEFINE_PER_CPU(seqcount_t, irq_time_seq); · line 90

Quoted 10 lines

kernel/sched/cputime.c +3 -0

+	if (irqtype == HARDIRQ_OFFSET) {
+		bool leaving_hardirq = hardirq_count();
+		delta = sched_clock_cpu(cpu) -

__this_cpu_read(hardirq_start_time);

kernel/sched/cputime.c +6 -0

+		__this_cpu_add(hardirq_start_time, delta);
+		if (leaving_hardirq) {
+			hardirq_time_write_begin();
+			__this_cpu_add(cpu_hardirq_time, delta);
+			hardirq_time_write_end();
+		}

This doesn't seem to work with nesting hardirqs.

Quoted 1 line

Thanks.

Where does it break?

enter hardirq A -> hardirq_start_time = now

enter hardirq B -> hardirq_start_time = now,
                   account already elapsed time

leave hardirq B -> account elapsed time, set
                   hardirq_start_time = now

leave hardirq A -> account elapsed time

What am I missing, except a softirq-style do-while loop to account for hardirq A being interrupted by hardirq B while updating the statistics?

Quoted 13 lines · Frederic Weisbecker

Quoted 12 lines · On Thu, Jun 30, 2016 at 03:35:50PM -0400, [email protected] wrote:

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.

Quoted 4 lines

Quoted 1 line

Signed-off-by Rik van Riel <[email protected]>

So the purpose is to get rid of local_irq_save/restore()? Is it really worth such complication?

local_irq_save/restore are quite slow, and look like the largest source of overhead in irq time accounting.

Quoted 14 lines · Rik van Riel

Quoted 13 lines · Frederic Weisbecker

Quoted 12 lines · On Thu, Jun 30, 2016 at 03:35:50PM -0400, [email protected] wrote:

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.

Quoted 7 lines

Quoted 4 lines

Quoted 1 line

Signed-off-by Rik van Riel <[email protected]>

So the purpose is to get rid of local_irq_save/restore()? Is it really worth such complication?

local_irq_save/restore are quite slow, and look like the largest source of overhead in irq time accounting.

I'm looking at an upstream tree, without your patches applied, but it seems to me that irqtime_account_irq is always called with interrupts disabled:

irqtime_account_irq

	-> account_irq_enter_time
		-> __irq_enter
			-> HARDIRQ_ENTER	[1]
			-> irq_enter		[3]
		-> __do_softirq			[1]
	-> account_irq_exit_time
		-> __do_softirq			[1]
		-> __irq_exit
			-> HARDIRQ_EXIT		[1]
		-> irq_exit			[2]

	[1] = does local_irq_disable/enable
	[2] = contains WARN_ON_ONCE(!irqs_disabled())
	[3] = calls rcu_irq_enter(), which checks irqs_disabled()

I don't think your first two patches change this, so perhaps it's enough
to remove that local_irq-save/restore?  Either this, or ENEEDWEEKEND...

Quoted 16 lines · Paolo Bonzini

I'm looking at an upstream tree, without your patches applied, but it seems to me that irqtime_account_irq is always called with interrupts disabled:

irqtime_account_irq

	-> account_irq_enter_time
		-> __irq_enter
			-> HARDIRQ_ENTER	[1]
			-> irq_enter		[3]
		-> __do_softirq			[1]
	-> account_irq_exit_time
		-> __do_softirq			[1]
		-> __irq_exit
			-> HARDIRQ_EXIT		[1]
		-> irq_exit			[2]

Quoted 8 lines

[1] = does local_irq_disable/enable
[2] = contains WARN_ON_ONCE(!irqs_disabled())
[3] = calls rcu_irq_enter(), which checks irqs_disabled()

I don't think your first two patches change this, so perhaps it's enough
to remove that local_irq-save/restore?  Either this, or ENEEDWEEKEND...

I think you are right!

__do_softirq() calls account_irq_enter_time() with irqs already disabled, and also has irqs disabled when it calls account_irq_exit_time()

This appears to be true for both ksoftirqd and softirq from irq context.

This could simplify my patch series a lot :)

Currently irq time accounting only works in these cases:
1) purely ticke based accounting
2) nohz_full accounting, but only on housekeeping & nohz_full CPUs
3) architectures with native vtime accounting

On nohz_idle CPUs, which are probably the majority nowadays, irq time accounting is currently broken. This leads to systems reporting a dramatically lower amount of irq & softirq time than is actually spent handling them, with all the time spent while the system is in the idle task being accounted as idle.

This patch set seems to bring the amount of irq time reported by top (and /proc/stat) roughly in line with that measured when I do a "perf record -g -a" run to see what is using all that time.

The amount of irq time used, especially softirq, is shockingly high, to the point of me thinking this patch set may be wrong, but the numbers seem to match what perf is giving me...

These patches apply on top of Wanpeng Li's steal time patches.

CONFIG_IRQ_TIME_ACCOUNTING is now a config option that is available as a separate choice from tick based / nohz_idle / nohz_full mode, a suggested by Frederic Weisbecker.

Next up: look at the things that are using CPU time on an otherwise idle system, and see if I can make those a little faster :)

v2: address Peterz's concerns, some more cleanups
v3: rewrite the code along Frederic's suggestions, now cputime_t
is used everywhere

Quoted 5 lines · On 06/30/2016 10:35 PM, [email protected] wrote:

Currently irq time accounting only works in these cases:
1) purely ticke based accounting
2) nohz_full accounting, but only on housekeeping & nohz_full CPUs
3) architectures with native vtime accounting

Quoted 5 lines

On nohz_idle CPUs, which are probably the majority nowadays, irq time accounting is currently broken. This leads to systems reporting a dramatically lower amount of irq & softirq time than is actually spent handling them, with all the time spent while the system is in the idle task being accounted as idle.

Is this supposed to alleviate the issue reported here:
http://www.gossamer-threads.com/lists/linux/kernel/2169180