Refactor timer merging and add it to CE plugin.

THIS CODE IS UNTESTED

We now initialize one event group for each cpu on system start. We can
get the event group for a CPU via a function in event_group.c

Another change is that an event now stores what group it is in when it
add_event() is called on it. This lets us cancel it without knowing what
event group it is in.

The above is important because Level-C events (like releases) have a
NULL event group. When calling add_event(), it will get the event group
of the current CPU. If the event needs to be canceled later, we need
that saved group in the event so we know where to remove it from.

1 files changed, 50 insertions, 15 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
index 276ba5dd242d..db43961258bf 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -1,5 +1,6 @@
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/module.h>
 
 #include <litmus/litmus.h>
 #include <litmus/trace.h>
@@ -158,6 +159,12 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
         VTRACE("Adding event 0x%p with priority %d for time %llu\n",
                e, e->prio, fire);
 
+        /* A NULL group means use the group of the currently executing CPU  */
+        if (NULL == group)
+                group = get_event_group_for(NO_CPU);
+        /* Saving the group is important for cancellations */
+        e->_event_group = group;
+
         raw_spin_lock(&group->queue_lock);
         el = get_event_list(group, e, fire, 0);
         if (!el) {
@@ -192,11 +199,12 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
 /**
  * cancel_event() - Remove event from the group.
  */
-void cancel_event(struct event_group *group, struct rt_event *e)
+void cancel_event(struct rt_event *e)
 {
         struct list_head *swap = NULL;
         struct rt_event *swappy;
         struct event_list *tmp;
+        struct event_group *group = e->_event_group;
 
         if (e->list.next != &e->list) {
                 raw_spin_lock(&group->queue_lock);
@@ -222,25 +230,12 @@ void cancel_event(struct event_group *group, struct rt_event *e)
 
                 hrtimer_try_to_cancel(&e->event_list->timer);
                 list_del_init(&e->event_list->list);
+                e->_event_group = NULL;
 
                 raw_spin_unlock(&group->queue_lock);
         }
 }
 
-/**
- * init_event_group() - Prepare group for events.
- */
-void init_event_group(struct event_group *group, lt_t res, int cpu)
-{
-        int i;
-        VTRACE("Creating group with res %llu on CPU %d", res, cpu);
-        group->res = res;
-        group->cpu = cpu;
-        for (i = 0; i < EVENT_QUEUE_SLOTS; i++)
-                INIT_LIST_HEAD(&group->event_queue[i]);
-        raw_spin_lock_init(&group->queue_lock);
-}
-
 struct kmem_cache *event_list_cache, *event_cache;
 
 struct event_list* event_list_alloc(int gfp_flags)
@@ -264,3 +259,43 @@ void init_event(struct rt_event *e, int prio, fire_event_t function,
         e->event_list = el;
         INIT_LIST_HEAD(&e->list);
 }
+
+/**
+ * init_event_group() - Prepare group for events.
+ * @group       Group to prepare
+ * @res         Timer resolution. Two events of @res distance will be merged
+ * @cpu         Cpu on which to fire timers
+ */
+static void init_event_group(struct event_group *group, lt_t res, int cpu)
+{
+        int i;
+        VTRACE("Creating group with resolution %llu on CPU %d", res, cpu);
+        group->res = res;
+        group->cpu = cpu;
+        for (i = 0; i < EVENT_QUEUE_SLOTS; i++)
+                INIT_LIST_HEAD(&group->event_queue[i]);
+        raw_spin_lock_init(&group->queue_lock);
+}
+
+
+DEFINE_PER_CPU(struct event_group, _event_groups);
+
+struct event_group *get_event_group_for(const int cpu)
+{
+        return &per_cpu(_event_groups,
+                        (NO_CPU == cpu) ? smp_processor_id() : cpu);
+}
+
+static int __init _init_event_groups(void)
+{
+        int cpu;
+        printk("Initializing LITMUS^RT event groups.\n");
+
+        for_each_online_cpu(cpu) {
+                init_event_group(get_event_group_for(cpu),
+                                CONFIG_MERGE_TIMERS_WINDOW, cpu);
+        }
+        return 0;
+}
+
+module_init(_init_event_groups);