tick: Dynamically set broadcast irq affinity

When a cpu goes to a deep idle state where its local timer is
shutdown, it notifies the time frame work to use the broadcast timer
instead.  Unfortunately, the broadcast device could wake up any CPU,
including an idle one which is not concerned by the wake up at all. So
in the worst case an idle CPU will wake up to send an IPI to the CPU
whose timer expired.

Provide an opt-in feature CLOCK_EVT_FEAT_DYNIRQ which tells the core
that is should set the interrupt affinity of the broadcast interrupt
to the cpu which has the earliest expiry time. This avoids unnecessary
spurious wakeups and IPIs.

[ tglx: Adopted to cpumask rework, silenced an uninitialized warning,
  massaged changelog ]

Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: viresh.kumar@linaro.org
Cc: jacob.jun.pan@linux.intel.com
Cc: linux-arm-kernel@lists.infradead.org
Cc: santosh.shilimkar@ti.com
Cc: linaro-kernel@lists.linaro.org
Cc: patches@linaro.org
Cc: rickard.andersson@stericsson.com
Cc: vincent.guittot@linaro.org
Cc: linus.walleij@stericsson.com
Cc: john.stultz@linaro.org
Link: http://lkml.kernel.org/r/1362219013-18173-3-git-send-email-daniel.lezcano@linaro.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 66346521cb6561641045297cb74c8d15f7b71f74..494d33ea78f80cdc8a4757899a91a91d0a8b656a 100644 (file)
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -55,6 +55,11 @@ enum clock_event_nofitiers {
 #define CLOCK_EVT_FEAT_C3STOP          0x000008
 #define CLOCK_EVT_FEAT_DUMMY           0x000010
 
+/*
+ * Core shall set the interrupt affinity dynamically in broadcast mode
+ */
+#define CLOCK_EVT_FEAT_DYNIRQ          0x000020
+
 /**
  * struct clock_event_device - clock event device descriptor
  * @event_handler:     Assigned by the framework to be called by the low

diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 70dd98ce18d77f1d02a827f9733a9818abf605b2..380910db71574025ea75e8d8f004660f58a977fc 100644 (file)
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -401,13 +401,34 @@ struct cpumask *tick_get_broadcast_oneshot_mask(void)
        return tick_broadcast_oneshot_mask;
 }
 
-static int tick_broadcast_set_event(struct clock_event_device *bc,
+/*
+ * Set broadcast interrupt affinity
+ */
+static void tick_broadcast_set_affinity(struct clock_event_device *bc,
+                                       const struct cpumask *cpumask)
+{
+       if (!(bc->features & CLOCK_EVT_FEAT_DYNIRQ))
+               return;
+
+       if (cpumask_equal(bc->cpumask, cpumask))
+               return;
+
+       bc->cpumask = cpumask;
+       irq_set_affinity(bc->irq, bc->cpumask);
+}
+
+static int tick_broadcast_set_event(struct clock_event_device *bc, int cpu,
                                    ktime_t expires, int force)
 {
+       int ret;
+
        if (bc->mode != CLOCK_EVT_MODE_ONESHOT)
                clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
 
-       return clockevents_program_event(bc, expires, force);
+       ret = clockevents_program_event(bc, expires, force);
+       if (!ret)
+               tick_broadcast_set_affinity(bc, cpumask_of(cpu));
+       return ret;
 }
 
 int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
@@ -436,7 +457,7 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
 {
        struct tick_device *td;
        ktime_t now, next_event;
-       int cpu;
+       int cpu, next_cpu = 0;
 
        raw_spin_lock(&tick_broadcast_lock);
 again:
@@ -447,10 +468,12 @@ again:
        /* Find all expired events */
        for_each_cpu(cpu, tick_broadcast_oneshot_mask) {
                td = &per_cpu(tick_cpu_device, cpu);
-               if (td->evtdev->next_event.tv64 <= now.tv64)
+               if (td->evtdev->next_event.tv64 <= now.tv64) {
                        cpumask_set_cpu(cpu, tmpmask);
-               else if (td->evtdev->next_event.tv64 < next_event.tv64)
+               } else if (td->evtdev->next_event.tv64 < next_event.tv64) {
                        next_event.tv64 = td->evtdev->next_event.tv64;
+                       next_cpu = cpu;
+               }
        }
 
        /*
@@ -473,7 +496,7 @@ again:
                 * Rearm the broadcast device. If event expired,
                 * repeat the above
                 */
-               if (tick_broadcast_set_event(dev, next_event, 0))
+               if (tick_broadcast_set_event(dev, next_cpu, next_event, 0))
                        goto again;
        }
        raw_spin_unlock(&tick_broadcast_lock);
@@ -515,7 +538,7 @@ void tick_broadcast_oneshot_control(unsigned long reason)
                if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_oneshot_mask)) {
                        clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
                        if (dev->next_event.tv64 < bc->next_event.tv64)
-                               tick_broadcast_set_event(bc, dev->next_event, 1);
+                               tick_broadcast_set_event(bc, cpu, dev->next_event, 1);
                }
        } else {
                if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_oneshot_mask)) {
@@ -581,7 +604,7 @@ void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
                        clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
                        tick_broadcast_init_next_event(tmpmask,
                                                       tick_next_period);
-                       tick_broadcast_set_event(bc, tick_next_period, 1);
+                       tick_broadcast_set_event(bc, cpu, tick_next_period, 1);
                } else
                        bc->next_event.tv64 = KTIME_MAX;
        } else {